Welcome to your first lesson in developing Gemini agents with tool integration! In this lesson, you'll learn the foundational skills needed to prepare function schemas that enable Gemini to understand and request the use of your custom tools through a process called function calling.

By the end of this lesson, you'll understand how to write Python functions and create OpenAPI-style schemas that describe these functions to Gemini. These schemas act as a bridge, allowing Gemini to understand what your functions do and how to call them, even though Gemini never sees your actual Python code. This foundational step is essential before you can build a complete Gemini agent system that can execute tools and use their results.

Function calling is the mechanism that allows Gemini to use external tools and capabilities beyond text generation. Gemini supports tool integration by allowing you to register functions (tools) with the agent, along with their schemas. Here’s how the process works:

1. You define your tool functions in Python and describe them using OpenAPI-style schemas.
2. You register these tools with Gemini, providing both the function and its schema.
3. When a user sends a request, Gemini analyzes the input and determines if any registered tools are needed.
4. If Gemini decides a tool is required, it generates a function call request with the tool name and specific parameters.
5. Your system receives this request, executes the corresponding Python function with the provided parameters, and returns the result to Gemini.
6. Gemini incorporates the result into its response to the user or may decide to use additional tools if needed.

The key insight is that Gemini only sees the schemas (OpenAPI-style descriptions), never your actual Python code. The schemas must contain all the information Gemini needs to understand what each tool does and how to use it correctly. This separation means you can organize your Python functions however you like — Gemini relies entirely on the schema descriptions to make decisions about tool usage.

When creating tool functions for Gemini agents, your Python functions serve two purposes: they contain the actual logic that will be executed, and they provide the foundation for creating accurate schemas. While Gemini never sees these functions directly, writing them clearly helps you create better schema descriptions.

This function includes type hints (a: float, b: float, -> float) and a detailed docstring that describes the function's purpose, parameters, and return value. These elements help you create accurate schemas, but remember — Gemini will only see the schema you create, not this Python code. The type hints and docstring are for your benefit when translating the function into a schema that Gemini can understand.

Gemini uses OpenAPI-style schemas to describe tools. These schemas tell Gemini exactly what each tool does and how to use it. The schema includes the function name, a description, and a specification of the parameters and their types.

Here’s an example schema for the sum_numbers function, formatted for Gemini:

Each schema contains several essential components that Gemini uses to understand your tool:

• The name field identifies the tool and should be descriptive to help Gemini understand what the tool does and when to use it. While it doesn't necessarily need to match your Python function name, keeping them consistent helps maintain clarity in your code.
• The description tells Gemini what the tool does and when to use it.
• The parameters section describes the parameters using JSON Schema format, where each property represents a function parameter with its data type and description.
• The required array lists which parameters are mandatory.

Gemini uses this schema information to decide when to use your tool and what parameters to provide. If the descriptions are unclear or incomplete, Gemini may use the tool incorrectly or not at all.

Real Gemini agents typically have access to multiple tools, each described by its own schema. Let’s create a second function and organize our functions in a dedicated file. In your functions.py file, you can collect your tool functions:

Organizing your functions in a separate file keeps your code organized and makes it easy to import them when needed. Each function follows the same pattern with clear type hints and detailed docstrings, providing consistency across your tool collection.

Just as you organize your Python functions in functions.py, you can organize your corresponding schemas in a schemas.json file. This creates a clean separation between your implementation and the descriptions that Gemini will see:

When Gemini receives this array of schemas, it can analyze user requests and select the most appropriate tool. For example, if a user asks, "What's 5 plus 3?", Gemini would choose sum_numbers. If they ask, "What's 4 times 7?", Gemini would choose multiply_numbers. The clear descriptions in each schema help Gemini make these decisions accurately.

After organizing your functions in functions.py and schemas in schemas.json, you need to load both and create a mapping that connects them. This creates two essential components: the schemas that you provide to Gemini, and the mapping that you use to execute functions when Gemini requests them.

The tool_schemas variable contains the JSON array that you'll register with Gemini — this is how Gemini learns about your available tools and their capabilities. The tools dictionary is your internal mapping that you use to execute the correct Python function when Gemini requests a tool by name.

This mapping must be precise — the keys in your tools dictionary must exactly match the name fields in your schemas. If there's a mismatch, your system won't be able to execute the function when Gemini requests it.

For example, when Gemini analyzes a user request and decides to use the "sum_numbers" tool with parameters {"a": 10, "b": 5}, the process works like this:

1. Gemini references the tool_schemas to understand available tools.
2. Gemini sends you a tool use request for "sum_numbers" with the parameters.
3. You look up in your dictionary.

Before using your tool schemas with Gemini, it's important to verify they're structured correctly and contain all necessary information:

This displays your tool definitions in a formatted way, allowing you to review each schema's structure:

Review this output to ensure your schemas have clear descriptions, correct parameter types, and complete required field lists. These details are crucial since Gemini depends entirely on this schema information to use your tools correctly.

With your schemas verified and mapping in place, you can test that your system can successfully execute tools based on their names:

Running this code produces:

This confirms your function mapping works correctly and your system can execute tools by name. When Gemini requests tool usage through function calling, you'll receive the tool name and parameters from Gemini, then use this mapping to look up and call the corresponding Python function yourself before sending the result back to Gemini.

You've now learned the essential process of preparing tools for Gemini agents through function calling. This involves writing well-structured Python functions, creating detailed OpenAPI-style schemas that describe these functions to Gemini, and setting up a mapping system that connects schema names to actual function implementations.

Remember the key separation: Gemini only sees the schemas and uses them to make tool selection decisions and provide parameters. Your Python functions and mapping system handle the actual execution. The quality of your schemas directly impacts how effectively Gemini can use your tools.

In the upcoming practice exercises, you'll apply these concepts to create your own tool functions and schemas, building toward the point where you can integrate these prepared tools with Gemini for powerful agent capabilities.