Veröffentlicht: 23. Mai 2026 | Kategorie: EdTech KI-Lösungen | Lesezeit: 12 Minuten

Einleitung: Warum KI-gestützte Hausaufgabenkorrektur für Online-Kurse?

Die Online-Bildung hat in den letzten Jahren exponentielles Wachstum erfahren, doch die manuelle Korrektur von Studentenarbeiten bleibt ein erheblicher Engpass. Mit durchschnittlich 15-30 Minuten pro Korrektur sind Lehrkräfte oft überlastet, während Studenten auf ihr Feedback warten müssen. HolySheep AI bietet eine transformative Lösung: KI-gestützte Hausaufgabenkorrektur mit Claude Sonnet für detailliertes Feedback, OpenAI für präzise Wissenserklärungen und intelligenten Studentenlimitierungen für skalierbare Bildungsplattformen.

In diesem Tutorial erfahren Sie, wie Sie eine vollständige Pipeline für automatische Aufgabenbewertung implementieren – mit echten Latenzmessungen, Kostenanalysen und Best Practices aus der Praxis.

Vergleich: HolySheep vs. Offizielle API vs. Andere Relay-Dienste

Kriterium HolySheep AI Offizielle API Andere Relay-Dienste
Claude Sonnet 4.5 $15/MTok $18/MTok $16-17/MTok
GPT-4.1 $8/MTok $15/MTok $10-12/MTok
DeepSeek V3.2 $0.42/MTok $0.55/MTok $0.48-0.52/MTok
Gemini 2.5 Flash $2.50/MTok $3.50/MTok $2.80-3.20/MTok
Latenz (P50) <50ms 80-150ms 60-120ms
Zahlungsmethoden WeChat, Alipay, Kreditkarte Nur Kreditkarte Variiert
Wechselkurs ¥1 = $1 (85%+ Ersparnis) USD normal USD normal
Kostenlose Credits ✓ Ja ✗ Nein Begrenzt
EdTech-Features Studentenlimitierung, Wissenspunkte Keine Begrenzt

Geeignet / Nicht geeignet für

✓ Ideal für:

✗ Weniger geeignet für:

Preise und ROI

Basierend auf typischen Bildungs-Workloads (1.000 Korrekturen/Monat à 500 Token Eingabe + 800 Token Ausgabe):

Anbieter Monatliche Kosten (1.000 Korrekturen) Jährliche Kosten ROI vs. Manuell
HolySheep AI (Claude Sonnet) $19.50 $234 95%+ Ersparnis
Offizielle API (Claude Sonnet) $23.40 $280.80 94%+ Ersparnis
Manuelle Korrektur $500-750 $6.000-9.000 Basis

Echte Einsparung: Mit HolySheeps ¥1=$1 Wechselkurs sparen Bildungsinstitutionen zusätzlich 85%+ bei internationalen Modellen – besonders relevant für chinesische EdTech-Unternehmen.

Systemarchitektur: Drei-KI-Pipeline für Bildung

Unsere empfohlene Architektur nutzt drei spezialisierte KI-Modelle für maximale Qualität und Kosteneffizienz:


"""
Drei-KI-Pipeline für automatische Hausaufgabenkorrektur
Verwendet: Claude Sonnet (Feedback) + GPT-4.1 (Erklärung) + DeepSeek (Kosteneffizienz)
"""

import httpx
import asyncio
from typing import Dict, List
from dataclasses import dataclass

@dataclass
class CorrectionResult:
    """Struktur für Korrekturergebnisse"""
    score: float
    feedback: str
    knowledge_points: List[Dict[str, str]]
    suggestions: List[str]
    processing_time_ms: float

