Meisterung von KI-Agenten & lokaler LLM-Infrastruktur: Streaming, Sandboxing und Prompt-Firewalls

Lokale LLM-Server und Agent-Frameworks sind heute in produktionsnahen Workflows üblich. Entwickler betreiben Ollama, llama.cpp oder vLLM auf eigener Hardware und stellen sie über einen Reverse-Tunnel bereit. Sie verbinden Agenten mit Tools über das Model Context Protocol (MCP), und sie delegieren Teilaufgaben an gehostete Modelle. Jede dieser Entscheidungen bringt eigene Infrastrukturprobleme mit sich. Lange Generierungen werden durch Proxy-Timeouts abgebrochen. Buffering unterbricht token-by-token Streaming. Drittanbieter-Toolserver erweitern die Angriffsfläche. Sensible Daten können innerhalb eines Prompts das System verlassen.

Dieser Artikel behandelt drei Muster für diese Probleme:

1. Lange laufende, gestreamte Generierungen durch Tunnel und Proxys am Leben erhalten.
2. Begrenzung der Möglichkeiten untrusted MCP-Toolcodes mit WebAssembly (Wasm).
3. Geheimnisse und PII am Rand redigieren, bevor ein Prompt eine Cloud-Modell erreicht.

Für jedes Muster wird erklärt, was die Technik bewirkt und was nicht.

---

1. Lange Generierungen: Streams durch Tunnel und Proxys am Leben halten

Das Overflow-Problem des Kontextfensters ist ein separates Thema. Es tritt auf, wenn der Input die konfigurierte Kontextlänge des Modells überschreitet, und die Lösung liegt auf dem Modellserver (bei Ollama z.B. im num_ctx-Parameter), nicht im Netzwerk. Das hier adressierte Problem ist, dass eine lange oder langsame Antwort zwischen lokalem Modell und Client abgebrochen oder verzögert wird.

[Lokaler LLM-Server]
      │  (localhost HTTP)
      ▼
[Edge-Proxy / Tunnel-Daemon] ──(chunked HTTP / SSE)──► [Remote-Client oder Gateway]
      ▲
 (Buffering aus, Heartbeats, angepasste Timeouts)

Ollama hört standardmäßig auf Port 11434. Es bietet einen OpenAI-kompatiblen /v1/chat/completions-Endpunkt, und stream: true liefert Server-Sent Events (SSE). Generierungen im Stil von Reasoning können Minuten dauern, und der Weg zwischen Modell und Client hat mehrere Stellen, an denen sie scheitern können.

Wo Streams brechen

1. Idle- und Response-Timeouts. Nginx’s proxy_read_timeout ist standardmäßig auf 60 Sekunden gesetzt. Es misst die Lücke zwischen zwei aufeinanderfolgenden Lesevorgängen vom Upstream, nicht die gesamte Request-Zeit. Wenn ein Modell länger braucht, um auf ein großes Prompt zu reagieren, schließt Nginx die Verbindung. Cloudflare’s Proxy gibt bei Nicht-Antwort innerhalb von ca. 100 Sekunden einen 524-Fehler aus. Dieser Wert kann nur bei Enterprise-Plänen geändert werden und betrifft die Wartezeit auf die Antwort, also ist eine lange, stille „Denken“-Phase gefährlich.
2. Response-Buffering. Nginx puffert Upstream-Antworten standardmäßig (proxy_buffering on). Clients erhalten Events dann in Chargen statt tokenweise. Einige CDNs und Gateways verhalten sich ähnlich.
3. Kompression und Middleware-Buffering. Eine Kompressionsschicht, die auf einen vollen Puffer wartet, verzögert SSE-Events stark. text/event-stream sollte von Kompression und Buffering ausgeschlossen werden.

Ein abgestimmter Nginx-Location-Block

Wenn Sie Ihren eigenen Nginx vor einem lokalen Modell betreiben, deckt diese Konfiguration die oben genannten Punkte:

