Llamadas a funciones con la API de Gemini

Las llamadas a función te permiten conectar modelos a herramientas y APIs externas. En lugar de generar respuestas de texto, el modelo comprende cuándo llamar a funciones específicas y proporciona los parámetros necesarios para ejecutar acciones del mundo real. Esto permite que el modelo actúe como un puente entre el lenguaje natural y las acciones y los datos del mundo real. Las llamadas a función tienen 3 casos de uso principales:

• Aumentar el conocimiento: Accede a información de fuentes externas, como bases de datos, APIs y bases de conocimiento.
• Extender las capacidades: Usa herramientas externas para realizar cálculos y extender las limitaciones del modelo, como usar una calculadora o crear gráficos.
• Tomar medidas: Interactuar con sistemas externos mediante APIs, como programar citas, crear facturas, enviar correos electrónicos o controlar dispositivos de casa inteligente

Obtener clima Programar reunión Crear gráfico

Cómo funcionan las llamadas a función

Las llamadas a funciones implican una interacción estructurada entre tu aplicación, el modelo y las funciones externas. A continuación, se detalla el proceso:

1. Define la declaración de la función: Define la declaración de la función en el código de tu aplicación. Las declaraciones de funciones describen el nombre, los parámetros y el propósito de la función al modelo.
2. Llama a LLM con declaraciones de funciones: Envía la instrucción del usuario junto con las declaraciones de las funciones al modelo. Analiza la solicitud y determina si sería útil una llamada a función. Si es así, responde con un objeto JSON estructurado.
3. Ejecutar el código de la función (tu responsabilidad): El modelo no ejecuta la función. Es responsabilidad de tu aplicación procesar la respuesta y verificar la llamada a función, si
   • Sí: Extrae el nombre y los argumentos de la función y ejecuta la función correspondiente en tu aplicación.
   • No: El modelo proporcionó una respuesta de texto directa a la instrucción (este flujo se enfatiza menos en el ejemplo, pero es un resultado posible).
4. Crea una respuesta fácil de usar: Si se ejecutó una función, captura el resultado y envíalo al modelo en un turno posterior de la conversación. Usará el resultado para generar una respuesta final fácil de usar que incorpore la información de la llamada a función.

Este proceso se puede repetir en varios turnos, lo que permite interacciones y flujos de trabajo complejos. El modelo también admite llamar a varias funciones en un solo turno (llamadas a función en paralelo) y en secuencia (llamadas a función de composición).

Paso 1: Define la declaración de la función

Define una función y su declaración dentro del código de tu aplicación que permita a los usuarios establecer valores de luz y realizar una solicitud a la API. Esta función podría llamar a APIs o servicios externos.

from google.genai import types

# Define a function that the model can call to control smart lights
set_light_values_declaration = {
    "name": "set_light_values",
    "description": "Sets the brightness and color temperature of a light.",
    "parameters": {
        "type": "object",
        "properties": {
            "brightness": {
                "type": "integer",
                "description": "Light level from 0 to 100. Zero is off and 100 is full brightness",
            },
            "color_temp": {
                "type": "string",
                "enum": ["daylight", "cool", "warm"],
                "description": "Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.",
            },
        },
        "required": ["brightness", "color_temp"],
    },
}

# This is the actual function that would be called based on the model's suggestion
def set_light_values(brightness: int, color_temp: str) -> dict[str, int | str]:
    """Set the brightness and color temperature of a room light. (mock API).

    Args:
        brightness: Light level from 0 to 100. Zero is off and 100 is full brightness
        color_temp: Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.

    Returns:
        A dictionary containing the set brightness and color temperature.
    """
    return {"brightness": brightness, "colorTemperature": color_temp}

import { Type } from '@google/genai';

// Define a function that the model can call to control smart lights
const setLightValuesFunctionDeclaration = {
  name: 'set_light_values',
  description: 'Sets the brightness and color temperature of a light.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      brightness: {
        type: Type.NUMBER,
        description: 'Light level from 0 to 100. Zero is off and 100 is full brightness',
      },
      color_temp: {
        type: Type.STRING,
        enum: ['daylight', 'cool', 'warm'],
        description: 'Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.',
      },
    },
    required: ['brightness', 'color_temp'],
  },
};

