Tutorial Completo de Chatbot AI GPT 4o do WhatsApp em C

Um chatbot de IA para WhatsApp de uso geral e personalizável em C# 🔷 que pode entender texto 📝, áudio 🎵 e imagens 🖼️, e responder aos seus clientes 💬 sobre qualquer coisa relacionada ao seu negócio 🏢 diretamente no WhatsApp ✅. Alimentado pelo OpenAI GPT4o 🚀 (outros modelos também podem ser usados) e pela Wassenger WhatsApp API 🔗.

Agora com suporte ao GPT-4o com entrada de texto + áudio + imagem 📝🎵🖼️, respostas em áudio 🔊, e RAG aprimorado + MCP com function calling 🛠️ e suporte a chamadas de APIs externas 🌐

Encontre outras implementações de AI Chatbot em Python, Node.js e PHP

🚀 Comece gratuitamente com a Wassenger WhatsApp API em minutos conectando seu número de WhatsApp existente e obtenha sua chave de API ✨

Recursos

🤖 Chatbot completo para o seu número WhatsApp conectado à Wassenger
💬 Respostas automáticas para mensagens recebidas de usuários
🌍 Suporte multilíngue — entende e responde em mais de 90 idiomas diferentes
🎤 Entrada/saída de áudio — capacidades de transcrição e texto-para-fala
🖼️ Processamento de imagens — pode analisar e entender imagens
👥 Transferência para humano — permite que usuários solicitem assistência humana
⚙️ Comportamento e instruções de IA personalizáveis
🔧 Capacidades de function calling para integração de dados externos
📊 Gerenciamento de memória com histórico de conversas e limitação de taxa
🚦 Roteamento inteligente com tratamento de webhook e gerenciamento de erros
🔒 Seguro com tratamento adequado de erros e logging
🔄 C# moderno com .NET 9, injeção de dependência e padrões async/await

Conteúdo

Início Rápido

Clone o repositório:

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

Instale o SDK .NET 8:
Baixe em: https://dotnet.microsoft.com/download/dotnet/8.0
Verifique a instalação: dotnet --version
Configure o ambiente:

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

Execute o bot (modo de desenvolvimento local):

cd src/WhatsAppChatBot dotnet run

Requisitos

.NET 9.0 SDK ou superior
Número pessoal ou comercial do WhatsApp
Chave de API Wassenger — Registre-se gratuitamente
Chave de API OpenAI — Registre-se gratuitamente
Conta no Ngrok (para desenvolvimento local) — Registre-se gratuitamente

Configuração

Edite o arquivo .env com suas credenciais 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

Configuração das Chaves de API

Chave de API Wassenger:

Cadastre-se em Wassenger (teste gratuito disponível)
Vá para API Keys
Crie uma nova chave de API e copie para API_KEY no arquivo .env

Chave de API OpenAI:

Cadastre-se em OpenAI (créditos gratuitos disponíveis)
Vá para API Keys
Crie uma nova chave de API e copie para OPENAI_API_KEY no arquivo .env

Token do Ngrok (para desenvolvimento local):

Cadastre-se em Ngrok (gratuito)
Obtenha seu auth token no dashboard
Copie para NGROK_TOKEN no arquivo .env

Personalização do Bot

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

Instruções e personalidade do bot
Mensagens de boas-vindas e ajuda
Recursos suportados (áudio, imagens, etc.)
Limites de taxa e cotas
Números na whitelist/blacklist
Configurações de labels e metadados

Uso

Desenvolvimento Local

Inicie o servidor de desenvolvimento:

cd src/WhatsAppChatBot dotnet run

O bot irá:

Iniciar um servidor HTTP local na porta 8080
Opcionalmente criar um túnel Ngrok automaticamente
Registrar o webhook na Wassenger
Começar a processar mensagens do WhatsApp

Envie uma mensagem para seu número WhatsApp conectado à Wassenger para testar o bot.

Implantação em Produção

Defina variáveis de ambiente no seu 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

Compile e execute:

dotnet build -c Release dotnet run - configuration Release

Certifique-se de que seu servidor possa receber requisições POST em /webhook

Implantação

Você pode implantar este bot em qualquer plataforma de nuvem que suporte .NET 8.

Implantação com 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

Arquitetura

A implementação em C# segue padrões modernos do .NET e arquitetura limpa:

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

Testes

O projeto inclui verificações de integridade (health checks) e validação integradas:

Teste de Conexão com a API

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

