Ir al contenido principal
Español— Elegir un idioma
Menú

Ejecutar y devolver el resultado

Lección 6 de 14 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. El paso que controlas por completo
  2. Ejecutar la función en el lado del cliente
  3. Construir el mensaje de herramienta
  4. Enviar el resultado y obtener la respuesta final
  5. El flujo completo en un solo bloque
  6. Estructura de mensajes en cada paso
  7. Vigila el formato del contenido
  8. Puntos clave

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
}
CampoFunción
role"tool": identifica el mensaje como un resultado de función
nameEl nombre de la función ejecutada
contentEl resultado como una cadena JSON
tool_call_idEl 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 el tool_call_id correspondiente
  • El content del 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