Asistente multi-agente para WhatsApp con LangGraph

Introducción

En esta guía te muestro cómo crear un asistente multi-agente para WhatsApp con Python y LangGraph.

La idea es tener varios agentes de IA trabajando juntos: uno que entiende la intención del usuario, otro que ejecuta la acción, y un supervisor que coordina a los dos.

Si ya armaste bots de WhatsApp con Twilio, este es el paso siguiente. En lugar de un solo bot basado en un prompt, vas a tener varios agentes especializados que razonan, delegan y completan tareas juntos.

¿Por qué asistentes multi-agente?

Casi todos los chatbots de WhatsApp siguen un patrón simple:

• Reciben un mensaje
• Se lo mandan a un LLM
• Devuelven la respuesta

Ese enfoque funciona, pero es limitado. Los problemas aparecen rápido cuando:

• Querés que el bot llame APIs (calendario, CRM, base de datos)
• Necesitás razonamiento estructurado entre varios pasos
• Querés separar tareas y reusarlas en distintos contextos

LangGraph resuelve eso: te deja definir workflows con estado entre varios agentes de IA, parecido a un diagrama de flujo pero definido en código.

Qué vamos a construir

Vamos a crear una arquitectura multi-agente simple que se adapta a distintos casos de uso.

Agentes de ejemplo:

• Interpreter: entiende qué quiere el usuario
• Executor: ejecuta la acción
• Supervisor: coordina a los dos

Una vez que entendés la estructura, la reusás para:

• Sistemas de reservas o agendamiento
• Soporte al cliente por WhatsApp
• Asistentes de ventas conectados a CRMs
• Automatizaciones internas o consultas de datos

Requisitos

Vas a necesitar:

• Python 3.10 o superior
• Un sandbox de WhatsApp en Twilio
• Una API key de OpenAI
• Los siguientes paquetes:

pip install langgraph langchain-openai fastapi python-dotenv

Creá un archivo .env:

OPENAI_API_KEY=sk-your-key 
MODEL_NAME=gpt-4o-mini

Armar los agentes

Arrancamos creando dos agentes: uno que interpreta el mensaje del usuario y otro que ejecuta la acción correspondiente.

# interpreter_agent.py
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field
import os

class IntentOutput(BaseModel):
    intent: str = Field(description="The user’s intent, e.g., check_status, create_booking, cancel")
    parameters: dict = Field(description="Extracted entities or parameters from the user message")

SYSTEM_PROMPT = """
You are the Interpreter Agent.
Your job is to read a WhatsApp message, detect the user’s intent, and extract structured parameters.

Example:
User: "Can you book a table for two tomorrow at 8pm?"
Response (as JSON):
{
  "intent": "create_booking",
  "parameters": {"people": 2, "time": "2025-07-10T20:00:00"}
}
"""

llm = ChatOpenAI(model=os.getenv("MODEL_NAME", "gpt-4o-mini"), use_responses_api=True)

interpreter_agent = create_react_agent(
    name="interpreter_agent",
    model=llm,
    tools=[],
    prompt=SYSTEM_PROMPT
)

# executor_agent.py
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
import os

SYSTEM_PROMPT = """
You are the Executor Agent.
You receive an intent and parameters from the Interpreter.
Your job is to perform the action (or simulate it) and return a WhatsApp-friendly message.

If intent == "create_booking", pretend to create a booking.
If intent == "check_status", pretend to look up an order or reservation.
If intent == "cancel", confirm the cancellation.

Always return a short, user-friendly message, e.g.:
"Your table for two tomorrow at 8pm has been booked ✅"
"""

llm = ChatOpenAI(model=os.getenv("MODEL_NAME", "gpt-4o-mini"), use_responses_api=True)

executor_agent = create_react_agent(
    name="executor_agent",
    model=llm,
    tools=[],
    prompt=SYSTEM_PROMPT
)

El supervisor

Esta es la parte que coordina todo.
Define la lógica que decide qué agente corre después y cómo fluye la información entre ellos.

from typing import Literal, TypedDict, Annotated
from langgraph.graph import StateGraph, START, END
from langchain_core.messages import HumanMessage, AIMessage, BaseMessage
import operator
from interpreter_agent import interpreter_agent
from executor_agent import executor_agent

class AssistantState(TypedDict):
    messages: Annotated[list[BaseMessage], operator.add]
    user_prompt: str
    intent: str | None
    parameters: dict | None
    result: str | None
    next_agent: Literal["interpreter", "executor", "finish"] | None

