Tutorial Completo de Chatbot de IA GPT 4o en C para WhatsApp

Un chatbot de IA para WhatsApp de propósito general y personalizable en C# 🔷 que puede entender texto 📝, audio 🎵 e imágenes 🖼️, y responder a tus clientes 💬 sobre cualquier tema relacionado con tu negocio 🏢 directamente en WhatsApp ✅. Impulsado por OpenAI GPT4o 🚀 (también se pueden usar otros modelos) y Wassenger WhatsApp API 🔗.

Ahora compatible con GPT-4o con entrada de texto + audio + imagen 📝🎵🖼️, respuestas de audio 🔊, y RAG mejorado + MCP con function calling 🛠️ y soporte para llamadas a APIs externas 🌐

Encuentra otras implementaciones de Chatbot IA en Python, Node.js y PHP

🚀 Comienza gratis con Wassenger WhatsApp API en minutos conectando tu número de WhatsApp existente y obtén tu clave API ✨

Características

🤖 Chatbot completamente funcional para tu número de WhatsApp conectado a Wassenger
💬 Respuestas automáticas a mensajes entrantes de usuarios
🌍 Soporte multilingüe — entiende y responde en más de 90 idiomas diferentes
🎤 Entrada/salida de audio — capacidades de transcripción y texto a voz
🖼️ Procesamiento de imágenes — puede analizar y comprender imágenes
👥 Transferencia a humano — permite a los usuarios solicitar asistencia humana
⚙️ Comportamiento de IA e instrucciones personalizables
🔧 Capacidades de function calling para integración con datos externos
📊 Gestión de memoria con historial de conversación y limitación de tasa
🚦 Enrutamiento inteligente con manejo de webhooks y gestión de errores
🔒 Seguro con manejo de errores y registro adecuados
🔄 C# moderno con .NET 9, inyección de dependencias y patrones async/await

Contenido

Inicio rápido

Clona el repositorio:

git clone https://github.com/wassengerhq/whatsapp-chatgpt-bot-csharp.git cd whatsapp-chatgpt-bot-csharp

Instala el SDK de .NET 8:
Descarga desde: https://dotnet.microsoft.com/download/dotnet/8.0
Verifica la instalación: dotnet --version
Configura el entorno:

cp.env.example.env # Edit.env file with your API keys(see Configuration section)

Ejecuta el bot (modo desarrollo local):

cd src/WhatsAppChatBot dotnet run

Requisitos

SDK de .NET 9.0 o superior
Número personal o Business de WhatsApp
Wassenger API key — Regístrate gratis
OpenAI API key — Regístrate gratis
Cuenta de Ngrok (para desarrollo local) — Regístrate gratis

Configuración

Edita el archivo .env con tus credenciales de API:

# Required: Wassenger API key
API_KEY=your_wassenger_api_key_here
# Required: OpenAI API key
OPENAI_API_KEY=your_openai_api_key_here
# OpenAI model to use(gpt-4o, gpt-4, gpt-3.5-turbo)
OPENAI_MODEL=gpt-4o
# Required for local development: Ngrok auth token
NGROK_TOKEN=your_ngrok_token_here
# Optional: Specific WhatsApp device ID
DEVICE=
# Optional: Webhook URL for production deployment
WEBHOOK_URL=https://yourdomain.com/webhook
# Server configuration
PORT=8080
LOG_LEVEL=Information
# Development mode(auto-initializes services)
DEV=true

Configuración de claves API

Wassenger API Key:

Regístrate en Wassenger (disponible prueba gratuita)
Ve a API Keys
Crea una nueva API key y cópiala a API_KEY en .env

OpenAI API Key:

Regístrate en OpenAI (créditos gratuitos disponibles)
Ve a API Keys
Crea una nueva API key y cópiala a OPENAI_API_KEY en .env

Token de Ngrok (para desarrollo local):

Regístrate en Ngrok (gratis)
Obtén tu token de autenticación desde el dashboard
Cópialo a NGROK_TOKEN en .env

Personalización del bot