location /v1/chat/completions {
    # Ollama hat keine integrierte Authentifizierung: hier durchsetzen (API-Key, mTLS, oder Auth-Subrequest)
    proxy_pass http://127.0.0.1:11434;

    # HTTP/1.1 Upstream mit Keep-Alive (Nginx streamt chunked responses standardmäßig)
    proxy_http_version 1.1;
    proxy_set_header Connection "";

    # Bytes sofort weiterleiten
    proxy_buffering off;
    proxy_cache off;
    gzip off;

    # Lange stille Pausen zwischen Upstream-Reads erlauben
    proxy_read_timeout 600s;
    proxy_send_timeout 600s;
}

Zwei Korrekturen bei häufig kopierten Snippets:

• X-Accel-Buffering: no ist ein Response-Header, den die Upstream-Anwendung sendet, um Nginx anzuweisen, nicht zu puffern. Das Setzen mit add_header in derselben Nginx-Location bewirkt nichts. Wenn Sie das Backend oder einen Wrapper kontrollieren, senden Sie es dort. Ansonsten reicht proxy_buffering off.
• Das Erhöhen der Nginx-Timeouts ändert keine Limits, die bei einem anderen Hop liegen. Ein proxy_read_timeout von einer Stunde bleibt bei Cloudflare’s ca. 100 Sekunden Limit.

Heartbeats senden

Der zuverlässigste Schutz gegen Idle-Timeouts ist, den Stream niemals still werden zu lassen. Senden Sie die Response-Header sofort, dann alle 20–30 Sekunden eine SSE-Kommentarlinie wie : ping, solange das Modell arbeitet. Kommentarzeilen werden von SSE-Parsern ignoriert und kosten wenige Bytes. Keepalives vom Client helfen bei SSE-Streams nicht, weil die Stille, die den Timeout auslöst, vom Server kommt.

Tunnel-spezifische Hinweise

Das Verhalten variiert je nach Tunnel-Produkt und ändert sich mit der Zeit. Manche Projekte dokumentieren, dass SSE durch Cloudflare Tunnel ohne Probleme läuft. Andere berichten von Buffering bei cloudflared. Testen Sie End-to-End mit einer langsamen, langen Generierung, bevor Sie sich auf einen Tunnel verlassen. Wenn ein Tunnel bufferiert und Sie es nicht ändern können, ist ein SSH-Reverse-Tunnel zu einer VM mit eigenem Nginx eine bewährte Lösung.

Auf Client-Seite lesen Sie die Antwort inkrementell mit einem Streaming-Parser. Warten Sie nicht auf den vollständigen Body.

---

2. Agenten-Sandboxing: Begrenzung untrusted MCP-Toolcodes mit WebAssembly

Das Model Context Protocol, entwickelt von Anthropic, ist heute der am weitesten verbreitete Standard, um KI-Anwendungen mit Tools und Daten zu verbinden. Im Dezember 2025 spendete Anthropic es an die Linux Foundation’s Agentic AI Foundation, zusammen mit Block’s goose und OpenAI’s AGENTS.md. Clients wie Claude, ChatGPT, Gemini, VS Code und Cursor unterstützen es.

MCP-Nachrichten verwenden JSON-RPC. Die Spezifikation definiert derzeit zwei Transporte, stdio und Streamable HTTP. Streamable HTTP hat den älteren HTTP+SSE-Transport abgelöst.

Die Bedrohung

Die Akzeptanz hat die Absicherung überholt. Forscher dokumentierten mehrere Angriffsarten gegen MCP-Deployments:

• Tool-Poisoning: bösartige Anweisungen in Tool-Beschreibungen oder Schema-Feldern, für Nutzer unsichtbar, vom Modell gelesen. Invariant Labs veröffentlichte die ursprüngliche Warnung im April 2025.
• Prompt-Injection durch Tool-Ausgabe: ein Server oder der abgefragte Inhalt liefert Text, der die nächsten Schritte des Agents hijackt. Prompt-Injection ist das Top-Risiko (LLM01) im OWASP Top 10 für LLM-Anwendungen 2025.
• Einfache Implementierungsfehler: Sicherheitsforscher meldeten über 30 CVEs gegen MCP-Server, Clients und Tools Anfang 2026, inklusive Kommando-Injection und Pfad-Traversal.

