Mejores prácticas y producción
En esta página
- De la prueba de concepto a la producción
- Lista de comprobación para el despliegue
- Redactar descripciones que hagan trabajar al modelo
- Elegir el modelo adecuado
- Estructurar el mensaje de sistema
- Gestionar los costes en producción
- Probar la llamada a funciones
- Monitorización en producción
- Próximos pasos
- Puntos clave
- Pon a prueba tus conocimientos
De la prueba de concepto a la producción
Ya tienes todos los componentes necesarios para construir sistemas de llamada a funciones con Mistral. Lo que separa tu prototipo de un servicio listo para producción no son funcionalidades faltantes, sino una serie de comprobaciones y ajustes que normalmente descubres durante un incidente. Esta última lección reúne las mejores prácticas, los errores comunes y una lista de comprobación para pasar a producción con confianza.
Lista de comprobación para el despliegue
Este es el único lugar del curso donde el formato de lista es obligatorio: antes de salir en vivo, marcas casillas. Debes cubrir cuatro dominios, cada uno respondiendo a una pregunta diferente.
Arquitectura garantiza que la mecánica funcione correctamente. Devolver cadenas JSON en la cadena de ejecución y disponer de un diccionario de despacho completo son las dos causas más frecuentes de fallos en la primera llamada real.
- Todas las funciones devuelven cadenas JSON (nunca objetos Python crudos)
- El diccionario de despacho está completo y actualizado
- Las funciones gestionan los casos de error y devuelven mensajes utilizables
- El mensaje de sistema es claro, preciso y ha sido probado
- El bucle de conversación gestiona llamadas secuenciales y paralelas
Seguridad asume que los argumentos provienen de un usuario, nunca de tu aplicación.
- Los argumentos se validan antes de la ejecución (formato, tipo, valores)
- Las consultas SQL utilizan parámetros (sin concatenación)
- Una lista blanca limita las funciones disponibles
- Las acciones destructivas requieren confirmación
- Se aplica limitación de tasa por función y por usuario
- Los resultados se sanitizan (no se devuelven datos sensibles al modelo)
Fiabilidad gestiona los fallos sin que nadie tenga la culpa.
- Los errores se devuelven al modelo en un formato estructurado
- Se implementa reintento con retroceso exponencial para errores transitorios
- Se configuran tiempos de espera para cada función externa
- El tamaño del historial se limita para evitar excesos de tokens
Monitorización, finalmente, es lo que te permite diagnosticar sin adivinar.
- Cada llamada a función se registra (nombre, argumentos, resultado, duración)
- Los errores activan alertas (Slack, PagerDuty, etc.)
- Se recopilan métricas (tasa de éxito, latencia, coste de API)
Redactar descripciones que hagan trabajar al modelo
La calidad de la descripción tiene un impacto directo en la precisión y, a menudo, es la palanca más barata de accionar. Tres patrones se repiten entre los equipos con altas tasas de llamadas correctas. El primero ancla la descripción en el contexto de negocio: en lugar de parafrasear el nombre de la función, enumera los posibles valores de retorno e indica explícitamente cuándo debe llamarse. El segundo introduce ejemplos de formato en la descripción del parámetro, lo que soluciona la mayoría de los errores de extracción de IDs. El tercero sustituye una instrucción en lenguaje natural por un enum, la única forma de prohibir realmente un valor fuera de la lista.
# Patrón 1: Descripción con contexto de negocio
{
"description": "Recupera el estado del pago. "
"Estados posibles: paid, pending, failed, refunded. "
"Usa esta función cuando el usuario pregunte "
"por el estado de un pago o si fue recibido."
}
# Patrón 2: Parámetros con ejemplos
{
"transaction_id": {
"type": "string",
"description": "ID único en formato T seguido de 4 dígitos (p. ej., T1001, T2345)"
}
}
# Patrón 3: Enum para valores limitados
{
"status": {
"type": "string",
"enum": ["paid", "pending", "failed", "refunded"],
"description": "Filtrar por estado del pago"
}
}
Elegir el modelo adecuado
La elección del modelo equilibra precisión frente a coste, y no hay una respuesta universal: depende del número de funciones expuestas y de la complejidad de sus esquemas. Un caso complejo con muchas funciones y parámetros anidados justifica Mistral Large 3, que es más fiable en la selección de funciones pero más caro. Un caso estándar con pocas funciones simples en producción de alto rendimiento funciona muy bien con Mistral Small 4, que es rápido y económico. Para la creación de prototipos y pruebas, Mistral Medium 3.5 ofrece un buen compromiso.
# Casos complejos: muchas funciones, parámetros anidados
# -> Mistral Large 3 (más fiable, más caro)
model = "mistral-large-latest"
# Casos estándar: pocas funciones simples, producción de alto rendimiento
# -> Mistral Small 4 (rápido, económico)
model = "mistral-small-latest"
# Casos de desarrollo: prototipado, pruebas
# -> Mistral Medium 3.5 (buen compromiso)
model = "mistral-medium-latest"
El método importa tanto como el resultado: en producción, comienza con el modelo más capaz, mide tu tasa de llamadas correctas y luego reduce gradualmente para encontrar la mejor relación coste/rendimiento. Hacer lo contrario —empezar por el modelo más barato— te priva de la línea base necesaria para saber si la degradación proviene del modelo o de tus descripciones.
Estructurar el mensaje de sistema
Un buen mensaje de sistema marca la diferencia entre un asistente mediocre y uno excelente. Este ilustra una estructura probada: una declaración de rol, un bloque de reglas imperativas y, finalmente, un recordatorio de las herramientas disponibles. Las dos reglas más rentables aquí son «Si el usuario no proporciona un ID requerido, pregúntalo amablemente» y «Nunca adivines un ID de transacción»; juntas, eliminan el comportamiento más dañino de todos: llamar a una función con un ID inventado.
system_message = {
"role": "system",
"content": """Eres un asistente de gestión de pagos para Acme Corporation.
Reglas:
- Responde siempre en inglés
- Formatea los importes en euros con el símbolo y 2 decimales
- Si el usuario no proporciona un ID requerido, pregúntalo amablemente
- Nunca adivines un ID de transacción
- Cuando una transacción falle, ofrece comprobar los detalles
Herramientas disponibles:
- retrieve_payment_status: para comprobar el estado de un pago
- retrieve_payment_date: para comprobar la fecha de un pago
- retrieve_payment_details: para obtener todos los detalles de una transacción
- list_customer_transactions: para ver todas las transacciones de un cliente"""
}
Gestionar los costes en producción
Cada llamada a función consume tokens, y la factura aumenta a través de dos canales subestimados: las definiciones de herramientas se envían en cada solicitud y el historial crece con cada turno. Filtrar funciones por contexto resuelve el primer punto: no hace falta enviar las doce herramientas cuando la pregunta trata claramente sobre pagos. Truncar el historial más allá de un umbral resuelve el segundo. Y cuando todos los datos necesarios ya están en contexto, tool_choice="none" evita una ida y vuelta adicional.
# 1. Limitar el número de funciones por solicitud
# Pasar solo las funciones relevantes para el contexto
def get_relevant_tools(user_input: str, all_tools: list) -> list:
"""Filtra las herramientas basándose en el contexto."""
if "payment" in user_input.lower() or "transaction" in user_input.lower():
return [t for t in all_tools if "payment" in t["function"]["name"]]
if "contact" in user_input.lower() or "customer" in user_input.lower():
return [t for t in all_tools if "contact" in t["function"]["name"]]
return all_tools
# 2. Limitar el tamaño del historial
MAX_HISTORY = 20 # mensajes
# 3. Usar tool_choice="none" cuando los datos ya están disponibles
Probar la llamada a funciones
Las pruebas son esenciales para evitar regresiones y, aquí, se dirigen a un objeto inusual: no estás comprobando el valor de retorno de tu función, sino la decisión del modelo. Dos familias de pruebas cubren lo esencial. La primera verifica que una pregunta de negocio active la función correcta con los argumentos extraídos adecuados. La segunda, igual de importante y a menudo olvidada, verifica que un saludo no active ninguna llamada; esta prueba detecta descripciones demasiado amplias que empujan al modelo a llamar a una función en cualquier circunstancia.
def test_payment_status():
"""Prueba que el modelo llama a la función correcta."""
messages = [{"role": "user", "content": "Status of payment T1001?"}]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
message = response.choices[0].message
assert message.tool_calls is not None
assert len(message.tool_calls) == 1
assert message.tool_calls[0].function.name == "retrieve_payment_status"
args = json.loads(message.tool_calls[0].function.arguments)
assert args["transaction_id"] == "T1001"
def test_no_function_for_greeting():
"""Prueba que el modelo no llama a una función para un saludo."""
messages = [{"role": "user", "content": "Hello!"}]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
message = response.choices[0].message
assert message.tool_calls is None or len(message.tool_calls) == 0
assert message.content is not None
Monitorización en producción
Ahora necesitas saber qué hace tu sistema una vez liberado al mundo real. La clase siguiente agrega tres señales que, juntas, cuentan casi toda la historia: tasa de éxito global, latencia media y desglose por función. Esta última es la más reveladora en la práctica: una función cuyo contador de errores se desvía de forma aislada apunta a un problema específico, mientras que una tasa global degradada no te dice dónde mirar.
import time
import logging
logger = logging.getLogger("fc_monitor")
class FunctionCallingMonitor:
def __init__(self):
self.metrics = {
"total_calls": 0,
"successful_calls": 0,
"failed_calls": 0,
"total_latency_ms": 0,
"calls_by_function": {}
}
def record(self, function_name: str, success: bool, latency_ms: float):
self.metrics["total_calls"] += 1
self.metrics["total_latency_ms"] += latency_ms
if success:
self.metrics["successful_calls"] += 1
else:
self.metrics["failed_calls"] += 1
if function_name not in self.metrics["calls_by_function"]:
self.metrics["calls_by_function"][function_name] = {
"count": 0, "errors": 0
}
self.metrics["calls_by_function"][function_name]["count"] += 1
if not success:
self.metrics["calls_by_function"][function_name]["errors"] += 1
def get_success_rate(self) -> float:
if self.metrics["total_calls"] == 0:
return 0.0
return self.metrics["successful_calls"] / self.metrics["total_calls"]
def get_avg_latency(self) -> float:
if self.metrics["total_calls"] == 0:
return 0.0
return self.metrics["total_latency_ms"] / self.metrics["total_calls"]
monitor = FunctionCallingMonitor()
Próximos pasos
Ahora que has dominado la llamada a funciones con Mistral, se abren varias direcciones. La más natural es construir agentes autónomos, combinando la llamada a funciones con un bucle de agente que planifique y ejecute tareas complejas; la API de Agentes de Mistral y su client.beta.agents.create() van más allá al ofrecer agentes persistentes con estado. Otro eje combina RAG y llamada a funciones: el modelo decide por sí mismo cuándo consultar una base de datos vectorial, en lugar de que la búsqueda se active sistemáticamente aguas arriba. En el lado de la experiencia de usuario, la transmisión en tiempo real (streaming) te permite mostrar respuestas mientras se ejecutan las funciones, cambiando la percepción de la latencia en cadenas de llamadas largas. Finalmente, lo multimodal abre la llamada a funciones a la visión para el análisis de documentos.
Puntos clave
- La lista de comprobación para el despliegue cubre arquitectura, seguridad, fiabilidad y monitorización
- Las descripciones precisas con ejemplos y enums mejoran la precisión del modelo
- Elige el modelo adecuado según la complejidad y el presupuesto (Large para fiabilidad, Small para rendimiento)
- El mensaje de sistema es una palanca poderosa para guiar el comportamiento
- Prueba las llamadas a funciones y el comportamiento sin función de forma sistemática
- Monitoriza la tasa de éxito, la latencia y los costes en producción
Pon a prueba tus conocimientos
Llamada a funciones de extremo a extremo: cinco comprobaciones.
1. ¿Cuáles son los cinco pasos de la llamada a funciones?
Respuesta: Definir funciones (esquemas), proporcionarlas a la API, el modelo solicita una llamada con sus argumentos, tu código ejecuta y devuelve el resultado, el modelo produce la respuesta final.
2. ¿Qué hace que un esquema de función sea bueno?
Respuesta: Tipos estrictos y descripciones operativas: nombre claro, cuándo usarlo, formato de cada parámetro; este es el texto que el modelo lee para decidir y rellenar.
3. ¿Qué permiten las llamadas paralelas?
Respuesta: El modelo solicita múltiples funciones en una sola respuesta cuando son independientes: menos idas y vueltas, siempre que coincidas cada resultado con su llamada.
4. ¿Para qué sirve tool_choice?
Respuesta: Para establecer la libertad del modelo: auto (decide él), any (debe usar una herramienta) o una herramienta forzada; esta última es clave para una extracción estructurada fiable.
5. ¿Qué reglas de seguridad para las funciones expuestas?
Respuesta: Validar los argumentos recibidos, limitar el alcance de cada función, registrar las llamadas y mantener la validación humana en acciones comprometedoras: el modelo propone, tu código dispone.
Los dos ejemplos trabajados en este curso (rastreador de pagos, CRM) aplican exactamente estas reglas; tus propias integraciones seguirán el mismo molde.