Edita src/WhatsAppChatBot/Config/BotConfig.cs para personalizar:

Instrucciones y personalidad del bot
Mensajes de bienvenida y ayuda
Funcionalidades soportadas (audio, imágenes, etc.)
Límites de tasa y cuotas
Números en lista blanca/negra
Configuración de etiquetas y metadatos

Uso

Desarrollo local

Inicia el servidor de desarrollo:

cd src/WhatsAppChatBot dotnet run

El bot:

Iniciará un servidor HTTP local en el puerto 8080
Opcionalmente creará un túnel Ngrok automáticamente
Registrará el webhook con Wassenger
Comenzará a procesar mensajes de WhatsApp

Envía un mensaje a tu número de WhatsApp conectado a Wassenger para probar el bot.

Despliegue en producción

Configura las variables de entorno en tu servidor:

export WEBHOOK_URL=https://yourdomain.com/webhook
export API_KEY=your_wassenger_api_key
export OPENAI_API_KEY=your_openai_api_key
export PRODUCTION=true

Compila y ejecuta:

dotnet build -c Release dotnet run - configuration Release

Asegúrate de que tu servidor pueda recibir peticiones POST en /webhook

Despliegue

Puedes desplegar este bot en cualquier plataforma cloud que soporte .NET 8.

Despliegue con Docker

# Build the Docker image
docker build -t whatsapp-chatbot.
# Run the container
docker run -d \
--name whatsapp-chatbot \
-p 8080:8080 \
-e API_KEY=your_wassenger_api_key \
-e OPENAI_API_KEY=your_openai_api_key \
-e WEBHOOK_URL=https://yourdomain.com/webhook \
-e PRODUCTION=true \
whatsapp-chatbot

Render

# Create render.yaml for automated deployment
cat > render.yaml << EOF
services:
- type: web
name: whatsapp-chatbot
env: docker
dockerfilePath:./Dockerfile
envVars:
- key: API_KEY
value: your_wassenger_api_key
- key: OPENAI_API_KEY
value: your_openai_api_key
- key: PRODUCTION
value: true
- key: PORT
value: 8080
EOF
# Connect your GitHub repo to Render and deploy automatically
# Or deploy manually:
# 1.Push to GitHub
# 2.Connect repo in Render dashboard
# 3.Set environment variables in Render UI

Heroku

# Login and create app
heroku login
heroku create your-whatsapp-bot
# Set environment variables
heroku config:set API_KEY=your_wassenger_api_key
heroku config:set OPENAI_API_KEY=your_openai_api_key
heroku config:set PRODUCTION=true
# Create heroku.yml for container deployment
cat > heroku.yml << EOF
build:
docker:
web: Dockerfile
run:
web: dotnet run --configuration Release
EOF
# Set stack to container
heroku stack:set container
# Deploy
git add.
git commit -m "Deploy to Heroku"
git push heroku main

Railway

# Install Railway CLI
npm install -g @railway/cli
# Login and deploy
railway login
railway new
# Deploy with environment variables
railway add --name API_KEY --value your_wassenger_api_key
railway add --name OPENAI_API_KEY --value your_openai_api_key
railway add --name PRODUCTION --value true
# Deploy from current directory
railway up

Fly.io

# Install flyctl
curl -L https://fly.io/install.sh | sh
# Initialize and configure
flyctl auth login
flyctl launch --name whatsapp-chatbot
# Create fly.toml configuration
cat > fly.toml << EOF
app = "whatsapp-chatbot"
primary_region = "iad"
[build]
dockerfile = "Dockerfile"
[env]
PRODUCTION = "true"
PORT = "8080"
[[services]]
http_checks = []
internal_port = 8080
processes = ["app"]
protocol = "tcp"
script_checks = []
[[services.ports]]
force_https = true
handlers = ["http"]
port = 80
[[services.ports]]
handlers = ["tls", "http"]
port = 443
EOF
# Set secrets
flyctl secrets set API_KEY=your_wassenger_api_key
flyctl secrets set OPENAI_API_KEY=your_openai_api_key
# Deploy
flyctl deploy

