Tutoriel complet du chatbot IA GPT 4o de WhatsApp en C

Un chatbot IA WhatsApp polyvalent et personnalisable en C# 🔷 capable de comprendre du texte 📝, de l'audio 🎵 et des images 🖼️, et de répondre à vos clients 💬 sur n'importe quel sujet lié à votre entreprise 🏢 directement sur WhatsApp ✅. Propulsé par OpenAI GPT4o 🚀 (d'autres modèles peuvent aussi être utilisés) et par Wassenger WhatsApp API 🔗.

Prend désormais en charge GPT-4o avec entrée texte + audio + image 📝🎵🖼️, réponses audio 🔊, et RAG amélioré + MCP avec appel de fonctions 🛠️ et prise en charge des appels API externes 🌐

Trouvez d'autres implémentations de chatbot IA en Python, Node.js et PHP

🚀 Commencez gratuitement avec Wassenger WhatsApp API en quelques minutes en connectant votre numéro WhatsApp existant et obtenez votre clé API ✨

Fonctionnalités

🤖 Chatbot complet pour votre numéro WhatsApp connecté à Wassenger
💬 Réponses automatiques aux messages entrants des utilisateurs
🌍 Support multilingue — comprend et répond dans plus de 90 langues différentes
🎤 Entrée/sortie audio — capacités de transcription et synthèse vocale
🖼️ Traitement d'images — peut analyser et comprendre des images
👥 Transfert vers un humain — permet aux utilisateurs de demander une assistance humaine
⚙️ Comportement et instructions de l'IA personnalisables
🔧 Appel de fonctions pour l'intégration de données externes
📊 Gestion de la mémoire avec historique de conversation et limitation de débit
🚦 Routage intelligent avec gestion des webhooks et des erreurs
🔒 Sécurisé avec gestion appropriée des erreurs et journalisation
🔄 C# moderne avec .NET 9, injection de dépendances et modèles async/await

Contenu

Démarrage rapide

Clonez le dépôt :

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

Installez le SDK .NET 8 :
Téléchargez depuis : https://dotnet.microsoft.com/download/dotnet/8.0
Vérifiez l'installation : dotnet --version
Configurez l'environnement :

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

Lancez le bot (mode développement local) :

cd src/WhatsAppChatBot dotnet run

Exigences

SDK .NET 9.0 ou version ultérieure
Numéro WhatsApp personnel ou professionnel (WhatsApp)
Clé API Wassenger — Inscrivez-vous gratuitement
Clé API OpenAI — Inscription gratuite
Compte Ngrok (pour le développement local) — Inscrivez-vous gratuitement

Configuration

Modifiez le fichier .env avec vos identifiants 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

Configuration des clés API

Clé API Wassenger :

Inscrivez-vous sur Wassenger (essai gratuit disponible)
Allez dans API Keys
Créez une nouvelle clé API et copiez-la dans API_KEY dans .env

Clé API OpenAI :

Inscrivez-vous sur OpenAI (crédits gratuits disponibles)
Allez dans API Keys
Créez une nouvelle clé API et copiez-la dans OPENAI_API_KEY dans .env

Jeton Ngrok (pour le développement local) :

Inscrivez-vous sur Ngrok (gratuit)
Récupérez votre jeton d'authentification depuis le tableau de bord
Copiez-le dans NGROK_TOKEN dans .env

Personnalisation du bot

Modifiez src/WhatsAppChatBot/Config/BotConfig.cs pour personnaliser :

Les instructions et la personnalité du bot
Les messages de bienvenue et d'aide
Les fonctionnalités prises en charge (audio, images, etc.)
Les limites de débit et les quotas
Les numéros en liste blanche/liste noire
Les étiquettes et paramètres de métadonnées

Utilisation

Développement local

Démarrez le serveur de développement :

cd src/WhatsAppChatBot dotnet run

Le bot va :

Démarrer un serveur HTTP local sur le port 8080
Éventuellement créer un tunnel Ngrok automatiquement
Enregistrer le webhook auprès de Wassenger
Commencer à traiter les messages WhatsApp

Envoyez un message à votre numéro WhatsApp connecté à Wassenger pour tester le bot.

Déploiement en production

Définissez les variables d'environnement sur votre serveur :

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

Build et exécution :

dotnet build -c Release dotnet run - configuration Release

Assurez-vous que votre serveur peut recevoir des requêtes POST à /webhook

Déploiement

Vous pouvez déployer ce bot sur n'importe quelle plateforme cloud qui prend en charge .NET 8.

Déploiement 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

Architecture

L'implémentation C# suit les patterns modernes de .NET et une architecture propre :

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

Tests