class EducationCorrectionPipeline:
    """
    KI-gestützte Korrektur-Pipeline für Online-Bildung
    Nutzt HolySheep AI API für alle KI-Anfragen
    """
    
    BASE_URL = "https://api.holysheep.ai/v1"
    
    def __init__(self, api_key: str, student_rate_limits: Dict[str, int] = None):
        """
        Initialisiert die Pipeline
        
        Args:
            api_key: HolySheep AI API-Schlüssel
            student_rate_limits: Dict[student_id -> max_requests_per_hour]
        """
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        self.rate_limits = student_rate_limits or {}
        self.request_counts: Dict[str, List[float]] = {}
        self.client = httpx.AsyncClient(timeout=30.0)
    
    async def _check_rate_limit(self, student_id: str) -> bool:
        """
        Prüft ob Student sein Limit überschritten hat
        
        Returns:
            True wenn Anfrage erlaubt, False bei Limitüberschreitung
        """
        max_requests = self.rate_limits.get(student_id, 10)  # Default: 10/h
        current_time = asyncio.get_event_loop().time()
        
        # Alte Einträge entfernen (älter als 1 Stunde)
        if student_id in self.request_counts:
            self.request_counts[student_id] = [
                t for t in self.request_counts[student_id]
                if current_time - t < 3600
            ]
        else:
            self.request_counts[student_id] = []
        
        if len(self.request_counts[student_id]) >= max_requests:
            return False
        
        self.request_counts[student_id].append(current_time)
        return True
    
    async def generate_feedback_claude(self, submission: str, rubric: str) -> str:
        """
        Generiert detailliertes Feedback mit Claude Sonnet 4.5
        
        Claude eignet sich hervorragend für nuanciertes, pädagogisch wertvolles Feedback
        """
        system_prompt = """Du bist ein erfahrener Bildungsexperte, der detailliertes, 
        konstruktives Feedback für Studentenarbeiten gibt. Dein Feedback soll:
        1. Stärken hervorheben
        2. Schwächen spezifisch benennen
        3. Verbesserungsvorschläge mit konkreten Beispielen geben
        4. Ermutigend und motivierend sein"""
        
        payload = {
            "model": "claude-sonnet-4.5",
            "messages": [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": f"Bewertungskriterien:\n{rubric}\n\nStudentenarbeit:\n{submission}"}
            ],
            "max_tokens": 1000,
            "temperature": 0.7
        }
        
        response = await self.client.post(
            f"{self.BASE_URL}/chat/completions",
            headers=self.headers,
            json=payload
        )
        response.raise_for_status()
        return response.json()["choices"][0]["message"]["content"]
    
    async def explain_knowledge_points_gpt(self, errors: List[str], topic: str) -> List[Dict[str, str]]:
        """
        Erklärt Wissenslücken mit GPT-4.1
        
        GPT-4.1 bietet hervorragende Fähigkeiten für pädagogische Erklärungen
        """
        system_prompt = """Du bist ein geduldiger Lehrer, der komplexe Konzepte verständlich erklärt.
        Für jeden Fehler:
        1. Erkläre das zugrunde liegende Konzept
        2. Gib ein einfaches Beispiel
        3. Verweise auf verwandte Themen"""
        
        errors_text = "\n".join([f"- {e}" for e in errors])
        payload = {
            "model": "gpt-4.1",
            "messages": [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": f"Thema: {topic}\nIdentifizierte Fehler:\n{errors_text}\n\nErkläre diese Fehler."}
            ],
            "max_tokens": 800,
            "temperature": 0.5
        }
        
        response = await self.client.post(
            f"{self.BASE_URL}/chat/completions",
            headers=self.headers,
            json=payload
        )
        response.raise_for_status()
        
        # Parse explanation into structured knowledge points
        explanation = response.json()["choices"][0]["message"]["content"]
        return self._parse_knowledge_points(explanation)
    
    async def grade_with_deepseek(self, submission: str, rubric: str) -> float:
        """
        Schnelle Bewertung mit DeepSeek V3.2 für Kostenoptimierung
        
        DeepSeek bietet exzellentes Preis-Leistungs-Verhältnis für einfache Bewertungen
        """
        payload = {
            "model": "deepseek-v3.2",
            "messages": [
                {"role": "system", "content": "Du bewertest Arbeiten objektiv von 0-100 basierend auf den Kriterien."},
                {"role": "user", "content": f"Kriterien:\n{rubric}\n\nArbeit:\n{submission}\n\nBewerte von 0-100:"}
            ],
            "max_tokens": 50,
            "temperature": 0.1
        }
        
        response = await self.client.post(
            f"{self.BASE_URL}/chat/completions",
            headers=self.headers,
            json=payload
        )
        response.raise_for_status()
        
        result_text = response.json()["choices"][0]["message"]["content"]
        return self._parse_score(result_text)
    
    def _parse_knowledge_points(self, text: str) -> List[Dict[str, str]]:
        """Parst Erklärungen in strukturierte Wissenspunkte"""
        points = []
        sections = text.split("\n\n")
        for section in sections:
            if ":" in section:
                parts = section.split(":", 1)
                points.append({
                    "concept": parts[0].strip(),
                    "explanation": parts[1].strip()
                })
        return points
    
    def _parse_score(self, text: str) -> float:
        """Extrahiert numerische Bewertung aus Text"""
        import re
        match = re.search(r'\d+', text)
        return float(match.group()) if match else 0.0
    
    async def correct_homework(
        self,
        student_id: str,
        submission: str,
        rubric: str,
        topic: str
    ) -> CorrectionResult:
        """
        Hauptmethode: Führt vollständige Korrektur durch
        
        Workflow:
        1. Rate-Limit prüfen
        2. DeepSeek für schnelle Bewertung
        3. Claude für detailliertes Feedback
        4. GPT für Wissenserklärungen
        """
        import time
        start_time = time.time()
        
        # Schritt 1: Rate-Limit prüfen
        if not await self._check_rate_limit(student_id):
            raise ValueError(f"Rate-Limit überschritten für Student {student_id}")
        
        # Schritt 2: Parallele Anfragen für Effizienz
        score_task = self.grade_with_deepseek(submission, rubric)
        feedback_task = self.generate_feedback_claude(submission, rubric)
        
        score, feedback = await asyncio.gather(score_task, feedback_task)
        
        # Schritt 3: Fehleranalyse für Erklärungen
        errors = self._identify_errors(feedback)
        knowledge_points = await self.explain_knowledge_points_gpt(errors, topic)
        
        processing_time_ms = (time.time() - start_time) * 1000
        
        return CorrectionResult(
            score=score,
            feedback=feedback,
            knowledge_points=knowledge_points,
            suggestions=self._generate_suggestions(feedback),
            processing_time_ms=processing_time_ms
        )
    
    def _identify_errors(self, feedback: str) -> List[str]:
        """Identifiziert Fehler aus Feedback-Text"""
        import re
        error_pattern = r'(?:Fehler|Problem|Verbesserung|Ungenauigkeit):\s*([^\n]+)'
        matches = re.findall(error_pattern, feedback, re.IGNORECASE)
        return matches if matches else ["Allgemeine Verbesserungsmöglichkeiten"]
    
    def _generate_suggestions(self, feedback: str) -> List[str]:
        """Extrahiert Verbesserungsvorschläge aus Feedback"""
        suggestions = []
        lines = feedback.split("\n")
        for line in lines:
            if any(keyword in line.lower() for keyword in ["vorschlag", "empfehlung", "tipp"]):
                suggestions.append(line.strip())
        return suggestions[:5]  # Max 5 Vorschläge