Azure App Service

# Create resource group
az group create --name rg-whatsapp-bot --location "East US"
# Create App Service plan
az appservice plan create --name asp-whatsapp-bot --resource-group rg-whatsapp-bot --sku B1 --is-linux
# Create web app
az webapp create --resource-group rg-whatsapp-bot --plan asp-whatsapp-bot --name your-app-name --runtime "DOTNETCORE:8.0"
# Configure app settings
az webapp config appsettings set --resource-group rg-whatsapp-bot --name your-app-name --settings \
API_KEY=your_wassenger_api_key \
OPENAI_API_KEY=your_openai_api_key \
PRODUCTION=true
# Deploy
dotnet publish -c Release
cd src/WhatsAppChatBot/bin/Release/net9.0/publish
zip -r../../../../../deploy.zip.
az webapp deployment source config-zip --resource-group rg-whatsapp-bot --name your-app-name --src deploy.zip

Arquitectura

La implementación en C# sigue patrones modernos de .NET y arquitectura limpia:

src/
├── WhatsAppChatBot/
│ ├── Api/ # API clients
│ │ ├── OpenAIClient.cs # OpenAI API integration
│ │ └── WassengerClient.cs # Wassenger API integration
│ ├── Bot/ # Core bot logic
│ │ ├── ChatBot.cs # Main bot processing
│ │ └── FunctionHandler.cs # Function calling system
│ ├── Config/ # Configuration management
│ │ └── BotConfig.cs # Centralized configuration
│ ├── Controllers/ # HTTP layer
│ │ └── WebhookController.cs # API endpoints and webhook handling
│ ├── Models/ # Data models
│ │ ├── OpenAIModels.cs # OpenAI API models
│ │ ├── WassengerModels.cs # Wassenger API models
│ │ └── WebhookModels.cs # Webhook and general models
│ ├── Services/ # Business services
│ │ ├── MemoryStore.cs # In-memory caching and state
│ │ └── NgrokTunnel.cs # Development tunnel management
│ ├── Program.cs # Application entry point
│ ├── appsettings.json # Application configuration
│ └── WhatsAppChatBot.csproj # Project file
├──.env.example # Environment template
├── Dockerfile # Docker configuration
└── README.md

Pruebas

El proyecto incluye comprobaciones de estado y validación integradas:

Prueba de conexión API

# Test the API endpoints
curl http://localhost:8080/

Prueba de webhook

# Simulate a webhook request
curl -X POST http://localhost:8080/webhook \
-H "Content-Type: application/json" \
-d '{
"event": "message:in:new", 
"data": {
"chat": {"id": "test", "fromNumber": "123", "type": "chat"}, 
"fromNumber": "123", 
"body": "Hello"
}
}'

Prueba de envío de mensaje

curl -X POST http://localhost:8080/message \
-H "Content-Type: application/json" \
-d '{
"phone": "1234567890", 
"message": "Test message", 
"device": "your-device-id"
}'

Desarrollo

Estructura del proyecto

La solución sigue principios de arquitectura limpia:

Controllers: Manejan peticiones y respuestas HTTP
Services: Lógica de negocio e integración con servicios externos
Models: Objetos de transferencia de datos y modelos de dominio
Configuration: Gestión centralizada de configuración
Dependency Injection: Contenedor DI integrado de .NET

Clases clave

ChatBot - Lógica principal de procesamiento del bot con filtrado y enrutamiento de mensajes
OpenAIClient - Integración con la API de OpenAI con soporte para chat, audio e imágenes
WassengerClient - Integración con la API de Wassenger para mensajería de WhatsApp
FunctionHandler - Sistema de function calling de la IA para integraciones externas
WebhookController - Enrutamiento de peticiones HTTP y manejo de webhooks
BotConfig - Gestión centralizada de configuración con variables de entorno
MemoryStore - Caché en memoria y gestión del estado de conversaciones
NgrokTunnel - Túnel de desarrollo para pruebas locales

Ejecutar en desarrollo

