# How to Implement Function Calling with Gemini Interactions API: A Complete Guide

> Learn how to implement function calling with the Gemini Interactions API and the google/skills repository. This guide explains how models invoke Python functions via tools configuration.

- Repository: [Google/skills](https://github.com/google/skills)
- Tags: how-to-guide
- Published: 2026-06-11

---

**The Gemini Interactions API enables models to invoke Python functions by passing them as `tools` in `GenerateContentConfig`, then executing any `function_calls` returned in the response.**

Function calling bridges the gap between static model knowledge and real-time data. In the `google/skills` repository, the Gemini Interactions API provides a structured way to expose Python callables to the model, allowing it to request specific computations or external data lookups during a conversation.

## Understanding the Gemini Function Calling Architecture

The function calling flow involves four distinct stages: client initialization, tool registration, model inference, and execution dispatch.

### The Client-Model-Tool Flow

1. **Client Initialization** – You instantiate `genai.Client()` and configure the request with `types.GenerateContentConfig`.
2. **Tool Registration** – Python functions are passed to the `tools` parameter, making them available for the model to invoke.
3. **Model Inference** – When the model determines it needs external data, it returns a `function_calls` object instead of text.
4. **Execution Dispatch** – Your application inspects `response.function_calls`, executes the matching Python function, and optionally returns results to the model for further processing.

According to the reference implementation in [`skills/cloud/gemini-api/references/structured_and_tools.md`](https://github.com/google/skills/blob/main/skills/cloud/gemini-api/references/structured_and_tools.md), the core components enabling this flow are:

| Component | Role |
|-----------|------|
| `types.GenerateContentConfig(tools=[callable])` | Registers Python callables that the model may invoke. |
| `response.function_calls` | Contains function call requests when the model requires tool execution. |
| `function_call.name` & `function_call.args` | Identify the specific function and parameters for execution. |

## Step-by-Step Implementation Guide

### Define Your Python Function

Create a function with type hints and docstrings. The Gemini Interactions API inspects the signature to generate the tool schema automatically.

```python
def get_current_weather(location: str) -> str:
    """Return a mock weather condition for the supplied location."""
    if "boston" in location.lower():
        return "Snowing"
    return "Sunny"

```

### Configure the Gemini Client with Tools

Pass your function to the `tools` parameter in `GenerateContentConfig`. As shown in the `google/skills` repository examples, this registration happens at request time.

```python
from google import genai
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="What is the weather like in Boston?",
    config=types.GenerateContentConfig(tools=[get_current_weather]),
)

```

### Handle Function Calls in the Response

Inspect `response.function_calls` to determine if the model requested tool execution. The API does **not** execute functions automatically—you maintain full control over dispatching.

```python
if response.function_calls:
    for fc in response.function_calls:
        print(f"Model wants to call {fc.name} with args {dict(fc.args)}")
        # Dispatch to the real function using the name and arguments

        result = globals()[fc.name](**fc.args)
        print("Result:", result)
else:
    print("Model answered directly:", response.text)

```

### Feed Results Back to the Model (Optional)

For refined answers that incorporate function output, make a follow-up request including the execution results.

```python
follow_up = client.models.generate_content(
    model="gemini-3.5-flash",
    contents=f"The weather in Boston is {result}. Explain why this matters for outdoor events.",
)
print(follow_up.text)

```

## Complete Code Examples

### Minimal Function Calling Example

This self-contained example demonstrates the basic pattern from the [`structured_and_tools.md`](https://github.com/google/skills/blob/main/structured_and_tools.md) reference file (lines 32-64):

```python
from google import genai
from google.genai import types

def get_current_weather(location: str) -> str:
    """Simple mock weather lookup."""
    return "Snowing" if "boston" in location.lower() else "Sunny"

client = genai.Client()
resp = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="What is the weather like in Boston?",
    config=types.GenerateContentConfig(tools=[get_current_weather]),
)

if resp.function_calls:
    for fc in resp.function_calls:
        # Call the real Python function with unpacked arguments

        result = globals()[fc.name](**fc.args)
        print(f"Function {fc.name} returned: {result}")
else:
    print("Model response:", resp.text)

```

### Full Round-Trip with Follow-Up Request

This example shows the complete workflow: initial request, function execution, and result incorporation:

```python

# 1. Initial request allowing function calls

initial = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Is it raining in Boston right now?",
    config=types.GenerateContentConfig(tools=[get_current_weather]),
)

# 2. Execute requested functions

if initial.function_calls:
    for fc in initial.function_calls:
        weather = globals()[fc.name](**fc.args)
        
        # 3. Send results back for contextualized response

        follow_up = client.models.generate_content(
            model="gemini-3.5-flash",
            contents=f"The weather is {weather}. Explain how this impacts outdoor activities today.",
        )
        print("Gemini says:", follow_up.text)

```

## Key Implementation Details

**Tool Registration** (`tools=[callable]`) exposes any Python callable to the model. The API automatically generates JSON schemas from type hints and docstrings, enabling natural-language argument extraction.

**Argument Conversion** happens automatically—the model returns arguments as JSON-compatible values that you can unpack directly into your function using `**fc.args`.

**Security Considerations** remain your responsibility. The Gemini Interactions API only *requests* function calls; it does **not** execute arbitrary code. Validate all function names and sanitize arguments before execution.

**Source References**:
- Authoritative reference: [`skills/cloud/gemini-api/references/structured_and_tools.md`](https://github.com/google/skills/blob/main/skills/cloud/gemini-api/references/structured_and_tools.md)
- Basic client example: [`skills/cloud/agent-platform-inference/scripts/gemini_vertexai_sdk.py`](https://github.com/google/skills/blob/main/skills/cloud/agent-platform-inference/scripts/gemini_vertexai_sdk.py)

## Summary

- **Register functions** by passing Python callables to `types.GenerateContentConfig(tools=[...])` when calling `client.models.generate_content`.
- **Check for function calls** by inspecting `response.function_calls`—the model returns these instead of text when it needs external data.
- **Execute manually** using `function_call.name` and `function_call.args`; the API never executes code automatically.
- **Chain interactions** by feeding function results back into subsequent `generate_content` calls for contextualized responses.
- **Install requirements** with `pip install google-genai` to access the `google.genai` client library.

## Frequently Asked Questions

### What is the Gemini Interactions API?

The Gemini Interactions API is part of the Vertex AI Gemini client library (`google-genai`) that allows developers to extend model capabilities through external tools. It enables the model to request execution of Python functions during inference, bridging the gap between static training data and real-time information.

### How do I register multiple functions with the API?

Pass a list of callables to the `tools` parameter: `config=types.GenerateContentConfig(tools=[get_weather, get_stock_price, calculate_sum])`. The model examines all available functions and selects the appropriate one based on the user's prompt context.

### Is function execution automatic or manual?

Execution is **manual**. When the model returns `function_calls`, your application must dispatch the execution using the provided name and arguments. The API does not execute arbitrary code—you maintain full control over which functions run and how they handle data.

### Where can I find the official reference implementation?

The canonical reference lives in [`skills/cloud/gemini-api/references/structured_and_tools.md`](https://github.com/google/skills/blob/main/skills/cloud/gemini-api/references/structured_and_tools.md) within the `google/skills` repository. This file contains detailed specifications for function calling, structured output, and tool configuration. For basic client setup patterns, see [`skills/cloud/agent-platform-inference/scripts/gemini_vertexai_sdk.py`](https://github.com/google/skills/blob/main/skills/cloud/agent-platform-inference/scripts/gemini_vertexai_sdk.py).