Cómo crear un agente de IA para WhatsApp

WhatsApp tiene más de 2,000 millones de usuarios activos al mes, y la mayoría de las empresas en LATAM aún lo atienden con personas respondiendo mensajes manualmente. Esta guía explica, con precisión técnica, cómo crear un agente de IA para WhatsApp que automatiza conversaciones reales sin perder el contexto ni la calidad de respuesta.

Qué es exactamente un agente de IA para WhatsApp

Un agente de IA para WhatsApp no es un chatbot de árbol de decisiones. Es un sistema que:

• Entiende lenguaje natural en lugar de depender de palabras clave exactas.
• Mantiene contexto a lo largo de la conversación, no solo responde el mensaje más reciente.
• Puede ejecutar acciones: consultar una base de datos, crear un ticket, agendar una cita, procesar un pago.
• Escala a miles de conversaciones simultáneas sin contratar más agentes humanos.

La diferencia técnica clave es que un agente tiene acceso a herramientas (tools) que puede invocar según la intención del usuario, no solo un flujo predefinido.

Los componentes del stack

Antes de escribir una línea de código, entiende qué piezas necesitas ensamblar:

1. Acceso a la API de WhatsApp

Tienes dos rutas:

• WhatsApp Business API (oficial, Meta): Requiere aprobación, un número dedicado y pasar por un Business Solution Provider (BSP) como Twilio, 360dialog o Meta directamente. Es la única opción para producción a escala.
• Librerías no oficiales (Baileys, WWebJS): Funcionan para prototipos y uso interno, pero violan los Términos de Servicio de Meta. No las uses para clientes finales.

Para un agente de producción, el camino correcto es la API oficial. El costo de mensajes varía: en México y Colombia, una conversación iniciada por la empresa cuesta entre $0.05 y $0.08 USD; las iniciadas por el usuario son más baratas.

2. El modelo de lenguaje (LLM)

Las opciones más usadas en 2025:

Para WhatsApp, la latencia importa: un usuario espera respuesta en menos de 5 segundos antes de perder interés. Gemini Flash o GPT-4o Mini son buenas opciones para casos de alto volumen.

3. El framework de agentes

Aquí decides cómo el LLM invoca herramientas y maneja el estado:

• LangChain / LangGraph: El más documentado, flexible, con buena comunidad en español.
• LlamaIndex: Mejor para agentes con fuerte componente de RAG (recuperación de documentos).
• Autogen (Microsoft): Útil cuando necesitas múltiples agentes colaborando.
• Código propio con la API de OpenAI function calling: Más control, menos abstracción mágica.

4. La capa de memoria y contexto

Por defecto, los LLMs no recuerdan conversaciones anteriores. Necesitas:

• Memoria de sesión: almacenada en Redis o en memoria del servidor mientras la conversación está activa.
• Memoria persistente: historial en PostgreSQL o MongoDB para que el agente sepa que ese número ya compró antes, o que ya escaló un reclamo.
• Base de conocimiento (RAG): documentos, FAQs, catálogos de productos en un vector store (Pinecone, Supabase pgvector, Weaviate).

5. El servidor webhook

WhatsApp Business API envía los mensajes entrantes a un endpoint tuyo vía HTTP POST. Necesitas:

• Un servidor siempre activo (Node.js, Python/FastAPI, etc.)
• HTTPS con certificado válido
• Lógica para verificar la firma del webhook de Meta
• Cola de mensajes (Redis Queue, BullMQ, Celery) para no bloquear respuestas si el LLM tarda

Arquitectura recomendada paso a paso

Esta es la arquitectura más común para un agente funcional en producción:

Usuario en WhatsApp
       ↓
Meta Cloud API
       ↓
Tu servidor webhook (FastAPI / Express)
       ↓
Cola de mensajes (BullMQ / Celery)
       ↓
Motor del agente (LangGraph / custom)
  ├── LLM (GPT-4o / Claude)
  ├── Memoria de sesión (Redis)
  ├── Historial largo plazo (PostgreSQL)
  └── Herramientas (Tools)
        ├── Consulta CRM
        ├── Búsqueda en catálogo (RAG)
        ├── Crear ticket
        └── Agendar cita (Google Calendar API)
       ↓
Respuesta → Meta Cloud API → Usuario

Paso 1: Configura tu cuenta de Meta for Developers

1. Crea una app en developers.facebook.com.
2. Agrega el producto "WhatsApp Business".
3. Obtén un número de teléfono de prueba (Meta da uno gratis).
4. Configura el webhook apuntando a tu servidor con el campo messages suscrito.

Paso 2: Implementa el webhook

En Python con FastAPI:

from fastapi import FastAPI, Request
import httpx, os

app = FastAPI()
VERIFY_TOKEN = os.getenv("WA_VERIFY_TOKEN")
WA_TOKEN = os.getenv("WA_ACCESS_TOKEN")
PHONE_ID = os.getenv("WA_PHONE_ID")

