WhatsApp GPT 4o AI-Chatbot in C Vollständiges Tutorial

Ein vielseitiger, anpassbarer WhatsApp AI-Chatbot in C# 🔷, der Text 📝, Audio 🎵 und Bilder 🖼️ verstehen kann und deinen Kund:innen 💬 direkt auf WhatsApp ✅ alles rund um dein Geschäft 🏢 beantworten kann. Angetrieben von OpenAI GPT4o 🚀 (andere Modelle sind ebenfalls nutzbar) und der Wassenger WhatsApp API 🔗.

Unterstützt jetzt GPT-4o mit Text‑ + Audio‑ + Bildeingabe 📝🎵🖼️, Audio‑Antworten 🔊 sowie verbessertes RAG + MCP mit Function Calling 🛠️ und Unterstützung für externe API‑Aufrufe 🌐

Finde weitere AI‑Chatbot‑Implementierungen in Python, Node.js und PHP

🚀 Starte kostenlos mit der Wassenger WhatsApp API in wenigen Minuten, indem du deine bestehende WhatsApp‑Nummer verbindest und deinen API‑Schlüssel erhältst ✨

Funktionen

• 🤖 Voll ausgestatteter Chatbot für deine mit Wassenger verbundene WhatsApp‑Nummer
• 💬 Automatische Antworten auf eingehende Nachrichten von Nutzer:innen
• 🌍 Mehrsprachige Unterstützung — versteht und antwortet in 90+ Sprachen
• 🎤 Audioein-/-ausgabe — Transkription und Text‑zu‑Sprache‑Funktionen
• 🖼️ Bildverarbeitung — kann Bilder analysieren und interpretieren
• 👥 Übergabe an Menschen — ermöglicht Nutzer:innen, menschliche Hilfe anzufordern
• ⚙️ Anpassbares AI‑Verhalten und Anweisungen
• 🔧 Function Calling zur Integration externer Daten
• 📊 Speicherverwaltung mit Gesprächsverlauf und Rate‑Limiting
• 🚦 Intelligentes Routing mit Webhook‑Verarbeitung und Fehlerbehandlung
• 🔒 Sicher mit ordentlicher Fehlerbehandlung und Protokollierung
• 🔄 Modernes C# mit .NET 9, Dependency Injection und async/await‑Mustern

Inhalt

• Funktionen
• Schnellstart
• Voraussetzungen
• Konfiguration
• API‑Schlüssel einrichten
• Bot‑Anpassung
• Verwendung
• Lokale Entwicklung
• Produktiv‑Bereitstellung
• Bereitstellung
• Docker
• Render
• Heroku
• Railway
• Fly.io
• Azure App Service
• Architektur
• Tests
• Entwicklung

Schnellstart

• Repository klonen:

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

• .NET 8 SDK installieren:
• Herunterladen von: https://dotnet.microsoft.com/download/dotnet/8.0
• Installation überprüfen: dotnet --version
• Umgebung konfigurieren:

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

• Bot starten (lokaler Entwicklungsmodus):

cd src/WhatsAppChatBot dotnet run

Voraussetzungen

• .NET 9.0 SDK oder neuer
• WhatsApp persönliche oder Business‑Nummer
• Wassenger API‑Key — Kostenlos registrieren
• OpenAI API‑Key — Kostenlos registrieren
• Ngrok Account (für lokale Entwicklung) — Kostenlos registrieren

Konfiguration

Bearbeite die .env‑Datei mit deinen API‑Zugangsdaten:

# 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

API‑Schlüssel einrichten

Wassenger API‑Schlüssel:

• Registriere dich bei Wassenger (kostenlose Testphase verfügbar)
• Gehe zu API Keys
• Erstelle einen neuen API‑Schlüssel und kopiere ihn in API_KEY in der .env

OpenAI API‑Schlüssel:

