Einen eigenen ChatGPT Chatbot Schritt für Schritt entwickeln

In diesem Tutorial lernst du, wie man einen Chatbot mit Python und der OpenAI API erstellt. Wir fangen ganz einfach an und erweitern unseren Bot dann Schritt für Schritt mit mehr Funktionen.

Teil 1: Der erste, einfache Chatbot

Was wir brauchen

Python (Version 3.8 oder höher)
Ein OpenAI-Konto mit API-Key
Ein Texteditor oder eine Entwicklungsumgebung

Einen API-Key bekommen: Schnellstart

OpenAI-Konto erstellen
- Gehe zu platform.openai.com
- Registriere dich mit E-Mail oder Google/Microsoft-Konto
Bezahlung einrichten
- Kreditkarte erforderlich
- Startguthaben: $5
- GPT-3.5-turbo kostet etwa 0.2 Cent pro 750 Wörter
- Tipp: Setze ein monatliches Limit (z.B. $5)
API-Key erstellen
- Im Dashboard: “API Keys” → “Create new secret key”
- Key SOFORT kopieren und sicher speichern
- Nie öffentlich teilen!

Installation der Grundlagen

Öffne die Kommandozeile und führe diese Befehle aus:

# Erstelle einen neuen Projektordner
mkdir mein-chatbot
cd mein-chatbot

# Erstelle eine virtuelle Umgebung
python -m venv venv

# Aktiviere die Umgebung
# Unter Windows:
venv\Scripts\activate
# Unter Mac/Linux:
source venv/bin/activate

# Installiere die benötigten Pakete
pip install openai python-dotenv

Der erste, einfache Code

Erstelle eine neue Datei simple_chat.py mit diesem grundlegenden Code:

import os
import openai
from dotenv import load_dotenv

# Lade den API-Key
load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Funktion für die Chat-Antwort
def get_response(frage):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "user", "content": frage}
        ]
    )
    return response.choices[0].message.content

# Hauptprogramm
print("Willkommen! Schreibe etwas (oder 'ende' zum Beenden)")

while True:
    # Benutzereingabe
    frage = input("Du: ")
    
    # Prüfe ob Benutzer beenden möchte
    if frage.lower() == "ende":
        print("Auf Wiedersehen!")
        break
        
    # Hole und zeige die Antwort
    antwort = get_response(frage)
    print("\nBot:", antwort, "\n")

API-Key einrichten

Erstelle eine Datei .env im gleichen Ordner:

OPENAI_API_KEY=dein-api-key-hier

Ersten Chat starten

python simple_chat.py

So einfach ist der erste Chat! Du kannst jetzt schon mit dem Bot sprechen.

Teil 2: Gedächtnis hinzufügen

Jetzt erweitern wir unseren Bot, damit er sich an die Unterhaltung erinnert.

import os
import openai
from dotenv import load_dotenv

load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def get_response(messages):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages
    )
    return response.choices[0].message.content

# Hauptprogramm
print("Willkommen! Schreibe etwas (oder 'ende' zum Beenden)")

# Liste für den Chatverlauf
messages = [
    {"role": "system", "content": "Du bist ein hilfreicher Assistent."}
]

while True:
    frage = input("Du: ")
    
    if frage.lower() == "ende":
        print("Auf Wiedersehen!")
        break
        
    # Füge die Frage zum Verlauf hinzu
    messages.append({"role": "user", "content": frage})
    
    # Hole die Antwort mit dem ganzen Verlauf
    antwort = get_response(messages)
    
    # Füge die Antwort zum Verlauf hinzu
    messages.append({"role": "assistant", "content": antwort})
    
    print("\nBot:", antwort, "\n")

Jetzt erinnert sich der Bot an vorherige Nachrichten und kann darauf Bezug nehmen!

Teil 3: Einfache Befehle hinzufügen

Als nächstes fügen wir ein paar nützliche Befehle hinzu:

import os
import openai
from dotenv import load_dotenv

load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def get_response(messages):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages
    )
    return response.choices[0].message.content

# Hauptprogramm
print("Willkommen! Hier sind die verfügbaren Befehle:")
print("/hilfe - Zeigt diese Hilfe an")
print("/neu - Startet einen neuen Chat")
print("/ende - Beendet das Programm")

messages = [
    {"role": "system", "content": "Du bist ein hilfreicher Assistent."}
]

