# Cómo darle memoria a tu bot de WhatsApp con IA (sin construir la infraestructura) > Source: > Published: 2026-06-06 05:40:11+00:00 Si alguna vez hiciste un bot de WhatsApp con IA, te topaste con esto: **WhatsApp no recuerda nada**. Cada mensaje que llega es un evento aislado. Si el cliente escribe "y el rojo, ¿lo tenés?", tu modelo no tiene idea de qué "rojo" habla, porque no sabe qué se dijo dos mensajes antes. Para resolverlo, todos terminamos construyendo la misma plomería: Es trabajo repetitivo que no tiene nada que ver con la lógica de tu agente. En este artículo te muestro el problema en detalle y cómo evitarlo con una API de memoria. Un primer intento típico en Python se ve así: ``` # Pseudo-código del enfoque manual historial = db.query("SELECT role, content FROM mensajes WHERE phone = %s ORDER BY created_at", phone) mensajes = [{"role": m.role, "content": m.content} for m in historial] mensajes.insert(0, {"role": "system", "content": "Sos el asistente de una pizzería..."}) respuesta = openai.chat.completions.create(model="gpt-4o", messages=mensajes) ``` Funciona... hasta que: `system` de los `messages` ).Cada una de esas cosas es una tarde de trabajo. Multiplicado por cada bot que hacés. La idea es delegar toda esa capa a una API REST. Guardás los mensajes con un `POST` y pedís el contexto ya armado con un `GET` . Veamos un bot completo de pizzería: ``` python import httpx, openai MEMORY_API = "https://whatsapp-memory-api.onrender.com" HEADERS = {"Authorization": "Bearer wma_live_xxxx"} def manejar_mensaje(phone: str, texto_cliente: str) -> str: # 1. Guardar el mensaje entrante httpx.post(f"{MEMORY_API}/sessions/{phone}/messages", headers=HEADERS, json={"role": "user", "content": texto_cliente}) # 2. Pedir el contexto YA formateado para OpenAI ctx = httpx.get(f"{MEMORY_API}/sessions/{phone}/context", headers=HEADERS, params={"format": "openai"}).json() # 3. Llamar al LLM con el historial inyectado respuesta = openai.chat.completions.create( model="gpt-4o", messages=[ {"role": "system", "content": "Sos el asistente de una pizzería..."}, *ctx["context"], # <-- historial listo para usar ], ).choices[0].message.content # 4. Guardar la respuesta del bot httpx.post(f"{MEMORY_API}/sessions/{phone}/messages", headers=HEADERS, json={"role": "assistant", "content": respuesta}) return respuesta ``` Eso es todo. No hay tablas que diseñar, no hay manejo de tokens, no hay reformateo. La API se encarga: trunca por presupuesto de tokens y, cuando la charla supera cierto tamaño, genera un **resumen automático** de lo viejo y lo antepone como contexto. Vos seguís pidiendo `/context` y siempre recibís algo que entra en el prompt. Cambiás un parámetro: ``` ctx = httpx.get(f"{MEMORY_API}/sessions/{phone}/context", headers=HEADERS, params={"format": "anthropic"}).json() # ahora ctx tiene "system" y "messages" separados, como espera Anthropic ``` Cada sesión tiene un store de metadata: ``` httpx.patch(f"{MEMORY_API}/sessions/{phone}/metadata", headers=HEADERS, json={"nombre": "Juan", "ultimo_pedido": "ORD-1234"}) ``` La API que usé en los ejemplos está en vivo y tiene docs interactivas: 👉 [https://whatsapp-memory-api.onrender.com/docs](https://whatsapp-memory-api.onrender.com/docs) Creás una key con un `POST /keys` y ya podés empezar. Si estás construyendo bots de WhatsApp, me encantaría saber qué le falta. *¿Hacés bots de WhatsApp? Contame en los comentarios cómo manejás hoy la memoria — me interesa ver qué enfoques usa cada uno.*