Llamada a funciones

Copyright 2026 Google LLC.

# @title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

La llamada a funciones permite a los desarrolladores crear una descripción de una función en su código y luego pasar esa descripción a un modelo de lenguaje en una solicitud. La respuesta del modelo incluye el nombre de una función que coincide con la descripción y los argumentos para llamarla. La llamada a funciones te permite usar funciones como herramientas en aplicaciones de IA generativa, y puedes definir más de una función en una sola solicitud.

Este notebook proporciona ejemplos de código para ayudarte a empezar. El inicio rápido de la documentación también es un buen lugar para empezar a entender la llamada a funciones.

Nota: Este notebook usa la API de interacciones, la forma más reciente de interactuar con los modelos Gemini. ¿Buscas la versión generateContent? Consulta la rama de archivo.

Configuración

Instalar dependencias

%pip install -U -q "google-genai>=2.9.0"  # 2.0 for Interactions API

Note: you may need to restart the kernel to use updated packages.

Configurar tu clave de API

Para ejecutar la siguiente celda, tu clave de API debe estar almacenada en un Secreto de Colab llamado GEMINI_API_KEY. Si aún no tienes una clave de API o no sabes cómo crear un Secreto de Colab, consulta Autenticación para ver un tutorial.

from google import genai
from google.colab import userdata

GEMINI_API_KEY = userdata.get("GEMINI_API_KEY")
client = genai.Client(api_key=GEMINI_API_KEY)

Elegir un modelo

La llamada a funciones funciona en todos los modelos Gemini.

MODEL_ID = "gemini-3.7-flash" # @param ["gemini-3.1-pro-preview", "gemini-3.7-flash", "gemini-3.5-flash-lite", "gemini-2.5-pro"] {"allow-input":true, isTemplate: true}

Configurar funciones como herramientas

Para usar la llamada a funciones, pasa una lista de funciones al parámetro tools al crear una interacción. Con la API de interacciones, las herramientas se declaran como diccionarios. El SDK también puede generar automáticamente esquemas de herramientas a partir de funciones de Python.

def enable_lights():
    """Turn on the lighting system."""
    print("LIGHTBOT: Lights enabled.")


def set_light_color(rgb_hex: str):
    """Set the light color. Lights must be enabled for this to work."""
    print(f"LIGHTBOT: Lights set to {rgb_hex}.")

def stop_lights():
    """Stop flashing lights."""
    print("LIGHTBOT: Lights turned off.")

# Map function names to callables for execution
light_functions = {
    "enable_lights": enable_lights,
    "set_light_color": set_light_color,
    "stop_lights": stop_lights,
}

# For interactions.create, tools must be declared as dicts
light_controls = [
    {
        "type": "function",
        "name": "enable_lights",
        "description": "Turn on the lighting system.",
        "parameters": {"type": "object", "properties": {}},
    },
    {
        "type": "function",
        "name": "set_light_color",
        "description": "Set the light color. Lights must be enabled for this to work.",
        "parameters": {
            "type": "object",
            "properties": {
                "rgb_hex": {"type": "string", "description": "The color as an RGB hex string"}
            },
            "required": ["rgb_hex"],
        },
    },
    {
        "type": "function",
        "name": "stop_lights",
        "description": "Stop flashing lights.",
        "parameters": {"type": "object", "properties": {}},
    },
]

instruction = """
  You are a helpful lighting system bot. You can turn
  lights on and off, and you can set the color. Do not perform any
  other tasks.
"""

Llamada a funciones básica con múltiples turnos

Las llamadas a funciones encajan naturalmente en conversaciones de múltiples turnos. Con la API de interacciones, el modelo devuelve salidas function_call que tú manejas y a las que respondes usando entradas function_result.

Nota: La llamada a funciones automática (donde el SDK llama a tus funciones automáticamente) es una característica de client.chats.create. Con interactions.create, tú manejas las llamadas a funciones manualmente, lo que te da más control.