/**
* Set the brightness and color temperature of a room light. (mock API)
* @param {number} brightness - Light level from 0 to 100. Zero is off and 100 is full brightness
* @param {string} color_temp - Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.
* @return {Object} A dictionary containing the set brightness and color temperature.
*/
function setLightValues(brightness, color_temp) {
  return {
    brightness: brightness,
    colorTemperature: color_temp
  };
}

Paso 2: Llama al modelo con declaraciones de funciones

Una vez que hayas definido tus declaraciones de funciones, puedes pedirle al modelo que las use. Analiza la instrucción y las declaraciones de la función y decide responder directamente o llamar a una función. Si se llama a una función, el objeto de respuesta contendrá una sugerencia de llamada a función.

from google import genai

# Generation Config with Function Declaration
tools = types.Tool(function_declarations=[set_light_values_declaration])
config = types.GenerateContentConfig(tools=[tools])

# Configure the client
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))

# Define user prompt
contents = [
    types.Content(
        role="user", parts=[types.Part(text="Turn the lights down to a romantic level")]
    )
]

# Send request with function declarations
response = client.models.generate_content(
    model="gemini-2.0-flash", config=config, contents=contents
)

print(response.candidates[0].content.parts[0].function_call)

import { GoogleGenAI } from '@google/genai';

// Generation Config with Function Declaration
const config = {
  tools: [{
    functionDeclarations: [setLightValuesFunctionDeclaration]
  }]
};

// Configure the client
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// Define user prompt
const contents = [
  {
    role: 'user',
    parts: [{ text: 'Turn the lights down to a romantic level' }]
  }
];

// Send request with function declarations
const response = await ai.models.generateContent({
  model: 'gemini-2.0-flash',
  contents: contents,
  config: config
});

console.log(response.functionCalls[0]); 

Luego, el modelo muestra un objeto functionCall en un esquema compatible con OpenAPI que especifica cómo llamar a una o más de las funciones declaradas para responder a la pregunta del usuario.

id=None args={'color_temp': 'warm', 'brightness': 25} name='set_light_values'

{
  name: 'set_light_values',
  args: { brightness: 25, color_temp: 'warm' }
}

Paso 3: Ejecuta el código de la función set_light_values

Extrae los detalles de la llamada a función de la respuesta del modelo, analiza los argumentos y ejecuta la función set_light_values en nuestro código.

# Extract tool call details
tool_call = response.candidates[0].content.parts[0].function_call

if tool_call.name == "set_light_values":
    result = set_light_values(**tool_call.args)
    print(f"Function execution result: {result}")

// Extract tool call details
const tool_call = response.functionCalls[0]

let result;
if (tool_call.name === 'set_light_values') {
  result = setLightValues(tool_call.args.brightness, tool_call.args.color_temp);
  console.log(`Function execution result: ${JSON.stringify(result)}`);
}

Paso 4: Crea una respuesta fácil de usar con el resultado de la función y vuelve a llamar al modelo

Por último, envía el resultado de la ejecución de la función al modelo para que pueda incorporar esta información en su respuesta final al usuario.

# Create a function response part
function_response_part = types.Part.from_function_response(
    name=tool_call.name,
    response={"result": result},
)

# Append function call and result of the function execution to contents
contents.append(types.Content(role="model", parts=[types.Part(function_call=tool_call)])) # Append the model's function call message
contents.append(types.Content(role="user", parts=[function_response_part])) # Append the function response

final_response = client.models.generate_content(
    model="gemini-2.0-flash",
    config=config,
    contents=contents,
)

print(final_response.text)

// Create a function response part
const function_response_part = {
  name: tool_call.name,
  response: { result }
}

// Append function call and result of the function execution to contents
contents.push({ role: 'model', parts: [{ functionCall: tool_call }] });
contents.push({ role: 'user', parts: [{ functionResponse: function_response_part }] });

// Get the final response from the model
const final_response = await ai.models.generateContent({
  model: 'gemini-2.0-flash',
  contents: contents,
  config: config
});

console.log(final_response.text);

Esto completa el flujo de llamadas a la función. El modelo usó correctamente la función set_light_values para realizar la acción de solicitud del usuario.

Declaraciones de funciones

Cuando implementas la llamada a función en una instrucción, creas un objeto tools, que contiene uno o más function declarations. Las funciones se definen con JSON, específicamente con un subconjunto seleccionado del formato de esquema de OpenAPI. Una sola declaración de función puede incluir los siguientes parámetros:

• name (cadena): Es un nombre único para la función (get_weather_forecast, send_email). Usa nombres descriptivos sin espacios ni caracteres especiales (usa guiones bajos o mayúsculas y minúsculas).
• description (cadena): Una explicación clara y detallada del propósito y las capacidades de la función. Esto es fundamental para que el modelo comprenda cuándo usar la función. Sé específico y proporciona ejemplos si es útil ("Encuentra cines en función de la ubicación y, de manera opcional, el título de la película que se está proyectando en los cines").
• parameters (objeto): Define los parámetros de entrada que espera la función.
  • type (cadena): Especifica el tipo de datos general, como object.
  • properties (objeto): Muestra una lista de parámetros individuales, cada uno con lo siguiente:
    • type (cadena): Es el tipo de datos del parámetro, como string, integer, boolean, array.
    • description (cadena): Es una descripción del propósito y el formato del parámetro. Proporciona ejemplos y restricciones ("La ciudad y el estado, p.ej., "San Francisco, CA" o un código postal, p.ej., '95616'.").
    • enum (array, opcional): Si los valores de los parámetros provienen de un conjunto fijo, usa "enum" para enumerar los valores permitidos en lugar de solo describirlos en la descripción. Esto mejora la precisión ("enum": ["daylight", "cool", "warm"]).
  • required (array): Es un array de cadenas que enumera los nombres de los parámetros que son obligatorios para que funcione la función.

Llamadas a función en paralelo

Además de las llamadas a funciones de un solo giro, también puedes llamar a varias funciones a la vez. Las llamadas a funciones en paralelo te permiten ejecutar varias funciones a la vez y se usan cuando las funciones no dependen entre sí. Esto es útil en situaciones como la recopilación de datos de varias fuentes independientes, como recuperar detalles de los clientes de diferentes bases de datos, verificar los niveles de inventario en varios almacenes o realizar varias acciones, como convertir tu departamento en un club.

power_disco_ball = {
    "name": "power_disco_ball",
    "description": "Powers the spinning disco ball.",
    "parameters": {
        "type": "object",
        "properties": {
            "power": {
                "type": "boolean",
                "description": "Whether to turn the disco ball on or off.",
            }
        },
        "required": ["power"],
    },
}

start_music = {
    "name": "start_music",
    "description": "Play some music matching the specified parameters.",
    "parameters": {
        "type": "object",
        "properties": {
            "energetic": {
                "type": "boolean",
                "description": "Whether the music is energetic or not.",
            },
            "loud": {
                "type": "boolean",
                "description": "Whether the music is loud or not.",
            },
        },
        "required": ["energetic", "loud"],
    },
}

dim_lights = {
    "name": "dim_lights",
    "description": "Dim the lights.",
    "parameters": {
        "type": "object",
        "properties": {
            "brightness": {
                "type": "number",
                "description": "The brightness of the lights, 0.0 is off, 1.0 is full.",
            }
        },
        "required": ["brightness"],
    },
}

import { Type } from '@google/genai';

const powerDiscoBall = {
  name: 'power_disco_ball',
  description: 'Powers the spinning disco ball.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      power: {
        type: Type.BOOLEAN,
        description: 'Whether to turn the disco ball on or off.'
      }
    },
    required: ['power']
  }
};

const startMusic = {
  name: 'start_music',
  description: 'Play some music matching the specified parameters.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      energetic: {
        type: Type.BOOLEAN,
        description: 'Whether the music is energetic or not.'
      },
      loud: {
        type: Type.BOOLEAN,
        description: 'Whether the music is loud or not.'
      }
    },
    required: ['energetic', 'loud']
  }
};

const dimLights = {
  name: 'dim_lights',
  description: 'Dim the lights.',
  parameters: {
    type: Type.OBJECT,
    properties: {
      brightness: {
        type: Type.NUMBER,
        description: 'The brightness of the lights, 0.0 is off, 1.0 is full.'
      }
    },
    required: ['brightness']
  }
};

Llama al modelo con una instrucción que pueda usar todas las herramientas especificadas. En este ejemplo, se usa un tool_config. Para obtener más información, puedes leer sobre cómo configurar llamadas a funciones.

from google import genai
from google.genai import types