Le projet inclut des vérifications de santé (health checks) et des validations intégrées :

Test de connexion API

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

Test du 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 d'envoi de message

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

Développement

Structure du projet

La solution suit les principes d'une architecture propre :

Controllers : Gèrent les requêtes et réponses HTTP
Services : Logique métier et intégration des services externes
Models : Objets de transfert de données et modèles de domaine
Configuration : Gestion centralisée de la configuration
Dependency Injection : Conteneur DI intégré de .NET

Classes clés

ChatBot - Logique principale de traitement du bot avec filtrage et routage des messages
OpenAIClient - Intégration de l'API OpenAI avec support chat, audio et image
WassengerClient - Intégration de l'API Wassenger pour la messagerie WhatsApp
FunctionHandler - Système d'appel de fonctions de l'IA pour intégrations externes
WebhookController - Routage des requêtes HTTP et gestion des webhooks
BotConfig - Gestion centralisée de la configuration via variables d'environnement
MemoryStore - Cache en mémoire et gestion de l'état des conversations
NgrokTunnel - Tunnel de développement pour les tests locaux

Exécution en développement

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

Ajout de packages NuGet

dotnet add package PackageName

Personnalisation

Instructions du bot

Modifiez le comportement de l'IA dans Config/BotConfig.cs :

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

Appel de fonctions

Ajoutez des fonctions personnalisées dans Bot/FunctionHandler.cs :

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

Limites de débit

Ajustez les limites dans 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
}

Ajout de nouvelles intégrations API

Créez un nouveau client dans le dossier Api/
Définissez les modèles dans Models/
Enregistrez dans Program.cs l'injection de dépendances
Utilisez dans ChatBot ou créez de nouveaux services

Endpoints API

GET / - Informations et état du bot
POST /webhook - Webhook pour les messages entrants WhatsApp
POST /message - Endpoint pour envoyer un message
GET /sample - Envoyer un message d'exemple
GET /files/{id} - Téléchargements temporaires de fichiers

Documentation Swagger

Lorsque vous exécutez en mode développement, visitez :

http://localhost:8080/swagger

Dépannage

Problèmes courants

« No active WhatsApp numbers »

Vérifiez votre clé API Wassenger
Vérifiez que vous avez un appareil WhatsApp connecté dans Wassenger

« WhatsApp number is not online »

Assurez-vous que votre appareil WhatsApp est connecté et en ligne dans le tableau de bord Wassenger

Le webhook ne reçoit pas de messages

Vérifiez que votre URL de webhook est accessible depuis Internet
Vérifiez les paramètres du pare-feu
Consultez les logs pour les erreurs d'enregistrement du webhook

Erreurs de l'API OpenAI

Vérifiez que votre clé API OpenAI est valide
Assurez-vous que le nom du modèle est correct
Vérifiez l'utilisation et la facturation de votre compte OpenAI

Mode debug

Activez la journalisation détaillée en le configurant dans .env :

LOG_LEVEL=Debug

Ou dans appsettings.Development.json :

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

Problèmes d'environnement courants

Port déjà utilisé : changez PORT dans .env
Ngrok introuvable : installez ngrok ou définissez NGROK_PATH
Version de .NET : assurez-vous que le SDK .NET 8.0 est installé

Ressources

Contribuer

Forkez le dépôt
Créez une branche de fonctionnalité (git checkout -b feature/amazing-feature)
Apportez vos modifications
Ajoutez des tests si nécessaire
Committez vos changements (git commit -m 'Add some amazing feature')
Poussez sur la branche (git push origin feature/amazing-feature)
Ouvrez une Pull Request

Directives de développement

Suivez les conventions de codage C#
Utilisez async/await pour toutes les opérations I/O
Ajoutez une documentation XML pour les API publiques
Incluez des tests unitaires pour les nouvelles fonctionnalités
Mettez à jour le README pour les nouvelles fonctionnalités

Performances et montée en charge

Cette implémentation C# offre plusieurs avantages :

Haute performance : optimisations du runtime .NET 8 et code compilé
Efficace en mémoire : bonnes pratiques de disposal et gestion de la mémoire
Traitement concurrent : async/await et traitement basé sur Task
Scalable : injection de dépendances intégrée et gestion des durées de vie des services
Prêt pour la production : journalisation complète, gestion des erreurs et health checks

Fonctionnalités de sécurité

Validation des entrées : toutes les entrées de webhook sont validées
Limitation de débit : quotas de messages et limites de conversation intégrés
Configuration sécurisée : gestion des secrets basée sur l'environnement
Gestion des erreurs : traitement complet des exceptions sans fuite d'informations
Sécurité HTTP : valeurs par défaut de sécurité modernes d'ASP.NET Core