La respuesta de interactions.create contiene una lista de steps. Para respuestas de texto, accede a la salida a través de interaction.steps[-1].content[0].text.

# First turn: ask the model, providing tool declarations
interaction = client.interactions.create(
    model=MODEL_ID,
    input="It's awful dark in here...",
    system_instruction=instruction,
    tools=light_controls,
)

# Check if the model wants to call a function
for step in interaction.steps:
    if step.type == "function_call":
        print(f"Model wants to call: {step.name}({step.arguments})")
        fn = light_functions[step.name]
        result = fn(**step.arguments) if step.arguments else fn() if step.arguments else fn()

Model wants to call: enable_lights({})
LIGHTBOT: Lights enabled.

Examinar las llamadas a funciones y el historial de ejecución

Con la API de interacciones, el estado de la conversación se gestiona en el servidor a través de previous_interaction_id. Cada objeto de interacción contiene las salidas de ese turno, que pueden incluir llamadas a funciones, resultados de funciones o respuestas de texto.

from IPython.display import Markdown, display

# Show the outputs of the last interaction
for step in interaction.steps:
    print(f"Type: {step.type}")
    if hasattr(step, 'content') and step.content and step.content[0].text:
        print(f"Text: {step.content[0].text}")

Type: thought
Type: function_call

Este historial muestra el flujo:

1. Usuario: Envía el mensaje.

2. Modelo: Responde no con texto, sino con una FunctionCall solicitando enable_lights.

3. Usuario (SDK): El ChatSession ejecuta automáticamente enable_lights() porque automatic_function_calling está habilitado. Envía el resultado de vuelta como una FunctionResponse.

4. Modelo: Usa el resultado de la función ("Luces habilitadas.") para formular la respuesta de texto final.

Ejecución automática de funciones (solo client.chats)

El ChatSession en el SDK de Python (es decir, client.chats.create) tiene una potente característica llamada Ejecución Automática de Funciones. Cuando está habilitada (que lo está por defecto), si el modelo responde con una FunctionCall, el SDK hará lo siguiente:

1. Encontrar la función de Python correspondiente en el tools proporcionado.

2. Ejecutar la función con los argumentos proporcionados por el modelo.

3. Enviar el valor de retorno de la función de vuelta al modelo en una FunctionResponse.

4. Devolver solo la respuesta final del modelo (normalmente texto) a tu código.

Esto simplifica significativamente el flujo de trabajo para casos de uso comunes.

Nota: La ejecución automática de funciones solo está disponible con client.chats.create (que usa generateContent internamente). Con la API de interacciones (client.interactions.create), tú manejas las llamadas a funciones manualmente; consulta Llamada a funciones manual a continuación.

Ejemplo: Operaciones matemáticas

from google.genai import types

def add(a: float, b: float):
    """returns a + b."""
    print(f"  >> add({a}, {b})")
    return a + b

def subtract(a: float, b: float):
    """returns a - b."""
    print(f"  >> subtract({a}, {b})")
    return a - b

def multiply(a: float, b: float):
    """returns a * b."""
    print(f"  >> multiply({a}, {b})")
    return a * b

def divide(a: float, b: float):
    """returns a / b."""
    print(f"  >> divide({a}, {b})")
    if b == 0:
        return "Cannot divide by zero."
    return a / b

operation_tools = [add, subtract, multiply, divide]

chat = client.chats.create(
    model=MODEL_ID,
    config={
        "tools": operation_tools,
        "automatic_function_calling": {"disable": False},  # Enabled by default
    },
)

response = chat.send_message(
    "I have 57 cats, each owns 44 mittens, how many mittens is that in total?"
)

print(response.text)

That is a total of 2,508 mittens.

# Print interaction outputs summary
for step in interaction.steps:
    print(f"Type: {step.type}", end="")
    if step.type == "model_output":
        print(f" | {step.content[0].text[:100]}")
    elif step.type == "function_call":
        print(f" | {step.name}({step.arguments})")
    else:
        print()