# Run with hot reload
dotnet watch run
# Run with specific environment
dotnet run --environment Development
# Run tests(if you add them)
dotnet test

Añadir paquetes NuGet

dotnet add package PackageName

Personalización

Instrucciones del bot

Edita el comportamiento de la IA en Config/BotConfig.cs:

private const string DefaultBotInstructions =
"You are a helpful assistant...";

Function Calling

Añade funciones personalizadas en Bot/FunctionHandler.cs:

["getBusinessHours"] = new()
{
Name = "getBusinessHours", 
Description = "Get business operating hours", 
Parameters = new { type = "object", properties = new { } }, 
Handler = GetBusinessHours
}

Límites de tasa

Ajusta los límites en Config/BotConfig.cs:

public class LimitsConfig
{
public int MaxInputCharacters { get; set; } = 1000;
public int MaxOutputTokens { get; set; } = 1000;
public int ChatHistoryLimit { get; set; } = 20;
//...more limits
}

Añadir nuevas integraciones de API

Crea un nuevo cliente en la carpeta Api/
Define modelos en Models/
Regístralo en Program.cs en la inyección de dependencias
Úsalo en ChatBot o crea nuevos servicios

Endpoints de la API

GET / - Información y estado del bot
POST /webhook - Webhook para mensajes entrantes de WhatsApp
POST /message - Endpoint para enviar mensajes
GET /sample - Enviar un mensaje de ejemplo
GET /files/{id} - Descargas temporales de archivos

Documentación Swagger

Cuando se ejecute en modo desarrollo, visita:

http://localhost:8080/swagger

Resolución de problemas

Problemas comunes

“No active WhatsApp numbers”

Verifica tu clave API de Wassenger
Comprueba que tienes un dispositivo de WhatsApp conectado en Wassenger

“WhatsApp number is not online”

Asegúrate de que tu dispositivo de WhatsApp esté conectado y en línea en el panel de Wassenger

Webhook no recibe mensajes

Comprueba que tu URL de webhook sea accesible desde internet
Verifica la configuración del firewall
Revisa los logs por errores en el registro del webhook

Errores de la API de OpenAI

Verifica que tu clave API de OpenAI sea válida
Asegúrate de que el nombre del modelo sea correcto
Revisa el uso y facturación de tu cuenta de OpenAI

Modo de depuración

Habilita el registro detallado configurándolo en .env:

LOG_LEVEL=Debug

O en appsettings.Development.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Debug"
    }
  }
}

Problemas comunes de entorno

Puerto en uso: Cambia PORT en .env
Ngrok no encontrado: Instala ngrok o configura NGROK_PATH
Versión de .NET: Asegúrate de tener instalado el SDK de .NET 8.0

Recursos

Contribuir

Haz un fork del repositorio
Crea una rama de feature (git checkout -b feature/amazing-feature)
Realiza tus cambios
Añade tests si aplica
Commita tus cambios (git commit -m 'Add some amazing feature')
Haz push a la rama (git push origin feature/amazing-feature)
Abre un Pull Request

Guías de desarrollo

Sigue las convenciones de código de C#
Usa async/await para todas las operaciones I/O
Añade documentación XML para las APIs públicas
Incluye tests unitarios para nueva funcionalidad
Actualiza el README para nuevas características

Rendimiento y escalabilidad

Esta implementación en C# ofrece varias ventajas:

Alto rendimiento: optimizaciones del runtime .NET 8 y código compilado
Eficiente en memoria: patrones de disposal y gestión de memoria adecuados
Procesamiento concurrente: async/await y procesamiento basado en Task
Escalable: inyección de dependencias integrada y gestión del ciclo de vida de servicios
Listo para producción: logging completo, manejo de errores y health checks

Características de seguridad

Validación de entrada: todas las entradas de webhook son validadas
Limitación de tasa: cuotas de mensajes y límites de conversación integrados
Configuración segura: gestión de secretos basada en entorno
Manejo de errores: manejo de excepciones exhaustivo sin filtración de información
Seguridad HTTP: valores predeterminados de seguridad modernos de ASP.NET Core