Ein Modell kann durch untrusted Text manipuliert werden, egal in welcher Runtime das Tool läuft. Was Sie kontrollieren, ist, wie viel Schaden ein kompromittiertes oder bösartiges Tool anrichten kann.

Was WebAssembly bietet

Das Ausführen von Tool-Code als WebAssembly beschränkt ihn auf eine Sandbox ohne Umgebungsrechte. Ein Gast-Modul kann nur Funktionen aufrufen, die der Host explizit bereitstellt. Wenn Sie keine WASI-Imports bereitstellen, hat es kein Dateisystem und keine Sockets. Laufzeiten wie Wasmtime setzen harte Grenzen:

• Fuel-Messung: begrenzt die Anzahl der ausgeführten Anweisungen, unendliche Schleifen führen zu Trap.
• Ressourcen-Limiter: begrenzt lineares Speicherwachstum und die Anzahl der Instanzen.
• Epoch-Interruption: fügt eine Deadlinemarke anhand der Uhrzeit hinzu.

Startkosten sind gering. Mit Wasmtime’s Pooling-Allocator, der standardmäßig nicht aktiviert ist, dauert die Instanziierung nur wenige Mikrosekunden. Kompilierung ist eine separate Kostenstelle, also kompilieren Sie vor und cachen Sie das Ergebnis.

[Agent / MCP-Client]
        │ JSON-RPC
        ▼
[Host-Prozess: Wasmtime]
   ├─ Fuel-Budget, Speicherlimit, Deadline
   └─ Imports: nur was Sie gewähren (kein WASI standardmäßig)
        ▼
[Untrusted Tool-Modul]

Beispiel: eine capabilities-freie Wasmtime-Sandbox

Dieses Beispiel nutzt die core-module API von Wasmtime. Es exportiert eine numerische Funktion, um das Beispiel kurz zu halten. Produktions-Tools für MCP verwenden normalerweise das Komponentenmodell mit WIT-Schnittstellen und explizit gewährten WASI-Fähigkeiten.

use wasmtime::{Config, Engine, Instance, Module, Store, StoreLimits, StoreLimitsBuilder};

struct HostState {
    limits: StoreLimits,
}

fn main() -> wasmtime::Result<()> {
    let mut config = Config::new();
    config.consume_fuel(true); // Instruktions-Messung aktivieren
    let engine = Engine::new(&config)?;
    let module = Module::from_file(&engine, "untrusted_tool.wasm")?;

    let mut store = Store::new(
        &engine,
        HostState {
            limits: StoreLimitsBuilder::new()
                .memory_size(64 * 1024 * 1024) // linear memory auf 64 MiB begrenzen
                .instances(1)
                .build(),
        },
    );
    store.limiter(|state| &mut state.limits);
    store.set_fuel(50_000_000)?; // Instruktionsbudget; bei Erschöpfung Trap für den Gast

    // Leere Importliste: kein WASI, keine Dateien, kein Netzwerk
    let instance = Instance::new(&mut store, &module, &[])?;
    let run = instance.get_typed_func::<i32, i32>(&mut store, "run")?;

    match run.call(&mut store, 42) {
        Ok(out) => println!("Tool hat {out} zurückgegeben"),
        Err(trap) => eprintln!("Tool hat getrapt (Budget überschritten oder Fehler): {trap}"),
    }
    Ok(())
}

Ein Modul, das Imports deklariert, die nicht bereitgestellt wurden, kann nicht instanziiert werden. Das ist das Capabilities-Modell, das wie vorgesehen funktioniert.

Grenzen dieses Ansatzes

