Online-Bildungsinhalte automatisch generieren: Kursmaterial-Zusammenfassungen und Übungsaufgaben mit AI erstellen

Automatische Übungsaufgaben generieren

Die Erstellung von Übungsaufgaben ist eine der zeitaufwändigsten Tätigkeiten für Lehrende. Mit HolySheep AI können Sie verschiedene Aufgabentypen automatisch generieren:

• Multiple-Choice-Fragen
• Offene Fragen mit Musterantworten
• Lückentexte
• Zuordnungsaufgaben
• Fallbeispiele mit Lösungen

def generate_uebungen(kursinhalt: str, aufgabentypen: list, anzahl: int = 5) -> dict:
    """
    Generiert automatisch verschiedene Typen von Übungsaufgaben.
    
    Args:
        kursinhalt: Der zugrundeliegende Kurs-/Lektionsinhalt
        aufgabentypen: Liste wie ["mc", "offen", "luecke"]
        anzahl: Anzahl der Aufgaben pro Typ
        
    Returns:
        Dictionary mit Aufgaben nach Typ sortiert
    """
    
    aufgaben_beschreibungen = {
        "mc": "Multiple-Choice-Fragen (4 Optionen, 1 richtige Antwort)",
        "offen": "Offene Fragen mit Musterlösungen",
        "luecke": "Lückentext-Aufgaben",
        "zuordnung": "Zuordnungsaufgaben (5 Paare)",
        "fall": "Fallbeispiele mit Problembeschreibung und Lösungsweg"
    }
    
    aufgaben_liste = []
    
    for typ in aufgabentypen:
        typ_prompt = f"""
        Erstelle {anzahl} {aufgaben_beschreibungen.get(typ, typ)}-Aufgaben basierend auf:
        
        ---KURSMATERIAL---
        {kursinhalt}
        ---ENDE MATERIAL---
        
        Anforderungen:
        - Schwierigkeitsgrad: Ausgewogen (60% Grundlagen, 30% Anwendung, 10% Vertiefung)
        - Jede Aufgabe muss eindeutig lösbar sein
        - Bei MC: Eine eindeutig beste Antwort
        - Bei offenen Fragen: 3-5 Punkte-Musterlösung
        - Ausgabe als JSON-Array
        
        Format für MC:
        {{
            "frage": "Fragetext",
            "optionen": ["A", "B", "C", "D"],
            "richtige_antwort": 0,
            "erklaerung": "Warum diese Antwort"
        }}
        """
        
        result = generate_content(typ_prompt, model=MODELS["uebungen"])
        
        import json
        try:
            aufgaben = json.loads(result)
            aufgaben_liste.extend([
                {"typ": typ, "aufgabe": a} for a in aufgaben
            ])
        except json.JSONDecodeError:
            aufgaben_liste.append({"typ": typ, "rohtext": result})
    
    return {
        "gesamtzahl": len(aufgaben_liste),
        "aufgaben": aufgaben_liste,
        "modell": MODELS["uebungen"],
        "kosten_schaetzung": f"~${len(aufgaben_liste) * 0.001:.4f}"
    }


Praxis-Beispiel: Englisch-Grammatik Übungen generieren
grammatik_lektion = """
Thema: Present Perfect vs. Simple Past

Regeln Present Perfect:
- Aktionen in unbestimmter Vergangenheit mit Bezug zur Gegenwart
- Signalwörter: already, yet, just, ever, never, for, since
- Struktur: have/has + Partizip II

Regeln Simple Past:
- Aktionen zu einem bestimmten Zeitpunkt in der Vergangenheit
- Signalwörter: yesterday, last week, in 2020, ago
- Struktur: Verb + -ed (regelmäßig) oder unregelmäßige Formen
"""

uebungen = generate_uebungen(
    kursinhalt=grammatik_lektion,
    aufgabentypen=["mc", "offen"],
    anzahl=3
)

print(f"Generiert: {uebungen['gesamtzahl']} Aufgaben")
print(f"Kosten: {uebungen['kosten_schaetzung']}")

from datetime import datetime
import json

class BildungsContentPipeline:
    """Komplette Pipeline für automatische Bildungsinhalts-Erstellung"""
    
    def __init__(self, api_key: str):
        self.client = OpenAI(
            api_key=api_key,
            base_url="https://api.holysheep.ai/v1"
        )
        
    def kompletter_kurs_workflow(self, rohkurs: str, sprache: str = "de") -> dict:
        """Führt den kompletten Workflow für einen Kurs aus"""
        
        print("Schritt 1: Zusammenfassung generieren...")
        zusammenfassung = self._generiere_zusammenfassung(rohkurs, sprache)
        
        print("Schritt 2: Übungsaufgaben erstellen...")
        uebungen = self._generiere_uebungen(rohkurs)
        
        print("Schritt 3: Wissensprüfung generieren...")
        quiz = self._generiere_abschluss_quiz(rohkurs)
        
        return {
            "kurs_id": f"KURS-{datetime.now().strftime('%Y%m%d-%H%M%S')}",
            "zusammenfassung": zusammenfassung,
            "uebungen": uebungen,
            "abschluss_quiz": quiz,
            "metadaten": {
                "erstellt_am": datetime.now().isoformat(),
                "modell_used": "HolySheep AI Multi-Model Pipeline",
                "kosten_optimiert": True
            }
        }
    
    def _generiere_zusammenfassung(self, inhalt: str, sprache: str) -> dict:
        # Hier Mock-Implementation
        return {"status": "generiert", "format": "structered"}
    
    def _generiere_uebungen(self, inhalt: str) -> dict:
        return {"status": "generiert", "anzahl": 10}
    
    def _generiere_abschluss_quiz(self, inhalt: str) -> dict:
        return {"status": "generiert", "fragen": 5}


Nutzung der Pipeline
pipeline = BildungsContentPipeline(api_key="YOUR_HOLYSHEEP_API_KEY")

kurs_data = {
    "titel": "Einführung in die Datenanalyse",
    "inhalt": """
    Kapitel 1: Grundlagen der Statistik
    - Mittelwert, Median, Modalwert
    - Standardabweichung und Varianz
    - Normalverteilung und ihre Eigenschaften
    """
}

ergebnis = pipeline.kompletter_kurs_workflow(kurs_data["inhalt"])
print(f"Kurs-ID: {ergebnis['kurs_id']}")

# FALSCH - Häufiger Fehler
client = OpenAI(api_key="sk-...")  # Standard OpenAI Key

RICHTIG - HolySheep API Konfiguration
client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",  # Direkt aus Dashboard
    base_url="https://api.holysheep.ai/v1"  # WICHTIG: Richtige Base URL
)

Debugging-Tipp
try:
    models = client.models.list()
    print("API-Verbindung erfolgreich!")
except Exception as e:
    print(f"Fehler: {e}")
    # Prüfe: 1. Key korrekt? 2. Base URL korrekt? 3. Guthaben vorhanden?