WhatsApp GPT 4o AI Chatbot in C Guida Completa

Un chatbot AI per WhatsApp generico e personalizzabile in C# 🔷 che può comprendere testo 📝, audio 🎵 e immagini 🖼️, e rispondere ai tuoi clienti 💬 su qualsiasi argomento relativo alla tua attività 🏢 direttamente su WhatsApp ✅. Alimentato da OpenAI GPT4o 🚀 (possono essere usati anche altri modelli) e da Wassenger WhatsApp API 🔗.

Ora supporta GPT-4o con input testo + audio + immagine 📝🎵🖼️, risposte audio 🔊, e RAG migliorato + MCP con function calling 🛠️ e supporto per chiamate a API esterne 🌐

Trova altre implementazioni del Chatbot AI in Python, Node.js e PHP

🚀 Inizia gratuitamente con Wassenger WhatsApp API in pochi minuti collegando il tuo numero WhatsApp esistente e ottieni la tua chiave API ✨

Funzionalità

🤖 Chatbot completo per il tuo numero WhatsApp connesso a Wassenger
💬 Risposte automatiche ai messaggi in arrivo dagli utenti
🌍 Supporto multilingue — comprende e risponde in oltre 90 lingue diverse
🎤 Input/output audio — funzionalità di trascrizione e text-to-speech
🖼️ Elaborazione delle immagini — può analizzare e comprendere immagini
👥 Handoff a operatore umano — consente agli utenti di richiedere assistenza umana
⚙️ Comportamento e istruzioni AI personalizzabili
🔧 Capacità di function calling per integrazione di dati esterni
📊 Gestione della memoria con cronologia conversazioni e limitazione delle richieste
🚦 Instradamento intelligente con gestione dei webhook ed errori
🔒 Sicurezza con corretta gestione degli errori e logging
🔄 C# moderno con .NET 9, dependency injection e pattern async/await

Contenuti

Avvio rapido

Clona il repository:

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

Installa il .NET 8 SDK:
Scarica da: https://dotnet.microsoft.com/download/dotnet/8.0
Verifica l'installazione: dotnet --version
Configura l'ambiente:

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

Avvia il bot (modalità sviluppo locale):

cd src/WhatsAppChatBot dotnet run

Requisiti

.NET 9.0 SDK o versione successiva
Numero WhatsApp personale o Business (WhatsApp)
Wassenger API key — Iscriviti gratuitamente
OpenAI API key — Iscriviti gratuitamente
Account Ngrok (per sviluppo locale) — Iscriviti gratuitamente

Configurazione

Modifica il file .env con le tue credenziali 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

Configurazione delle chiavi API

Wassenger API Key:

Iscriviti su Wassenger (prova gratuita disponibile)
Vai a API Keys
Crea una nuova chiave API e copiala in API_KEY nel file .env

OpenAI API Key:

Iscriviti su OpenAI (crediti gratuiti disponibili)
Vai a API Keys
Crea una nuova chiave API e copiala in OPENAI_API_KEY nel file .env

Token Ngrok (per sviluppo locale):

Iscriviti su Ngrok (gratuito)
Ottieni il tuo auth token dalla dashboard
Copialo in NGROK_TOKEN nel file .env

Personalizzazione del bot

Modifica src/WhatsAppChatBot/Config/BotConfig.cs per personalizzare:

Istruzioni e personalità del bot
Messaggi di benvenuto e di aiuto
Funzionalità supportate (audio, immagini, ecc.)
Limiti di velocità e quote
Numeri in whitelist/blacklist
Impostazioni di etichette e metadata

Utilizzo

Sviluppo locale

Avvia il server di sviluppo:

cd src/WhatsAppChatBot dotnet run

Il bot:

Avvierà un server HTTP locale sulla porta 8080
Potenzialmente creerà automaticamente un tunnel Ngrok
Registrerà il webhook con Wassenger
Inizierà a processare i messaggi WhatsApp

Invia un messaggio al tuo numero WhatsApp connesso a Wassenger per testare il bot.

Distribuzione in produzione

Imposta le variabili d'ambiente sul tuo server:

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 ed esegui:

dotnet build -c Release dotnet run - configuration Release

Assicurati che il tuo server possa ricevere richieste POST su /webhook

Distribuzione

Puoi distribuire questo bot su qualsiasi piattaforma cloud che supporti .NET 8.

Distribuzione 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

Architettura

L'implementazione in C# segue i pattern moderni di .NET e una clean architecture:

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

Testing

Il progetto include health check e validazioni integrate:

Test di connessione API

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

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

