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

Conversaciones de varios turnos en Python

Lección 7 de 14 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Una memoria que no es realmente memoria
  2. Los tres roles que estructuran el historial
  3. Una conversación completa, turno a turno
  4. Evitar que el historial resulte prohibitivamente caro
  5. Diseñar el mensaje de sistema
  6. Puntos clave

Una memoria que no es realmente memoria

A diferencia de un motor de búsqueda, un modelo de lenguaje sigue el hilo de una conversación: tiene en cuenta lo dicho anteriormente y construye sus respuestas sobre ese contexto acumulado. Esto se denomina conversación de varios turnos (multi-turn) y es lo que hace posibles preguntas elípticas como «¿y con argumentos?».

Técnicamente, sin embargo, el modelo no recuerda nada. No se conserva ningún estado en el servidor entre llamadas. Con cada solicitud, debes reenviar el historial completo, que el modelo lee de principio a fin antes de responder. Este mecanismo explica dos aspectos que retomaremos más adelante: eres totalmente responsable de la gestión de la memoria y cada turno de la conversación cuesta más que el anterior.

Los tres roles que estructuran el historial

Cada mensaje del historial incluye un rol que indica al modelo quién está hablando. El rol system define el comportamiento general: colocado en primer lugar, influye en todas las respuestas siguientes.

{"role": "system", "content": "Eres un asistente experto en cocina francesa. Responde siempre en francés utilizando términos culinarios precisos."}

El rol user contiene los mensajes del usuario, es decir, la pregunta o instrucción enviada:

{"role": "user", "content": "¿Cómo hago un hojaldre perfecto?"}

Por último, el rol assistant contiene las respuestas previas del modelo. Estos son los mensajes que debes reinyectar en el historial para mantener la coherencia. Olvidarlos equivale a borrar la memoria de la conversación en cada turno.

{"role": "assistant", "content": "Para hacer un hojaldre perfecto, empieza por..."}

Una conversación completa, turno a turno

El código siguiente aplica este principio: una función que añade la pregunta al historial, llama al modelo y, a continuación, almacena la respuesta en el lugar adecuado antes de devolverla.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

historique = [
    {
        "role": "system",
        "content": "Eres un asistente docente especializado en programación en Python. Responde de forma concisa e incluye ejemplos de código."
    }
]

def poser_question(question: str) -> str:
    """Envía una pregunta y actualiza el historial."""
    historique.append({"role": "user", "content": question})

    response = client.chat.complete(
        model="mistral-small-latest",
        messages=historique,
    )

    reponse_texte = response.choices[0].message.content
    historique.append({"role": "assistant", "content": reponse_texte})

    return reponse_texte

# Turno 1
print("P: ¿Qué es un decorador en Python?")
r1 = poser_question("What is a decorator in Python?")
print(f"R: {r1}\n")

# Turno 2: el modelo conoce el contexto
print("P: ¿Puedes mostrarme un ejemplo concreto?")
r2 = poser_question("Can you show me a concrete example?")
print(f"R: {r2}\n")

# Turno 3: referencia implícita a los turnos anteriores
print("P: ¿Cómo lo uso con argumentos?")
r3 = poser_question("How do I use it with arguments?")
print(f"R: {r3}\n")

En el tercer turno, la pregunta no vuelve a mencionar la palabra «decorador». El modelo sigue entendiendo que «usarlo» se refiere a ese concepto porque vuelve a leer todo el intercambio. Elimina la línea que añade la respuesta al historial y ejecútalo de nuevo: el modelo preguntará de qué estás hablando. Esta es la prueba más rápida de que la continuidad no proviene del modelo, sino de tu código.

Evitar que el historial resulte prohibitivamente caro

Cada modelo tiene una ventana de contexto limitada, medida en tokens. A medida que crece el historial, cada solicitud resulta más cara porque se retransmite todo. Una conversación de treinta turnos factura efectivamente su inicio treinta veces.

La solución más sencilla es truncar, conservando el mensaje de sistema y los últimos N intercambios:

MAX_MESSAGES = 20

def ajouter_message(historique, role, content):
    historique.append({"role": role, "content": content})

    # Conservar el mensaje de sistema + los últimos N mensajes
    if len(historique) > MAX_MESSAGES + 1:  # +1 para el mensaje de sistema
        system_msg = historique[0]
        historique = [system_msg] + historique[-(MAX_MESSAGES):]

    return historique

Este enfoque es barato, pero brutal: lo que el usuario especificó en el segundo turno desaparece para siempre. Cuando la conversación es larga y ese contexto antiguo importa (una entrevista de recopilación de requisitos, por ejemplo), resúmelo en lugar de descartarlo:

def resumer_historique(client, historique):
    """Resume mensajes antiguos para liberar contexto."""
    texte_complet = "\n".join(
        f"{m['role']}: {m['content']}"
        for m in historique[1:-4]  # Excluir sistema y los últimos 4 mensajes
    )

    resume = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {"role": "user", "content": f"Resume esta conversación en 3-4 frases:\n{texte_complet}"}
        ]
    )

    return [
        historique[0],  # Mensaje de sistema
        {"role": "assistant", "content": f"[Resumen de la conversación] {resume.choices[0].message.content}"},
    ] + historique[-4:]  # Los últimos 4 mensajes

La idea consiste en comprimir el pasado lejano en unas pocas frases mientras se mantienen intactos los últimos cuatro mensajes, ya que contienen el contexto inmediato. El resumen consume una llamada adicional, pero se amortiza con creces en los turnos siguientes.

Diseñar el mensaje de sistema

El mensaje de sistema es la herramienta más potente y menos utilizada de esta lección. Muchos se conforman con un genérico «Eres un asistente útil» que no aporta nada. Un buen mensaje de sistema establece restricciones verificables:

system_prompt = """Eres un asistente técnico de Corsen AI.

Reglas:
- Responde en francés con un tono profesional
- Proporciona ejemplos de código cuando sea relevante
- Si no estás seguro, dilo en lugar de inventar
- Limita tus respuestas a 200 palabras salvo que se te pida lo contrario

Contexto: El usuario está trabajando en un proyecto Python 3.12 con FastAPI."""

Cada línea aquí produce un efecto medible: el límite de longitud contiene los costes, la invitación a reconocer la incertidumbre reduce las alucinaciones y mencionar la pila tecnológica evita respuestas genéricas y fuera de tema. Solo necesita ser conciso, preciso y sin ambigüedades.

Puntos clave

  • El historial completo se reenvía con cada solicitud; el modelo no «recuerda» nada
  • Tres roles (system, user, assistant) estructuran la conversación
  • El mensaje system define el comportamiento general; colócalo siempre en primer lugar
  • Gestiona el tamaño del contexto truncando o resumiendo mensajes antiguos
  • Cuanto más largo sea el historial, más costará cada solicitud en tokens