Conversaciones de varios turnos en Python
En esta página
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
systemdefine 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