• Wasm ist eine starke Grenze, aber keine absolute. Fehler im Runtime oder in den Host-Funktionen können die Isolation trotzdem brechen. Halten Sie die Runtime aktuell und den Host-API klein.
• Es schützt den Host vor dem Tool-Code. Es verhindert nicht, dass eine vergiftete Tool-Beschreibung das Modell steuert oder das Modell die Tools missbraucht. Kombinieren Sie es mit menschlicher Freigabe für sensible Aktionen, Least-Privilege-Credentials und geprüften, reviewten Servern.
• Die meisten MCP-Server laufen als Node.js- oder Python-Prozesse, die über stdio gestartet werden. Ohne Rewrite oder Recompilation laufen sie nicht in Wasm. Für diese Server ist eine OS-Sandbox oder ein Container die praktische Lösung.

---

3. Prompt-Firewall: Geheimnisse und PII vor Cloud-Übergabe redigieren

Hybride Setups schicken einige Aufgaben von einer lokalen Anwendung an ein gehostetes Modell. Alles im Prompt, sei es Quellcode, Verbindungsstrings, API-Keys, Kundendaten oder Logs, verlässt dann Ihren Rechner. Die Offenlegung sensibler Daten ist das zweitgrößte Risiko (LLM02) im OWASP Top 10 für LLM-Anwendungen 2025.

Ein lokaler Proxy kann ausgehende Requests inspizieren und sensible Werte vor dem Verlassen durch Platzhalter ersetzen.

[Lokale Anwendung] ──► [Lokaler Proxy: erkennen + ersetzen] ──► [Cloud LLM API]
                       │
              In-Memory-Platzhalter-Map
                       ▲
[Lokale Anwendung] ◄── [Platzhalter in der Antwort wiederherstellen]

Erkennungsschichten

• Deterministische Muster. Reguläre Ausdrücke mit Prüfsummen finden gut strukturierte Geheimnisse: Cloud-Access-Keys, JWTs, API-Key-Präfixe, E-Mails und Kartennummern.
• NER-basierte Erkennung. Microsoft Presidio ist ein Open-Source SDK, das Named-Entity Recognition, Regex, regelbasierte Logik und Prüfsummen kombiniert. Der NER-Schritt nutzt meist spaCy-Modelle. Es ist kein kleines Sprachmodell (SLM). Die Sprachabdeckung hängt von den installierten Modellen ab.

Behandeln Sie Erkennung als probabilistisch. Presidio gibt an, dass es nicht garantiert, alle sensiblen Daten zu finden. Eine Prompt-Firewall reduziert die Exposition, eliminiert sie aber nicht.

Beispiel: Minimaler Redaktions-Proxy

Dieses Beispiel behandelt nur nicht-streamende Requests. Streaming erfordert das Wiederherstellen von Platzhaltern über Chunk-Grenzen, was hier nicht gezeigt wird.

import os
import re

import httpx
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

PATTERNS = {
    "API_KEY": re.compile(r"\bsk-[A-Za-z0-9_-]{20,}") ,
    "AWS_KEY_ID": re.compile(r"\bAKIA[0-9A-Z]{16}\b"),
    "JWT": re.compile(r"\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+"),
    "EMAIL": re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b"),
}


def scrub(text: str, mapping: dict[str, str]) -> str:
    """Ersetzt sensible Treffer durch stabile Platzhalter, die in `mapping` gespeichert werden."""
    for label, pattern in PATTERNS.items():
        def repl(match: re.Match) -> str:
            value = match.group(0)
            for placeholder, original in mapping.items():
                if original == value:  # Wiederverwendung des Platzhalters
                    return placeholder
            placeholder = "{{" + f"{label}_{len(mapping) + 1}" + "}}"
            mapping[placeholder] = value
            return placeholder

        text = pattern.sub(repl, text)
    return text