Test invio messaggio

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

Sviluppo

Struttura del progetto

La soluzione segue i principi della clean architecture:

Controllers: Gestiscono richieste e risposte HTTP
Services: Logica di business e integrazione con servizi esterni
Models: Oggetti di trasferimento dati e modelli di dominio
Configuration: Gestione centralizzata della configurazione
Dependency Injection: Container DI integrato di .NET

Classi chiave

ChatBot - Logica principale del bot con filtraggio e instradamento dei messaggi
OpenAIClient - Integrazione con l'API OpenAI per chat, audio e immagini
WassengerClient - Integrazione con l'API Wassenger per messaggistica WhatsApp
FunctionHandler - Sistema di function calling AI per integrazioni esterne
WebhookController - Instradamento delle richieste HTTP e gestione dei webhook
BotConfig - Gestione centralizzata della configurazione tramite variabili d'ambiente
MemoryStore - Caching in-memory e gestione dello stato delle conversazioni
NgrokTunnel - Tunneling per sviluppo locale

Esecuzione in ambiente di sviluppo

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

Aggiunta di pacchetti NuGet

dotnet add package PackageName

Personalizzazione

Istruzioni del bot

Modifica il comportamento AI in Config/BotConfig.cs:

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

Function Calling

Aggiungi funzioni personalizzate in Bot/FunctionHandler.cs:

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

Limiti di velocità

Regola i limiti in 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
}

Aggiungere nuove integrazioni API

Crea un nuovo client nella cartella Api/
Definisci i modelli in Models/
Registralo in Program.cs per la dependency injection
Usalo in ChatBot o crea nuovi servizi

Endpoint API

GET / - Informazioni e stato del bot
POST /webhook - Webhook per messaggi WhatsApp in arrivo
POST /message - Endpoint per inviare messaggi
GET /sample - Invia un messaggio di esempio
GET /files/{id} - Download temporanei di file

Documentazione Swagger

Quando esegui in modalità sviluppo, visita:

http://localhost:8080/swagger

Risoluzione dei problemi

Problemi comuni

“No active WhatsApp numbers”

Verifica la tua chiave API Wassenger
Controlla di avere un dispositivo WhatsApp connesso in Wassenger

“WhatsApp number is not online”

Assicurati che il tuo dispositivo WhatsApp sia connesso e online nel dashboard di Wassenger

Webhook che non riceve messaggi

Controlla che l'URL del webhook sia accessibile da Internet
Verifica le impostazioni del firewall
Controlla i log per errori nella registrazione del webhook

Errori API OpenAI

Verifica che la tua chiave API OpenAI sia valida
Assicurati che il nome del modello sia corretto
Controlla l'utilizzo e la fatturazione del tuo account OpenAI

Modalità Debug

Abilita il logging dettagliato impostandolo in .env:

LOG_LEVEL=Debug

Oppure in appsettings.Development.json:

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

Problemi comuni con l'ambiente

Porta già in uso: cambia PORT nel file .env
Ngrok non trovato: installa ngrok o imposta NGROK_PATH
Versione .NET: assicurati di avere installato il .NET 8.0 SDK

Risorse

Contribuire

Fai il fork del repository
Crea un branch per la feature (git checkout -b feature/amazing-feature)
Apporta le tue modifiche
Aggiungi test se applicabile
Commit delle modifiche (git commit -m 'Add some amazing feature')
Push del branch (git push origin feature/amazing-feature)
Apri una Pull Request

Linee guida per lo sviluppo

Segui le convenzioni di codifica C#
Usa async/await per tutte le operazioni di I/O
Aggiungi documentazione XML per le API pubbliche
Includi unit test per le nuove funzionalità
Aggiorna il README per le nuove funzionalità

Prestazioni e scalabilità

Questa implementazione in C# offre diversi vantaggi:

Alte prestazioni: ottimizzazioni del runtime .NET 8 e codice compilato
Efficienza di memoria: pattern di disposal corretti e gestione della memoria
Elaborazione concorrente: async/await e processing basato su Task
Scalabile: dependency injection integrata e gestione dei lifecycle dei servizi
Pronta per la produzione: logging, gestione degli errori e health check completi

Funzionalità di sicurezza

Validazione degli input: tutti gli input dei webhook sono validati
Rate Limiting: quote e limiti delle conversazioni integrati
Configurazione sicura: gestione dei segreti basata su variabili d'ambiente
Gestione degli errori: gestione completa delle eccezioni senza perdita di informazioni sensibili
Sicurezza HTTP: impostazioni di sicurezza predefinite moderne di ASP.NET Core