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

Conversación multi-turno

Lección 7 de 14 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Más allá de las llamadas únicas
  2. El principio: mantener el historial
  3. Bucle de conversación completo
  4. Ejemplo de conversación multi-turno
  5. Encadenamiento de llamadas secuenciales
  6. Gestión del tamaño del historial
  7. Puntos clave

Más allá de las llamadas únicas

En una aplicación real, los usuarios no formulan una pregunta y desaparecen. Encadenan solicitudes, retoman temas anteriores y lanzan pistas como «¿y este?» que la frase por sí sola no puede resolver. La llamada a funciones debe operar dentro de este contexto de conversación multi-turno, donde el modelo puede invocar funciones en cada paso del diálogo sin perder nunca el hilo de lo ocurrido anteriormente.

El principio: mantener el historial

La clave se resume en una frase: mantén todos los mensajes en una lista que crece con cada intercambio. El modelo no tiene memoria propia entre llamadas a la API; el único contexto del que dispone es lo que tú le envías. Este historial completo es lo que le permite comprender referencias implícitas.

import os
import json
from mistralai.client import Mistral
from functools import partial

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Historial de la conversación
messages = [
    {
        "role": "system",
        "content": "Eres un asistente de seguimiento de pagos. "
                   "Responde en inglés conciso."
    }
]

Bucle de conversación completo

El código siguiente funciona en dos fases. process_tool_calls ejecuta todas las llamadas solicitadas por el modelo y reinicia la conversación con los resultados; chat gestiona un turno completo, desde la entrada del usuario hasta el texto final.

def process_tool_calls(response, messages, available_functions, tools):
    """Procesa las tool_calls y devuelve la respuesta final."""
    message = response.choices[0].message
    messages.append(message)

    # Ejecutar cada tool_call
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)

        if function_name in available_functions:
            result = available_functions[function_name](**function_params)
        else:
            result = json.dumps({"error": f"Función desconocida {function_name}"})

        messages.append({
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        })

    # Volver a llamar al modelo con los resultados
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Gestiona un turno completo de conversación."""
    messages.append({"role": "user", "content": user_input})

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )

    message = response.choices[0].message

    # Bucle mientras el modelo quiera llamar a funciones
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # El modelo ha terminado: responde con texto
    messages.append(message)
    return message.content

El bucle while es la pieza crítica. Tras recibir el resultado de una función, es muy posible que el modelo solicite otra: el bucle continúa mientras se generen tool_calls y se detiene solo cuando finalmente devuelve texto. Un simple if gestionaría la primera llamada y devolvería una respuesta vacía en cualquier caso en que fueran necesarias dos llamadas.

Ejemplo de conversación multi-turno

Veamos cómo se comporta este bucle a lo largo de cuatro turnos encadenados.

# Turno 1
reponse = chat("What is the status of payment T1001?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 status: paid."

# Turno 2 — pregunta de seguimiento
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Turno 3 — nueva transacción
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Turno 4 — pregunta sin función
reponse = chat("Thanks, that's all for today.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "You're welcome! Feel free to ask if you have other questions."

El turno 2 es el que hay que examinar de cerca. «When was it made?» no contiene ningún identificador; es el historial lo que permite al modelo entender que esto sigue refiriéndose a T1001 y llamar a retrieve_payment_date con el argumento correcto. Elimina los mensajes del turno 1 y esta frase se vuelve irresoluble. En el turno 3, el modelo puede decidir llamar a varias funciones —estado y fecha para T1003— para construir la comparación con los resultados ya obtenidos para T1001. El turno 4 no activa ninguna llamada: el modelo también sabe cuándo contenerse.

Encadenamiento de llamadas secuenciales

Algunas solicitudes requieren que el modelo espere a un resultado antes de saber qué pedir a continuación. El bucle while en chat() gestiona este caso sin necesidad de ni una sola línea de código adicional.

# El usuario pide algo que requiere 2 llamadas secuenciales
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# El modelo puede:
# 1. Llamar a retrieve_payment_status(T1002)
# 2. Recibir el resultado
# 3. Llamar a retrieve_payment_date(T1002)
# 4. Recibir el resultado
# 5. Formular la respuesta final con ambas informaciones

Visto desde el historial de mensajes, el flujo secuencial tiene este aspecto:

user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)

Cuenta los turnos del asistente: tres, es decir, tres solicitudes facturadas a la API. Ese es el coste de la ejecución secuencial, y la razón por la que la siguiente lección se centra en las llamadas paralelas.

Gestión del tamaño del historial

En producción, una conversación de larga duración resulta costosa: cada turno reenvía el conjunto completo de mensajes anteriores y la factura de tokens crece de forma cuadrática. Una estrategia sencilla consiste en conservar solo el mensaje de sistema y los intercambios más recientes.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Mantiene el mensaje de sistema y los últimos N mensajes."""
    system_messages = [m for m in messages if hasattr(m, "role")
                       and m.get("role") == "system"
                       or (isinstance(m, dict) and m.get("role") == "system")]

    non_system = [m for m in messages if m not in system_messages]

    if len(non_system) > max_messages:
        non_system = non_system[-max_messages:]

    return system_messages + non_system

Una precaución antes de integrar esta función: nunca cortes una tool_call sin su mensaje tool correspondiente. Si el truncamiento cae entre ambos, la API recibe una solicitud de llamada sin respuesta y rechaza la consulta. Ajusta el punto de corte para preservar pares completos en lugar de contar mensajes a ciegas.

Puntos clave

  • Mantén un historial completo de mensajes para que el modelo entienda el contexto
  • Usa un bucle while para gestionar llamadas a funciones secuenciales
  • El modelo comprende referencias implícitas («ese», «el anterior») gracias al contexto
  • En producción, limita el tamaño del historial manteniendo intactos los pares tool_call/tool
  • La función chat() mostrada aquí es un patrón reutilizable para cualquier aplicación de llamada a funciones