AI APIs

Building Intelligent Agents: Mastering Gemini API's Function Calling and Code Execution

Oct 26, 2026 · 2 views
pythonAI AgentsLLM DevelopmentGoogle GeminiFunction Callingcode-execution

The era of simple question-and-answer interactions with Large Language Models (LLMs) is rapidly evolving. Today's development landscape demands systems that can reason, act, and verify. Google’s Gemini API stands at the forefront of this shift, offering powerful primitives that allow developers to construct agentic workflows. By combining Function Calling with Code Execution capabilities, developers can build AI agents that not only generate plans but also execute complex logic and retrieve real-time data.

Understanding the Agentic Loop

An "agentic" system operates in a loop: it plans, acts, observes the result, and then replans. In the context of the Gemini API, this loop is orchestrated by two key mechanisms:

  1. Function Calling: This allows the model to output structured JSON data indicating which external functions it wants to call and with what parameters. It is the bridge between the LLM's "thought process" and your application's "action layer."
  2. Code Execution (Sandboxed Python): Gemini can generate and execute Python code in a secure sandbox environment. This is crucial for tasks requiring numerical precision, data manipulation, or multi-step logical verification that pure text generation might handle poorly.

Step 1: Defining Functions for External Actions

To enable an agent to interact with your specific application or data sources, you must define function signatures. Consider an agent that needs to check weather and calculate optimal travel times.

import google.generativeai as genai

# Define the function signature
def get_weather(location: str):
    # This function would normally call an external API
    return {"temp_c": 22, "condition": "Sunny"}

def calculate_optimal_time(distance_km: float, speed_kmh: float):
    # This function would perform complex logistics calculations
    return {"hours": distance_km / speed_kmh}

# Configure the model with available tools
genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel(
    'gemini-1.5-pro',
    tools=[get_weather, calculate_optimal_time]
)

Step 2: Enabling Code Execution for Logical Reasoning

While function calling handles external actions, code execution handles internal computation. When using the `code_execution` tool, Gemini can write Python scripts to solve math problems or manipulate data tables provided in the prompt.

Here is how you enable this in your model configuration:

# Note: In the latest SDK, code execution is often enabled via specific tool settings
# or by utilizing the 'code_execution' capability if available in your region/plan.

model_with_code = genai.GenerativeModel(
    'gemini-1.5-pro',
    system_instruction="You are a data analysis agent. Use code execution to verify calculations."
)

# The model will now decide to run code if it sees mathematical or data-heavy tasks
response = model_with_code.generate_content("Analyze this dataset and find the top 3 trends.")
print(response.text)

Practical Example: The Hybrid Agent

Imagine a scenario where a user asks: "What is the best time to book a flight to Paris if I have $1,000, and what's the weather likely to be?"

The agent works as follows:

  1. Plan: The model identifies two sub-tasks: checking weather (external data) and budgeting (logical calculation).
  2. Action 1: It triggers the `get_weather("Paris")` function.
  3. Action 2: It executes a Python script to determine if $1,000 covers typical flight prices based on historical data provided in the context.
  4. Observation: The model receives the JSON from the function and the output from the Python sandbox.
  5. Final Answer: It synthesizes both pieces of information into a coherent response: "It is currently 20°C and sunny in Paris. With your budget of $1,000, you can secure a mid-range ticket departing on Tuesday."

Best Practices for Robust Agents

  • Clear Descriptions: Your function docstrings are the LLM's primary source of truth. Be explicit about parameter types and expected outcomes.
  • Error Handling: Always catch exceptions within your function callbacks. Return a structured error message to the LLM so it can retry or inform the user.
  • Limit Sandbox Complexity: While Gemini's code execution is powerful, keep the generated code simple to ensure faster execution times and easier debugging.

Conclusion

By leveraging the Gemini API's function calling and code execution tools, developers move beyond static chatbots into the realm of autonomous agents. These agents can perceive their environment through external APIs and reason through complex problems via sandboxed code. As these capabilities mature, the ability to orchestrate such multi-step, tool-using workflows will become a standard requirement for enterprise-grade AI applications. Start small, define clear tools, and let the model handle the orchestration.

Share:
Related Posts