ChatGPT API in Django Integrieren: Praktischer Leitfaden

Warum ChatGPT Integrieren

Die OpenAI APIs ermöglichen es, künstliche Intelligenz zu Ihren Anwendungen hinzuzufügen: Chatbots, Content-Generierung, Textanalyse und vieles mehr.

1. Erste Einrichtung

pip install openai python-dotenv

Konfiguration settings.py

import os
from dotenv import load_dotenv

load_dotenv()

OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
OPENAI_MODEL = 'gpt-4-turbo-preview'  # oder gpt-3.5-turbo für geringere Kosten

2. OpenAI Service

# services/openai_service.py
from openai import OpenAI
from django.conf import settings

class OpenAIService:
    def __init__(self):
        self.client = OpenAI(api_key=settings.OPENAI_API_KEY)
        self.model = settings.OPENAI_MODEL

    def chat(self, messages, temperature=0.7, max_tokens=1000):
        """Basis-API-Aufruf"""
        response = self.client.chat.completions.create(
            model=self.model,
            messages=messages,
            temperature=temperature,
            max_tokens=max_tokens
        )
        return response.choices[0].message.content

    def chat_stream(self, messages, temperature=0.7):
        """Streaming-Antwort"""
        stream = self.client.chat.completions.create(
            model=self.model,
            messages=messages,
            temperature=temperature,
            stream=True
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield chunk.choices[0].delta.content

    def generate_with_system_prompt(self, system_prompt, user_message):
        """Chat mit System-Prompt"""
        messages = [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_message}
        ]
        return self.chat(messages)

openai_service = OpenAIService()

3. View für Chat-API

# views.py
from django.http import StreamingHttpResponse, JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
import json
from .services.openai_service import openai_service

@csrf_exempt
@require_POST
def chat_api(request):
    """API-Endpunkt für Chat"""
    data = json.loads(request.body)
    messages = data.get('messages', [])

    try:
        response = openai_service.chat(messages)
        return JsonResponse({'response': response})
    except Exception as e:
        return JsonResponse({'error': str(e)}, status=500)

@csrf_exempt
@require_POST
def chat_stream_api(request):
    """Streaming-API-Endpunkt"""
    data = json.loads(request.body)
    messages = data.get('messages', [])

    def generate():
        try:
            for chunk in openai_service.chat_stream(messages):
                yield f"data: {json.dumps({'content': chunk})}\n\n"
            yield "data: [DONE]\n\n"
        except Exception as e:
            yield f"data: {json.dumps({'error': str(e)})}\n\n"

    return StreamingHttpResponse(
        generate(),
        content_type='text/event-stream'
    )

4. Konversationsverwaltung mit Kontext

# models.py
from django.db import models

class Conversation(models.Model):
    user = models.ForeignKey('auth.User', on_delete=models.CASCADE)
    created_at = models.DateTimeField(auto_now_add=True)
    system_prompt = models.TextField(default="Du bist ein hilfreicher Assistent.")

class Message(models.Model):
    conversation = models.ForeignKey(Conversation, on_delete=models.CASCADE)
    role = models.CharField(max_length=20)  # user, assistant, system
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    tokens_used = models.IntegerField(default=0)

    class Meta:
        ordering = ['created_at']

# services/conversation_service.py
class ConversationService:
    def __init__(self, conversation):
        self.conversation = conversation
        self.openai = openai_service

    def get_messages_for_api(self, limit=20):
        """Bereitet Nachrichten für API mit Kontext vor"""
        messages = [
            {"role": "system", "content": self.conversation.system_prompt}
        ]

        # Letzte N Nachrichten für Kontext
        recent = self.conversation.message_set.all()[:limit]
        for msg in recent:
            messages.append({
                "role": msg.role,
                "content": msg.content
            })

        return messages

    def send_message(self, user_message):
        """Sendet Nachricht und erhält Antwort"""
        # Benutzernachricht speichern
        Message.objects.create(
            conversation=self.conversation,
            role='user',
            content=user_message
        )

        # Kontext vorbereiten und API aufrufen
        messages = self.get_messages_for_api()
        response = self.openai.chat(messages)

        # Antwort speichern
        Message.objects.create(
            conversation=self.conversation,
            role='assistant',
            content=response
        )

        return response

5. Prompt Engineering

# prompts.py

BLOG_WRITER_PROMPT = """
Du bist ein erfahrener Copywriter und Blogger.
Schreibe SEO-freundliche, ansprechende und gut strukturierte Inhalte.
Verwende Zwischenüberschriften, Aufzählungen und kurze Absätze.
Füge praktische Beispiele ein, wenn möglich.
"""

CODE_REVIEWER_PROMPT = """
Du bist ein erfahrener Senior-Entwickler für Code-Reviews.
Analysiere den bereitgestellten Code und:
1. Identifiziere potenzielle Bugs
2. Schlage Performance-Verbesserungen vor
3. Überprüfe Best Practices
4. Kontrolliere die Sicherheit
Gib konstruktives und spezifisches Feedback.
"""

TRANSLATOR_PROMPT = """
Du bist ein professioneller Übersetzer.
Übersetze den Text unter Beibehaltung von:
- Originalem Ton und Stil
- Formatierung (HTML, Markdown)
- Angemessener technischer Terminologie
Übersetze keinen Code oder Eigennamen.
"""

def get_content_generator_prompt(topic, keywords):
    return f"""
Schreibe einen vollständigen Blog-Artikel über: {topic}

Einzuschließende Keywords: {', '.join(keywords)}

Erforderliche Struktur:
- Ansprechende Einleitung
- 3-5 Hauptabschnitte mit H2
- Praktische Beispiele mit Code wenn relevant
- Fazit mit Call-to-Action

Länge: 1500-2000 Wörter
Ton: professionell aber zugänglich
"""

6. Rate Limiting und Caching

from django.core.cache import cache
from functools import wraps
import hashlib
import time

def rate_limit(max_calls, period):
    """Decorator für Rate-Limiting"""
    def decorator(func):
        @wraps(func)
        def wrapper(request, *args, **kwargs):
            user_id = request.user.id if request.user.is_authenticated else 'anon'
            key = f"ratelimit:{func.__name__}:{user_id}"

            calls = cache.get(key, 0)
            if calls >= max_calls:
                return JsonResponse(
                    {'error': 'Rate-Limit überschritten'},
                    status=429
                )

            cache.set(key, calls + 1, period)
            return func(request, *args, **kwargs)
        return wrapper
    return decorator

def cache_ai_response(timeout=3600):
    """Cache Antworten basierend auf Eingabe"""
    def decorator(func):
        @wraps(func)
        def wrapper(messages, *args, **kwargs):
            # Hash des Inhalts erstellen
            content_hash = hashlib.md5(
                str(messages).encode()
            ).hexdigest()
            cache_key = f"ai_response:{content_hash}"

            # Im Cache suchen
            cached = cache.get(cache_key)
            if cached:
                return cached

            # Generieren und speichern
            response = func(messages, *args, **kwargs)
            cache.set(cache_key, response, timeout)
            return response
        return wrapper
    return decorator

Best Practices

• Verwenden Sie immer Umgebungsvariablen für API-Schlüssel
• Implementieren Sie Rate-Limiting pro Benutzer
• Cachen Sie Antworten für identische Prompts
• Überwachen Sie Kosten durch Token-Logging
• Behandeln Sie API-Fehler mit Retry und Fallback

Fazit

Die Integration von ChatGPT in Django eröffnet unendliche Möglichkeiten. Mit den richtigen Sicherheits- und Optimierungspraktiken können Sie leistungsstarke und zuverlässige KI-Anwendungen erstellen.