Einen eigenen ChatGPT Chatbot Schritt für Schritt entwickeln (2026 Update)

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. Dieser Guide wurde für 2026 aktualisiert mit den neuesten API-Versionen und Best Practices derinformatikstudent.de.

Teil 1: Der erste, einfache Chatbot

Was wir brauchen

• Python (Version 3.10 oder höher empfohlen)
• Ein OpenAI-Konto mit API-Key und aktiviertem Billing
• Ein Texteditor oder eine Entwicklungsumgebung (VS Code, PyCharm, etc.)
• OpenAI Python Library (v1.0+)

Einen API-Key bekommen: Schnellstart

1. OpenAI-Konto erstellen

   • Gehe zu platform.openai.com
   • Registriere dich mit E-Mail oder Google/Microsoft-Konto
   • Verifiziere deine Telefonnummer (erforderlich seit 2024)

2. Bezahlung einrichten

   • Kreditkarte oder Prepaid-Guthaben erforderlich
   • Startguthaben variiert je nach Region
   • Aktuelle Preise (2026):
     • GPT-4o: ~$0.005 pro 1K Tokens (Input)
     • GPT-4-Turbo: ~$0.01 pro 1K Tokens (Input)
     • GPT-3.5-Turbo: ~$0.0005 pro 1K Tokens (Input)
   • Tipp: Setze ein monatliches Limit im Dashboard consultee.ai

3. API-Key erstellen

   • Im Dashboard: “API Keys” → “Create new secret key”
   • Key SOFORT kopieren und sicher speichern
   • Nie öffentlich teilen oder in Git committen!

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 (aktuelle Versionen 2026)
pip install openai python-dotenv rich

Der erste, einfache Code (OpenAI Library v1.0+)

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

import os
from openai import OpenAI
from dotenv import load_dotenv

# Lade den API-Key aus der .env Datei
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Funktion für die Chat-Antwort
def get_response(frage):
    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",  # Aktualisiertes Modell 2026
            messages=[
                {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
                {"role": "user", "content": frage}
            ],
            max_tokens=500,
            temperature=0.7
        )
        return response.choices[0].message.content
    except Exception as e:
        return f"Ein Fehler ist aufgetreten: {str(e)}"

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

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

API-Key einrichten

Erstelle eine Datei .env im gleichen Ordner:

OPENAI_API_KEY=sk-proj-dein-api-key-hier

⚠️ Wichtig: Füge .env zu deiner .gitignore Datei hinzu!

echo ".env" >> .gitignore

Ersten Chat starten

python simple_chat.py

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

Teil 2: Gedächtnis hinzufügen (Conversation History)

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

import os
from openai import OpenAI
from dotenv import load_dotenv

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

def get_response(messages):
    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            max_tokens=500,
            temperature=0.7
        )
        return response.choices[0].message.content
    except Exception as e:
        return f"⚠️ Fehler: {str(e)}"

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

# Liste für den Chatverlauf mit System-Message
messages = [
    {"role": "system", "content": "Du bist ein hilfreicher, freundlicher Assistent. Antworte präzise aber ausführlich."}
]

while True:
    frage = input("\n👤 Du: ")
    
    if frage.lower() in ["ende", "exit", "quit"]:
        print("🤖 Bot: 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(f"\n🤖 Bot: {antwort}")
    
    # Optional: Begrenze die Nachrichtenanzahl für Kostenkontrolle
    if len(messages) > 20:
        messages = [messages[0]] + messages[-19:]

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

Teil 3: Befehle und Fehlerbehandlung

Als nächstes fügen wir nützliche Befehle und robuste Fehlerbehandlung hinzu:

import os
from openai import OpenAI
from dotenv import load_dotenv
from rich.console import Console
from rich.markdown import Markdown

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

def get_response(messages, model="gpt-4o-mini"):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            max_tokens=1000,
            temperature=0.7,
            timeout=30
        )
        return response.choices[0].message.content, None
    except Exception as e:
        return None, f"⚠️ Fehler: {str(e)}"

def print_help():
    console.print("""
[bold]📋 Verfügbare Befehle:[/bold]
  /hilfe     - Zeigt diese Hilfe an
  /neu       - Startet einen neuen Chat
  /clear     - Löscht den Bildschirm
  /modell    - Zeigt/ändert das Modell
  /info      - Zeigt Chat-Statistiken
  /ende      - Beendet das Programm
""")