• Registriere dich bei OpenAI (kostenlose Guthaben verfügbar)
• Gehe zu API Keys
• Erstelle einen neuen API‑Schlüssel und kopiere ihn in OPENAI_API_KEY in der .env

Ngrok Token (für lokale Entwicklung):

• Registriere dich bei Ngrok (kostenlos)
• Hole dein Auth‑Token aus dem Dashboard
• Kopiere es in NGROK_TOKEN in der .env

Bot‑Anpassung

Bearbeite src/WhatsAppChatBot/Config/BotConfig.cs, um Folgendes anzupassen:

• Bot‑Anweisungen und Persönlichkeit
• Begrüßungs‑ und Hilfenachrichten
• Unterstützte Funktionen (Audio, Bilder usw.)
• Ratenlimits und Kontingente
• Whitelist-/Blacklist‑Nummern
• Labels und Metadaten‑Einstellungen

Verwendung

Lokale Entwicklung

Starte den Entwicklungsserver:

cd src/WhatsAppChatBot dotnet run

Der Bot wird:

• Einen lokalen HTTP‑Server auf Port 8080 starten
• Optional automatisch einen Ngrok‑Tunnel erstellen
• Den Webhook bei Wassenger registrieren
• Mit der Verarbeitung von WhatsApp‑Nachrichten beginnen

Sende eine Nachricht an deine mit Wassenger verbundene WhatsApp‑Nummer, um den Bot zu testen.

Produktiv‑Bereitstellung

Setze die Umgebungsvariablen auf deinem 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

Builden und ausführen:

dotnet build -c Release dotnet run - configuration Release

Stelle sicher, dass dein Server POST‑Anfragen an /webhook empfangen kann

Bereitstellung

Du kannst diesen Bot auf jeder Cloud‑Plattform bereitstellen, die .NET 8 unterstützt.

Docker‑Bereitstellung

# 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

Architektur

Die C#‑Implementierung folgt modernen .NET‑Mustern und 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

Tests

Das Projekt enthält eingebaute Health‑Checks und Validierungen:

API‑Verbindungstest

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

Webhook‑Test

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

Sende‑Nachricht‑Test

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

Entwicklung

Projektstruktur

Die Lösung folgt den Prinzipien der Clean Architecture:

• Controllers: Verarbeiten HTTP‑Anfragen und ‑Antworten
• Services: Geschäftslogik und Integration externer Dienste
• Models: Data Transfer Objects und Domain‑Modelle
• Configuration: Zentrale Konfigurationsverwaltung
• Dependency Injection: Eingebaute .NET DI‑Container

Wichtige Klassen

• ChatBot - Hauptlogik des Bots mit Nachrichtenfilterung und Routing
• OpenAIClient - OpenAI API‑Integration mit Chat, Audio und Bildunterstützung
• WassengerClient - Wassenger API‑Integration für WhatsApp‑Nachrichten
• FunctionHandler - AI‑Function‑Calling‑System für externe Integrationen
• WebhookController - HTTP‑Routing und Webhook‑Verarbeitung
• BotConfig - Zentrale Konfigurationsverwaltung über Umgebungsvariablen
• MemoryStore - In‑Memory‑Caching und Gesprächszustandsverwaltung
• NgrokTunnel - Development‑Tunneling für lokale Tests

Ausführung in der Entwicklung

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

NuGet‑Pakete hinzufügen

dotnet add package PackageName

Anpassung

Bot‑Anweisungen

Bearbeite das AI‑Verhalten in Config/BotConfig.cs:

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

Funktionsaufrufe

Füge benutzerdefinierte Funktionen in Bot/FunctionHandler.cs hinzu:

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

Ratenlimits

Passe die Limits in Config/BotConfig.cs an:

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

Neue API‑Integrationen hinzufügen

1. Erstelle einen neuen Client im Api/‑Ordner
2. Definiere Modelle in Models/
3. Registriere ihn in Program.cs via Dependency Injection
4. Nutze ihn im ChatBot oder erstelle neue Services