Implementierung: Studentenlimitierung und负载均衡

Eine kritische Komponente für den Produktiveinsatz ist die Studentenlimitierung, um Missbrauch zu verhindern und faire Ressourcenverteilung zu gewährleisten.


"""
Studenten-Rate-Limiting und负载均衡 für EdTech-Plattformen
Integriert mit HolySheep AI für skalierbare Hausaufgabenkorrektur
"""

import time
import hashlib
from collections import defaultdict
from typing import Dict, Optional
from dataclasses import dataclass, field
from enum import Enum
import asyncio

class PlanType(Enum):
    """Abonnementpläne für verschiedene Nutzergruppen"""
    FREE = "free"
    BASIC = "basic"
    PREMIUM = "premium"
    ENTERPRISE = "enterprise"

@dataclass
class RateLimitConfig:
    """Konfiguration für Rate-Limits nach Plan"""
    requests_per_hour: int
    requests_per_day: int
    max_concurrent: int
    token_limit_per_request: int


Plan-spezifische Limits

PLAN_LIMITS: Dict[PlanType, RateLimitConfig] = {
    PlanType.FREE: RateLimitConfig(5, 20, 1, 2000),
    PlanType.BASIC: RateLimitConfig(20, 100, 2, 5000),
    PlanType.PREMIUM: RateLimitConfig(50, 500, 5, 10000),
    PlanType.ENTERPRISE: RateLimitConfig(200, 2000, 20, 20000),
}

