Memoria y personalidad

"La personalidad de un bot no se entrena: se escribe. Y su memoria no existe: se reenvía."

Qué vas a aprender en este capítulo

Al final de este capítulo vas a tener el primer bot funcional de La Esquina: un programa de consola con el que podés mantener una conversación real — que recuerda lo que dijiste, que habla como empleado cordial de pupusería migueleña, que responde fluido (streaming) y que guarda la conversación en disco. Cumple los requisitos R6 y R7 de la tabla del capítulo 1.

En el camino vas a entender las dos piezas más malentendidas de los chatbots:

• La memoria: por qué es una lista que tu código acumula y reenvía, qué pasa cuando crece, y cómo recortarla sin que el bot se vuelva amnésico.
• La personalidad: cómo se escribe un system prompt profesional — no "sé amable", sino rol, tono, reglas, límites y formato, con ejemplos.

2.1 El loop de conversación

Vamos directo al código. Creá bot_v1.py:

"""Bot de La Esquina v1: loop de conversación con memoria."""
from dotenv import load_dotenv
import anthropic

load_dotenv()

SYSTEM_PROMPT = "Sos el asistente de La Esquina, una pupusería de San Miguel, El Salvador."


class Chatbot:
    """Un chatbot con memoria: acumula el historial y lo reenvía completo."""

    def __init__(self, system_prompt: str, model: str = "claude-opus-4-8"):
        self.client = anthropic.Anthropic()
        self.system_prompt = system_prompt
        self.model = model
        self.historial: list[dict] = []   # la "memoria" vive aca

    def enviar(self, mensaje_usuario: str) -> str:
        # Paso 1: agregar el turno del usuario al historial
        self.historial.append({"role": "user", "content": mensaje_usuario})

        # Paso 2: mandar el historial COMPLETO (la API es stateless)
        respuesta = self.client.messages.create(
            model=self.model,
            max_tokens=1024,
            system=self.system_prompt,
            messages=self.historial,
        )
        texto = respuesta.content[0].text

        # Paso 3: agregar la respuesta al historial para el proximo turno
        self.historial.append({"role": "assistant", "content": texto})
        return texto


def main():
    bot = Chatbot(SYSTEM_PROMPT)
    print("Bot de La Esquina v1 — escribí 'salir' para terminar.\n")
    while True:
        entrada = input("Vos: ").strip()
        if entrada.lower() in ("salir", "exit", "quit"):
            print("¡Que le vaya bien!")
            break
        if not entrada:
            continue
        print(f"\nBot: {bot.enviar(entrada)}\n")


if __name__ == "__main__":
    main()

Corrélo y probá la memoria:

Vos: Me llamo Beatriz y quiero pupusas de queso
Bot: ¡Hola Beatriz! Con gusto...
Vos: ¿Cómo me llamo?
Bot: ¡Te llamás Beatriz! 😊

Funciona. La "magia" es el append antes y después de cada llamada.

def enviar(self, mensaje_usuario: str) -> str:
    respuesta = self.client.messages.create(
        model=self.model,
        max_tokens=1024,
        system=self.system_prompt,
        messages=[{"role": "user", "content": mensaje_usuario}],   # ❌ solo el ultimo turno
    )
    return respuesta.content[0].text

2.2 El system prompt: la personalidad por escrito

El bot v1 responde, pero su comportamiento es genérico. Hora de cumplir el requisito R6: tono cordial salvadoreño, reglas claras, y — crítico — qué no debe hacer.

Este es el system prompt real del bot de La Esquina. Leelo completo — cada sección existe por una razón:

SYSTEM_PROMPT = """Sos "Esquinita", el asistente virtual de La Esquina, pupusería \
con 3 sucursales en San Miguel, El Salvador.

# Tu rol
Atendés clientes por chat: respondés preguntas sobre el menú, los precios y los \
horarios, y ayudás a armar y registrar pedidos.

# Tono
- Cordial y cercano, al estilo salvadoreño: "con gusto", "fíjese que", "¡cómo no!".
- Tratá al cliente de "usted".
- Respuestas CORTAS: 1 a 3 oraciones para preguntas simples. Esto es un chat,
  no una carta.
- Podés usar un emoji ocasional (😊 🫓), máximo uno por mensaje.

# Reglas del negocio
- Sucursales: Centro, Roosevelt y Metrocentro.
- Si el cliente quiere pedir, necesitás: los items, su nombre y la sucursal.
  Pedí SOLO los datos que falten, de uno en uno, sin interrogatorios.
- Los precios y el menú los consultás con tus herramientas cuando las tengás
  disponibles; si todavía no las tenés, decí que vas a confirmar el dato.

# Qué NO hacés (importante)
- NUNCA inventés precios, promociones ni platillos. Si no sabés un dato, decilo:
  "Fíjese que ese dato no lo tengo a mano, con gusto se lo confirmo".
- No hablés de temas ajenos a la pupusería (política, religión, otros negocios).
  Redirigí con amabilidad: "Yo solo le puedo ayudar con cositas de La Esquina 😊".
- No prometás tiempos de entrega exactos ni descuentos.
- Si el cliente está molesto, disculpate una vez, no discutás, y ofrecé que
  un encargado lo contacte.

# Formato
- Cuando confirmés un pedido, listá los items con viñetas y el total al final.
- Nunca uses tablas ni encabezados markdown: esto se lee en una burbuja de chat.
"""

2.3 Streaming: que se sienta vivo

Con respuestas de 2-3 segundos, el usuario mira una pantalla congelada y duda si el bot murió. Streaming resuelve esto: la API va enviando la respuesta token a token a medida que se genera, y vos la mostrás al instante — como ver escribir a alguien.

def enviar_streaming(self, mensaje_usuario: str) -> str:
    """Como enviar(), pero muestra la respuesta token a token."""
    self.historial.append({"role": "user", "content": mensaje_usuario})

    with self.client.messages.stream(
        model=self.model,
        max_tokens=1024,
        system=self.system_prompt,
        messages=self.historial,
    ) as stream:
        for texto in stream.text_stream:
            print(texto, end="", flush=True)   # mostrar cada fragmento YA
        print()                                 # salto de linea final
        mensaje = stream.get_final_message()    # el objeto Message completo

    texto_completo = mensaje.content[0].text
    self.historial.append({"role": "assistant", "content": texto_completo})
    return texto_completo

Tres detalles que importan:

• with ... as stream — el context manager garantiza que la conexión HTTP se cierre bien aunque haya una excepción a mitad del stream.
• flush=True — sin esto, Python guarda la salida en un buffer y la imprime a borbotones; el streaming se vería igual de congelado que antes.
• stream.get_final_message() — al terminar el stream, te da el objeto Message completo, con usage y stop_reason incluidos. De ahí sacás el texto para el historial — no vayas concatenando fragmentos a mano, que es frágil.

2.4 Cuando la memoria crece: ventana deslizante

Cada turno agranda el historial. Tres problemas crecen con él:

1. Costo: cada token viejo se re-factura como entrada en cada turno nuevo.
2. Latencia: requests más grandes tardan más en procesarse.
3. Límite duro: la ventana de contexto del modelo (1M tokens en Opus 4.8 — lejana para un chat de pupusería, pero existe).

La solución más simple y usada: ventana deslizante — conservar solo los últimos K turnos.

MAX_TURNOS = 20   # turnos = entradas en el historial (10 intercambios)

def _recortar_historial(self) -> list[dict]:
    """Devuelve el historial recortado a los ultimos MAX_TURNOS turnos.

    Garantiza que el primer mensaje del recorte sea 'user', porque la API
    exige que messages empiece con un turno user.
    """
    if len(self.historial) <= MAX_TURNOS:
        return self.historial
    recorte = self.historial[-MAX_TURNOS:]
    # Si el recorte quedo empezando en 'assistant', descartamos ese turno:
    if recorte[0]["role"] == "assistant":
        recorte = recorte[1:]
    return recorte

Y en enviar_streaming, cambiás messages=self.historial por messages=self._recortar_historial(). Ojo: el historial completo se sigue guardando en self.historial (para persistirlo, para auditoría) — lo que se recorta es lo que se envía.

2.5 Persistir la conversación en JSON

Si el programa se cierra, la conversación muere. Para retomarla (y para que doña Carmen pueda revisar qué piden los clientes), la guardamos en disco. El historial ya es una lista de dicts — JSON nativo:

import json
from datetime import datetime, timezone
from pathlib import Path

def guardar(self, ruta: str) -> None:
    """Guarda la conversacion completa en un archivo JSON."""
    datos = {
        "guardado_en": datetime.now(timezone.utc).isoformat(),
        "model": self.model,
        "system_prompt": self.system_prompt,
        "historial": self.historial,
    }
    Path(ruta).parent.mkdir(parents=True, exist_ok=True)
    with open(ruta, "w", encoding="utf-8") as f:
        json.dump(datos, f, ensure_ascii=False, indent=2)

def cargar(self, ruta: str) -> None:
    """Restaura una conversacion guardada."""
    with open(ruta, encoding="utf-8") as f:
        datos = json.load(f)
    self.historial = datos["historial"]
    self.system_prompt = datos.get("system_prompt", self.system_prompt)

