Gemini Tool Integration Basics

Introduction & Goals

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.

How Gemini Uses Tools Through Function Calling

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: You define your tool functions in Python and describe them using OpenAPI-style schemas. You register these tools with Gemini, providing both the function and its schema. When a user sends a request, Gemini analyzes the input and determines if any registered tools are needed. If Gemini decides a tool is required, it generates a function call request with the tool name and specific parameters. Your system receives this request, executes the corresponding Python function with the provided parameters, and returns the result to Gemini. 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.

Writing Python Tool Functions

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. Python def sum_numbers(a: float, b: float) -> float: """ Sum two numbers and return the result. Args: a (float): First number to add b (float): Second number to add Returns: float: The sum of a and b """ return a + b 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.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Organizing Multiple Schemas in JSON Format

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:

JSON

[
  {
    "name": "sum_numbers",
    "description": "Sum two numbers and return the result.",
    "parameters": {
      "type": "object",
      "properties": {
        "a": {
          "type": "number",
          "description": "First number to add"
        },
        "b": {
          "type": "number",
          "description": "Second number to add"
        }
      },
      "required": ["a", "b"]
    }
  },
  {
    "name": "multiply_numbers",
    "description": "Multiply two numbers and return the result.",
    "parameters": {
      "type": "object",
      "properties": {
        "a": {
          "type": "number",
          "description": "First number to multiply"
        },
        "b": {
          "type": "number",
          "description": "Second number to multiply"
        }
      },
      "required": ["a", "b"]
    }
  }
]

[
  {
    "name": "sum_numbers",
    "description": "Sum two numbers and return the result.",
    "parameters": {
      "type": "object",
      "properties": {
        "a": {
          "type": "number",
          "description": "First number to add"
        },
        "b": {
          "type": "number",
          "description": "Second number to add"
        }
      },
      "required": ["a", "b"]
    }
  },
  {
    "name": "multiply_numbers",
    "description": "Multiply two numbers and return the result.",
    "parameters": {
      "type": "object",
      "properties": {
        "a": {
          "type": "number",
          "description": "First number to multiply"
        },
        "b": {
          "type": "number",
          "description": "Second number to multiply"
        }
      },
      "required": ["a", "b"]
    }
  }
]

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.

Function-to-Schema Mapping

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.

Python

import json
from functions import sum_numbers, multiply_numbers

# Load the schemas from your JSON file
with open('schemas.json', 'r') as f:
    tool_schemas = json.load(f)

# Create a dictionary mapping tool names to functions
tools = {
    "sum_numbers": sum_numbers,
    "multiply_numbers": multiply_numbers
}

import json
from functions import sum_numbers, multiply_numbers

# Load the schemas from your JSON file
with open('schemas.json', 'r') as f:
    tool_schemas = json.load(f)

# Create a dictionary mapping tool names to functions
tools = {
    "sum_numbers": sum_numbers,
    "multiply_numbers": multiply_numbers
}

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:

Gemini references the tool_schemas to understand available tools.
Gemini sends you a tool use request for "sum_numbers" with the parameters.
You look up "sum_numbers" in your tools dictionary.
You execute tools["sum_numbers"](10, 5), which calls your actual sum_numbers function.
You return the result back to Gemini.

Gemini only sees the tool_schemas, while the tools dictionary is your internal system for translating Gemini's requests into actual function calls.

Verifying Your Tool Schemas

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

Python

# Print the loaded tool schemas in a readable JSON format
print(json.dumps(tool_schemas, indent=2))

# Print the loaded tool schemas in a readable JSON format
print(json.dumps(tool_schemas, indent=2))

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

text

[
  {
    "name": "sum_numbers",
    "description": "Sum two numbers and return the result.",
    "parameters": {
      "type": "object",
      "properties": {
        "a": {
          "type": "number",
          "description": "First number to add"
        },
        "b": {
          "type": "number",
          "description": "Second number to add"
        }
      },
      "required": [
        "a",
        "b"
      ]
    }
  },
  {
    "name": "multiply_numbers",
    "description": "Multiply two numbers and return the result.",
    "parameters": {
      "type": "object",
      "properties": {
        "a": {
          "type": "number",
          "description": "First number to multiply"
        },
        "b": {
          "type": "number",
          "description": "Second number to multiply"
        }
      },
      "required": [
        "a",
        "b"
      ]
    }
  }
]

[
  {
    "name": "sum_numbers",
    "description": "Sum two numbers and return the result.",
    "parameters": {
      "type": "object",
      "properties": {
        "a": {
          "type": "number",
          "description": "First number to add"
        },
        "b": {
          "type": "number",
          "description": "Second number to add"
        }
      },
      "required": [
        "a",
        "b"
      ]
    }
  },
  {
    "name": "multiply_numbers",
    "description": "Multiply two numbers and return the result.",
    "parameters": {
      "type": "object",
      "properties": {
        "a": {
          "type": "number",
          "description": "First number to multiply"
        },
        "b": {
          "type": "number",
          "description": "Second number to multiply"
        }
      },
      "required": [
        "a",
        "b"
      ]
    }
  }
]

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.

Introduction & Goals

How Gemini Uses Tools Through Function Calling

Writing Python Tool Functions

Join the 1M+ learners on CodeSignal

Creating OpenAPI Schemas for Single Functions

Building Multiple Tool Schemas

Organizing Multiple Schemas in JSON Format

Function-to-Schema Mapping

Verifying Your Tool Schemas

Testing Your Function Mapping

Summary & Next Steps