Bot de WhatsApp con GPT y memoria en ~40 líneas de Python

JoeRodriguez — Sat, 06 Jun 2026 07:01:19 +0000

Bot de WhatsApp con GPT y memoria en ~40 líneas de Python

Uno de los problemas más molestos al armar un bot de WhatsApp con IA es la memoria: WhatsApp no recuerda nada entre mensajes, así que el modelo no tiene contexto de lo que se habló antes. En este tutorial armamos un bot que sí recuerda, sin construir ninguna base de datos, usando una API de memoria y su SDK.

Qué vamos a usar

OpenAI para generar las respuestas.
WhatsApp Memory API para guardar el historial y devolverlo ya formateado para el LLM. Tiene un SDK de Python que hace todo el trabajo pesado.

pip install openai whatsapp-memory

El bot completo

import openai
from whatsapp_memory import WhatsAppMemory

wa = WhatsAppMemory("wma_live_xxxx")   # tu API key
openai.api_key = "sk-..."

SYSTEM = "Sos el asistente de una pizzería. Sé breve y amable."

def responder(phone: str, texto_cliente: str) -> str:
    # 1. Guardar el mensaje entrante
    wa.add_message(phone, "user", texto_cliente)

    # 2. Traer el contexto ya formateado para OpenAI
    ctx = wa.get_context(phone, format="openai")

    # 3. Llamar al modelo con el historial completo
    respuesta = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "system", "content": SYSTEM}, *ctx["context"]],
    ).choices[0].message.content

    # 4. Guardar la respuesta del bot
    wa.add_message(phone, "assistant", respuesta)
    return respuesta

Eso es todo. Cada vez que llega un mensaje, llamás a responder(phone, texto) y el bot recuerda toda la conversación de ese número.

Probémoslo

phone = "+5491112345678"
print(responder(phone, "Hola, quiero una pizza"))
# -> "¡Hola! ¿De qué te gustaría? Tenemos margarita, napolitana..."

print(responder(phone, "la margarita, grande"))
# -> "¡Buenísimo! Una margarita grande. ¿Para retirar o envío?"

Notá que en el segundo mensaje el bot sabe que hablamos de la margarita, sin que nosotros le pasemos el historial a mano. Eso lo resuelve get_context, que además trunca por tokens y resume las conversaciones largas automáticamente.

¿Qué más trae?

Metadata por sesión: guardá el nombre del cliente, su último pedido, etc.

  wa.update_metadata(phone, nombre="Juan", ultimo_pedido="ORD-1234")

Formato Anthropic: wa.get_context(phone, format="anthropic").
Webhooks firmados y API keys con límites de uso.

Conectar con WhatsApp real

La función responder() es agnóstica de cómo recibís los mensajes. Conectala a tu webhook de la WhatsApp Business API (o Twilio, 360dialog, Builderbot, etc.): cuando llega un mensaje, llamás a responder() y enviás lo que devuelve.

Probalo

La API y sus docs interactivas están acá: https://whatsapp-memory-api.onrender.com/docs
Creás una key con un POST /keys y ya podés empezar. Si armás algo con esto, me encantaría saber qué.

¿Hacés bots de WhatsApp? ¿Cómo venías resolviendo la memoria hasta ahora? Contame en los comentarios.

Cómo darle memoria a tu bot de WhatsApp con IA (sin construir la infraestructura)

JoeRodriguez — Sat, 06 Jun 2026 05:40:11 +0000

Cómo darle memoria a tu bot de WhatsApp con IA (sin construir la infraestructura)

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:

Una base de datos para guardar el historial por número de teléfono.
Lógica para armar el "contexto" que le mandás al LLM.
Manejo de la ventana de contexto: ¿qué pasa cuando la conversación tiene 200 mensajes y no entran en el prompt?
Reformateo del historial al formato de OpenAI o Anthropic.

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.

El enfoque "a mano" (y por qué cansa)

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:

La conversación crece y te pasás del límite de tokens. Ahora necesitás truncar o resumir.
Querés cambiar de OpenAI a Anthropic y el formato es distinto (Anthropic separa el system de los messages).
Necesitás guardar datos del cliente (nombre, último pedido) junto a la conversación.
Tenés muchos clientes y cada número es una sesión distinta que hay que aislar.

Cada una de esas cosas es una tarde de trabajo. Multiplicado por cada bot que hacés.

El enfoque con una API de memoria

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:

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.

¿Y la conversación larga?

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.

¿Y cambiar de proveedor?

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

¿Y los datos del cliente?

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"})

¿Cuándo conviene cada enfoque?

Hacelo a mano si es un bot de juguete, un solo cliente, o querés aprender cómo funciona por dentro.
Usá una API si tenés varios bots, varios clientes, o simplemente no querés mantener esa infraestructura.

Probalo

La API que usé en los ejemplos está en vivo y tiene docs interactivas:

👉 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.

DEV Community: JoeRodriguez

Bot de WhatsApp con GPT y memoria en ~40 líneas de Python

Bot de WhatsApp con GPT y memoria en ~40 líneas de Python

Qué vamos a usar

El bot completo

Probémoslo

¿Qué más trae?

Conectar con WhatsApp real

Probalo

Cómo darle memoria a tu bot de WhatsApp con IA (sin construir la infraestructura)

Cómo darle memoria a tu bot de WhatsApp con IA (sin construir la infraestructura)

El enfoque "a mano" (y por qué cansa)

El enfoque con una API de memoria

¿Y la conversación larga?

¿Y cambiar de proveedor?

¿Y los datos del cliente?

¿Cuándo conviene cada enfoque?

Probalo