# Set up function declarations
house_tools = [
    types.Tool(function_declarations=[power_disco_ball, start_music, dim_lights])
]

config = {
    "tools": house_tools,
    "automatic_function_calling": {"disable": True},
    # Force the model to call 'any' function, instead of chatting.
    "tool_config": {"function_calling_config": {"mode": "any"}},
}

# Configure the client
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))

chat = client.chats.create(model="gemini-2.0-flash", config=config)
response = chat.send_message("Turn this place into a party!")

# Print out each of the function calls requested from this single call
print("Example 1: Forced function calling")
for fn in response.function_calls:
    args = ", ".join(f"{key}={val}" for key, val in fn.args.items())
    print(f"{fn.name}({args})")

import { GoogleGenAI } from '@google/genai';

// Set up function declarations
const houseFns = [powerDiscoBall, startMusic, dimLights];

const config = {
    tools: [{
        functionDeclarations: houseFns
    }],
    // Force the model to call 'any' function, instead of chatting.
    toolConfig: {
        functionCallingConfig: {
        mode: 'any'
        }
    }
};

// Configure the client
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// Create a chat session
const chat = ai.chats.create({
    model: 'gemini-2.0-flash',
    config: config
});
const response = await chat.sendMessage({message: 'Turn this place into a party!'});

// Print out each of the function calls requested from this single call
console.log("Example 1: Forced function calling");
for (const fn of response.functionCalls) {
    const args = Object.entries(fn.args)
        .map(([key, val]) => `${key}=${val}`)
        .join(', ');
    console.log(`${fn.name}(${args})`);
}

Cada uno de los resultados impresos refleja una sola llamada a función que solicitó el modelo. Para enviar los resultados, incluye las respuestas en el mismo orden en que se solicitaron.

El SDK de Python admite una función llamada llamada a función automática, que convierte la función de Python en declaraciones, controla la ejecución de la llamada a función y el ciclo de respuesta por ti. A continuación, se muestra un ejemplo de nuestro caso de uso de disco.

from google import genai
from google.genai import types

# Actual implementation functions
def power_disco_ball_impl(power: bool) -> dict:
    """Powers the spinning disco ball.

    Args:
        power: Whether to turn the disco ball on or off.

    Returns:
        A status dictionary indicating the current state.
    """
    return {"status": f"Disco ball powered {'on' if power else 'off'}"}

def start_music_impl(energetic: bool, loud: bool) -> dict:
    """Play some music matching the specified parameters.

    Args:
        energetic: Whether the music is energetic or not.
        loud: Whether the music is loud or not.

    Returns:
        A dictionary containing the music settings.
    """
    music_type = "energetic" if energetic else "chill"
    volume = "loud" if loud else "quiet"
    return {"music_type": music_type, "volume": volume}

def dim_lights_impl(brightness: float) -> dict:
    """Dim the lights.

    Args:
        brightness: The brightness of the lights, 0.0 is off, 1.0 is full.

    Returns:
        A dictionary containing the new brightness setting.
    """
    return {"brightness": brightness}

config = {
    "tools": [power_disco_ball_impl, start_music_impl, dim_lights_impl],
}

chat = client.chats.create(model="gemini-2.0-flash", config=config)
response = chat.send_message("Do everything you need to this place into party!")

print("\nExample 2: Automatic function calling")
print(response.text)
# I've turned on the disco ball, started playing loud and energetic music, and dimmed the lights to 50% brightness. Let's get this party started!

Llamadas a función de composición

Gemini 2.0 admite llamadas a funciones de composición, lo que significa que el modelo puede encadenar varias llamadas a funciones. Por ejemplo, para responder "Obtén la temperatura en mi ubicación actual", la API de Gemini podría invocar una función get_current_location() y una función get_weather() que tome la ubicación como parámetro.

# Light control schemas
turn_on_the_lights_schema = {'name': 'turn_on_the_lights'}
turn_off_the_lights_schema = {'name': 'turn_off_the_lights'}

prompt = """
  Hey, can you write run some python code to turn on the lights, wait 10s and then turn off the lights?
  """

tools = [
    {'code_execution': {}},
    {'function_declarations': [turn_on_the_lights_schema, turn_off_the_lights_schema]}
]

await run(prompt, tools=tools, modality="AUDIO")