# Hauptprogramm
console.print("[bold green]🤖 Willkommen![/bold green]")
print_help()

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

current_model = "gpt-4o-mini"
message_count = 0
token_estimate = 0

while True:
    try:
        frage = console.input("\n[bold cyan]👤 Du:[/bold cyan] ")
        
        # Befehlsverarbeitung
        if frage.startswith("/"):
            befehl = frage.lower().split()[0]
            
            if befehl == "/ende":
                console.print("[green]🤖 Bot: Auf Wiedersehen![/green]")
                break
            elif befehl == "/neu":
                messages = [
                    {"role": "system", "content": "Du bist ein hilfreicher, freundlicher Assistent."}
                ]
                message_count = 0
                console.print("[yellow]🔄 Neuer Chat gestartet![/yellow]")
                continue
            elif befehl == "/hilfe":
                print_help()
                continue
            elif befehl == "/clear":
                console.clear()
                continue
            elif befehl == "/info":
                console.print(f"[blue]📊 Nachrichten: {len(messages)} | Modell: {current_model}[/blue]")
                continue
            elif befehl == "/modell":
                args = frage.split()
                if len(args) > 1:
                    new_model = args[1]
                    if new_model in ["gpt-4o-mini", "gpt-4o", "gpt-4-turbo"]:
                        current_model = new_model
                        console.print(f"[green]✅ Modell geändert zu: {current_model}[/green]")
                    else:
                        console.print("[red]❌ Ungültiges Modell[/red]")
                else:
                    console.print(f"[blue]Aktuelles Modell: {current_model}[/blue]")
                continue
            else:
                console.print("[red]❌ Unbekannter Befehl. Tippe /hilfe für Hilfe.[/red]")
                continue
        
        # Normale Chatverarbeitung
        messages.append({"role": "user", "content": frage})
        message_count += 1
        
        antwort, error = get_response(messages, current_model)
        
        if error:
            console.print(f"[red]{error}[/red]")
            messages.pop()  # Entferne die letzte Nachricht bei Fehler
        else:
            messages.append({"role": "assistant", "content": antwort})
            console.print("\n[bold green]🤖 Bot:[/bold green]")
            console.print(Markdown(antwort))
        
        # Automatische Begrenzung für Kostenkontrolle
        if len(messages) > 25:
            messages = [messages[0]] + messages[-24:]
            
    except KeyboardInterrupt:
        console.print("\n[yellow]⚠️ Unterbrochen. Tippe /ende zum Beenden.[/yellow]")
    except Exception as e:
        console.print(f"[red]❌ Unerwarteter Fehler: {str(e)}[/red]")

Teil 4: Streaming-Antworten (Echtzeit-Ausgabe)

Für ein besseres Nutzererlebnis implementieren wir Streaming:

from openai import OpenAI
from rich.console import Console
from rich.live import Live
from rich.markdown import Markdown
from dotenv import load_dotenv
import os

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

def stream_response(messages, model="gpt-4o-mini"):
    """Generiert eine Streaming-Antwort mit Live-Update"""
    try:
        stream = client.chat.completions.create(
            model=model,
            messages=messages,
            max_tokens=1000,
            temperature=0.7,
            stream=True  # Aktiviert Streaming
        )
        
        full_response = ""
        
        with Live("", console=console, refresh_per_second=10) as live:
            for chunk in stream:
                if chunk.choices[0].delta.content:
                    part = chunk.choices[0].delta.content
                    full_response += part
                    live.update(Markdown(full_response))
        
        return full_response, None
        
    except Exception as e:
        return None, f"⚠️ Fehler: {str(e)}"

# Integration in den Haupt-Loop
# Ersetze die get_response Funktion durch stream_response

Teil 5: Chatverlauf speichern und laden

import json
from datetime import datetime