Teste 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"
}
}'

Teste de Envio de Mensagem

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

Desenvolvimento

Estrutura do Projeto

A solução segue princípios de arquitetura limpa:

Controllers: Tratam requisições e respostas HTTP
Services: Lógica de negócio e integração com serviços externos
Models: Objetos de transferência de dados e modelos de domínio
Configuration: Gerenciamento centralizado de configuração
Dependency Injection: Container DI embutido no .NET

Classes Principais

ChatBot - Lógica principal de processamento do bot com filtragem e roteamento de mensagens
OpenAIClient - Integração com a API OpenAI com suporte a chat, áudio e imagem
WassengerClient - Integração com a API Wassenger para envio de mensagens no WhatsApp
FunctionHandler - Sistema de function calling da IA para integrações externas
WebhookController - Roteamento de requisições HTTP e tratamento de webhooks
BotConfig - Gerenciamento centralizado de configuração com variáveis de ambiente
MemoryStore - Cache em memória e gerenciamento do estado das conversas
NgrokTunnel - Túnel de desenvolvimento para testes locais

Executando em Desenvolvimento

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

Adicionando Pacotes NuGet

dotnet add package PackageName

Personalização

Instruções do Bot

Edite o comportamento da IA em Config/BotConfig.cs:

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

Function Calling

Adicione funções personalizadas em Bot/FunctionHandler.cs:

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

Limites de Taxa

Ajuste os limites em 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
}

Adicionando Novas Integrações de API

Crie um novo cliente na pasta Api/
Defina modelos em Models/
Registre em Program.cs na injeção de dependência
Use em ChatBot ou crie novos serviços

Endpoints da API

GET / - Informações e status do bot
POST /webhook - Webhook para mensagens recebidas do WhatsApp
POST /message - Endpoint para enviar mensagens
GET /sample - Envia uma mensagem de exemplo
GET /files/{id} - Downloads temporários de arquivos

Documentação Swagger

Quando rodando em modo de desenvolvimento, visite:

http://localhost:8080/swagger

Solução de Problemas

Problemas Comuns

“No active WhatsApp numbers”

Verifique sua chave de API Wassenger
Confira se você tem um dispositivo WhatsApp conectado na Wassenger

“WhatsApp number is not online”

Certifique-se de que seu dispositivo WhatsApp está conectado e online no dashboard da Wassenger

Webhook não está recebendo mensagens

Verifique se sua URL de webhook é acessível da internet
Verifique as configurações de firewall
Consulte os logs para erros de registro do webhook

Erros da API OpenAI

Verifique se sua chave de API OpenAI é válida
Garanta que o nome do modelo está correto
Verifique o uso e faturamento na sua conta OpenAI

Modo de Depuração

Habilite logging detalhado configurando em .env:

LOG_LEVEL=Debug

Ou em appsettings.Development.json:

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

Problemas Comuns de Ambiente

Porta já em uso: Altere PORT em .env
Ngrok não encontrado: Instale ngrok ou defina NGROK_PATH
Versão do .NET: Garanta que o SDK .NET 8.0 está instalado

Recursos

Contribuindo

Fork o repositório
Crie uma branch de feature (git checkout -b feature/amazing-feature)
Faça suas alterações
Adicione testes se aplicável
Commite suas mudanças (git commit -m 'Add some amazing feature')
Faça push para a branch (git push origin feature/amazing-feature)
Abra um Pull Request

Diretrizes de Desenvolvimento

Siga convenções de codificação C#
Use async/await para todas as operações de I/O
Adicione documentação XML para APIs públicas
Inclua testes unitários para novas funcionalidades
Atualize o README para novos recursos

Performance & Escalabilidade

Esta implementação em C# oferece várias vantagens:

Alta performance: otimizações do runtime .NET 8 e código compilado
Uso eficiente de memória: padrões adequados de disposal e gerenciamento de memória
Processamento concorrente: async/await e processamento baseado em Task
Escalável: injeção de dependência embutida e gerenciamento de lifetime de serviços
Pronto para produção: logging abrangente, tratamento de erros e health checks

Recursos de Segurança

Validação de Entrada: Todas as entradas do webhook são validadas
Limitação de Taxa: Cotas de mensagens e limites de conversas embutidos
Configuração Segura: Gerenciamento de segredos baseado em ambiente
Tratamento de Erros: Manipulação abrangente de exceções sem vazamento de informações
Segurança HTTP: Padrões modernos de segurança do ASP.NET Core