Aller au contenu
Retour au blog
Pour les entreprisesIA et chatbotsTutoriels

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

whatsapp gpt 4o ai chatbot in c full tutori

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

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

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) :

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

  1. Créez un nouveau client dans le dossier Api/
  2. DĂ©finissez les modĂšles dans Models/
  3. Enregistrez dans Program.cs l'injection de dépendances
  4. 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 :

DĂ©pannage

ProblĂšmes courants

  1. « No active WhatsApp numbers »
  • VĂ©rifiez votre clĂ© API Wassenger
  • VĂ©rifiez que vous avez un appareil WhatsApp connectĂ© dans Wassenger
  1. « WhatsApp number is not online »
  • Assurez-vous que votre appareil WhatsApp est connectĂ© et en ligne dans le tableau de bord Wassenger
  1. 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
  1. 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

  1. Forkez le dépÎt
  2. Créez une branche de fonctionnalité (git checkout -b feature/amazing-feature)
  3. Apportez vos modifications
  4. Ajoutez des tests si nécessaire
  5. Committez vos changements (git commit -m 'Add some amazing feature')
  6. Poussez sur la branche (git push origin feature/amazing-feature)
  7. 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
Plus

Plus d’articles et de tutoriels

PrĂȘt Ă  transformer votre communication WhatsApp ?

Commencez dùs aujourd’hui à automatiser vos interactions client avec Wassenger.

Commencer gratuitementVoir les tarifs

Explorer plus

Tutoriels, guides et Ă©tudes de cas pour utiliser WhatsApp Ă  l’échelle d’une Ă©quipe.

Tous les articlesIntégrationsMCP pour les agents IA
PrĂȘt pour l'API officielle WhatsApp Business ?DĂ©couvrez ce que Meta facture, et gardez votre numĂ©ro actuel.
Tarifs de l'API WhatsApp