def route_to_next(state: AssistantState) -> Literal["interpreter", "executor", "finish"]:
    if not state.get("intent"):
        return "interpreter"
    elif not state.get("result"):
        return "executor"
    else:
        return "finish"

def call_interpreter(state: AssistantState) -> dict:
    result = interpreter_agent.invoke({
        "messages": [HumanMessage(content=state["user_prompt"])]
    })
    intent = None
    parameters = {}

    text = result["messages"][-1].content if "messages" in result else ""
    if "intent" in text:
        import json
        try:
            parsed = json.loads(text)
            intent = parsed.get("intent")
            parameters = parsed.get("parameters", {})
        except:
            pass

    return {
        "intent": intent,
        "parameters": parameters,
        "messages": [AIMessage(content=f"Detected intent: {intent}", name="interpreter")]
    }

def call_executor(state: AssistantState) -> dict:
    prompt = f"Intent: {state['intent']}\nParameters: {state['parameters']}"
    result = executor_agent.invoke({"messages": [HumanMessage(content=prompt)]})
    text = result["messages"][-1].content if "messages" in result else ""
    return {"result": text, "messages": [AIMessage(content=text, name="executor")]}

def create_assistant():
    workflow = StateGraph(AssistantState)
    workflow.add_node("interpreter", call_interpreter)
    workflow.add_node("executor", call_executor)
    workflow.add_edge(START, "interpreter")
    workflow.add_conditional_edges("interpreter", route_to_next, {"executor": "executor"})
    workflow.add_conditional_edges("executor", route_to_next, {"finish": END})
    return workflow.compile()

assistant_team = create_assistant()

Exponerlo por WhatsApp

Podés usar FastAPI y el webhook de WhatsApp de Twilio para manejar los mensajes.

from fastapi import FastAPI, Form
from fastapi.responses import PlainTextResponse
from langchain_core.messages import HumanMessage
from supervisor import assistant_team

app = FastAPI()

@app.post("/twilio/whatsapp")
async def whatsapp_webhook(From: str = Form(...), Body: str = Form("")):
    state = {"messages": [HumanMessage(content=Body)], "user_prompt": Body}
    result = assistant_team.invoke(state)
    reply = result.get("result") or "I couldn’t process that yet."
    twiml = f"""
<Response>
  <Message>{reply}</Message>
</Response>
"""
    return PlainTextResponse(twiml, media_type="application/xml")

Cómo funciona

1. El usuario manda un mensaje de WhatsApp.
2. Twilio lo reenvía a tu webhook.
3. El Supervisor corre primero el Interpreter para detectar la intención.
4. Después llama al Executor, que ejecuta la acción.
5. El resultado final vuelve a WhatsApp.

Pensalo como dos agentes teniendo una conversación corta: uno entiende qué hay que hacer, el otro lo ejecuta.

Flujo de ejemplo

Usuario: "¿Podés chequear el estado de mi pedido?"
Interpreter: { "intent": "check_status" }
Executor: "Tu pedido se está preparando 🚚"

Usuario: "Cancelá mi reunión de las 5pm"
Interpreter: { "intent": "cancel", "parameters": {"time": "17:00"} }
Executor: "La reunión de las 5pm fue cancelada ✅"

Por qué este patrón importa

Los sistemas multi-agente te dejan escalar más allá de los bots de palabras clave.
Reusás agentes, los conectás a APIs y les das responsabilidades específicas.
Eso significa menos complejidad de prompt, más confiabilidad e integraciones más limpias.

Este enfoque encaja perfecto en:

• Salud: agendamiento de turnos y recordatorios
• Inmobiliarias: mostrar disponibilidad y agendar visitas
• E-commerce: consultas de pedidos y devoluciones
• Servicios profesionales: agendar o reprogramar reuniones

Con este armado bajás el trabajo manual, respondés más rápido y mejorás la experiencia del cliente,  todo dentro de WhatsApp.

Para cerrar

LangGraph simplifica construir workflows multi-agente estructurados.
Combinado con la API de WhatsApp de Twilio, pasás de un chatbot estático a un asistente que entiende, actúa y colabora.

Empezá con dos agentes y un workflow. Cuando funcione, extendelo a todo tu flujo de comunicación, desde la calificación de leads hasta el seguimiento post-venta.

¿Te sirvió el post? ¡Suscribite al newsletter de abajo para más!