// Light control schemas
const turnOnTheLightsSchema = { name: 'turn_on_the_lights' };
const turnOffTheLightsSchema = { name: 'turn_off_the_lights' };

const prompt = `
  Hey, can you write run some python code to turn on the lights, wait 10s and then turn off the lights?
`;

const tools = [
  { codeExecution: {} },
  { functionDeclarations: [turnOnTheLightsSchema, turnOffTheLightsSchema] }
];

await run(prompt, tools=tools, modality="AUDIO")

Modos de llamada a función

La API de Gemini te permite controlar cómo el modelo usa las herramientas proporcionadas (declaraciones de funciones). Específicamente, puedes configurar el modo dentro de function_calling_config.

• AUTO (Default): El modelo decide si generar una respuesta de lenguaje natural o sugerir una llamada a función según la instrucción y el contexto. Este es el modo más flexible y se recomienda para la mayoría de las situaciones.
• ANY: El modelo está restringido para predecir siempre una llamada a función y garantizar el cumplimiento del esquema de la función. Si no se especifica allowed_function_names, el modelo puede elegir entre cualquiera de las declaraciones de funciones proporcionadas. Si allowed_function_names se proporciona como una lista, el modelo solo puede elegir entre las funciones de esa lista. Usa este modo cuando necesites una llamada a función en respuesta a cada instrucción (si corresponde).

• NONE: Se prohíbe que el modelo realice llamadas a función. Esto equivale a enviar una solicitud sin ninguna declaración de función. Úsalo para inhabilitar temporalmente las llamadas a funciones sin quitar las definiciones de herramientas.

from google.genai import types

# Configure function calling mode
tool_config = types.ToolConfig(
    function_calling_config=types.FunctionCallingConfig(
        mode="ANY", allowed_function_names=["get_current_temperature"]
    )
)

# Create the generation config
config = types.GenerateContentConfig(
    temperature=0,
    tools=[tools],  # not defined here.
    tool_config=tool_config,
)

import { FunctionCallingConfigMode } from '@google/genai';

// Configure function calling mode
const toolConfig = {
  functionCallingConfig: {
    mode: FunctionCallingConfigMode.ANY,
    allowedFunctionNames: ['get_current_temperature']
  }
};

// Create the generation config
const config = {
  temperature: 0,
  tools: tools, // not defined here.
  toolConfig: toolConfig,
};

Llamadas a función automáticas (solo Python)

Cuando usas el SDK de Python, puedes proporcionar funciones de Python directamente como herramientas. El SDK convierte automáticamente la función de Python en declaraciones y controla la ejecución de la llamada a función y el ciclo de respuesta por ti. Luego, el SDK de Python realiza automáticamente las siguientes acciones:

1. Detecta respuestas de llamadas a función del modelo.
2. Llama a la función de Python correspondiente en tu código.
3. Vuelve a enviar la respuesta de la función al modelo.
4. Muestra la respuesta de texto final del modelo.

Para usar esto, define tu función con sugerencias de tipo y una docstring, y, luego, pasa la función en sí (no una declaración JSON) como herramienta:

from google import genai
from google.genai import types

# Define the function with type hints and docstring
def get_current_temperature(location: str) -> dict:
    """Gets the current temperature for a given location.

    Args:
        location: The city and state, e.g. San Francisco, CA

    Returns:
        A dictionary containing the temperature and unit.
    """
    # ... (implementation) ...
    return {"temperature": 25, "unit": "Celsius"}

# Configure the client and model
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))  # Replace with your actual API key setup
config = types.GenerateContentConfig(
    tools=[get_current_temperature]
)  # Pass the function itself

# Make the request
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents="What's the temperature in London?",
    config=config,
)

print(response.text)  # The SDK handles the function call and returns the final text

Puedes inhabilitar las llamadas a funciones automáticas con lo siguiente:

# To disable automatic function calling:
config = types.GenerateContentConfig(
    tools=[get_current_temperature],
    automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True)
)

Declaración de esquemas de funciones automáticas

La extracción automática de esquemas de las funciones de Python no funciona en todos los casos. Por ejemplo, no controla los casos en los que describes los campos de un objeto de diccionario anidado. La API puede describir cualquiera de los siguientes tipos:

AllowedType = (int | float | bool | str | list['AllowedType'] | dict[str, AllowedType])