Type: thought
Type: function_call | enable_lights({})

La ejecución automática manejó la llamada multiply sin problemas.

Declaración automática del esquema de funciones

Una conveniencia clave del SDK de Python es su capacidad para generar automáticamente el esquema FunctionDeclaration requerido a partir de tus funciones de Python. Inspecciona:

• Nombre de la función: (func.__name__)

• Docstring: Se usa para la descripción de la función.

• Parámetros: Nombres y anotaciones de tipo (int, str, float, bool, list, dict). Los docstrings para los parámetros (si se usan formatos específicos como el estilo de Google) también pueden mejorar la descripción.

• Anotación del tipo de retorno: Aunque el modelo no la usa estrictamente para decidir qué función llamar, es una buena práctica.

Generalmente, no necesitas crear objetos FunctionDeclaration manualmente cuando usas funciones de Python directamente como herramientas.

Sin embargo, puedes generar el esquema explícitamente usando genai.types.FunctionDeclaration.from_callable si necesitas inspeccionarlo, modificarlo o usarlo en escenarios donde no tienes el objeto de función de Python disponible.

Usa .to_json_dict() para obtener la representación JSON; este es el formato que pasas como herramientas cuando usas client.interactions.create:

import json

set_color_declaration = types.FunctionDeclaration.from_callable(
    callable = set_light_color,
    client = client
)

print(json.dumps(set_color_declaration.to_json_dict(), indent=4))

{
    "description": "Set the light color. Lights must be enabled for this to work.",
    "name": "set_light_color",
    "parameters": {
        "properties": {
            "rgb_hex": {
                "type": "STRING"
            }
        },
        "required": [
            "rgb_hex"
        ],
        "type": "OBJECT"
    }
}

Llamada a funciones manual

Con la API de interacciones (client.interactions.create), la llamada a funciones siempre es manual: recibes solicitudes de llamada a funciones del modelo y las manejas tú mismo. Esto te da control total sobre la ejecución, el manejo de errores y la validación.

En lugar de sesiones de chat, la API de interacciones usa previous_interaction_id para encadenar solicitudes, manteniendo el contexto de la conversación a lo largo de los turnos.

El flujo de trabajo manual funciona de la siguiente manera:

1. Envía un prompt con declaraciones de herramientas a client.interactions.create.
2. Verifica las entradas steps de la respuesta en busca de entradas function_call.
3. Ejecuta las funciones correspondientes localmente.
4. Envía los resultados de vuelta usando previous_interaction_id para continuar la conversación.

Este también sería el caso si usas un Chat con "automatic_function_calling": {"disable": True}.

Ejemplo: Películas

El siguiente ejemplo es un equivalente aproximado del ejemplo de curl de llamada a funciones de un solo turno en Python. Usa funciones que devuelven información (simulada) sobre el tiempo de reproducción de películas, posiblemente de una API hipotética:

def find_movies(description: str, location: str):
    """find movie titles currently playing in theaters."""
    return ["Barbie", "Oppenheimer"]


def find_theaters(location: str, movie: str):
    """Find theaters showing a movie in a location."""
    return ["Googleplex 16", "Android Theatre"]


def get_showtimes(location: str, movie: str, theater: str, date: str):
    """Find the start times for movies playing in a specific theater."""
    return ["10:00", "11:00"]

# Map function names to callables
available_functions = {
    "find_movies": find_movies,
    "find_theaters": find_theaters,
    "get_showtimes": get_showtimes,
}