@app.get("/webhook")
async def verify(hub_mode: str, hub_verify_token: str, hub_challenge: str):
    if hub_mode == "subscribe" and hub_verify_token == VERIFY_TOKEN:
        return int(hub_challenge)
    return {"error": "Token inválido"}, 403

@app.post("/webhook")
async def receive_message(request: Request):
    body = await request.json()
    # Extraer número y texto del payload de Meta
    entry = body["entry"][0]["changes"][0]["value"]
    msg = entry["messages"][0]
    phone = msg["from"]
    text = msg["text"]["body"]
    # Enviar a la cola de procesamiento
    await process_with_agent(phone, text)
    return {"status": "ok"}

Paso 3: Construye el agente con herramientas

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.tools import tool

@tool
def consultar_pedido(numero_pedido: str) -> str:
    """Consulta el estado de un pedido por su número."""
    # Aquí conectas con tu base de datos real
    return f"El pedido {numero_pedido} está en camino. Llega mañana antes de las 6pm."

@tool
def agendar_cita(fecha: str, hora: str) -> str:
    """Agenda una cita para el usuario en la fecha y hora indicadas."""
    # Aquí conectas con Google Calendar API
    return f"Cita agendada para el {fecha} a las {hora}. Te llegará una confirmación."

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
tools = [consultar_pedido, agendar_cita]
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

Paso 4: Conecta la memoria de sesión

from langchain_community.chat_message_histories import RedisChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

def get_session_history(session_id: str):
    return RedisChatMessageHistory(session_id, url=os.getenv("REDIS_URL"))

agent_with_memory = RunnableWithMessageHistory(
    executor,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

Paso 5: Envía la respuesta de vuelta

async def send_whatsapp_message(phone: str, text: str):
    url = f"https://graph.facebook.com/v19.0/{PHONE_ID}/messages"
    headers = {"Authorization": f"Bearer {WA_TOKEN}"}
    payload = {
        "messaging_product": "whatsapp",
        "to": phone,
        "type": "text",
        "text": {"body": text}
    }
    async with httpx.AsyncClient() as client:
        await client.post(url, json=payload, headers=headers)

Errores comunes que arruinan los proyectos

Estos son los problemas que aparecen en producción y que los tutoriales básicos ignoran:

• No manejar mensajes duplicados. WhatsApp puede reenviar el mismo webhook. Implementa idempotencia con el message_id.
• Ignorar los límites de tasa. La API tiene rate limits por número. Un burst de mensajes puede hacer que tu agente responda fuera de orden.
• Confundir sesión con usuario. El mismo número puede abrir múltiples conversaciones en horas diferentes. Define bien cuándo "resetear" la memoria de sesión.
• No tener un flujo de escalamiento humano. El agente debe saber cuándo decir "te conecto con un asesor" y hacer el handoff real. Sin esto, los usuarios frustrados abandonan.
• Olvidar el cumplimiento de privacidad. En México (LFPDPPP) y Colombia (Ley 1581), tienes obligaciones sobre cómo almacenas conversaciones. No guardes historial indefinidamente sin política de retención.

Casos de uso con ROI comprobable

• Atención al cliente e-commerce: Una tienda online con 500 pedidos diarios puede automatizar el 80% de las consultas de "¿dónde está mi pedido?" sin contratar operadores adicionales.
• Agendamiento médico: Clínicas con 3-5 consultorios eliminan entre 60-70% del volumen de llamadas para agendar y confirmar citas.
• Calificación de leads B2B: El agente hace las primeras 5 preguntas de cualificación, registra en CRM y solo escala al vendedor cuando el lead cumple criterios. Equipos de 3 personas manejan el volumen de 10.
• Soporte técnico con RAG: Un agente entrenado sobre documentación técnica resuelve tickets de nivel 1 con una tasa de resolución del 65-75% sin intervención humana.

Cuándo construirlo tú vs. contratar a un equipo especializado

Construirlo tú tiene sentido si tienes un equipo con experiencia en APIs, Python/Node.js y quieres control total del stack. El tiempo realista para un agente funcional en producción, con memoria y al menos 3 herramientas integradas, es de 4 a 8 semanas con un equipo dedicado.

Si el tiempo al mercado importa —y generalmente importa— estudios un estudio especializado en IA puede comprimir ese tiempo significativamente. En Catalizadora construimos agentes de este tipo como parte de Catalizadora Core (12 semanas, producto completo) o Solo (15 días, un caso de uso específico). El cliente se queda con el 100% del código y la IP, sin licencias recurrentes.

CTA: Lee el manifiesto de Catalizadora

Si llegaste hasta aquí, ya tienes el mapa técnico completo. La diferencia entre un prototipo y un agente en producción que genera valor real está en los detalles: la arquitectura de memoria, el manejo de errores, el escalamiento humano, la privacidad.

Construimos software así todos los días. Si quieres entender nuestra filosofía de cómo lo hacemos y por qué funciona, lee el manifiesto de Catalizadora →