Para ver cómo se ve el esquema inferido, puedes convertirlo con from_callable:

def multiply(a: float, b: float):
    """Returns a * b."""
    return a * b

fn_decl = types.FunctionDeclaration.from_callable(callable=multiply, client=client)

# to_json_dict() provides a clean JSON representation.
print(fn_decl.to_json_dict())

Uso de varias herramientas: Combina herramientas nativas con llamadas a función

Con Gemini 2.0, puedes habilitar varias herramientas que combinan herramientas nativas con llamadas a funciones al mismo tiempo. Este es un ejemplo que habilita dos herramientas, Grounding with Google Search y code execution, en una solicitud con la API en vivo.

# Multiple tasks example - combining lights, code execution, and search
prompt = """
  Hey, I need you to do three things for me.

    1.  Turn on the lights.
    2.  Then compute the largest prime palindrome under 100000.
    3.  Then use Google Search to look up information about the largest earthquake in California the week of Dec 5 2024.

  Thanks!
  """

tools = [
    {'google_search': {}},
    {'code_execution': {}},
    {'function_declarations': [turn_on_the_lights_schema, turn_off_the_lights_schema]} # not defined here.
]

# Execute the prompt with specified tools in audio modality
await run(prompt, tools=tools, modality="AUDIO")

// Multiple tasks example - combining lights, code execution, and search
const prompt = `
  Hey, I need you to do three things for me.

    1.  Turn on the lights.
    2.  Then compute the largest prime palindrome under 100000.
    3.  Then use Google Search to look up information about the largest earthquake in California the week of Dec 5 2024.

  Thanks!
`;

const tools = [
  { googleSearch: {} },
  { codeExecution: {} },
  { functionDeclarations: [turnOnTheLightsSchema, turnOffTheLightsSchema] } // not defined here.
];

// Execute the prompt with specified tools in audio modality
await run(prompt, {tools: tools, modality: "AUDIO"});

Los desarrolladores de Python pueden probar esto en el notebook de uso de la herramienta de API en vivo.

Modelos compatibles

No se incluyen los modelos experimentales. Puedes encontrar sus funciones en la página de descripción general del modelo.

Prácticas recomendadas

• Descripciones de funciones y parámetros: Sé muy claro y específico en tus descripciones. El modelo se basa en ellos para elegir la función correcta y proporcionar los argumentos adecuados.
• Nombres: Usa nombres de función descriptivos (sin espacios, puntos ni guiones).
• Tipos estrictos: Usa tipos específicos (número entero, cadena, enumeración) para los parámetros para reducir los errores. Si un parámetro tiene un conjunto limitado de valores válidos, usa una enumeración.
• Ingeniería de instrucciones:
  • Proporciona contexto: Indícale al modelo su rol (p.ej., "Eres un asistente del clima servicial").
  • Dar instrucciones: Especifica cómo y cuándo usar las funciones (p.ej., "No averigües las fechas. Siempre usa una fecha futura para las previsiones").
  • Fomenta las aclaraciones: Pídele al modelo que haga preguntas aclaratorias si es necesario.
• Temperatura: Usa una temperatura baja (p.ej., 0) para obtener llamadas a funciones más determinísticas y confiables.
• Validación: Si una llamada a función tiene consecuencias significativas (p.ej., realizar un pedido), valida la llamada con el usuario antes de ejecutarla.
• Manejo de errores: Implementa un manejo de errores sólido en tus funciones para controlar de forma fluida las entradas inesperadas o las fallas de la API. Muestra mensajes de error informativos que el modelo puede usar para generar respuestas útiles para el usuario.
• Seguridad: Ten en cuenta la seguridad cuando llames a APIs externas. Usa los mecanismos de autenticación y autorización adecuados. Evita exponer datos sensibles en las llamadas a función.
• Límites de tokens: Las descripciones y los parámetros de las funciones se tienen en cuenta para el límite de tokens de entrada. Si alcanzas los límites de tokens, considera limitar la cantidad de funciones o la longitud de las descripciones, y divide las tareas complejas en conjuntos de funciones más pequeños y enfocados.

Notas y limitaciones

• Solo se admite un subconjunto del esquema de OpenAPI.
• Los tipos de parámetros admitidos en Python son limitados.
• Las llamadas a función automáticas son solo una función del SDK de Python.