# Dict-based tool declarations for interactions.create
theater_functions = [
    {"type": "function", "name": "find_movies",
     "description": "find movie titles currently playing in theaters based on any description, genre, title words, etc.",
     "parameters": {"type": "object", "properties": {
         "description": {"type": "string", "description": "Any kind of description including category or genre"},
         "location": {"type": "string", "description": "The city and state, e.g. San Francisco, CA"}
     }, "required": ["description", "location"]}},
    {"type": "function", "name": "find_theaters",
     "description": "Find theaters based on location and movie title.",
     "parameters": {"type": "object", "properties": {
         "location": {"type": "string"}, "movie": {"type": "string"}
     }, "required": ["location", "movie"]}},
    {"type": "function", "name": "get_showtimes",
     "description": "Find the start times for movies playing in a specific theater.",
     "parameters": {"type": "object", "properties": {
         "location": {"type": "string"}, "movie": {"type": "string"},
         "theater": {"type": "string"}, "date": {"type": "string"}
     }, "required": ["location", "movie", "theater", "date"]}},
]

Después de usar interactions.create() para hacer una pregunta, el modelo solicita una function_call:

interaction = client.interactions.create(
    model=MODEL_ID,
    input="Which theaters in Mountain View, CA show the Barbie movie?",
    tools=theater_functions,
)

# Find the function call in the outputs
for step in interaction.steps:
    if step.type == "function_call":
        print(f"Function call: {step.name}")
        print(f"Arguments: {step.arguments}")
        function_call_step = step
        break

Function call: find_theaters
Arguments: {'movie': 'Barbie', 'location': 'Mountain View, CA'}

Dado que esto no usa un ChatSession con llamada a funciones automática, tienes que llamar a la función tú mismo.

Una forma muy sencilla de hacerlo sería con sentencias if:

if function_call.name == 'find_theaters':
  find_theaters(**function_call.args)
elif ...

Sin embargo, dado que ya hiciste la lista theater_functions, esto se puede simplificar a:

def call_function(function_call_output, functions):
    function_name = function_call_output.name
    function_args = function_call_output.arguments
    return functions[function_name](**function_args)

result = call_function(function_call_step, available_functions)
print(result)

['Googleplex 16', 'Android Theatre']

Finalmente, pasa el resultado de la función de vuelta usando previous_interaction_id para continuar la conversación y obtener una respuesta de texto final del modelo.

# Send the function result back to the model
interaction_2 = client.interactions.create(
    model=MODEL_ID,
    previous_interaction_id=interaction.id,
    input={
        "type": "function_result",
        "name": function_call_step.name,
        "call_id": function_call_step.id,
        "result": str(result),
    },
    tools=theater_functions,
)

# Get the final text response
text_outputs = [o for o in interaction_2.steps if o.type == "text"]
if text_outputs:
    print(text_outputs[-1].text)

Esto demuestra el flujo de trabajo manual: llamar, verificar, ejecutar, responder, llamar de nuevo.

Llamadas a funciones paralelas

La API de Gemini puede llamar a varias funciones en un solo turno. Esto se adapta a escenarios en los que hay varias llamadas a funciones que pueden realizarse de forma independiente para completar una tarea.

Primero, configura las herramientas. A diferencia del ejemplo de la película anterior, estas funciones no requieren entrada entre sí para ser llamadas, por lo que deberían ser buenas candidatas para llamadas paralelas.

def power_disco_ball(power: bool) -> bool:
    """Powers the spinning disco ball."""
    print(f"Disco ball is {'spinning!' if power else 'stopped.'}")
    return True

def start_music(energetic: bool, loud: bool, bpm: int) -> str:
    """Play some music matching the specified parameters."""
    print(f"Starting music! {energetic=} {loud=}, {bpm=}")
    return "Never gonna give you up."

def dim_lights(brightness: float) -> bool:
    """Dim the lights."""
    print(f"Lights are now set to {brightness:.0%}")
    return True

house_functions = {
    "power_disco_ball": power_disco_ball,
    "start_music": start_music,
    "dim_lights": dim_lights,
}

