La llamada a función, también conocida como uso de herramientas, proporciona al LLM definiciones de herramientas externas (por ejemplo, una función de get_current_weather). Cuando procesa una instrucción, el modelo determina de forma inteligente si se necesita una herramienta y, si es así, genera datos estructurados que especifican la herramienta que se debe llamar y sus parámetros (por ejemplo, get_current_weather(location='Boston')). Luego, tu aplicación ejecuta esta herramienta y devuelve el resultado al modelo, lo que le permite completar su respuesta con información dinámica del mundo real o el resultado de una acción. Esto conecta de manera eficaz el LLM con tus sistemas y extiende sus capacidades.
Las llamadas a función permiten dos casos de uso principales:
Recuperación de datos: Recupera información actualizada para las respuestas del modelo, como el clima actual, la conversión de divisas o datos específicos de bases de conocimiento y APIs (RAG).
Tomar medidas: Realizar operaciones externas, como enviar formularios, actualizar el estado de la aplicación o coordinar flujos de trabajo de agentes (p. ej., transferencias de conversaciones)
Para ver más casos de uso y ejemplos basados en la llamada a función, consulta Casos de uso.
Funciones y limitaciones
Los siguientes modelos admiten llamadas a funciones:
Modelos de Gemini:
- Gemini 2.5 Flash-Lite
- Gemini 2.5 Flash con audio nativo de la API de Live (versión preliminar)
- Gemini 2.0 Flash con la API en vivo (versión preliminar)
- Vertex AI Model Optimizer (experimental)
- Gemini 2.5 Pro
- Gemini 2.5 Flash
- Gemini 2.0 Flash
- Gemini 2.0 Flash-Lite
Modelos abiertos:
Puedes especificar hasta 512
FunctionDeclarations.Define tus funciones en el formato de esquema de OpenAPI.
Para conocer las prácticas recomendadas relacionadas con las declaraciones de funciones, incluidas sugerencias de nombres y descripciones, consulta Prácticas recomendadas.
En el caso de los modelos abiertos, sigue esta guía del usuario.
Cómo crear una aplicación que llame a una función
Para usar la llamada a función, realiza las siguientes tareas:
- Envía las declaraciones de funciones y la instrucción al modelo.
- Proporcionar la salida de la API al modelo.
Paso 1: Envía la instrucción y las declaraciones de funciones al modelo
Declara un Tool en un formato de esquema que sea compatible con el esquema de OpenAPI. Para obtener más información, consulta Ejemplos de esquemas.
En los siguientes ejemplos, se envía una instrucción y una declaración de función a los modelos de Gemini.
REST
PROJECT_ID=myproject
LOCATION=us-central1
MODEL_ID=gemini-2.0-flash-001
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:generateContent \
-d '{
"contents": [{
"role": "user",
"parts": [{
"text": "What is the weather in Boston?"
}]
}],
"tools": [{
"functionDeclarations": [
{
"name": "get_current_weather",
"description": "Get the current weather in a given location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city name of the location for which to get the weather.",
"default": {
"string_value": "Boston, MA"
}
}
},
"required": [
"location"
]
}
}
]
}]
}'
Python
Puedes especificar el esquema de forma manual con un diccionario de Python o automáticamente con la función auxiliar from_func. En el siguiente ejemplo, se muestra cómo declarar una función de forma manual.
import vertexai
from vertexai.generative_models import (
Content,
FunctionDeclaration,
GenerationConfig,
GenerativeModel,
Part,
Tool,
ToolConfig
)
# Initialize Vertex AI
# TODO(developer): Update the project
vertexai.init(project="PROJECT_ID", location="us-central1")
# Initialize Gemini model
model = GenerativeModel(model_name="gemini-2.0-flash")
# Manual function declaration
get_current_weather_func = FunctionDeclaration(
name="get_current_weather",
description="Get the current weather in a given location",
# Function parameters are specified in JSON schema format
parameters={
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city name of the location for which to get the weather.",
"default": {
"string_value": "Boston, MA"
}
}
},
},
)
response = model.generate_content(
contents = [
Content(
role="user",
parts=[
Part.from_text("What is the weather like in Boston?"),
],
)
],
generation_config = GenerationConfig(temperature=0),
tools = [
Tool(
function_declarations=[get_current_weather_func],
)
]
)
Como alternativa, puedes declarar la función automáticamente con la función auxiliar from_func, como se muestra en el siguiente ejemplo:
def get_current_weather(location: str = "Boston, MA"):
"""
Get the current weather in a given location
Args:
location: The city name of the location for which to get the weather.
"""
# This example uses a mock implementation.
# You can define a local function or import the requests library to call an API
return {
"location": "Boston, MA",
"temperature": 38,
"description": "Partly Cloudy",
"icon": "partly-cloudy",
"humidity": 65,
"wind": {
"speed": 10,
"direction": "NW"
}
}
get_current_weather_func = FunctionDeclaration.from_func(get_current_weather)
Node.js
En este ejemplo, se muestra una situación de texto con una función y una instrucción.
Node.js
Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Node.js.
Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.
Go
En este ejemplo, se muestra una situación de texto con una función y una instrucción.
Obtén más información para instalar o actualizar Go.
Para obtener más información, consulta la documentación de referencia del SDK.
Establece variables de entorno para usar el SDK de IA generativa con Vertex AI:
# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values # with appropriate values for your project. export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT export GOOGLE_CLOUD_LOCATION=global export GOOGLE_GENAI_USE_VERTEXAI=True
C#
En este ejemplo, se muestra una situación de texto con una función y una instrucción.
C#
Antes de probar este ejemplo, sigue las instrucciones de configuración para C# incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI C#.
Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.
Java
Java
Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.
Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.
Si el modelo determina que necesita el resultado de una función en particular, la respuesta que recibe la aplicación del modelo contiene el nombre de la función y los valores de los parámetros con los que se debe llamar a la función.
El siguiente es un ejemplo de una respuesta de modelo a la instrucción del usuario “¿Cómo está el clima en Boston?”. El modelo propone llamar a la función get_current_weather con el parámetro Boston, MA.
candidates {
content {
role: "model"
parts {
function_call {
name: "get_current_weather"
args {
fields {
key: "location"
value {
string_value: "Boston, MA"
}
}
}
}
}
}
...
}
Paso 2: Proporciona la salida de la API al modelo
Invocar la API externa y pasar la salida de la API al modelo.
En el siguiente ejemplo, se usan datos sintéticos para simular una carga útil de respuesta desde una API externa y se envía la salida de vuelta al modelo.
REST
PROJECT_ID=myproject
MODEL_ID=gemini-2.0-flash
LOCATION="us-central1"
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:generateContent \
-d '{
"contents": [
{
"role": "user",
"parts": {
"text": "What is the weather in Boston?"
}
},
{
"role": "model",
"parts": [
{
"functionCall": {
"name": "get_current_weather",
"args": {
"location": "Boston, MA"
}
}
}
]
},
{
"role": "user",
"parts": [
{
"functionResponse": {
"name": "get_current_weather",
"response": {
"temperature": 20,
"unit": "C"
}
}
}
]
}
],
"tools": [
{
"function_declarations": [
{
"name": "get_current_weather",
"description": "Get the current weather in a specific location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city name of the location for which to get the weather."
}
},
"required": [
"location"
]
}
}
]
}
]
}'
Python
function_response_contents = []
function_response_parts = []
# Iterates through the function calls in the response in case there are parallel function call requests
for function_call in response.candidates[0].function_calls:
print(f"Function call: {function_call.name}")
# In this example, we'll use synthetic data to simulate a response payload from an external API
if (function_call.args['location'] == "Boston, MA"):
api_response = { "location": "Boston, MA", "temperature": 38, "description": "Partly Cloudy" }
if (function_call.args['location'] == "San Francisco, CA"):
api_response = { "location": "San Francisco, CA", "temperature": 58, "description": "Sunny" }
function_response_parts.append(
Part.from_function_response(
name=function_call.name,
response={"contents": api_response}
)
)
# Add the function call response to the contents
function_response_contents = Content(role="user", parts=function_response_parts)
# Submit the User's prompt, model's response, and API output back to the model
response = model.generate_content(
[
Content( # User prompt
role="user",
parts=[
Part.from_text("What is the weather like in Boston?"),
],
),
response.candidates[0].content, # Function call response
function_response_contents # API output
],
tools=[
Tool(
function_declarations=[get_current_weather_func],
)
],
)
# Get the model summary response
print(response.text)
Para conocer las prácticas recomendadas relacionadas con la invocación de APIs, consulta Prácticas recomendadas: Invocación de APIs.
Si el modelo propuso varias llamadas a funciones paralelas, la aplicación debe proporcionar todas las respuestas al modelo. Para obtener más información, consulta Ejemplo de llamada a función paralela.
El modelo puede determinar que el resultado de otra función es necesario para responder a la instrucción. En este caso, la respuesta que recibe la aplicación del modelo contiene otro nombre de función y otro conjunto de valores del parámetro.
Si el modelo determina que la respuesta de la API es suficiente para responder a la instrucción del usuario, crea una respuesta de lenguaje natural y la muestra a la aplicación. En este caso, la aplicación debe pasar la respuesta al usuario. A continuación, se muestra un ejemplo de una respuesta de lenguaje natural:
It is currently 38 degrees Fahrenheit in Boston, MA with partly cloudy skies.
Llamada a función con pensamientos
Cuando llames a funciones con la opción thinking habilitada, deberás obtener el thought_signature del objeto de respuesta del modelo y devolverlo cuando envíes el resultado de la ejecución de la función al modelo. Por ejemplo:
Python
# Call the model with function declarations
# ...Generation config, Configure the client, and Define user prompt (No changes)
# Send request with declarations (using a thinking model)
response = client.models.generate_content(
model="gemini-2.5-flash", config=config, contents=contents)
# See thought signatures
for part in response.candidates[0].content.parts:
if not part.text:
continue
if part.thought and part.thought_signature:
print("Thought signature:")
print(part.thought_signature)
No es necesario que veas las firmas de pensamiento, pero deberás ajustar el paso 2 para que las muestre junto con el resultado de la ejecución de la función, de modo que pueda incorporar los pensamientos en su respuesta final:
Python
# Create user friendly response with function result and call the model again
# ...Create a function response part (No change)
# Append thought signatures, function call and result of the function execution to contents
function_call_content = response.candidates[0].content
# Append the model's function call message, which includes thought signatures
contents.append(function_call_content)
contents.append(types.Content(role="user", parts=[function_response_part])) # Append the function response
final_response = client.models.generate_content(
model="gemini-2.5-flash",
config=config,
contents=contents,
)
print(final_response.text)
Cuando devuelvas firmas de pensamiento, sigue estos lineamientos:
- El modelo devuelve firmas dentro de otras partes de la respuesta, por ejemplo, partes de llamadas a funciones o resúmenes de texto, texto o pensamiento. Devuelve toda la respuesta con todas las partes al modelo en turnos posteriores.
- No combines una parte con una firma con otra parte que también contenga una firma. Las firmas no se pueden concatenar.
- No combines una parte con una firma con otra parte sin firma. Esto rompe el posicionamiento correcto del pensamiento representado por la firma.
Obtén más información sobre las limitaciones y el uso de las firmas de pensamiento, y sobre los modelos de pensamiento en general, en la página Pensamiento.
Llamada a función paralela
Para instrucciones como “¿Obtener detalles del clima en Boston y San Francisco?”, el modelo puede proponer varias llamadas a función paralelas. Para obtener una lista de los modelos que admiten llamadas a funciones paralelas, consulta Modelos compatibles.
REST
En este ejemplo, se muestra una situación con una función get_current_weather.
La instrucción del usuario es "¿Obtener detalles del clima en Boston y San Francisco?". El modelo propone dos llamadas a función get_current_weather paralelas: una con el parámetro Boston y la otra con el parámetro San Francisco.
Para obtener más información sobre los parámetros de la solicitud, consulta la API de Gemini.
{
"candidates": [
{
"content": {
"role": "model",
"parts": [
{
"functionCall": {
"name": "get_current_weather",
"args": {
"location": "Boston"
}
}
},
{
"functionCall": {
"name": "get_current_weather",
"args": {
"location": "San Francisco"
}
}
}
]
},
...
}
],
...
}
El siguiente comando demuestra cómo puedes proporcionar el resultado de la función al modelo. Reemplaza my-project por el nombre de tu Google Cloud proyecto.
Solicitud de modelo
PROJECT_ID=my-project
MODEL_ID=gemini-2.0-flash
LOCATION="us-central1"
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:generateContent \
-d '{
"contents": [
{
"role": "user",
"parts": {
"text": "What is difference in temperature in Boston and San Francisco?"
}
},
{
"role": "model",
"parts": [
{
"functionCall": {
"name": "get_current_weather",
"args": {
"location": "Boston"
}
}
},
{
"functionCall": {
"name": "get_current_weather",
"args": {
"location": "San Francisco"
}
}
}
]
},
{
"role": "user",
"parts": [
{
"functionResponse": {
"name": "get_current_weather",
"response": {
"temperature": 30.5,
"unit": "C"
}
}
},
{
"functionResponse": {
"name": "get_current_weather",
"response": {
"temperature": 20,
"unit": "C"
}
}
}
]
}
],
"tools": [
{
"function_declarations": [
{
"name": "get_current_weather",
"description": "Get the current weather in a specific location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city name of the location for which to get the weather."
}
},
"required": [
"location"
]
}
}
]
}
]
}'
La respuesta de lenguaje natural que crea el modelo es similar a la siguiente:
Respuesta del modelo
[
{
"candidates": [
{
"content": {
"parts": [
{
"text": "The temperature in Boston is 30.5C and the temperature in San Francisco is 20C. The difference is 10.5C. \n"
}
]
},
"finishReason": "STOP",
...
}
]
...
}
]
Python
En este ejemplo, se muestra una situación con una función get_current_weather.
La instrucción del usuario es "¿Cómo está el clima en Boston y San Francisco?".
Reemplaza my-project por el nombre de tu Google Cloud proyecto.
import vertexai
from vertexai.generative_models import (
Content,
FunctionDeclaration,
GenerationConfig,
GenerativeModel,
Part,
Tool,
ToolConfig
)
# Initialize Vertex AI
# TODO(developer): Update the project
vertexai.init(project="my-project", location="us-central1")
# Initialize Gemini model
model = GenerativeModel(model_name="gemini-2.0-flash")
# Manual function declaration
get_current_weather_func = FunctionDeclaration(
name="get_current_weather",
description="Get the current weather in a given location",
# Function parameters are specified in JSON schema format
parameters={
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city name of the location for which to get the weather.",
"default": {
"string_value": "Boston, MA"
}
}
},
},
)
response = model.generate_content(
contents = [
Content(
role="user",
parts=[
Part.from_text("What is the weather like in Boston and San Francisco?"),
],
)
],
generation_config = GenerationConfig(temperature=0),
tools = [
Tool(
function_declarations=[get_current_weather_func],
)
]
)
El siguiente comando demuestra cómo puedes proporcionar el resultado de la función al modelo.
function_response_contents = []
function_response_parts = []
# You can have parallel function call requests for the same function type.
# For example, 'location_to_lat_long("London")' and 'location_to_lat_long("Paris")'
# In that case, collect API responses in parts and send them back to the model
for function_call in response.candidates[0].function_calls:
print(f"Function call: {function_call.name}")
# In this example, we'll use synthetic data to simulate a response payload from an external API
if (function_call.args['location'] == "Boston, MA"):
api_response = { "location": "Boston, MA", "temperature": 38, "description": "Partly Cloudy" }
if (function_call.args['location'] == "San Francisco, CA"):
api_response = { "location": "San Francisco, CA", "temperature": 58, "description": "Sunny" }
function_response_parts.append(
Part.from_function_response(
name=function_call.name,
response={"contents": api_response}
)
)
# Add the function call response to the contents
function_response_contents = Content(role="user", parts=function_response_parts)
function_response_contents
response = model.generate_content(
contents = [
Content(
role="user",
parts=[
Part.from_text("What is the weather like in Boston and San Francisco?"),
],
), # User prompt
response.candidates[0].content, # Function call response
function_response_contents, # Function response
],
tools = [
Tool(
function_declarations=[get_current_weather_func],
)
]
)
# Get the model summary response
print(response.text)
Go
Modos de llamada a funciones
Puedes controlar cómo el modelo usa las herramientas proporcionadas (declaraciones de funciones) configurando el modo dentro de function_calling_config.
| Modo | Descripción |
|---|---|
AUTO |
El comportamiento predeterminado del modelo. El modelo decide si predecir llamadas a funciones o responder con lenguaje natural según el contexto. Este es el modo más flexible y se recomienda para la mayoría de las situaciones. |
VALIDATED (Vista previa) |
El modelo está restringido para predecir llamadas a funciones o lenguaje natural, y garantiza el cumplimiento del esquema de funciones. Si no se proporciona allowed_function_names, el modelo elige entre todas las declaraciones de funciones disponibles. Si se proporciona allowed_function_names, el modelo elige entre el conjunto de funciones permitidas. |
ANY |
El modelo está restringido para predecir siempre una o más llamadas a función y garantiza el cumplimiento del esquema de funciones. Si no se proporciona allowed_function_names, el modelo elige entre todas las declaraciones de funciones disponibles. Si se proporciona allowed_function_names, el modelo elige entre el conjunto de funciones permitidas. Usa este modo cuando requieras una respuesta de llamada a función para cada instrucción (si corresponde). |
NONE |
El modelo tiene prohibido realizar llamadas a funciones. Esto equivale a enviar una solicitud sin ninguna declaración de función. Usa este modo para inhabilitar temporalmente la llamada a funciones sin quitar las definiciones de tus herramientas. |
Llamada a función forzada
En lugar de permitir que el modelo elija entre una respuesta de lenguaje natural y una llamada a función, puedes forzarlo para que prediga solo las llamadas a función. Esto se conoce como llamada a función forzada. También puedes optar por proporcionar al modelo un conjunto completo de declaraciones de funciones, pero restringir sus respuestas a un subconjunto de ellas.
En el siguiente ejemplo, se fuerza la predicción de solo llamadas a la función get_weather.
Python
response = model.generate_content(
contents = [
Content(
role="user",
parts=[
Part.from_text("What is the weather like in Boston?"),
],
)
],
generation_config = GenerationConfig(temperature=0),
tools = [
Tool(
function_declarations=[get_weather_func, some_other_function],
)
],
tool_config=ToolConfig(
function_calling_config=ToolConfig.FunctionCallingConfig(
# ANY mode forces the model to predict only function calls
mode=ToolConfig.FunctionCallingConfig.Mode.ANY,
# Allowed function calls to predict when the mode is ANY. If empty, any of
# the provided function calls will be predicted.
allowed_function_names=["get_weather"],
)
)
)
Ejemplos de esquemas de funciones
Las declaraciones de funciones son compatibles con el esquema de OpenAPI. Admitimos los siguientes atributos: type, nullable, required, format, description, properties, items, enum, anyOf, $ref y $defs. No se admiten los atributos restantes.
Función con parámetros de objetos y arrays
En el siguiente ejemplo, se usa un diccionario de Python para declarar una función que toma parámetros de objetos y arrays:
extract_sale_records_func = FunctionDeclaration( name="extract_sale_records", description="Extract sale records from a document.", parameters={ "type": "object", "properties": { "records": { "type": "array", "description": "A list of sale records", "items": { "description": "Data for a sale record", "type": "object", "properties": { "id": {"type": "integer", "description": "The unique id of the sale."}, "date": {"type": "string", "description": "Date of the sale, in the format of MMDDYY, e.g., 031023"}, "total_amount": {"type": "number", "description": "The total amount of the sale."}, "customer_name": {"type": "string", "description": "The name of the customer, including first name and last name."}, "customer_contact": {"type": "string", "description": "The phone number of the customer, e.g., 650-123-4567."}, }, "required": ["id", "date", "total_amount"], }, }, }, "required": ["records"], }, )
Función con parámetro de enumeración
En el siguiente ejemplo, se usa un diccionario de Python para declarar una función que toma un parámetro enum de números enteros:
set_status_func = FunctionDeclaration( name="set_status", description="set a ticket's status field", # Function parameters are specified in JSON schema format parameters={ "type": "object", "properties": { "status": { "type": "integer", "enum": [ "10", "20", "30" ], # Provide integer (or any other type) values as strings. } }, }, )
Función con ref y def
La siguiente declaración de función JSON usa los atributos ref y defs:
{ "contents": ..., "tools": [ { "function_declarations": [ { "name": "get_customer", "description": "Search for a customer by name", "parameters": { "type": "object", "properties": { "first_name": { "ref": "#/defs/name" }, "last_name": { "ref": "#/defs/name" } }, "defs": { "name": { "type": "string" } } } } ] } ] }
Notas de uso:
- A diferencia del esquema de OpenAPI, especifica
refydefssin el símbolo$. refdebe hacer referencia al elemento secundario directo dedefs; no se permiten referencias externas.- La profundidad máxima del esquema anidado es 32.
- La profundidad de recursión en
defs(autorreferencia) se limita a dos.
from_func con parámetro de array
En la siguiente muestra de código, se declara una función que multiplica un array de números y usa from_func para generar el esquema FunctionDeclaration.
from typing import List # Define a function. Could be a local function or you can import the requests library to call an API def multiply_numbers(numbers: List[int] = [1, 1]) -> int: """ Calculates the product of all numbers in an array. Args: numbers: An array of numbers to be multiplied. Returns: The product of all the numbers. If the array is empty, returns 1. """ if not numbers: # Handle empty array return 1 product = 1 for num in numbers: product *= num return product multiply_number_func = FunctionDeclaration.from_func(multiply_numbers) """ multiply_number_func contains the following schema: {'name': 'multiply_numbers', 'description': 'Calculates the product of all numbers in an array.', 'parameters': {'properties': {'numbers': {'items': {'type': 'INTEGER'}, 'description': 'list of numbers', 'default': [1.0, 1.0], 'title': 'Numbers', 'type': 'ARRAY'}}, 'description': 'Calculates the product of all numbers in an array.', 'title': 'multiply_numbers', 'property_ordering': ['numbers'], 'type': 'OBJECT'}} """
Prácticas recomendadas para las llamadas a función
Escribe nombres de funciones, descripciones de parámetros e instrucciones claros y detallados.
Los nombres de funciones deben comenzar con una letra o un guion bajo, y solo deben contener caracteres de la A a la Z (mayúsculas o minúsculas), números del 0 al 9, guiones bajos, puntos o guiones, con una longitud máxima de 64.
Sé muy claro y específico en las descripciones de las funciones y los parámetros. El modelo se basa en estos para elegir la función correcta y proporcionar argumentos adecuados. Por ejemplo, una función
book_flight_ticketpodría tener la descripciónbook flight tickets after confirming users' specific requirements, such as time, departure, destination, party size and preferred airline.
Usa parámetros con tipos estrictos
Si los valores de los parámetros son de un conjunto finito, agrega un campo enum en lugar de colocar el conjunto de valores en la descripción. Si el valor del parámetro es siempre un número entero, establece el tipo en integer en lugar de number.
Selección de herramientas
Si bien el modelo puede usar una cantidad arbitraria de herramientas, proporcionar demasiadas puede aumentar el riesgo de seleccionar una herramienta incorrecta o subóptima. Para obtener los mejores resultados, intenta proporcionar solo las herramientas pertinentes para el contexto o la tarea, y, de ser posible, mantén el conjunto activo en un máximo de 10 a 20. Si tienes una gran cantidad de herramientas, considera la selección dinámica de herramientas según el contexto de la conversación.
Si proporcionas herramientas genéricas de bajo nivel (como bash), es posible que el modelo las use con más frecuencia, pero con menos precisión. Si proporcionas una herramienta específica de alto nivel (como get_weather), el modelo podrá usarla con mayor precisión, pero es posible que no se use con tanta frecuencia.
Usa las instrucciones del sistema
Cuando uses funciones con parámetros de fecha, hora o ubicación, incluye la fecha, la hora o la información de ubicación actual que sea pertinente (por ejemplo, ciudad y país) en la instrucción del sistema. Esto proporciona al modelo el contexto necesario para procesar la solicitud con precisión, incluso si la instrucción del usuario carece de detalles.
Ingeniería de instrucciones
Para obtener mejores resultados, antepone los siguientes detalles a la instrucción del usuario:
- Contexto adicional para el modelo, por ejemplo,
You are a flight API assistant to help with searching flights based on user preferences. - Detalles o instrucciones sobre cómo y cuándo usar las funciones; por ejemplo,
Don't make assumptions on the departure or destination airports. Always use a future date for the departure or destination time. - Instrucciones para hacer preguntas aclaratorias si las búsquedas de los usuarios son ambiguas, por ejemplo,
Ask clarifying questions if not enough information is available.
Usar la configuración de generación
Para el parámetro de temperatura, usa 0 o algún otro valor bajo. Esto le indica al modelo que genere resultados más seguros y reduzca las alucinaciones.
Valida la llamada a la API
Si el modelo propone la invocación de una función que enviaría un pedido, actualizaría una base de datos o tendría consecuencias significativas, valida la llamada a función con el usuario antes de ejecutarla.
Usa firmas de pensamiento
Las firmas de pensamiento siempre se deben usar con la llamada a función para obtener mejores resultados.
Precios
El precio de la llamada a función se basa en la cantidad de caracteres dentro de las entradas y resultados de texto. Para obtener más información, consulta Certificaciones de Vertex AI.
Aquí, la entrada de texto (instrucción) se refiere a la instrucción del usuario para el turno de conversación actual, las declaraciones de función para el turno de conversación actual y el historial de la conversación. El historial de la conversación incluye las consultas, las llamadas a función y las respuestas de función de turnos de conversación anteriores. Vertex AI trunca el historial de la conversación en 32,000 caracteres.
El resultado de texto (respuesta) se refiere a las llamadas a función y las respuestas de texto para el turno de la conversación actual.
Casos de uso de llamada a función
Puedes usar la llamada a función para las siguientes tareas:
| Caso de uso | Descripción de ejemplo | Vínculo del ejemplo |
|---|---|---|
| Realiza la integración con APIs externas | Obtén información meteorológica con una API meteorológica | Instructivo de notebook |
| Convierte direcciones en coordenadas de latitud y longitud | Instructivo de notebook | |
| Cómo convertir monedas con una API de intercambio de divisas | Codelab | |
| Crea chatbots avanzados | Responder las preguntas de los clientes sobre productos y servicios | Instructivo de notebook |
| Crea un asistente para responder preguntas financieras y de noticias sobre empresas | Instructivo de notebook | |
| Estructura y control de las llamadas a funciones | Extrae entidades estructuradas de los datos de registro sin procesar | Instructivo de notebook |
| Extrae uno o varios parámetros de la entrada del usuario | Instructivo de notebook | |
| Cómo controlar listas y estructuras de datos anidadas en llamadas a funciones | Instructivo de notebook | |
| Cómo controlar el comportamiento de la llamada a función | Cómo controlar llamadas y respuestas a funciones paralelas | Instructivo de notebook |
| Administra cuándo y qué funciones puede llamar el modelo | Instructivo de notebook | |
| Realiza consultas en bases de datos con lenguaje natural | Convierte preguntas en lenguaje natural en consultas de SQL para BigQuery | App de ejemplo |
| Llamada a funciones multimodales | Usar imágenes, videos, audio y archivos PDF como entrada para activar llamadas a funciones | Instructivo de notebook |
Estos son otros casos prácticos:
Interpretar comandos por voz: Crea funciones que correspondan a las tareas en un vehículo. Por ejemplo, puedes crear funciones que activen la radio o el aire acondicionado. Envía archivos de audio de los comandos por voz del usuario al modelo y pídele que convierta el audio en texto y que identifique la función a la que el usuario desea llamar.
Automatizar los flujos de trabajo según los activadores de entorno: Crea funciones que representen procesos que se pueden automatizar. Proporciónale al modelo datos de los sensores ambientales y pídele que analice y procese los datos para determinar si uno o más de los flujos de trabajo deben activarse. Por ejemplo, un modelo podría procesar datos de temperatura en un almacén y elegir activar una función de rociador.
Automatizar la asignación de tickets de asistencia: Proporciónale al modelo tickets de asistencia, registros y reglas contextuales. Pídele al modelo que procese toda esta información para determinar a quién se le debe asignar el ticket. Llama a una función para asignarle el ticket a la persona que sugiere el modelo.
Recuperar información de una base de conocimiento: Crea funciones que recuperen artículos académicos sobre un tema determinado y los resuma. Permite que el modelo responda preguntas sobre temas académicos y proporcione citas para sus respuestas.
¿Qué sigue?
Consulta la referencia de la API para la llamada a función.
Obtén información sobre Vertex AI Agent Engine.