def restore(obj, mapping: dict[str, str]):
    """Traversiert eine geparste JSON-Antwort und setzt Originalwerte wieder ein."""
    if isinstance(obj, str):
        for placeholder in sorted(mapping, key=len, reverse=True):
            obj = obj.replace(placeholder, mapping[placeholder])
        return obj
    if isinstance(obj, list):
        return [restore(item, mapping) for item in obj]
    if isinstance(obj, dict):
        return {key: restore(value, mapping) for key, value in obj.items()}
    return obj


@app.post("/v1/chat/completions")
async def proxy(request: Request):
    body = await request.json()
    mapping: dict[str, str] = {}  # pro Request, nur im Speicher

    for message in body.get("messages", []):
        if isinstance(message.get("content"), str):
            message["content"] = scrub(message["content"], mapping)

    async with httpx.AsyncClient(timeout=120) as client:
        upstream = await client.post(
            "https://api.openai.com/v1/chat/completions",
            json=body,
            headers={"Authorization": f"Bearer {os.environ['UPSTREAM_API_KEY']}"},
        )

    return JSONResponse(restore(upstream.json(), mapping), status_code=upstream.status_code)

Hinweise zum Design:

• Mapping lokal und kurz halten. Es im Speicher für die Dauer der Anfrage behalten oder in einem kurzen TTL-Store. Originalwerte niemals loggen.
• Platzhalter abgrenzen. Das schließende }} verhindert, dass {{EMAIL_1}} innerhalb von {{EMAIL_10}} passt. Bei unmarkierten Tokens ohne Delimiter, wie im Code, sollten längere Tokens zuerst wiederhergestellt werden, um Teilreplaces zu vermeiden.
• Anmeldedaten aus der Umgebung laden. Nicht hardcoden.
• Nicht-Text-Inhalte behandeln. Das Beispiel überspringt nicht-String-Nachrichten, z.B. Multimodal-Parts. Ein echter Proxy muss diese ebenfalls inspizieren, inklusive Tool-Call-Argumente und Anhänge.

Compliance-Check

Vorschriften wie GDPR und HIPAA regeln, wie personenbezogene Daten verarbeitet und geteilt werden. SOC 2 ist ein Prüfrahmen, kein Gesetz. Platzhalter ersetzen ist Pseudonymisierung, keine Anonymisierung. Pseudonymisierte Daten gelten weiterhin als personenbezogen, und Erkennungsfehler können echte Werte leaken. Ein Prompt-Firewall ist eine Maßnahme unter mehreren: Datenminimierung, Vendor-Agreements, Zugriffskontrollen und Überprüfung durch Ihr Compliance-Team.

---

Fazit

Lang laufende lokale Generierungen benötigen streaming-freundliche Proxys. Das heißt: kein Buffering, angemessene Timeouts und regelmäßige Heartbeats. Untrusted MCP-Toolcode läuft besser in einer Runtime, die keine Fähigkeiten gewährt und CPU- sowie Speicherbudgets durchsetzt. Ausgehende Prompts sollten durch einen lokalen Filter laufen, der Geheimnisse und Identifikatoren entfernt, die Sie erkennen.

Keiner dieser Maßnahmen ist eine vollständige Garantie. Jede begrenzt eine spezifische Fehlerquelle, und jede sollte vor der Nutzung mit Ihrem Tunnel, Runtime-Versionen und Daten getestet werden.

---

Quellen

• Anthropic spendet MCP an die Agentic AI Foundation (IT Brief)
• MCP-Spezifikation: Transporte
• Wasmtime: Optimierung für schnelle Instanziierung
• Wasmtime 10 Performance (Bytecode Alliance)
• wasmtime Store API (Limiter, Fuel)
• Microsoft Presidio
• OWASP Top 10 für LLM-Anwendungen 2025
• MCP-Sicherheit: Tool-Poisoning und Prompt-Injection
• Cloudflare Community: 524 Timeout bei 100 Sekunden
• Nginx-Konfiguration für Server-Sent Events (OneUptime)
• Ollamas OpenAI-kompatible API