house_fns = [
    {"type": "function", "name": "power_disco_ball", "description": "Powers the spinning disco ball.",
     "parameters": {"type": "object", "properties": {"power": {"type": "boolean"}}, "required": ["power"]}},
    {"type": "function", "name": "start_music", "description": "Play some music matching the specified parameters.",
     "parameters": {"type": "object", "properties": {
         "energetic": {"type": "boolean"}, "loud": {"type": "boolean"}, "bpm": {"type": "integer"}
     }, "required": ["energetic", "loud", "bpm"]}},
    {"type": "function", "name": "dim_lights", "description": "Dim the lights.",
     "parameters": {"type": "object", "properties": {"brightness": {"type": "number"}}, "required": ["brightness"]}},
]

Ahora llama al modelo con una instrucción que podría usar todas las herramientas especificadas.

# Use "any" mode via tool_config is not yet supported in Interactions API.
# Instead, we make a direct call and handle functions manually.
interaction = client.interactions.create(
    model=MODEL_ID,
    input="Turn this place into a party!",
    tools=house_fns,
)

prev_id = interaction.id
while any(s.type == "function_call" for s in interaction.steps):
    results = []
    for step in interaction.steps:
        if step.type == "function_call":
            print(f"Calling: {step.name}({step.arguments})")
            fn = house_functions[step.name]
            result = fn(**step.arguments) if step.arguments else fn() if step.arguments else fn()
            results.append({
                "type": "function_result",
                "name": step.name,
                "call_id": step.id,
                "result": str(result),
            })
    interaction = client.interactions.create(
        model=MODEL_ID,
        input=results,
        previous_interaction_id=prev_id,
        tools=house_fns,
    )
    prev_id = interaction.id

for step in interaction.steps:
    if step.type == "model_output":
        print(f"\nModel: {step.content[0].text}")

Calling: dim_lights({'brightness': 0.3})
Lights are now set to 30%
Calling: start_music({'bpm': 128, 'loud': True, 'energetic': True})
Starting music! energetic=True loud=True, bpm=128
Calling: power_disco_ball({'power': True})
Disco ball is spinning!

Model: OK! The lights are dimmed, the disco ball is spinning, and the music is cranking! Let's get this party started!

Observa que el turno del modelo contiene tres partes de FunctionCall, que el SDK ejecutó antes de obtener la respuesta de texto final.

Llamada a funciones composicional

El modelo puede encadenar llamadas a funciones en varios turnos, usando el resultado de una llamada para informar la siguiente. Esto permite un razonamiento complejo de varios pasos y la finalización de tareas.

Ejemplo: Encontrar horarios específicos de películas

Reutilicemos las funciones de teatro y hagamos una consulta más compleja que requiera encontrar películas primero, luego potencialmente teatros y luego horarios.

interaction = client.interactions.create(
    model=MODEL_ID,
    input="""
    Find comedy movies playing in Mountain View, CA on 01/01/2025.
    First, find the movie titles.
    Then, find the theaters showing those movies.
    Finally, find the showtimes for each movie at each theater.
""",
    tools=theater_functions,
)

prev_id = interaction.id
while any(s.type == "function_call" for s in interaction.steps):
    results = []
    for step in interaction.steps:
        if step.type == "function_call":
            print(f"Calling: {step.name}({step.arguments})")
            fn = available_functions[step.name]
            result = fn(**step.arguments) if step.arguments else fn()
            results.append({
                "type": "function_result",
                "name": step.name,
                "call_id": step.id,
                "result": str(result),
            })
    interaction = client.interactions.create(
        model=MODEL_ID,
        input=results,
        previous_interaction_id=prev_id,
        tools=theater_functions,
    )
    prev_id = interaction.id

for step in interaction.steps:
    if step.type == "model_output":
        print(step.content[0].text)