API‑Endpunkte

• GET / - Bot‑Informationen und Status
• POST /webhook - Webhook für eingehende WhatsApp‑Nachrichten
• POST /message - Endpoint zum Senden von Nachrichten
• GET /sample - Sendet eine Beispielnachricht
• GET /files/{id} - Temporäre Dateidownloads

Swagger‑Dokumentation

Im Entwicklungsmodus besuchen:

• http://localhost:8080/swagger

Fehlerbehebung

Häufige Probleme

1. „Keine aktiven WhatsApp‑Nummern“

• Überprüfe deinen Wassenger API‑Schlüssel
• Stelle sicher, dass du ein verbundenes WhatsApp‑Gerät in Wassenger hast

2. „WhatsApp‑Nummer ist nicht online“

• Stelle sicher, dass dein WhatsApp‑Gerät verbunden und online im Wassenger‑Dashboard ist

3. Webhook empfängt keine Nachrichten

• Prüfe, ob deine Webhook‑URL aus dem Internet erreichbar ist
• Überprüfe Firewall‑Einstellungen
• Prüfe die Logs auf Fehler bei der Webhook‑Registrierung

4. OpenAI‑API‑Fehler

• Überprüfe, ob dein OpenAI API‑Schlüssel gültig ist
• Stelle sicher, dass der Modellname korrekt ist
• Prüfe die Nutzung und Abrechnung deines OpenAI‑Kontos

Debug‑Modus

Aktiviere detailliertes Logging, indem du es in der .env setzt:

LOG_LEVEL=Debug

Oder in appsettings.Development.json:

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

Häufige Umgebungsprobleme

• Port bereits in Verwendung: Ändere PORT in der .env
• Ngrok nicht gefunden: Installiere ngrok oder setze NGROK_PATH
• .NET‑Version: Stelle sicher, dass das .NET 8.0 SDK installiert ist

Ressourcen

• .NET Documentation
• ASP.NET Core Documentation
• Wassenger Documentation
• OpenAI API Documentation
• C# Language Reference
• GitHub Issues

Mitwirken

1. Forke das Repository
2. Erstelle einen Feature‑Branch (git checkout -b feature/amazing-feature)
3. Nimm deine Änderungen vor
4. Füge Tests hinzu, falls anwendbar
5. Committe deine Änderungen (git commit -m 'Add some amazing feature')
6. Push auf den Branch (git push origin feature/amazing-feature)
7. Öffne einen Pull Request

Entwicklungsrichtlinien

• Folge den C#‑Coding‑Konventionen
• Verwende async/await für alle I/O‑Operationen
• Füge XML‑Dokumentation für öffentliche APIs hinzu
• Inkludiere Unit‑Tests für neue Funktionalität
• Aktualisiere das README für neue Features

Performance & Skalierbarkeit

Diese C#‑Implementierung bietet mehrere Vorteile:

• Hohe Performance: .NET 8 Runtime‑Optimierungen und kompilierter Code
• Speicher‑Effizienz: Korrekte Disposal‑Muster und Speicherverwaltung
• Nebenläufige Verarbeitung: Async/await und Task‑basierte Verarbeitung
• Skalierbar: Eingebaute Dependency Injection und Service‑Lifetime‑Verwaltung
• Produktionsreif: Umfassendes Logging, Fehlerbehandlung und Health‑Checks

Sicherheitsfunktionen

• Eingabevalidierung: Alle Webhook‑Eingaben werden validiert
• Ratenbegrenzung: Eingebaute Nachrichtenquoten und Gesprächsbegrenzungen
• Sichere Konfiguration: Verwaltung von Geheimnissen über Umgebungsvariablen
• Fehlerbehandlung: Umfassende Exception‑Behandlung ohne Informationsleckage
• HTTP‑Sicherheit: Moderne ASP.NET Core Sicherheits‑Defaults