Rückblick VL 2 — KI-Grundlagen

Von Chat zu Agent — Die Evolution

Was sind KI-Agenten?

# Start: User-Frage als erste Aktion
action = user_prompt

while not done:
    # 🛠️ Tool führt Aktion aus
    observation = tool.execute(action)

    # 🧠 LLM schaut Ergebnis an,
    #    entscheidet nächste Aktion
    action = llm.decide(observation)

Moment — du nutzt schon einen Agenten

In genau diesem Moment, während ihr zuhört, läuft auf euren Rechnern ein KI-Agent — und ihr merkt es nicht mal.
Sein Name: Claude Code.

➡️ Schauen wir uns die Schleife jetzt im Detail an — auf Code-Ebene.

Agentic Loop im Detail

Wir haben die Schleife jetzt zweimal gesehen — abstrakt (Slide 4) und live in Claude Code (Slide 5).
Jetzt zoomen wir rein — was passiert in jeder einzelnen Iteration auf Code-Ebene?

# Agentic Loop
def agent_loop(user_prompt):
    context = user_prompt

    while True:
        # 🧠 Think
        plan = llm.think(context)

        if plan.is_done:
            return plan.answer

        # 🛠️ Act
        result = execute_tool(
            plan.tool, plan.args)

        # 👀 Observe
        context += result

➡️ Damit dieser Loop überhaupt funktioniert, braucht ein Agent eine bestimmte Architektur. Die schauen wir uns als Nächstes an.

Agenten-Architektur

Tool Use: Wie Agenten Werkzeuge nutzen

{
  "tool": "read_file",
  "args": {
    "path": "server.py"
  }
}

# Host liest die Datei
content = read_file(
  "server.py"
)
# Ergebnis → zurück an LLM

# LLM sieht den Inhalt
# und entscheidet:
# → Bug auf Zeile 42
# → nächster Schritt:
#   write_file(...)

Multi-Agent Systeme

Model Context Protocol (MCP)

MCP — Architektur

MCP im Detail: Request/Response

// Client → Server
{
  "method": "tools/list"
}
// Server → Client
{
  "tools": [
    {"name": "get_weather",
     "description": "...",
     "inputSchema": {...}}
  ]
}

// Client → Server
{
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "city": "Berlin"
    }
  }
}

// Server → Client
{
  "content": [{
    "type": "text",
    "text": "Wetter in
    Berlin: 18°C,
    bewölkt"
  }]
}

MCP-Session — Lebenszyklus

Wie ein Telefongespräch: erst „Hallo!", dann reden, dann auflegen. Eine MCP-Session läuft immer in dieser Reihenfolge ab.

Wie kommen die Nachrichten an?

MCP sagt nur, was in den Nachrichten steht (das Format).
Wie die Bytes von A nach B kommen, ist eine eigene Frage.

MCP im großen Bild — wo passt es hin?

Programme reden auf vier verschiedene Arten miteinander. MCP ist eine davon — speziell für AI:

Verfügbare MCP-Server

MCP-Server selbst bauen — die Bauteile

Jeder MCP-Server hat dieselben vier Bauteile. Schauen wir uns einen Wetter-Server an:

# ① Server-Objekt
from mcp.server import Server
server = Server("wetter")

# ② Tool-Decorator
@server.tool()
async def get_weather(city: str) -> str:
    """Aktuelles Wetter abrufen."""
    # ③ Tool-Logik
    return f"In {city}: 18°C"

# ④ Server starten
server.run()

anthropic SDK — Tool-Use ohne MCP

So gibt man Claude Tools — direkt im Python-Code, ohne MCP:

import anthropic

client = anthropic.Anthropic()

# 1. Wir definieren das Tool selbst (Schema von Hand)
tools = [{
    "name": "get_weather",
    "description": "Aktuelles Wetter abrufen",
    "input_schema": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"]
    }
}]

# 2. Tools mit der Anfrage an Claude schicken
response = client.messages.create(
    model="claude-sonnet-4-6",
    tools=tools,
    messages=[{"role": "user",
               "content": "Wie ist das Wetter in Berlin?"}]
)
# Claude antwortet: „Ich brauche get_weather(city='Berlin')"
# → wir müssen die Funktion JETZT selbst aufrufen + Antwort zurückschicken

End-to-End: Claude + MCP-Server zusammen

Mit MCP: Server einmal schreiben — alle Clients (Claude Code, Claude Desktop, dein Python-Programm) nutzen ihn.

from mcp.server import Server

server = Server("wetter")

@server.tool()
async def get_weather(city: str) -> str:
    """Wetter für eine Stadt."""
    return f"In {city}: 18°C"

server.run()  # läuft auf Port 8000

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    mcp_servers=[{
        "name": "wetter",
        "url": "http://localhost:8000"
    }],
    messages=[{"role": "user",
               "content": "Wetter Berlin?"}]
)

Warum muss man Claude Code etwas sagen?

Datei: ~/.claude/settings.json

{
  "mcpServers": {
    "filesystem": {                      // Name den DU vergibst
      "command": "npx",                  // welches Programm starten
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/pfad"]
    },                                  // ↑ Argumente fürs Programm
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_xxx" }    // geheime Daten
    }
  }
}

Lokale vs. Cloud KI

➡️ Wenn wir uns für Cloud entscheiden — wohin genau gehen unsere Daten dann? Schauen wir es uns an.

Sicherheit — Wo gehen die Daten wirklich hin?

Sicherheit — Best Practices

Zero-Trust für KI

Offene Forschungsfragen

Sichere KI-Infrastruktur — Bedrohung & Lösung

Sobald MCP über Netzwerk läuft (egal ob Café-WiFi oder Firmen-LAN), gelten klassische Angriffe.
„Intern" ist nicht automatisch sicher.

Praxis-Tools: Tailscale · WireGuard · mTLS-only HTTPS · Cloudflare Tunnel · Zero-Trust-Mesh-Networks

Agenten + Verteilte Systeme

Zusammenfassung — VL 3

Links & Ressourcen