Calling: find_movies({'description': 'comedy', 'location': 'Mountain View, CA'})
Calling: find_theaters({'location': 'Mountain View, CA', 'movie': 'Barbie'})
Calling: find_theaters({'location': 'Mountain View, CA', 'movie': 'Oppenheimer'})
Calling: get_showtimes({'location': 'Mountain View, CA', 'date': '2025-01-01', 'theater': 'Googleplex 16', 'movie': 'Barbie'})
Calling: get_showtimes({'date': '2025-01-01', 'theater': 'Android Theatre', 'movie': 'Barbie', 'location': 'Mountain View, CA'})
Calling: get_showtimes({'date': '2025-01-01', 'movie': 'Oppenheimer', 'theater': 'Googleplex 16', 'location': 'Mountain View, CA'})
Calling: get_showtimes({'location': 'Mountain View, CA', 'date': '2025-01-01', 'theater': 'Android Theatre', 'movie': 'Oppenheimer'})
OK. On January 1, 2025, the comedy movies playing in Mountain View, CA are "Barbie" and "Oppenheimer". Both are showing at the Googleplex 16 and the Android Theatre. Here are the showtimes:

*   **Barbie**
    *   **Googleplex 16:** 10:00 AM, 11:00 AM
    *   **Android Theatre:** 10:00 AM, 11:00 AM
*   **Oppenheimer**
    *   **Googleplex 16:** 10:00 AM, 11:00 AM
    *   **Android Theatre:** 10:00 AM, 11:00 AM

Aquí puedes ver que el modelo hizo siete llamadas para responder tu pregunta y usó sus resultados en las llamadas subsiguientes y en la respuesta final.

Configuración de llamada a funciones usando modos

Nota: Los modos tool_config (AUTO, ANY, NONE) son características de la API generateContent. Aún no están disponibles con la API de interacciones. Los ejemplos a continuación usan client.interactions.create para mostrar soluciones alternativas equivalentes.

Con generateContent, puedes controlar con precisión cuándo y qué funciones el modelo puede llamar usando el parámetro tool_config.

El tool_config acepta un objeto ToolConfig, que contiene un FunctionCallingConfig con dos campos principales:

• mode: Controla el comportamiento general de la llamada a funciones (AUTO, ANY, NONE).

• allowed_function_names: Una lista opcional de nombres de funciones a las que el modelo está restringido a llamar en este turno.

Así es como funciona cada modo y cómo lograr un comportamiento similar con la API de interacciones:

AUTO (Modo predeterminado)

• Comportamiento generateContent: El modelo decide si responder con texto o llamar a una o más funciones del tools proporcionado. Este es el modo más flexible.

• Equivalente de la API de interacciones: Este es el comportamiento predeterminado; cuando pasas tools a interactions.create, el modelo decide naturalmente si llamarlas.

# In Interactions API, there is no "auto" mode config.
# The model will naturally decide whether to call tools.
interaction = client.interactions.create(
    model=MODEL_ID,
    input="Turn on the lights!",
    system_instruction=instruction,
    tools=light_controls,
)

for step in interaction.steps:
    if step.type == "function_call":
        print(f"Function call: {step.name}({step.arguments})")
        fn = light_functions[step.name]
        result = fn(**step.arguments) if step.arguments else fn() if step.arguments else fn()
    elif step.type == "model_output":
        print(f"Model: {step.content[0].text}")

Function call: enable_lights({})
LIGHTBOT: Lights enabled.

Modo NONE

• Comportamiento generateContent: El modelo tiene explícitamente prohibido llamar a cualquier función, incluso si se proporcionan herramientas. Solo responderá con texto.

• Equivalente de la API de interacciones: Simplemente no pases ningún tools a la llamada.

# "none" mode equivalent: don't pass any tools
interaction = client.interactions.create(
    model=MODEL_ID,
    input="Hello light-bot, what can you do?",
    system_instruction=instruction,
    # No tools provided = model can't call functions
)

for step in interaction.steps:
    if step.type == "model_output":
        print(f"Model: {step.content[0].text}")