ensure_ascii=False mantiene las tildes y eñes legibles en el archivo; encoding="utf-8" en ambas direcciones evita el clásico desastre de caracteres en Windows. Guardamos también el system prompt: si mañana lo cambiás, querés saber con cuál se generó cada conversación vieja.

2.6 El bot completo: bot_v2.py

Todo junto — este es el código íntegro del bot de consola de La Esquina al final del capítulo 2. Copialo y corrélo:

"""Bot de La Esquina v2: memoria + personalidad + streaming + recorte + JSON."""
import json
from datetime import datetime, timezone
from pathlib import Path

from dotenv import load_dotenv
import anthropic

load_dotenv()

MAX_TURNOS = 20

SYSTEM_PROMPT = """Sos "Esquinita", el asistente virtual de La Esquina, pupusería \
con 3 sucursales en San Miguel, El Salvador.

# Tu rol
Atendés clientes por chat: respondés preguntas sobre el menú, los precios y los \
horarios, y ayudás a armar y registrar pedidos.

# Tono
- Cordial y cercano, al estilo salvadoreño: "con gusto", "fíjese que", "¡cómo no!".
- Tratá al cliente de "usted".
- Respuestas CORTAS: 1 a 3 oraciones para preguntas simples.
- Podés usar un emoji ocasional (😊 🫓), máximo uno por mensaje.

# Reglas del negocio
- Sucursales: Centro, Roosevelt y Metrocentro.
- Si el cliente quiere pedir, necesitás: los items, su nombre y la sucursal.
  Pedí SOLO los datos que falten, de uno en uno.
- Los precios y el menú los consultás con tus herramientas cuando las tengás
  disponibles; si todavía no las tenés, decí que vas a confirmar el dato.

# Qué NO hacés
- NUNCA inventés precios, promociones ni platillos. Si no sabés, decilo.
- No hablés de temas ajenos a la pupusería. Redirigí con amabilidad.
- No prometás tiempos de entrega exactos ni descuentos.
- Si el cliente está molesto, disculpate una vez y ofrecé que un encargado
  lo contacte.

# Formato
- Pedidos confirmados: items con viñetas y el total al final.
- Nada de tablas ni encabezados markdown: esto es una burbuja de chat.
"""


class Chatbot:
    """Chatbot con historial, streaming, recorte y persistencia."""

    def __init__(self, system_prompt: str, model: str = "claude-opus-4-8"):
        self.client = anthropic.Anthropic()
        self.system_prompt = system_prompt
        self.model = model
        self.historial: list[dict] = []
        self.tokens_entrada = 0
        self.tokens_salida = 0

    # ---------- memoria ----------

    def _recortar_historial(self) -> list[dict]:
        if len(self.historial) <= MAX_TURNOS:
            return self.historial
        recorte = self.historial[-MAX_TURNOS:]
        if recorte[0]["role"] == "assistant":
            recorte = recorte[1:]
        return recorte

    # ---------- conversacion ----------

    def enviar(self, mensaje_usuario: str) -> str:
        """Envia un mensaje y muestra la respuesta con streaming."""
        self.historial.append({"role": "user", "content": mensaje_usuario})
        try:
            with self.client.messages.stream(
                model=self.model,
                max_tokens=1024,
                system=self.system_prompt,
                messages=self._recortar_historial(),
            ) as stream:
                for texto in stream.text_stream:
                    print(texto, end="", flush=True)
                print()
                mensaje = stream.get_final_message()
        except anthropic.RateLimitError:
            self.historial.pop()   # deshacer el turno: no hubo respuesta
            return "⏳ Demasiados mensajes seguidos. Esperá un minuto."
        except anthropic.APIConnectionError:
            self.historial.pop()
            return "🔌 Sin conexión. Revisá tu internet."

        texto_completo = mensaje.content[0].text
        self.historial.append({"role": "assistant", "content": texto_completo})
        self.tokens_entrada += mensaje.usage.input_tokens
        self.tokens_salida += mensaje.usage.output_tokens
        return texto_completo

    # ---------- costo ----------

    def costo_acumulado(self) -> float:
        """Costo en USD de la sesion (precios Opus 4.8, junio 2026)."""
        return (self.tokens_entrada * 5.00 + self.tokens_salida * 25.00) / 1_000_000

    # ---------- persistencia ----------

    def guardar(self, ruta: str) -> None:
        datos = {
            "guardado_en": datetime.now(timezone.utc).isoformat(),
            "model": self.model,
            "system_prompt": self.system_prompt,
            "historial": self.historial,
        }
        Path(ruta).parent.mkdir(parents=True, exist_ok=True)
        with open(ruta, "w", encoding="utf-8") as f:
            json.dump(datos, f, ensure_ascii=False, indent=2)

    def cargar(self, ruta: str) -> None:
        with open(ruta, encoding="utf-8") as f:
            datos = json.load(f)
        self.historial = datos["historial"]
        self.system_prompt = datos.get("system_prompt", self.system_prompt)