class ChatBot:
    def __init__(self):
        load_dotenv()
        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        self.messages = [
            {"role": "system", "content": "Du bist ein hilfreicher Assistent."}
        ]
        self.console = Console()
    
    def save_conversation(self, filename=None):
        """Speichert den Chatverlauf als JSON"""
        if filename is None:
            filename = f"chat_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
        
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump({
                'messages': self.messages,
                'timestamp': datetime.now().isoformat(),
                'message_count': len(self.messages)
            }, f, indent=2, ensure_ascii=False)
        
        self.console.print(f"[green]💾 Chat gespeichert als {filename}[/green]")
        return filename
    
    def load_conversation(self, filename):
        """Lädt einen gespeicherten Chatverlauf"""
        try:
            with open(filename, 'r', encoding='utf-8') as f:
                data = json.load(f)
            
            self.messages = data['messages']
            self.console.print(f"[green]📂 Chat geladen: {len(self.messages)} Nachrichten[/green]")
            return True
        except Exception as e:
            self.console.print(f"[red]❌ Fehler beim Laden: {str(e)}[/red]")
            return False
    
    def get_response(self, stream=False):
        """Holt eine Antwort von der API"""
        try:
            if stream:
                return self._stream_response()
            else:
                response = self.client.chat.completions.create(
                    model="gpt-4o-mini",
                    messages=self.messages,
                    max_tokens=1000
                )
                return response.choices[0].message.content, None
        except Exception as e:
            return None, str(e)
    
    def _stream_response(self):
        """Streaming-Antwort mit Live-Update"""
        stream = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=self.messages,
            max_tokens=1000,
            stream=True
        )
        
        full_response = ""
        with Live("", console=self.console, refresh_per_second=10) as live:
            for chunk in stream:
                if chunk.choices[0].delta.content:
                    part = chunk.choices[0].delta.content
                    full_response += part
                    live.update(Markdown(full_response))
        
        return full_response, None
    
    def trim_messages(self, max_messages=20):
        """Begrenzt die Nachrichtenanzahl für Token-Kontrolle"""
        if len(self.messages) > max_messages + 1:
            self.messages = [self.messages[0]] + self.messages[-(max_messages):]
            self.console.print("[yellow]📉 Chatverlauf gekürzt[/yellow]")

Best Practices und Sicherheit (2026 Update)

🔐 API-Key Sicherheit

💰 Kostenmanagement

class CostTracker:
    def __init__(self):
        self.token_counts = {'input': 0, 'output': 0}
        self.prices = {
            'gpt-4o-mini': {'input': 0.00015, 'output': 0.0006},
            'gpt-4o': {'input': 0.005, 'output': 0.015},
            'gpt-4-turbo': {'input': 0.01, 'output': 0.03}
        }
    
    def track_usage(self, response, model='gpt-4o-mini'):
        usage = response.usage
        self.token_counts['input'] += usage.prompt_tokens
        self.token_counts['output'] += usage.completion_tokens
    
    def estimate_cost(self, model='gpt-4o-mini'):
        input_cost = self.token_counts['input'] * self.prices[model]['input'] / 1000
        output_cost = self.token_counts['output'] * self.prices[model]['output'] / 1000
        return input_cost + output_cost
    
    def print_summary(self, model='gpt-4o-mini'):
        cost = self.estimate_cost(model)
        print(f"📊 Tokens: {self.token_counts['input']} input, {self.token_counts['output']} output")
        print(f"💰 Geschätzte Kosten: ${cost:.4f}")

⚡ Fehlerbehandlung & Retries

from tenacity import retry, stop_after_attempt, wait_exponential

class RobustChatBot(ChatBot):
    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
    def get_response_with_retry(self, stream=False):
        """API-Aufruf mit automatischem Retry bei Fehlern"""
        return self.get_response(stream)
    
    def handle_rate_limit(self):
        """Behandelt Rate-Limit-Fehler"""
        import time
        self.console.print("[yellow]⏳ Rate Limit erreicht. Warte 30 Sekunden...[/yellow]")
        time.sleep(30)

Häufige Probleme und Lösungen

Weiterführende Ressourcen

• 📚 OpenAI API Dokumentation
• 🐍 Python Best Practices
• 📊 Rate Limits und Quotas
• 💡 ChatGPT API Guide für Anfänger

Zusammenfassung

In diesem Tutorial hast du gelernt:

✅ Einen grundlegenden Chatbot mit Python zu erstellen
✅ Conversation History für kontextbewusste Gespräche
✅ Befehle und Fehlerbehandlung für robuste Anwendungen
✅ Streaming-Antworten für besseres UX
✅ Chatverlauf speichern und laden
✅ Kosten- und Sicherheitsbest Practices

Viel Erfolg beim Experimentieren mit deinem Chatbot!