Model: Hello! I am a lighting system bot. I can perform the following tasks for you:

*   **Turn lights on**
*   **Turn lights off**
*   **Set the light color**

How can I help you with your lighting today?

Modo ANY

• Comportamiento generateContent: Obliga al modelo a llamar al menos a una función.

  • Si allowed_function_names está configurado, el modelo debe elegir de esa lista.

  • Si allowed_function_names no está configurado, el modelo debe elegir de la lista completa de herramientas.

• Equivalente de la API de interacciones: Todavía no hay un equivalente directo. Pasa las herramientas y confía en el juicio del modelo. Puedes fomentar la llamada a funciones a través de instrucciones del sistema o la redacción del prompt.

Aquí tienes un ejemplo usando la API generateContent con tool_config:

from google.genai import types

response = client.models.generate_content(
    model=MODEL_ID,
    contents="Make this place PURPLE!",
    config=types.GenerateContentConfig(
        system_instruction=instruction,
        tools=light_controls,
        tool_config=types.ToolConfig(
            function_calling_config=types.FunctionCallingConfig(
                mode="ANY",
            ),
        ),
    ),
)

Con la API de interacciones, simplemente pasas las herramientas y manejas las llamadas manualmente:

# Force function calling by providing tools
interaction = client.interactions.create(
    model=MODEL_ID,
    input="Make this place PURPLE!",
    system_instruction=instruction,
    tools=light_controls,
)

# Manual function execution loop
prev_id = interaction.id
while any(s.type == "function_call" for s in interaction.steps):
    results = []
    for step in interaction.steps:
        if step.type == "function_call":
            print(f"Calling: {step.name}({step.arguments})")
            fn = light_functions[step.name]
            result = fn(**step.arguments) if step.arguments else fn() if step.arguments else fn()
            results.append({
                "type": "function_result",
                "name": step.name,
                "call_id": step.id,
                "result": str(result),
            })
    interaction = client.interactions.create(
        model=MODEL_ID,
        input=results,
        previous_interaction_id=prev_id,
        tools=light_controls,
    )
    prev_id = interaction.id

for step in interaction.steps:
    if step.type == "model_output":
        print(f"Model: {step.content[0].text}")

Calling: enable_lights({})
LIGHTBOT: Lights enabled.
Calling: set_light_color({'rgb_hex': '#800080'})
LIGHTBOT: Lights set to #800080.
Model: OK. The lights are now purple!

Próximos pasos

Referencias útiles de la API:

• La clase genai.Client
  • Su método client.interactions.create acepta tools como una lista de declaraciones de funciones o elementos invocables de Python.
  • Su método client.chats.create admite la llamada a funciones automática a través de la configuración automatic_function_calling.
• Con la API de interacciones, la respuesta contiene steps. Los pasos de tipo function_call tienen atributos .name, .arguments y .id. Devuelve los resultados usando las entradas previous_interaction_id y function_result.
• Con generateContent, las partes del contenido del candidato de la respuesta pueden contener un genai.types.FunctionCall.
• En respuesta a una FunctionCall, el modelo siempre espera una FunctionResponse.

Ejemplos relacionados

Consulta estos ejemplos que usan la llamada a funciones para darte más ideas sobre cómo usar esa característica tan útil:

• Barista Bot, un agente para pedir café
• Navegador como herramienta, usando la llamada a funciones para llamar a un navegador web.
• Usar la llamada a funciones para reordenar los resultados de búsqueda.
• Usar herramientas con la API en vivo, usando la llamada a funciones y otras herramientas con las API en vivo.

Continúa tu descubrimiento de la API de Gemini

Aprende a controlar cómo la API de Gemini interactúa con tus funciones en el inicio rápido de configuración de llamada a funciones, descubre cómo controlar la salida del modelo en JSON o usando un Enum o aprende cómo la API de Gemini puede generar y ejecutar código por sí misma usando la ejecución de código