def main():
    bot = Chatbot(SYSTEM_PROMPT)
    ruta = "conversaciones/ultima.json"
    if Path(ruta).exists():
        if input("¿Retomar la conversación anterior? (s/n): ").lower() == "s":
            bot.cargar(ruta)
            print(f"({len(bot.historial)} turnos restaurados)\n")

    print("🫓 Esquinita v2 — 'salir' para terminar.\n")
    while True:
        entrada = input("Vos: ").strip()
        if entrada.lower() in ("salir", "exit", "quit"):
            bot.guardar(ruta)
            print(f"\nConversación guardada. Costo de la sesión: "
                  f"${bot.costo_acumulado():.4f} USD. ¡Que le vaya bien!")
            break
        if not entrada:
            continue
        print("Bot: ", end="", flush=True)
        bot.enviar(entrada)
        print()


if __name__ == "__main__":
    main()

Fijate en un detalle de robustez: cuando una llamada falla, hacemos self.historial.pop() para deshacer el turno del usuario que acabábamos de agregar. Si no, el historial queda con un user colgado sin respuesta, y el siguiente mensaje del usuario crearía dos user consecutivos → error 400.

Resumen visual

U->>B: "Me llamo Beatriz, 3 de queso"
B->>B: historial.append(user)
B->>A: system + historial completo
A-->>B: stream token a token
B-->>U: muestra en vivo (flush)
B->>B: historial.append(assistant)
Note over B: turno 2 en adelante:<br/>recortar a MAX_TURNOS<br/>(sin romper alternancia)
U->>B: "¿Cómo me llamo?"
B->>A: system + TODO el historial otra vez
A-->>B: "¡Beatriz!" (lo leyó en el historial)
Note over B: al salir: guardar(ruta) → JSON

Estado del proyecto — R6 (personalidad y tono) ✅ y R7 (memoria) ✅. El bot conversa, recuerda, suena a La Esquina y persiste. Pero si le preguntás el precio de la pupusa de ayote, te va a decir (correctamente, gracias al prompt) que no lo tiene a mano. En el capítulo 3 le damos manos: herramientas para consultar el menú real y registrar pedidos.

Ejercicios

def enviar(self, mensaje_usuario: str) -> str:
    self.historial.append({"role": "user", "content": mensaje_usuario})
    respuesta = self.client.messages.create(
        model=self.model,
        max_tokens=1024,
        system=self.system_prompt,
        messages=self.historial,
    )
    return respuesta.content[0].text

self.historial.append({"role": "assistant", "content": respuesta.content[0].text})

def _recortar_con_resumen(self) -> list[dict]:
    if len(self.historial) <= MAX_TURNOS:
        return self.historial
    viejos = self.historial[:-MAX_TURNOS]
    recientes = self.historial[-MAX_TURNOS:]
    if recientes[0]["role"] == "assistant":
        viejos.append(recientes[0])
        recientes = recientes[1:]
    texto_viejo = "\n".join(f"{m['role']}: {m['content']}" for m in viejos
                            if isinstance(m["content"], str))
    resumen = self.client.messages.create(
        model=self.model,
        max_tokens=150,
        system="Resumí esta conversación en un párrafo. Conservá nombres, "
               "items pedidos y sucursal si aparecen.",
        messages=[{"role": "user", "content": texto_viejo}],
    ).content[0].text
    return ([{"role": "user", "content": f"[Resumen de lo conversado antes: {resumen}]"}]
            + recientes)

if entrada == "/costo":
    conteo = bot.client.messages.count_tokens(
        model=bot.model,
        system=bot.system_prompt,
        messages=bot._recortar_historial() + [{"role": "user", "content": "x"}],
    )
    print(f"Turnos: {len(bot.historial)} | Próximo request ≈ "
          f"{conteo.input_tokens} tokens | Sesión: ${bot.costo_acumulado():.4f}")
    continue

Para profundizar

• Guía de system prompts — platform.claude.com/docs, sección Prompt engineering: patrones oficiales para roles, tono y límites, con ejemplos buenos y malos.
• Streaming en el SDK de Python — platform.claude.com/docs, sección Streaming: todos los eventos del stream (acá usamos solo text_stream; hay eventos más finos para UIs avanzadas).
• Capítulo 5 de este libro — el mismo streaming, pero hacia el navegador con Server-Sent Events.
• json en la biblioteca estándar — docs.python.org/3/library/json.html: si la persistencia en archivos se te queda corta, el paso natural es SQLite (visto en Bases de Datos I).