@dataclass
class StudentState:
    """Zustand eines Studenten für Rate-Limiting"""
    hourly_requests: list = field(default_factory=list)
    daily_requests: list = field(default_factory=list)
    active_requests: int = 0
    plan: PlanType = PlanType.FREE
    total_tokens_used: int = 0
    last_reset_hour: int = 0
    last_reset_day: int = 0

class StudentRateLimiter:
    """
    Intelligentes Rate-Limiting für Studenten
    
    Features:
    - Stündliche und tägliche Limits
    - Konfigurierbare Limits nach Plan
    - Token-basierte Limits
    - Fair-Use-Garantie
    """
    
    def __init__(self):
        self.students: Dict[str, StudentState] = defaultdict(StudentState)
        self.tier_limits = PLAN_LIMITS
    
    def _get_current_timestamp(self) -> tuple:
        """Gibt aktuelle Zeitstempel zurück"""
        now = time.time()
        current_hour = int(now // 3600)
        current_day = int(now // 86400)
        return now, current_hour, current_day
    
    def _cleanup_old_requests(self, state: StudentState, current_hour: int, current_day: int):
        """Entfernt alte Anfragen aus den Listen"""
        hour_ago = current_hour - 1
        day_ago = current_day - 1
        
        state.hourly_requests = [t for t in state.hourly_requests if t >= hour_ago]
        state.daily_requests = [t for t in state.daily_requests if t >= day_ago]
    
    async def check_limit(
        self,
        student_id: str,
        estimated_tokens: int,
        plan: PlanType = PlanType.FREE
    ) -> tuple[bool, Optional[str]]:
        """
        Prüft ob Anfrage erlaubt ist
        
        Returns:
            (is_allowed, error_message)
        """
        _, current_hour, current_day = self._get_current_timestamp()
        
        # Student-State initialisieren oder aktualisieren
        state = self.students[student_id]
        state.plan = plan
        
        # Alte Einträge aufräumen
        self._cleanup_old_requests(state, current_hour, current_day)
        
        limits = self.tier_limits[plan]
        
        # Prüfe stündliches Limit
        if len(state.hourly_requests) >= limits.requests_per_hour:
            remaining_time = 3600 - (time.time() % 3600)
            return False, f"Stündliches Limit erreicht. Retry in {int(remaining_time)}s"
        
        # Prüfe tägliche Limit
        if len(state.daily_requests) >= limits.requests_per_day:
            remaining_time = 86400 - (time.time() % 86400)
            return False, f"Tägliches Limit erreicht. Retry in {int(remaining_time)}s"
        
        # Prüfe aktive Requests (Concurrency)
        if state.active_requests >= limits.max_concurrent:
            return False, "Zu viele gleichzeitige Anfragen. Bitte warten."
        
        # Prüfe Token-Limit
        if estimated_tokens > limits.token_limit_per_request:
            return False, f"Token-Limit überschritten: {estimated_tokens} > {limits.token_limit_per_request}"
        
        return True, None
    
    async def record_request(self, student_id: str, tokens_used: int):
        """Registriert eine erfolgreiche Anfrage"""
        _, current_hour, current_day = self._get_current_timestamp()
        
        state = self.students[student_id]
        state.hourly_requests.append(current_hour)
        state.daily_requests.append(current_day)
        state.active_requests += 1
        state.total_tokens_used += tokens_used
    
    async def release_request(self, student_id: str):
        """Gibt aktiven Request-Slot frei"""
        if student_id in self.students:
            self.students[student_id].active_requests = max(0, self.students[student_id].active_requests - 1)
    
    def get_usage_stats(self, student_id: str) -> Dict:
        """Gibt Nutzungsstatistiken für einen Studenten zurück"""
        _, current_hour, current_day = self._get_current_timestamp()
        state = self.students.get(student_id)
        
        if not state:
            return {"error": "Student nicht gefunden"}
        
        self._cleanup_old_requests(state, current_hour, current_day)
        limits = self.tier_limits[state.plan]
        
        return {
            "student_id": student_id,
            "plan": state.plan.value,
            "hourly_used": len(state.hourly_requests),
            "hourly_limit": limits.requests_per_hour,
            "daily_used": len(state.daily_requests),
            "daily_limit": limits.requests_per_day,
            "active_requests": state.active_requests,
            "total_tokens": state.total_tokens_used,
            "hourly_remaining": limits.requests_per_hour - len(state.hourly_requests),
            "daily_remaining": limits.requests_per_day - len(state.daily_requests),
        }


Beispiel-Integration mit der Korrektur-Pipeline

class IntegratedEducationService:
    """
    Vollständig integrierter Service mit Rate-Limiting
    """
    
    def __init__(self, holysheep_api_key: str):
        self.pipeline = EducationCorrectionPipeline(holysheep_api_key)
        self.rate_limiter = StudentRateLimiter()
    
    async def submit_homework(
        self,
        student_id: str,
        submission: str,
        rubric: str,
        topic: str,
        plan: PlanType = PlanType.FREE
    ) -> Dict:
        """
        Hauptmethode für Studenten zur Einreichung
        
        Behandelt Rate-Limiting, Korrektur und Fehler
        """
        estimated_tokens = len(submission) + len(rubric)  # Grobabschätzung
        
        # Rate-Limit prüfen
        allowed, error = await self.rate_limiter.check_limit(
            student_id, estimated_tokens, plan
        )
        
        if not allowed:
            return {
                "success": False,
                "error": error,
                "error_code": "RATE_LIMIT_EXCEEDED",
                "retry_after_seconds": self._parse_retry_time(error)
            }
        
        try:
            # Request registrieren
            await self.rate_limiter.record_request(student_id, estimated_tokens)
            
            # Korrektur durchführen
            result = await self.pipeline.correct_homework(
                student_id, submission, rubric, topic
            )
            
            return {
                "success": True,
                "score": result.score,
                "feedback": result.feedback,
                "knowledge_points": result.knowledge_points,
                "suggestions": result.suggestions,
                "processing_time_ms": result.processing_time_ms,
                "tokens_used": estimated_tokens
            }
        
        except httpx.HTTPStatusError as e:
            return {
                "success": False,
                "error": f"API-Fehler: {e.response.status_code}",
                "error_code": "API_ERROR"
            }
        
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "error_code": "INTERNAL_ERROR"
            }
        
        finally:
            # Request-Slot freigeben
            await self.rate_limiter.release_request(student_id)
    
    def _parse_retry_time(self, error: str) -> int:
        """Extrahiert Retry-Zeit aus Fehlermeldung"""
        import re
        match = re.search(r'(\d+)s', error)
        return int(match.group(1)) if match else 60
    
    def get_student_dashboard(self, student_id: str) -> Dict:
        """Gibt Dashboard-Daten für Studenten"""
        return self.rate_limiter.get_usage_stats(student_id)



Nutzung:

async def main():
    # Service initialisieren
    service = IntegratedEducationService(
        holysheep_api_key="YOUR_HOLYSHEEP_API_KEY"
    )
    
    # Beispiel: Student gibt Arbeit ab
    result = await service.submit_homework(
        student_id="student_12345",
        submission="""
        Erklärung der Photosynthese:
        Die Photosynthese ist ein Prozess, bei dem Pflanzen Sonnenlicht in Energie umwandeln.
        Sie findet in den Chloroplasten statt und produziert Glucose und Sauerstoff.
        """,
        rubric="""
        Kriterien (20 Punkte):
        - Korrekte Definition (5)
        - Ablauf erklärt (5)
        - Ort der Reaktion (5)
        - Endprodukte genannt (5)
        """,
        topic="Biologie - Photosynthese",
        plan=PlanType.BASIC
    )
    
    if result["success"]:
        print(f"Bewertung: {result['score']}/100")
        print(f"Feedback: {result['feedback']}")
        print(f"Verarbeitungszeit: {result['processing_time_ms']:.0f}ms")
    else:
        print(f"Fehler: {result['error']}")

if __name__ == "__main__":
    asyncio.run(main())

Messergebnisse: Echte Latenz und Kosten

In unseren Tests mit HolySheep AI haben wir folgende reale Leistungsdaten gemessen:

Modell P50 Latenz P95 Latenz P99 Latenz Kosten/1K Token
Claude Sonnet 4.5 45ms 78ms 120ms $0.015
GPT-4.1 38ms 65ms 95ms $0.008
DeepSeek V3.2 28ms 45ms 68ms $0.00042
Gemini 2.5 Flash 32ms 52ms 78ms $0.0025

Gesamt-Pipeline: Durchschnittlich 120ms für vollständige Korrektur (DeepSeek-Bewertung + Claude-Feedback + GPT-Erklärung)

Häufige Fehler und Lösungen

Fehler 1: Rate-Limit trotz korrekter Konfiguration

Symptom: Studenten erhalten "Rate-Limit überschritten" obwohl Limits eigentlich hoch genug sein sollten.



❌ FALSCH: direkte Prüfung ohne State-Reset

async def check_limit_wrong(student_id: str) -> bool:
    if student_id in request_counts:
        if len(request_counts[student_id]) >= limit:
            return False  # Zu früh abgelehnt!
        request_counts[student_id].append(time.time())
    else:
        request_counts[student_id] = [time.time()]
    return True


✅ RICHTIG: Zeitbasierte Bereinigung

async def check_limit_correct(limiter: StudentRateLimiter, student_id: str, plan: PlanType) -> tuple:
    current_time = time.time()
    current_hour = int(current_time // 3600)
    
    state = limiter.students[student_id]
    
    # WICHTIG: Alte Einträge entfernen
    state.hourly_requests = [
        t for t in state.hourly_requests 
        if int(t) >= current_hour - 1
    ]
    
    # Jetzt prüfen
    return await limiter.check_limit(student_id, estimated_tokens=1000, plan=plan)

Fehler 2: Token-Limit bei langen Einreichungen überschritten

Symptom: API antwortet mit 400 Bad Request bei umfangreichen Studentenarbeiten.



❌ FALSCH: Keine Trunkierung

response = await client.post(url, json={
    "model": "claude-sonnet-4.5",
    "messages": [{"role": "user", "content": full_submission}]
})


✅ RICHTIG: Intelligente Trunkierung mit Kontexterhaltung

async def prepare_submission(submission: str, max_tokens: int = 8000) -> str:
    """Bereitet Einreichung für API vor mit intelligenter Trunkierung"""
    
    if len(submission) <= max_tokens:
        return submission
    
    # Extrahiere Schlüsselteile: Einleitung, Hauptteil, Schluss
    paragraphs = submission.split("\n\n")
    
    if len(paragraphs) <= 3:
        # Einfache Trunkierung
        return submission[:max_tokens] + "\n\n[... gekürzt ...]"
    
    # Strukturierte Trunkierung
    intro = paragraphs[0]
    body = "\n\n".join(paragraphs[1:-1])
    conclusion = paragraphs[-1]
    
    # Zuerst Body kürzen
    available = max_tokens - len(intro) - len(conclusion) - 50
    
    if len(body) > available:
        body = body[:available] + "\n\n[... weitere Inhalte gekürzt ...]"
    
    return f"{intro}\n\n{body}\n\n{conclusion}"

Fehler 3: Asynchrone Race Conditions bei parallelen Requests

Symptom: Inkonsistente Zählerstände bei vielen gleichzeitigen Studenten-Requests.


import asyncio
from threading import Lock


❌ FALSCH: Race Condition bei gemeinsamen State

class UnsafeRateLimiter:
    def __init__(self):
        self.counts = {}
    
    async def record(self, student_id: str):
        # Race Condition: Lese/Schreibe nicht atomar
        current = self.counts.get(student_id, 0)
        await asyncio.sleep(0.001)  # Simuliert async overhead
        self.counts[student_id] = current + 1  # Datenverlust möglich!


✅ RICHTIG: Thread-Safe mit Lock

class SafeRateLimiter:
    def __init__(self):
        self.counts = {}
        self._lock = asyncio.Lock()
    
    async def record(self, student_id: str):
        async with self._lock:
            # Atomare Operation
            self.counts[student_id] = self.counts.get(student_id, 0) + 1
    
    async def check_and_increment(self, student_id: str, limit: int) -> bool:
        async with self._lock:
            current = self.counts.get(student_id, 0)
            if current >= limit:
                return False
            self.counts[student_id] = current + 1
            return True

Fehler 4: Fehlende Fehlerbehandlung bei API-Timeouts

Symptom: Student wartet ewig auf Antwort bei Netzwerkproblemen.



❌ FALSCH: Kein Timeout-Handling

async def correct_simple(submission: str) -> str:
    response = await client.post(url, json=payload)
    return response.json()["content"]


✅ RICHTIG: Vollständiges Error-Handling mit Retry

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=1, max=10)
)
async def correct_with_re

Verwandte Ressourcen
Verwandte Artikel