Lernziele

Warum diese Vorlesung — warum jetzt?

Was ist ein Large Language Model (LLM)?

In einem Satz: ein neuronales Netz, das die nächste Worteinheit (Token) vorhersagt — gegeben den bisherigen Text.

"Hallo Welt!"
→ ["Hallo", " Welt", "!"]
→ [15043, 4435, 0]   (Zahlen)

"Paris"   → 92%
"Berlin"  →  2%
"Lyon"    →  1%
…

Transformer — die Schlüssel-Architektur

Vor 2017: RNNs/LSTMs verarbeiteten Text sequenziell — langsam, kurzer Kontext. Der Transformer („Attention is all you need", Vaswani et al. 2017) änderte alles.

Vor dem Transformer: RNNs und LSTMs

Wie hat man Text vor 2017 verarbeitet? Mit sequenziellen Netzen — und das war das Problem.

Wie wird ein LLM trainiert? — in 3 Phasen

Die KI-Landschaft 2026 — die wichtigsten Modelle

Was kann ein LLM? Was nicht?

Realistische Erwartungen — was ein LLM standalone kann, und wo es scheitert.

Zwei zentrale Entwickler-Konzepte

Halluzinationen + die Lösung: RAG

Claude Code — Terminal & VS Code

Die KI-Engine für Entwickler, die wir hier nutzen. Läuft in zwei Modi.

# Claude Code starten
$ claude

# Beispiel-Prompts:
> Erkläre mir dieses Projekt
> Finde den Bug in server.py
> Schreibe Unit-Tests für api.py

Prompt Engineering — Grundlagen

Vier Regeln, die 80% des Unterschieds zwischen brauchbaren und unbrauchbaren Antworten ausmachen.

"Mach mir eine API"

"Erstelle einen REST-Server in
Python mit Flask:
- GET /api/sensors → Liste (JSON)
- POST /api/sensors → Hinzufügen
- Verwende SQLite
- Füge Error-Handling hinzu"

Von Chat zu Agent — die Evolution

Bisher: ein Prompt → eine Antwort. Aber moderne KI-Anwendungen brauchen mehr: mehrere Schritte, externe Daten, Aktionen in der Welt.

Was ist ein KI-Agent?

Der Agentic Loop visualisiert

Wiederholt sich, bis Modell kein Tool mehr aufruft (= „Aufgabe erledigt").

Tool Use — Code-Beispiel

Wir geben Claude ein Tool zum Wetter-Abfragen — und lassen es entscheiden, wann es dieses ruft.

# 1. Tool definieren — JSON-Schema
tools = [{
    "name": "get_weather",
    "description": "Aktuelles Wetter für eine Stadt",
    "input_schema": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"]
    }
}]

# 2. Anfrage mit Tools
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "Wie ist das Wetter in Berlin?"}]
)

# 3. Claude antwortet mit tool_use Block
if response.stop_reason == "tool_use":
    tool_call = response.content[0]
    # tool_call.name = "get_weather"
    # tool_call.input = {"city": "Berlin"}
    result = get_weather(tool_call.input["city"])    # unsere Funktion

    # 4. Ergebnis zurück an Claude, fragen weiter
    final = client.messages.create(
        model="claude-opus-4-7", max_tokens=1024, tools=tools,
        messages=[
            {"role": "user", "content": "Wie ist das Wetter in Berlin?"},
            {"role": "assistant", "content": response.content},
            {"role": "user", "content": [{"type": "tool_result",
                "tool_use_id": tool_call.id, "content": result}]}
        ]
    )
    print(final.content[0].text)   # "In Berlin ist es heute 18°C…"

Multi-Agent-Systeme

Statt einem großen Agent: mehrere spezialisierte Agenten, koordiniert von einem Orchestrator.

Model Context Protocol (MCP) — das Problem

Jede Host-App (Claude Desktop, Cursor, Claude Code) braucht Zugriff auf Tools und Daten. Bisher: jede App implementiert ihre Integration selbst → Code-Duplikation, inkompatibel.

MCP-Architektur

Drei Rollen, klar getrennt.

MCP unter der Haube — JSON-RPC

MCP nutzt JSON-RPC 2.0 — ein einfaches Request/Response-Format.

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "read_file",
    "arguments": {
      "path": "/etc/hosts"
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [{
      "type": "text",
      "text": "127.0.0.1 localhost..."
    }]
  }
}

Eigener MCP-Server — in 20 Zeilen Python

Mit pip install mcp ist das offizielle SDK installiert.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("htw-tools")

@mcp.tool()
def grade_lookup(student_id: str) -> str:
    """Liefert die Note eines Studierenden anhand seiner Matrikelnummer."""
    # Hier würdest du eine DB abfragen — vereinfacht hardcoded:
    grades = {"12345": "1.7", "67890": "2.3"}
    return grades.get(student_id, "keine Note gefunden")

@mcp.tool()
def average(numbers: list[float]) -> float:
    """Berechnet den Durchschnitt einer Liste von Zahlen."""
    return sum(numbers) / len(numbers)

if __name__ == "__main__":
    mcp.run()   # startet stdio-Server

End-to-End: Claude + MCP-Server

Wir verbinden den MCP-Server von eben mit Claude Desktop / Claude Code.

{
  "mcpServers": {
    "htw-tools": {
      "command": "python",
      "args": ["/Users/htw/server.py"]
    }
  }
}

Es gibt schon viele MCP-Server

Anthropic + Community pflegen einen großen Pool — meistens reicht: installieren, konfigurieren, fertig.

Sicherheit — Wo gehen die Daten wirklich hin?

Sicherheit — Best Practices

Zusammenfassung

📚 Quellen & weiterführende Literatur

Was ihr lesen / ausprobieren solltet, wenn ihr tiefer einsteigen wollt: