Tutorial: construye un agente WhatsApp con Vercel AI SDK + Claude en 60 minutos
Tutorial técnico paso a paso para construir tu primer agente WhatsApp empresarial: setup Vercel AI SDK + Claude + Twilio en 60 minutos, con código real ejecutable.
Este tutorial entrega el código mínimo viable para tener un agente WhatsApp empresarial corriendo en producción usando Vercel AI SDK + Claude + Twilio. En 60 minutos vas desde cero hasta un agente que recibe mensajes, decide qué hacer, llama tools tipadas y responde con calidad enterprise. Asume conocimiento básico de TypeScript y línea de comandos. Repositorio público con el código completo en preparación en github.com/cognitiva-ai-agency (anunciado en el cornerstone del stack). Este artículo lo reemplaza mientras tanto.
Requisitos previos
Tres cuentas y dos herramientas locales:
- Cuenta Anthropic (console.anthropic.com) con tarjeta + API key generada.
- Cuenta Vercel (vercel.com) free tier suficiente para empezar.
- Cuenta Twilio (twilio.com) con número WhatsApp sandbox o productivo.
- Node.js 20+ instalado localmente.
- Editor (VS Code recomendado) + Cursor o Claude Code para acelerar.
Tiempo total esperado: 60 minutos a 90 minutos según experiencia previa con APIs.
Paso 1: Setup del proyecto Next.js
Creamos un proyecto Next.js 16 con App Router:
npx create-next-app@latest agente-whatsapp \
--typescript --eslint --app --src-dir --no-tailwind
cd agente-whatsappInstalamos las dependencias del agente:
npm install ai @ai-sdk/anthropic zod twilioConfiguramos variables de entorno en .env.local:
ANTHROPIC_API_KEY=sk-ant-...
TWILIO_ACCOUNT_SID=AC...
TWILIO_AUTH_TOKEN=...
TWILIO_WHATSAPP_NUMBER=whatsapp:+14155238886Paso 2: Crear el endpoint webhook de Twilio
Twilio reenvía mensajes WhatsApp a un endpoint nuestro. Creamos src/app/api/whatsapp/route.ts:
import { NextResponse } from 'next/server';
import { anthropic } from '@ai-sdk/anthropic';
import { generateText, tool } from 'ai';
import { z } from 'zod';
import twilio from 'twilio';
const client = twilio(
process.env.TWILIO_ACCOUNT_SID!,
process.env.TWILIO_AUTH_TOKEN!
);
export async function POST(request: Request) {
const formData = await request.formData();
const from = formData.get('From') as string;
const body = formData.get('Body') as string;
if (!from || !body) {
return NextResponse.json({ error: 'missing fields' }, { status: 400 });
}
const { text } = await generateText({
model: anthropic('claude-opus-4-7'),
system: `Eres un agente de atención al cliente chileno de la empresa "Acme".
Respondes en espanol de Chile, registro formal-ejecutivo, sin emojis.
Si no puedes ayudar, deriva con la frase "Te conecto con un humano".`,
prompt: body,
maxSteps: 5,
tools: {
consultarPedido: tool({
description: 'Consulta el estado de un pedido por numero.',
parameters: z.object({ numero: z.string().min(1) }),
execute: async ({ numero }) => {
return { estado: 'En transito', ETA: '3 dias habiles', numero };
},
}),
},
});
await client.messages.create({
from: process.env.TWILIO_WHATSAPP_NUMBER,
to: from,
body: text,
});
return NextResponse.json({ ok: true });
}
Notas clave del código: (1) usamos generateText (no streamText) porque Twilio espera respuesta sincrónica; (2) maxSteps=5 permite hasta 5 vueltas de tool calling antes de responder; (3) las tools se declaran tipadas con Zod, no como functions sueltas; (4) la respuesta se envía vía Twilio en lugar de devolverla por HTTP.
Paso 3: Probar localmente con ngrok
Twilio necesita una URL pública para reenviar mensajes. Usamos ngrok para exponer el localhost:
# Terminal 1
npm run dev
# Terminal 2
npx ngrok http 3000ngrok entrega una URL https://xxx.ngrok-free.app. La configuramos en el sandbox de Twilio:
- Twilio Console → Messaging → Try it out → Send a WhatsApp message → Sandbox settings.
- En "When a message comes in" pegar: https://xxx.ngrok-free.app/api/whatsapp
- Método HTTP: POST.
Enviamos un mensaje al número del sandbox desde nuestro WhatsApp personal (siguiendo las instrucciones del sandbox) y vemos respuesta.
Paso 4: Deployment en Vercel
Para producción reemplazamos ngrok por la URL de Vercel:
npm install -g vercel
vercel login
vercel --prodConfigurar variables de entorno en el dashboard de Vercel (Settings → Environment Variables) con los mismos valores que .env.local.
Actualizar el webhook de Twilio con la URL de producción: https://tu-app.vercel.app/api/whatsapp.
Para número WhatsApp productivo (no sandbox) necesitas: cuenta Twilio business + aprobación de Meta para tu marca + número aprobado. Proceso 1-3 semanas.
Paso 5: Agregar memoria entre mensajes
El código anterior es stateless: cada mensaje no recuerda los anteriores. Para conversación con memoria, persistimos historia en Postgres + pgvector. Agregamos una tabla simple:
CREATE TABLE conversations (
id BIGSERIAL PRIMARY KEY,
whatsapp_from TEXT NOT NULL,
role TEXT NOT NULL,
content TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX idx_conv_from ON conversations (whatsapp_from, created_at);Modificamos el handler para cargar últimos N mensajes antes de generar respuesta:
// Pseudocódigo simplificado
const messages = await db.query(
'SELECT role, content FROM conversations WHERE whatsapp_from = $1 ORDER BY created_at DESC LIMIT 20',
[from]
).then(rows => rows.reverse());
const { text } = await generateText({
model: anthropic('claude-opus-4-7'),
system: '...',
messages: [...messages, { role: 'user', content: body }],
maxSteps: 5,
tools: { ... },
});
await db.query(
'INSERT INTO conversations (whatsapp_from, role, content) VALUES ($1, $2, $3), ($1, $4, $5)',
[from, 'user', body, 'assistant', text]
);Con esto el agente recuerda la conversación. Postgres + pgvector es perfecto para este caso porque la mayoría de PyMEs ya tiene Postgres operacional.
Paso 6: Observabilidad mínima
En producción necesitas saber qué pasa. Cuatro cosas que recomendamos desde el día uno:
- Logs estructurados de cada interacción (input, output, tools llamadas, latencia, tokens consumidos).
- Alerta por error o latencia anómala (Sentry, Logflare o equivalente).
- Métricas agregadas diarias (cantidad de conversaciones, ratio resolución sin escalamiento, costo de inferencia).
- Eval suite con 20-30 casos golden para detectar regresiones cuando se actualiza modelo o prompt.
Implementación mínima: console.log estructurado + dashboard en Grafana o Logflare. Mejorar después con LangSmith o Honeycomb.
Próximos pasos
Este tutorial entrega el MVP. Para producción enterprise faltan:
- Handoff humano cuando el agente no resuelve (ver cornerstone del stack).
- RAG sobre tu base documental para que el agente conozca tu negocio.
- Múltiples tools conectadas a sistemas reales (CRM, ERP, calendarios).
- Rate limiting y protección contra abuso.
- Cumplimiento Ley 21.719 (DPA con Anthropic + Twilio, retención de conversaciones, opt-out).
- Eval suite robusta con casos representativos del negocio.
Si quieres acompañamiento para implementación productiva, conversemos.
Construye un agente WhatsApp en 60 minutos
Seis pasos desde cero hasta agente productivo con Vercel AI SDK + Claude + Twilio.
- 10 min
Setup
Crear proyecto Next.js + dependencias + variables de entorno.
- create-next-app + install ai @ai-sdk/anthropic zod twilio
- Configurar .env.local con API keys
- 15 min
Endpoint webhook
Crear src/app/api/whatsapp/route.ts con generateText + tool calling.
- Implementar handler POST que reciba Twilio
- Declarar tool tipada con Zod
- Responder vía Twilio API
- 10 min
Prueba local con ngrok
Exponer localhost vía ngrok y configurar sandbox de Twilio.
- npm run dev + npx ngrok http 3000
- Configurar webhook en sandbox Twilio
- Probar enviando WhatsApp al sandbox
- 10 min
Deploy en Vercel
Publicar en Vercel y apuntar Twilio a la URL productiva.
- vercel --prod
- Variables de entorno en dashboard
- Actualizar webhook Twilio
- 15 min
Memoria + observabilidad
Agregar persistencia en Postgres y logs mínimos.
- Tabla conversations + cargar historial antes de generateText
- Logs estructurados + alertas básicas
Preguntas frecuentes
Da el siguiente paso
Hablemos
Cuéntanos sobre tu negocio. Respondemos en 24 horas.
Otros canales
Escríbenos por WhatsApp o agenda una llamada de 30 minutos.