while True:
    frage = input("Du: ")
    
    # Befehlsverarbeitung
    if frage.startswith("/"):
        if frage == "/ende":
            print("Auf Wiedersehen!")
            break
        elif frage == "/neu":
            messages = [
                {"role": "system", "content": "Du bist ein hilfreicher Assistent."}
            ]
            print("Neuer Chat gestartet!")
            continue
        elif frage == "/hilfe":
            print("\nVerfügbare Befehle:")
            print("/hilfe - Zeigt diese Hilfe an")
            print("/neu - Startet einen neuen Chat")
            print("/ende - Beendet das Programm\n")
            continue
        
    # Normale Chatverarbeitung
    messages.append({"role": "user", "content": frage})
    antwort = get_response(messages)
    messages.append({"role": "assistant", "content": antwort})
    print("\nBot:", antwort, "\n")

Teil 4: Was kommt als Nächstes?

Nachdem du die Grundlagen verstanden hast, hier einige Vorschläge, was du als Nächstes hinzufügen könntest:

Chatverlauf speichern
- Speichere Gespräche in einer Datei
- Lade alte Gespräche wieder
Verschiedene Persönlichkeiten
- Lass den Bot verschiedene Rollen spielen
- Ändere die System-Message
Fehlerbehandlung
- Fange Netzwerkfehler ab
- Reagiere auf API-Limits
Fortgeschrittene Funktionen
- Token-Zähler
- Modellauswahl (GPT-3.5 oder GPT-4)
- Streaming-Antworten

Möchtest du einen dieser Bereiche vertiefen? Schau dir dazu Teil 5 an!

Teil 5: Fortgeschrittene Funktionen

1. Streaming-Unterstützung

def generate_response_stream(self, prompt):
    self.conversation.append({"role": "user", "content": prompt})
    try:
        stream = client.chat.completions.create(
            model=self.model,
            messages=self.conversation,
            stream=True
        )
        
        response_parts = []
        for chunk in stream:
            if chunk.choices[0].delta.content:
                part = chunk.choices[0].delta.content
                response_parts.append(part)
                print(part, end='', flush=True)
                
        full_response = ''.join(response_parts)
        self.conversation.append({"role": "assistant", "content": full_response})
        return full_response
        
    except Exception as e:
        return f"Ein Fehler ist aufgetreten: {str(e)}"

2. Kontextlängen-Management

def trim_conversation(self, max_messages=10):
    if len(self.conversation) > max_messages + 1:  # +1 für die System-Message
        # Behalte System-Message und die letzten n Nachrichten
        self.conversation = [
            self.conversation[0],  # System-Message
            *self.conversation[-(max_messages):]  # Letzte Nachrichten
        ]

3. Markdown-Formatierung

Füge die rich Bibliothek hinzu für schönere Ausgaben:

pip install rich

from rich.console import Console
from rich.markdown import Markdown

console = Console()

def display_response(response):
    console.print(Markdown(response))

Best Practices und Tipps

Kostenmanagement

Verwende zunächst GPT-3.5-Turbo für Tests
Implementiere Token-Limits
Überwache die API-Nutzung

Sicherheit

Speichere den API-Key nie im Code
Prüfe User-Eingaben
Implementiere Rate-Limiting

Fehlerbehandlung

Fange Netzwerkfehler ab
Implementiere Retries bei API-Fehlern
Logge Fehler für die Analyse

Häufige Probleme und Lösungen

Problem: API-Timeouts

import tenacity

@tenacity.retry(stop=tenacity.stop_after_attempt(3))
def generate_response_with_retry(self, prompt):
    return self.generate_response(prompt)

Problem: Große Konversationen

Implementiere das Trimming von alten Nachrichten
Verwende Zusammenfassungen für lange Kontexte

Weiterführende Ressourcen

Tipps für Anfänger

Experimentiere schrittweise
- Verstehe jeden Teil, bevor du weitermachst
- Teste neue Funktionen einzeln
- Mach regelmäßig Sicherungskopien
Debugging
- Nutze print()-Befehle zum Debuggen
- Prüfe den Chatverlauf
- Schau dir die API-Antworten genau an
API-Kosten
- Starte mit GPT-3.5-Turbo (günstiger)
- Setze Limits für API-Aufrufe
- Überwache deine Kosten

Häufige Fehler und Lösungen

API-Key nicht gefunden
- Prüfe, ob die .env Datei im richtigen Ordner ist
- Prüfe den API-Key auf Tippfehler
Verbindungsfehler
- Prüfe deine Internetverbindung
- Warte kurz und versuche es erneut
Zu viele Nachrichten
- Begrenze die Anzahl der gespeicherten Nachrichten
- Lösche alte Nachrichten

Fazit

Dieses Tutorial hat dich von einem einfachen Chatbot zu einer erweiterbaren Basis geführt. Du kannst nun:

Einen grundlegenden Chatbot erstellen
Den Bot mit Gedächtnis ausstatten
Einfache Befehle hinzufügen
Weitere Funktionen nach Bedarf einbauen

Viel Spaß beim Experimentieren mit deinem Bot!

Anfängertutorial: Einen eigenen Chatbot programmieren (updated)