Ejecutar y devolver el resultado
En esta página
El paso que controlas por completo
Has recibido un tool_call del modelo. Este te indica qué función llamar y con qué argumentos, nada más. Ahora tu código toma el relevo: ejecuta la función, recupera el resultado y lo envía de vuelta al modelo como un mensaje con el rol tool. Esta lección cubre todo ese ciclo de ida y vuelta. Este es el único momento del ciclo en el que tú tomas todas las decisiones.
Ejecutar la función en el lado del cliente
Volvamos al diccionario de despacho de la Lección 4 y conectémoslo con la respuesta del modelo.
import json
from functools import partial
# Funciones ya definidas
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# El modelo devolvió un tool_call
tool_call = response.choices[0].message.tool_calls[0]
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Ejecutar la función
if function_name in available_functions:
result = available_functions[function_name](**function_params)
print(f"Resultado: {result}")
# → '{"status": "paid"}'
else:
result = json.dumps({"error": f"Función {function_name} no disponible"})
Aquí intervienen dos mecanismos. El primero es **function_params, que desempaqueta el diccionario del JSON en argumentos con nombre: si el modelo generó {"transaction_id": "T1001"}, la llamada es exactamente equivalente a retrieve_payment_status(transaction_id="T1001"). El segundo es el bloque else. Es menos llamativo, pero esencial. Un modelo podría alucinar un nombre de función que no existe en tu despacho; sin esta comprobación, tu aplicación lanzaría un KeyError y la conversación se detendría en seco. Con él, el error se convierte en datos que el modelo puede gestionar con elegancia.
Construir el mensaje de herramienta
El resultado debe volver al modelo en un formato específico: un mensaje con el rol "tool":
tool_message = {
"role": "tool",
"name": function_name,
"content": result, # Debe ser una cadena
"tool_call_id": tool_call.id
}
| Campo | Función |
|---|---|
role | "tool": identifica el mensaje como un resultado de función |
name | El nombre de la función ejecutada |
content | El resultado como una cadena JSON |
tool_call_id | El ID del tool_call original: permite al modelo asociar el resultado a la llamada correcta |
Enviar el resultado y obtener la respuesta final
El modelo no tiene memoria de una llamada a la siguiente: no recuerda haberte pedido nada. Por tanto, debes reconstruir para él toda la conversación, incluida su propia solicitud de llamada a herramienta, antes de presentarle el resultado.
# 1. Añadir el mensaje del asistente (con el tool_call)
messages.append(response.choices[0].message)
# 2. Añadir el resultado de la función
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# 3. Volver a llamar al modelo con el contexto completo
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
# 4. Mostrar la respuesta final
print(final_response.choices[0].message.content)
# → "Payment T1001 status is: paid."
El orden de las dos operaciones append es innegociable: el mensaje del asistente que contiene el tool_call debe ir antes del mensaje tool que lo responde. Intercambiarlos crea un historial inconsistente que la API rechaza.
El flujo completo en un solo bloque
Aquí tienes todo el proceso, desde la pregunta del usuario hasta la respuesta final:
import os
import json
from mistralai.client import Mistral
from functools import partial
# Configuración
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"
# Funciones y herramientas (definidas anteriormente)
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# Pasos 1-2: Pregunta del usuario + llamada a la API
messages = [
{"role": "user", "content": "What is the status of payment T1001?"}
]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
# Pasos 3-4: Extraer el tool_call y ejecutar
message = response.choices[0].message
if message.tool_calls:
tool_call = message.tool_calls[0]
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Ejecución en el lado del cliente
result = available_functions[function_name](**function_params)
# Paso 5: Enviar el resultado de vuelta al modelo
messages.append(message)
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
final_response = client.chat.complete(
model=model, messages=messages, tools=tools
)
print(final_response.choices[0].message.content)
else:
print(message.content)
Estructura de mensajes en cada paso
Merece la pena inspeccionar la lista messages una vez finalizado el ciclo, porque es la mejor manera de depurar llamadas a funciones que no funcionan correctamente. Contiene cuatro mensajes.
# Mensaje 1: La pregunta del usuario
{"role": "user", "content": "What is the status of payment T1001?"}
# Mensaje 2: La respuesta del modelo con el tool_call
{"role": "assistant", "tool_calls": [{"id": "call_abc123", ...}]}
# Mensaje 3: El resultado de la función
{"role": "tool", "name": "retrieve_payment_status",
"content": '{"status": "paid"}', "tool_call_id": "call_abc123"}
# Mensaje 4 (implícito): La respuesta final del modelo
# → "Payment T1001 status is: paid."
Sigue el ID call_abc123: nace en el Mensaje 2 y reaparece en el Mensaje 3. Ese hilo vincula la solicitud con su respuesta. Esta estructura es el patrón fundamental de la llamada a funciones; cualquier variación que encuentres más adelante, ya sea en múltiples turnos o en paralelo, simplemente lo repite o duplica.
Vigila el formato del contenido
Un error aparece con más frecuencia que todos los demás, y se reduce al tipo del campo content: debe ser siempre una cadena.
# Correcto — cadena JSON
{"content": '{"status": "paid"}'}
# Correcto — texto plano
{"content": "The status is paid"}
# Incorrecto — diccionario de Python (causará un error)
{"content": {"status": "paid"}}
La diferencia entre el primer y el tercer ejemplo radica en las comillas que envuelven el JSON. Si tu función devuelve un diccionario, conviértelo con json.dumps() antes de enviarlo; esa es precisamente la razón por la que todas las funciones de la Lección 4 terminaban con un json.dumps().
Puntos clave
- La ejecución de la función ocurre en el lado del cliente, en tu código, nunca por parte del modelo
- El resultado se envía de vuelta en un mensaje con el rol
"tool"y eltool_call_idcorrespondiente - El
contentdel mensaje de herramienta debe ser una cadena (una cadena JSON) - Tras enviar el resultado, vuelves a llamar a
chat.complete()para que el modelo pueda formular la respuesta final - Verifica siempre que la función solicitada existe en tu diccionario de despacho