Der Shop ist online

Wir bauen Workstation AI-Maschinen für Websites, KI-Agenten und LLM-Training – online konfigurieren und kaufen.

Händlerpreise erhalten
KI-Produkte
KI-LabsOpenAI-AgentenClaude-AgentenGrok-BotWorkstation AI-natives CRMMarketingAlle Produkte
KI-Lösungen
Angewandte KIKI-AgentenGenerative KIKI-AutomatisierungKI-WeiterbildungKI-Pakete für KMUEnterprise AI LabKI-WorkstationsNVIDIA-Hardware & -SoftwareNVIDIA Accelerated ComputingPrivate KIGPU-Private-CloudGPU-ClusterEdge-KIKI nach Branche
KI-Services
PlattformmodernisierungDigital EngineeringDatengrundlagen & KIAutonomer BetriebKI-BeratungDevOps-AutomatisierungCybersicherheitSoftwareentwicklungAgentenentwicklungMLOps-EinrichtungGPU-LeasingGPU-Private-Cloud
Über uns
UnternehmenUnsere GeschichtePartnerKundengeschichten
KI-Rechenzentren
KI-RechenzentrenGPU-Private-CloudGPU-ClusterGPU-Leasing
KI-EinblickeJev-ReiheBenchmark LabModellauswahl
Technische Hinweise
Dokumentation
Linux-BetriebssystemeUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
KI-Cloud-PlattformenAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryGPU-Clouds & Marktplätze
Private KI-RechenzentrenFür AnwaltskanzleienFür Steuer- und WirtschaftsprüfungskanzleienOn-Premises-PlattformenVollständig abgesicherte Cloud
ToolsRing PromoterJobshout
News
Blog
KontaktAnmelden

KI-Workstations, Multi-Agenten-KI-Software, GPU-Infrastruktur und intelligente Agentenlösungen für moderne Unternehmen.

Kontakt

KI-Lösungen

Angewandte KIKI-AgentenGenerative KIKI-AutomatisierungKI-WeiterbildungKI-Pakete für KMUEnterprise AI LabKI nach Branche

Produkte

Alle ProdukteWorkstation AI-natives CRM & ERPMarketingOpenAI-AgentenRing PromoterJobshout

Unternehmen

Über unsUnternehmenKI-RechenzentrenWarum WorkstationPartnerKundengeschichtenPreiseKontaktTenthMatrix

Ressourcen

KI-EinblickeTechnische HinweiseDokumentationLinux-BetriebssystemeKI-Cloud-PlattformenPrivate KI-RechenzentrenBlogSucheSitemap
Büro Belgien
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Mo – Fr: 9:00 – 18:00 Uhr MEZ
+32 492 45 67 46
Hauptsitz Großbritannien
77-79 Marlowes, Hemel Hempstead HP1 1LFAnfahrt – Ausfahrt 20 der M25 (Outer London)Handelsregisternr.: 11641870Mo – Fr: 9:00 – 18:00 Uhr GMT
+44 7515 356 146
Büro Indien
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Büro Taiwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Mo – Fr: 9:00 – 18:00 Uhr Taiwan-Zeit (GMT+8)
+886 926 892 701+32 492 45 67 46
Büro Estland
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaMo - Fr: 9:00 - 18:00 Uhr estnischer Zeit (EET)
+32 492 45 67 46

© 2026 Workstation AI. Alle Rechte vorbehalten.

DatenschutzDatenlöschungCookiesNutzungsbedingungenWebsite-Sitemap

NVIDIA, das NVIDIA-Logo, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX und HGX sind Marken und/oder eingetragene Marken der NVIDIA Corporation in den USA und anderen Ländern. AMD, das AMD-Arrow-Logo, EPYC, Instinct, Ryzen und Threadripper sind Marken von Advanced Micro Devices, Inc. Dell und PowerEdge sind Marken der Dell Inc. oder ihrer Tochtergesellschaften. Intel und Xeon sind Marken der Intel Corporation oder ihrer Tochtergesellschaften. AMAX, AceleMax und LiquidMax sind Marken der AMAX Engineering Corporation. Alle anderen Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Inhaber. Wir verwenden sie ausschließlich, um die Produkte zu kennzeichnen, die wir beschreiben, liefern oder unterstützen; ihre Verwendung bedeutet nicht, dass ihre Inhaber uns empfehlen.

Startseite / Technische Hinweise / Technology
AISecurityArchitectureAI Agents

KI-Nutzungsrichtlinie als Code: ein LLM-Gateway mit PII-Schwärzung, Tool-Allow-Lists und Telemetrie bauen

Die KI-Anleitungslücke im Code schließen: eine versionierte Richtliniendatei, ein OpenAI-kompatibles FastAPI-Gateway, Schwärzung mit Presidio, Tool- und MCP-Allow-Lists pro Team, Red-Team-Tests, ein Audit-Log, Prometheus-Metriken und ein Nutzungsbericht

16. November 2026Technology29 min read

In den meisten Organisationen nutzen Mitarbeitende bereits KI ohne jede Anleitung, und viele führen inzwischen interne Assistenten und Agenten ein. Diese Technote macht aus einer KI-Nutzungsrichtlinie lauffähigen Code: ein kleines OpenAI-kompatibles Gateway in Python, das jede Anfrage gegen eine versionierte Richtliniendatei prüft, personenbezogene Daten mit Microsoft Presidio schwärzt, Tools und MCP-Server pro Team per Allow-List freigibt, jede Entscheidung protokolliert und die Nutzung zählt, damit Sie sehen, wo noch Anleitung fehlt. Der gesamte Code unten wurde am 16. November 2026 ausgeführt und getestet.

Eine Richtliniendatei in YAML speist ein Gateway, das Anfragen prüft, schwärzt und protokolliert, bevor sie externe oder private Modelle erreichen.

Zusammenfassung. Setzen Sie ein einziges Gateway zwischen Ihre Mitarbeitenden, Apps und Agenten und jedes Modell, das sie nutzen. Schreiben Sie die Richtlinie als YAML-Datei, die wie Code geprüft wird: welche Teams welche Datenklassen an welche Modelle senden dürfen und welche Tools jedes Team einem Agenten geben darf. Das Gateway setzt sie durch, ersetzt E-Mail-Adressen, National-Insurance-Nummern, Kartennummern und Ähnliches durch Platzhalter, bevor irgendetwas das Haus verlässt, blockiert mit einer Meldung, die auf die Richtlinie verweist, und schreibt pro Anfrage eine JSON-Audit-Zeile und Prometheus-Metriken. Red-Team-Tests in pytest belegen, dass die Regeln greifen, und ein kurzer Bericht zeigt, welche Teams auf Blockaden stoßen oder personenbezogene Daten einfügen: Dort sollte die nächste Schulung ansetzen. Etwa 250 Zeilen Python; die Tabelle der Alternativen zeigt, wann Sie stattdessen LiteLLM, Envoy AI Gateway oder NeMo Guardrails einsetzen sollten.

Diese Technote begleitet unseren Blogbeitrag Die KI-Anleitungslücke: Die Nutzung überholt die Schulung in Schule und Beruf, der die Forschungslage (79 % der Schülerinnen und Schüler nutzen KI für Hausaufgaben, 47 % wurde gezeigt, wie das geht, laut einer von OpenAI zitierten Studie von ThinkYoung [1]) und das Vorgehen für Unternehmen behandelt. Hier bauen wir die technische Hälfte.

Für wen das ist, was Sie bauen, Voraussetzungen

Für wen es ist: Plattform-, ML- und Security-Engineers, die den Auftrag haben, „Mitarbeitenden die sichere Nutzung von KI zu ermöglichen“, unternehmensweit, oder einen internen Assistenten oder Agenten mit Leitplanken zu versehen, bevor er echte Nutzer erreicht.

Was Sie bauen:

  • policy.yaml: die KI-Nutzungsrichtlinie als Code (Datenklassen, Modelle, Teams, Tools, Limits).
  • Ein FastAPI-Gateway, das /v1/chat/completions bereitstellt, sodass jedes OpenAI-kompatible SDK, jedes IDE-Plug-in und jedes Agenten-Framework durch Ändern der Basis-URL funktioniert.
  • Schwärzung personenbezogener Daten mit Presidio, einschließlich des Erkenners für die britische National-Insurance-Nummer.
  • Tool- und MCP-Kontrollen: Tool-Allow-Lists pro Team, eine Prüfung der Tools, die das Modell tatsächlich aufruft, ein Freigabe-Flag für schreibende Tools und ein schreibgeschützter MCP-Server.
  • Red-Team-Tests in pytest, ein JSON-Audit-Log, Prometheus-Metriken und ein Bericht „Wo fehlt Anleitung?“.
  • Ein Container-Image und Hinweise für die Produktion.

Voraussetzungen: Python 3.12 (spaCy, das Presidio verwendet, ließ sich bei unserem Test nicht unter Python 3.15 installieren), FastAPI-Grundkenntnisse und entweder ein OpenAI-kompatibler Modell-Endpunkt (eine gehostete API oder vLLM bzw. Ollama für private Modelle) oder das Mock-Modell unten. Für das Gateway selbst ist keine GPU nötig. Getestete Versionen: FastAPI 0.163.1, uvicorn 0.54.0, httpx 0.28.1, presidio-analyzer und presidio-anonymizer 2.2.366, spaCy 3.8.18 mit en_core_web_sm 3.8.0, prometheus-client 0.26.0, mcp 2.3.0, pytest 9.2.0.

1. Architektur

Jede Anfrage durchläuft im Gateway vier Schritte: den Aufrufer authentifizieren und sein Team ermitteln; die Richtlinie prüfen; schwärzen, was die Datenklasse verlangt; an das richtige Upstream-Modell weiterleiten. Die Antwort kommt durch einen fünften Schritt zurück, der prüft, welche Tools das Modell aufrufen wollte. Jede Anfrage erzeugt eine Audit-Zeile und aktualisiert Zähler.

Clients wie SDKs, IDE-Assistenten und Agenten senden Anfragen an das Gateway, das authentifiziert, die Richtlinie prüft, schwärzt und an ein externes oder ein privates Modell weiterleitet; jede Anfrage schreibt in ein Audit-Log und in Prometheus-Metriken.
Ein Gateway zwischen jedem Client und jedem Modell. Die Richtliniendatei ist der einzige Ort, an dem Regeln stehen.

Warum ein Gateway statt Regeln in jeder App? Weil die Anleitungslücke ein organisatorisches Problem ist. Wenn zehn Teams jeweils einen Assistenten bauen, erhalten Sie zehn Auslegungen der Richtlinie und keine einheitliche Sicht auf die Nutzung. Ein Gateway bietet einen Durchsetzungspunkt, ein Log und einen Satz Zahlen, und bestehende Tools brauchen nur eine geänderte Basis-URL.

2. Das Projekt einrichten

mkdir llm-gateway && cd llm-gateway
mkdir gateway tests && touch gateway/__init__.py
python3.12 -m venv .venv && source .venv/bin/activate
cat > requirements.txt <<'EOF'
fastapi==0.163.1
uvicorn[standard]==0.54.0
httpx==0.28.1
pyyaml==6.0.3
prometheus-client==0.26.0
presidio-analyzer==2.2.366
presidio-anonymizer==2.2.366
pytest==9.2.0
en_core_web_sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl
EOF
pip install -r requirements.txt

Die letzte Zeile von requirements.txt installiert das kleine englische spaCy-Modell als festgelegtes Wheel, sodass Builds reproduzierbar sind und zur Laufzeit kein python -m spacy download brauchen. Der Download umfasst etwa 13 MB; das große Modell (en_core_web_lg, mehrere hundert MB) erkennt Namen zuverlässiger und ist einen Test wert, wenn Sie PERSON schwärzen.

3. Die Richtlinie als Code schreiben

Die Richtlinie ist nach Datenklassen organisiert, nicht nach Tools, denn Tools ändern sich monatlich, Datenklassen nicht. Jede Klasse listet die Modell-Aliasse, die sie nutzen darf, und die zu schwärzenden Entitätstypen. Teams erhalten eine Obergrenze (die höchste Datenklasse, die sie senden dürfen) und eine Tool-Liste. Nutzer sehen Aliasse wie external-general; der echte Upstream-Modellname ist Konfiguration, die Sie ändern können, ohne irgendjemanden neu schulen zu müssen.

# AI usage policy as code. Reviewed like any other change (pull request + owner approval).
version: 7
guidance_url: https://intranet.example.internal/ai-policy   # shown to users when a request is blocked

# Data classes, lowest to highest. A team may send data up to its max_data_class.
data_classes:
  public:       {rank: 0, models: [external-general, internal-private], redact: []}
  internal:     {rank: 1, models: [external-general, internal-private],
                 redact: [EMAIL_ADDRESS, PHONE_NUMBER, UK_NINO, CREDIT_CARD, IBAN_CODE]}
  confidential: {rank: 2, models: [internal-private],
                 redact: [EMAIL_ADDRESS, PHONE_NUMBER, UK_NINO, CREDIT_CARD, IBAN_CODE, PERSON]}
  restricted:   {rank: 3, models: [], redact: []}   # never leaves the source system

# Model aliases users see -> the real upstream (any OpenAI-compatible endpoint).
models:
  external-general: {base_url_env: EXTERNAL_LLM_URL, key_env: EXTERNAL_LLM_KEY, upstream_model: gpt-4.1-mini}
  internal-private: {base_url_env: INTERNAL_LLM_URL, key_env: INTERNAL_LLM_KEY, upstream_model: meta-llama/Llama-3.1-8B-Instruct}

# Tools (function calls, usually backed by MCP servers) and who may use them.
tools:
  search_docs:     {mcp_server: docs-readonly, scope: read}
  read_invoice:    {mcp_server: erp,           scope: read}
  create_ticket:   {mcp_server: servicedesk,   scope: write}
  send_email:      {mcp_server: mail,          scope: write, requires_approval: true}

teams:
  finance:     {max_data_class: confidential, tools: [search_docs, read_invoice, send_email]}
  engineering: {max_data_class: internal,     tools: [search_docs, create_ticket]}
  marketing:   {max_data_class: public,       tools: [search_docs]}

limits:
  max_tokens: 2048
  max_messages: 50

Behandeln Sie diese Datei wie Code: Änderungen laufen über einen Pull Request mit Freigabe durch eine verantwortliche Person, die version-Nummer wird erhöht, und die Tests aus Abschnitt 8 laufen in CI, bevor die Änderung ausgeliefert wird. Jede Audit-Zeile erfasst die Richtlinienversion, sodass Sie auch Monate später beantworten können: „Welche Regeln galten für diese Anfrage?“

4. Die Richtlinie laden und durchsetzen

Policy validiert die Datei beim Start (unbekannte Modell-, Klassen- oder Tool-Namen schlagen sofort fehl statt erst bei der ersten Anfrage), und decide() liefert entweder eine Decision oder einen PolicyError mit einem stabilen Ursachencode. Diese Codes werden zu Metrik-Labels; halten Sie sie also kurz und unveränderlich.

# gateway/policy.py
"""Load policy.yaml and decide whether a request may go upstream."""
from dataclasses import dataclass, field
from pathlib import Path

import yaml


class PolicyError(Exception):
    """A request that breaks the policy. `reason` is a stable code for metrics."""

    def __init__(self, reason: str, message: str):
        super().__init__(message)
        self.reason = reason
        self.message = message


@dataclass
class Decision:
    model_alias: str
    model: dict
    data_class: str
    redact_entities: list[str]
    approval_tools: set[str] = field(default_factory=set)


class Policy:
    def __init__(self, raw: dict):
        self.raw = raw
        self.version = raw["version"]
        self.guidance_url = raw.get("guidance_url", "")
        self.data_classes = raw["data_classes"]
        self.models = raw["models"]
        self.tools = raw["tools"]
        self.teams = raw["teams"]
        self.limits = raw.get("limits", {})
        self._validate()

    @classmethod
    def load(cls, path: str | Path) -> "Policy":
        return cls(yaml.safe_load(Path(path).read_text(encoding="utf-8")))

    def _validate(self) -> None:
        # Fail at start-up, not on the first request, if the policy refers to unknown names.
        for name, dc in self.data_classes.items():
            for m in dc["models"]:
                if m not in self.models:
                    raise ValueError(f"data class {name}: unknown model {m}")
        for team, t in self.teams.items():
            if t["max_data_class"] not in self.data_classes:
                raise ValueError(f"team {team}: unknown data class {t['max_data_class']}")
            for tool in t["tools"]:
                if tool not in self.tools:
                    raise ValueError(f"team {team}: unknown tool {tool}")

    def decide(self, team: str, data_class: str, model_alias: str, body: dict) -> Decision:
        if team not in self.teams:
            raise PolicyError("unknown_team", f"Team '{team}' has no AI access configured.")
        if data_class not in self.data_classes:
            raise PolicyError("unknown_data_class", f"Unknown data class '{data_class}'.")
        t = self.teams[team]
        if self.data_classes[data_class]["rank"] > self.data_classes[t["max_data_class"]]["rank"]:
            raise PolicyError(
                "data_class_exceeds_team",
                f"Team '{team}' may send data up to '{t['max_data_class']}', not '{data_class}'.",
            )
        allowed_models = self.data_classes[data_class]["models"]
        if model_alias not in allowed_models:
            raise PolicyError(
                "model_not_allowed",
                f"'{data_class}' data may only go to {allowed_models or 'no model'}, not '{model_alias}'.",
            )
        if len(body.get("messages", [])) > self.limits.get("max_messages", 100):
            raise PolicyError("too_many_messages", "Conversation is too long for the gateway limit.")
        approval = set()
        for tool in body.get("tools") or []:
            name = tool.get("function", {}).get("name", "")
            if name not in t["tools"]:
                raise PolicyError("tool_not_allowed", f"Tool '{name}' is not approved for team '{team}'.")
            if self.tools[name].get("requires_approval"):
                approval.add(name)
        return Decision(
            model_alias=model_alias,
            model=self.models[model_alias],
            data_class=data_class,
            redact_entities=self.data_classes[data_class]["redact"],
            approval_tools=approval,
        )
Entscheidungsablauf: Ist das Team bekannt, liegt die Datenklasse innerhalb der Obergrenze des Teams, ist das Modell für die Datenklasse erlaubt, stehen alle deklarierten Tools auf der Liste des Teams; jedes Nein liefert eine 403 mit Ursachencode und einem Link zur Richtlinie; bei durchgehend Ja wird geschwärzt und weitergeleitet.
Die Reihenfolge der Prüfungen in decide(). Jedes „Nein“ hat seinen eigenen Ursachencode, und genau den zählt später der Nutzungsbericht.

5. Personenbezogene Daten mit Presidio schwärzen

Der Analyzer von Presidio kombiniert ein spaCy-Modell zur Erkennung benannter Entitäten mit Mustererkennern (reguläre Ausdrücke plus Prüfsummen oder Kontextwörter) und liefert Textbereiche mit Konfidenzwerten; der Anonymizer ersetzt sie [2]. Wir fragen nur die Entitätstypen ab, die die Datenklasse auflistet, was die meisten Fehlalarme vermeidet.

# gateway/redact.py
"""PII redaction with Microsoft Presidio (spaCy NER + pattern recognisers)."""
import logging
from collections import Counter

from presidio_analyzer import AnalyzerEngine
from presidio_analyzer.nlp_engine import NlpEngineProvider
from presidio_analyzer.predefined_recognizers import UkNinoRecognizer
from presidio_anonymizer import AnonymizerEngine
from presidio_anonymizer.entities import OperatorConfig

logging.getLogger("presidio-analyzer").setLevel(logging.ERROR)  # quiet start-up warnings


class Redactor:
    def __init__(self, spacy_model: str = "en_core_web_sm", score_threshold: float = 0.4):
        provider = NlpEngineProvider(nlp_configuration={
            "nlp_engine_name": "spacy",
            "models": [{"lang_code": "en", "model_name": spacy_model}],
        })
        self.analyzer = AnalyzerEngine(nlp_engine=provider.create_engine(), supported_languages=["en"])
        self.analyzer.registry.add_recognizer(UkNinoRecognizer())  # shipped, but not loaded by default
        self.anonymizer = AnonymizerEngine()
        self.threshold = score_threshold

    def redact(self, text: str, entities: list[str]) -> tuple[str, Counter]:
        if not entities or not text:
            return text, Counter()
        results = self.analyzer.analyze(
            text=text, language="en", entities=entities, score_threshold=self.threshold
        )
        if not results:
            return text, Counter()
        out = self.anonymizer.anonymize(
            text=text,
            analyzer_results=results,
            operators={e: OperatorConfig("replace", {"new_value": f"<{e}>"}) for e in entities},
        )
        # Count what was actually replaced (overlapping hits are merged by the anonymizer).
        return out.text, Counter(item.entity_type for item in out.items)

    def redact_messages(self, messages: list[dict], entities: list[str]) -> tuple[list[dict], Counter]:
        total: Counter = Counter()
        clean = []
        for m in messages:
            m = dict(m)
            if isinstance(m.get("content"), str):
                m["content"], found = self.redact(m["content"], entities)
                total += found
            elif isinstance(m.get("content"), list):  # multi-part content: redact the text parts
                parts = []
                for p in m["content"]:
                    if p.get("type") == "text":
                        p = dict(p)
                        p["text"], found = self.redact(p["text"], entities)
                        total += found
                    parts.append(p)
                m["content"] = parts
            clean.append(m)
        return clean, total

Drei Dinge, die wir beim Testen festgestellt haben und die Sie kennen sollten, bevor Sie sich darauf verlassen:

  • Der Erkenner für die britische National-Insurance-Nummer wird mit Presidio ausgeliefert, aber nicht standardmäßig geladen. Dasselbe gilt für die anderen britischen Erkenner (Reisepass, Führerschein, Postleitzahl, Kfz-Kennzeichen). Fügen Sie die benötigten mit registry.add_recognizer() hinzu, wie oben gezeigt.
  • Der E-Mail-Erkenner validiert die Top-Level-Domain. jane.doe@example.test wird nicht erkannt, weil .test kein öffentliches Suffix ist; jane.doe@example.eu dagegen schon. Verwenden Sie realistische Testdaten, sonst bestehen Ihre Tests aus dem falschen Grund.
  • Das kleine spaCy-Modell ist unzuverlässig, wenn Sie nach allem fragen. Ohne Entitätsliste markierte es „Email“ als Person und Teile einer Telefonnummer als Datum. Beschränken Sie die Entitäten pro Datenklasse und behalten Sie einen Schwellenwert bei (wir verwenden 0.4). Eine britische Mobilnummer im internationalen Format (Ländervorwahl zuerst, mit Leerzeichen) wurde in unserem Test bei diesem Schwellenwert nicht erkannt; betrachten Sie die Schwärzung von Telefonnummern also nicht als vollständig.

6. Das Gateway

Das Gateway spricht das Chat-Completions-Format von OpenAI, weil sich fast jedes SDK, jeder IDE-Assistent und jedes Agenten-Framework darauf ausrichten lässt. Es speichert für das Audit-Log einen Hash des Prompts statt des Prompts selbst, begrenzt max_tokens, tauscht den Alias gegen den echten Modellnamen und prüft die Tool-Aufrufe in der Antwort, nicht nur die vom Client deklarierten Tools.

# gateway/app.py
"""A small LLM gateway: policy check -> PII redaction -> upstream -> audit log + metrics.

Speaks the OpenAI-compatible /v1/chat/completions API, so existing SDKs and tools work by
changing their base URL. Run:  uvicorn gateway.app:create_app --factory --port 8080
"""
import hashlib
import json
import logging
import os
import sys
import time
import uuid
from contextlib import asynccontextmanager

import httpx
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from prometheus_client import Counter, Histogram, make_asgi_app

from .policy import Policy, PolicyError
from .redact import Redactor

REQUESTS = Counter("gateway_requests_total", "Chat requests", ["team", "model", "outcome"])
BLOCKS = Counter("gateway_blocks_total", "Requests blocked by policy", ["team", "reason"])
REDACTIONS = Counter("gateway_redactions_total", "PII entities redacted", ["team", "entity"])
TOKENS = Counter("gateway_tokens_total", "Tokens used", ["team", "model", "kind"])
LATENCY = Histogram("gateway_upstream_seconds", "Upstream latency", ["model"])

audit = logging.getLogger("audit")
audit.setLevel(logging.INFO)
audit.addHandler(logging.StreamHandler(sys.stdout))
audit.propagate = False


def parse_keys(raw: str) -> dict[str, str]:
    """GATEWAY_KEYS="token1=finance,token2=engineering" -> {token: team}. Use SSO in production."""
    pairs = (p.split("=", 1) for p in raw.split(",") if "=" in p)
    return {k.strip(): v.strip() for k, v in pairs}


def create_app(policy_path: str | None = None, transport: httpx.AsyncBaseTransport | None = None) -> FastAPI:
    policy = Policy.load(policy_path or os.environ.get("POLICY_PATH", "policy.yaml"))
    redactor = Redactor(os.environ.get("SPACY_MODEL", "en_core_web_sm"))
    keys = parse_keys(os.environ.get("GATEWAY_KEYS", ""))

    @asynccontextmanager
    async def lifespan(app: FastAPI):
        app.state.http = httpx.AsyncClient(timeout=60, transport=transport)
        yield
        await app.state.http.aclose()

    app = FastAPI(title="llm-gateway", lifespan=lifespan)
    app.mount("/metrics", make_asgi_app())

    def blocked(team: str, reason: str, message: str, status: int, record: dict) -> JSONResponse:
        BLOCKS.labels(team, reason).inc()
        REQUESTS.labels(team, record.get("model", "-"), "blocked").inc()
        audit.info(json.dumps(record | {"outcome": "blocked", "reason": reason}))
        return JSONResponse(status_code=status, content={"error": {
            "type": "policy_violation", "code": reason, "message": message,
            "guidance": policy.guidance_url, "policy_version": policy.version,
        }})

    @app.get("/healthz")
    async def healthz():
        return {"status": "ok", "policy_version": policy.version}

    @app.post("/v1/chat/completions")
    async def chat(request: Request):
        started = time.perf_counter()
        token = request.headers.get("authorization", "").removeprefix("Bearer ").strip()
        team = keys.get(token)
        if team is None:
            return JSONResponse(status_code=401, content={"error": {"message": "unknown gateway key"}})
        body = await request.json()
        model_alias = body.get("model", "")
        data_class = request.headers.get("x-data-class", "internal")  # default to a cautious class
        record = {
            "ts": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
            "request_id": str(uuid.uuid4()),
            "team": team,
            "user": request.headers.get("x-user", "unknown"),
            "use_case": request.headers.get("x-use-case", "unspecified"),
            "model": model_alias,
            "data_class": data_class,
            "policy_version": policy.version,
            "tools": [t.get("function", {}).get("name") for t in body.get("tools") or []],
            # A hash lets you join repeated prompts without storing their text.
            "prompt_sha256": hashlib.sha256(json.dumps(body.get("messages", []), sort_keys=True).encode()).hexdigest(),
        }
        if body.get("stream"):
            return blocked(team, "stream_not_supported", "Streaming is not enabled on this gateway.", 400, record)
        try:
            decision = policy.decide(team, data_class, model_alias, body)
        except PolicyError as e:
            return blocked(team, e.reason, e.message, 403, record)

        messages, found = redactor.redact_messages(body.get("messages", []), decision.redact_entities)
        for entity, n in found.items():
            REDACTIONS.labels(team, entity).inc(n)
        record["redactions"] = dict(found)

        upstream = dict(body, messages=messages, model=decision.model["upstream_model"])
        upstream["max_tokens"] = min(int(body.get("max_tokens") or 1024), policy.limits.get("max_tokens", 2048))
        upstream.pop("max_completion_tokens", None)
        base_url = os.environ[decision.model["base_url_env"]].rstrip("/")
        headers = {}
        if key := os.environ.get(decision.model.get("key_env", ""), ""):
            headers["Authorization"] = f"Bearer {key}"

        t0 = time.perf_counter()
        try:
            resp = await request.app.state.http.post(f"{base_url}/chat/completions", json=upstream, headers=headers)
        except httpx.HTTPError as e:
            REQUESTS.labels(team, model_alias, "upstream_error").inc()
            audit.info(json.dumps(record | {"outcome": "upstream_error", "error": type(e).__name__}))
            return JSONResponse(status_code=502, content={"error": {"message": "upstream unavailable"}})
        LATENCY.labels(model_alias).observe(time.perf_counter() - t0)
        if resp.status_code != 200:
            REQUESTS.labels(team, model_alias, "upstream_error").inc()
            audit.info(json.dumps(record | {"outcome": "upstream_error", "status": resp.status_code}))
            return JSONResponse(status_code=502, content={"error": {"message": f"upstream returned {resp.status_code}"}})

        data = resp.json()
        # Check what the model asked to call, not only what the client declared.
        allowed = set(policy.teams[team]["tools"])
        called = [tc["function"]["name"]
                  for ch in data.get("choices", [])
                  for tc in (ch.get("message", {}).get("tool_calls") or [])]
        if bad := [c for c in called if c not in allowed]:
            return blocked(team, "model_called_unapproved_tool", f"Model tried to call {bad}.", 502, record)
        needs_approval = sorted(set(called) & decision.approval_tools)

        usage = data.get("usage") or {}
        for kind in ("prompt_tokens", "completion_tokens"):
            TOKENS.labels(team, model_alias, kind).inc(usage.get(kind, 0))
        REQUESTS.labels(team, model_alias, "ok").inc()
        audit.info(json.dumps(record | {
            "outcome": "ok", "tool_calls": called, "approval_required": needs_approval,
            "usage": usage, "latency_ms": round((time.perf_counter() - started) * 1000),
        }))
        data["model"] = model_alias
        data["gateway"] = {"request_id": record["request_id"], "redactions": dict(found),
                           "approval_required": needs_approval, "policy_version": policy.version}
        return data

    return app

Hinweise zu den Entscheidungen:

  • Authentifizierung. GATEWAY_KEYS ordnet einen Schlüssel einem Team zu, damit Sie das Ganze in wenigen Minuten ausprobieren können. In der Produktion stellen Sie das Gateway hinter Ihren Identity Provider (zum Beispiel oauth2-proxy oder Ihr API-Gateway, das ein OIDC-Token validiert) und entnehmen Team und Benutzer verifizierten Claims, nicht Headern.
  • Datenklasse. Der Aufrufer deklariert sie in X-Data-Class, standardmäßig internal. Das geht ehrlich mit einem schwierigen Problem um: Nur die aufrufende App weiß, was sie sendet. Geben Sie jeder App nach Möglichkeit einen eigenen Schlüssel mit fester Klasse und nutzen Sie die Schwärzung als letzte Absicherung, nicht als primäre Kontrolle.
  • Streaming wird mit einer klaren Fehlermeldung abgelehnt. Um Tool-Aufrufe zu prüfen und die Nutzung bei einem Stream zu protokollieren, muss die Antwort gepuffert oder während des Durchlaufs geparst werden; ergänzen Sie das, sobald die Grundlagen funktionieren.
  • Blockierte Anfragen erreichen nie ein Modell, und die Fehlermeldung enthält die Ursache, die Richtlinienversion und einen Link zur Anleitung. Diese Meldung ist Schulung, genau in dem Moment geliefert, in dem sie gebraucht wird.

7. Lokal ausführen

Um es ohne API-Schlüssel auszuprobieren, verwenden Sie ein Ersatzmodell, das zurückgibt, was es empfangen hat; so sehen Sie genau, was das Haus verlassen hätte.

# mock_llm.py
"""A stand-in OpenAI-compatible model that echoes what it received. For local testing only."""
from fastapi import FastAPI, Request

app = FastAPI()


@app.post("/v1/chat/completions")
async def chat(request: Request):
    body = await request.json()
    last = body["messages"][-1]["content"]
    return {
        "id": "mock-1", "object": "chat.completion", "model": body["model"],
        "choices": [{"index": 0, "finish_reason": "stop",
                     "message": {"role": "assistant", "content": f"Model received: {last}"}}],
        "usage": {"prompt_tokens": len(last.split()), "completion_tokens": 4, "total_tokens": len(last.split()) + 4},
    }
uvicorn mock_llm:app --port 9001 &
export GATEWAY_KEYS="dev-eng=engineering,dev-fin=finance,dev-mkt=marketing"
export EXTERNAL_LLM_URL=http://127.0.0.1:9001/v1 INTERNAL_LLM_URL=http://127.0.0.1:9001/v1
uvicorn gateway.app:create_app --factory --port 8091 --no-access-log > audit.jsonl &

curl -s http://127.0.0.1:8091/v1/chat/completions \
  -H "Authorization: Bearer dev-eng" -H "X-Data-Class: internal" \
  -H "X-User: sam" -H "X-Use-Case: support-reply" -H "Content-Type: application/json" \
  -d '{"model":"external-general","messages":[{"role":"user",
       "content":"Reply to jane.doe@example.eu, NI number AB 12 34 56 C, about her refund."}]}'

Erwartete Ausgabe (gekürzt). Das Modell hat ausschließlich Platzhalter gesehen:

{
  "model": "external-general",
  "choices": [{"message": {"role": "assistant",
    "content": "Model received: Reply to <EMAIL_ADDRESS>, NI number <UK_NINO>, about her refund."}}],
  "gateway": {"redactions": {"UK_NINO": 1, "EMAIL_ADDRESS": 1},
              "approval_required": [], "policy_version": 7}
}

Senden Sie nun als Finanzabteilung vertrauliche Daten an das externe Modell:

curl -s http://127.0.0.1:8091/v1/chat/completions \
  -H "Authorization: Bearer dev-fin" -H "X-Data-Class: confidential" -H "Content-Type: application/json" \
  -d '{"model":"external-general","messages":[{"role":"user","content":"Summarise the board pack"}]}'
{"error": {"type": "policy_violation", "code": "model_not_allowed",
  "message": "'confidential' data may only go to ['internal-private'], not 'external-general'.",
  "guidance": "https://intranet.example.internal/ai-policy", "policy_version": 7}}

Bestehender Code braucht nur eine neue Basis-URL. Mit dem offiziellen OpenAI Python SDK (wir haben 3.51.0 getestet) ist das zusätzliche Feld gateway des Gateways über model_extra verfügbar:

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:8091/v1", api_key="dev-eng",
                default_headers={"X-Data-Class": "internal", "X-Use-Case": "code-review"})
r = client.chat.completions.create(
    model="external-general",
    messages=[{"role": "user", "content": "Explain this stack trace, card=4111 1111 1111 1111"}])
print(r.choices[0].message.content)   # Model received: Explain this stack trace, card=<CREDIT_CARD>
print(r.model_extra["gateway"])       # {'request_id': '…', 'redactions': {'CREDIT_CARD': 1}, …}

Fallstrick: Auf unserer Testmaschine lauschte bereits ein anderer Prozess über IPv6 auf Port 8080, sodass curl localhost:8080 den falschen Server erreichte und das SDK einen 404 erhielt. Verwenden Sie beim lokalen Testen 127.0.0.1 und einen freien Port.

8. Agenten und MCP: Tools per Allow-List mit begrenzten Berechtigungen

Ein Agent ist ein Modell, das Tools aufrufen kann, und das Model Context Protocol (MCP) ist der übliche Weg, Tools anzubinden. Agenten brauchen drei Kontrollebenen, weil keine einzelne Ebene alles sieht.

Drei Kontrollebenen für Agenten: Der Client lädt nur MCP-Server von der Allow-List; das Gateway prüft deklarierte Tools und die Tools, die das Modell tatsächlich aufruft, und markiert schreibende Tools zur Freigabe; jeder MCP-Server läuft mit minimalen Berechtigungen, etwa einer schreibgeschützten Datenbankverbindung.
Gestaffelte Verteidigung für Agenten. Das Gateway sieht die Absicht (Tool-Aufrufe); nur die eigenen Zugangsdaten des MCP-Servers begrenzen, was tatsächlich passiert.

Ebene 1, der Client: Beschränken Sie, welche MCP-Server Assistenten laden dürfen. Für Claude Code legen Administratoren eine Allow-List in den verwalteten Einstellungen fest; mit allowManagedMcpServersOnly können Benutzer sie nicht erweitern, und entfernte Server müssen einem serverUrl-Muster entsprechen [7]:

{
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [
    { "serverUrl": "https://mcp-docs.internal.example.com/*" },
    { "serverUrl": "https://mcp-servicedesk.internal.example.com/*" }
  ],
  "deniedMcpServers": [
    { "serverUrl": "https://*.untrusted.example.com/*" }
  ]
}

Dieselbe Dokumentation warnt, dass ein Abgleich über serverName keine Sicherheitskontrolle ist, weil Benutzer den Namen selbst wählen; gleichen Sie stattdessen über URL oder Befehl ab [7]. Andere Clients haben eigene Entsprechungen; prüfen Sie diese vor dem Rollout.

Ebene 2, das Gateway: bereits im Code oben enthalten. Eine Anfrage, die ein Tool außerhalb der Liste des Teams deklariert, erhält 403 tool_not_allowed; eine Antwort, in der das Modell ein Tool aufruft, das ihm nicht gegeben wurde, wird durch 502 model_called_unapproved_tool ersetzt; und ein Aufruf eines Tools, das mit requires_approval markiert ist, wird mit gesetztem approval_required zurückgegeben, was Ihre Agenten-Laufzeitumgebung vor der Ausführung an einen Menschen weiterleiten muss.

Ebene 3, das Tool selbst: Geben Sie jedem MCP-Server die engsten Zugangsdaten, mit denen er funktioniert. Dieser schreibgeschützte Dokumentationsserver verwendet das MCP Python SDK 2.x. Beachten Sie, dass 2.x FastMCP in MCPServer umbenannt hat und Feldnamen in snake_case verwendet, sodass viele 1.x-Beispiele im Netz sich nicht mehr importieren lassen.

# docs_mcp.py
"""A read-only MCP server: one tool, no write paths, read-only credentials."""
import sqlite3

from mcp.server.mcpserver import MCPServer
from mcp.types import ToolAnnotations

server = MCPServer("docs-readonly")
DB = "file:docs.db?mode=ro"  # the OS-level guarantee: this process cannot write


@server.tool(annotations=ToolAnnotations(read_only_hint=True, open_world_hint=False))
def search_docs(query: str, limit: int = 5) -> list[dict]:
    """Search approved internal documentation by title. Returns title and URL only."""
    limit = max(1, min(limit, 20))
    with sqlite3.connect(DB, uri=True) as conn:
        rows = conn.execute(
            "SELECT title, url FROM docs WHERE title LIKE ? ORDER BY title LIMIT ?",
            (f"%{query}%", limit),
        ).fetchall()
    return [{"title": t, "url": u} for t, u in rows]


if __name__ == "__main__":
    server.run(transport="streamable-http")

Die Annotation read_only_hint teilt Clients mit, dass das Tool nichts verändert, aber sie ist nur ein Hinweis. Die Garantie ist mode=ro: Der Prozess kann nicht schreiben, selbst wenn das Modell ihn dazu auffordert. Testen Sie es im Arbeitsspeicher, ohne Netzwerk:

# test_mcp.py  (run python seed_docs.py first to create docs.db)
import asyncio
from mcp import Client
from docs_mcp import server

async def main():
    async with Client(server) as client:          # in-memory transport, no network
        tools = await client.list_tools()
        for t in tools.tools:
            print(t.name, t.annotations.read_only_hint)
        result = await client.call_tool("search_docs", {"query": "policy"})
        print(result.structured_content)

asyncio.run(main())
search_docs True
{'result': [{'title': 'AI acceptable use policy', 'url': 'https://intranet.example.internal/ai-policy'}]}

Führen Sie es mit python docs_mcp.py als Dienst aus; standardmäßig stellt es Streamable HTTP unter http://127.0.0.1:8000/mcp bereit, das wir ebenfalls erfolgreich mit mcp.Client aufgerufen haben [8].

9. Testen: Leitplanken- und Red-Team-Tests

Ungetestete Leitplanken sind Vermutungen. Die Tests unten verwenden httpx.MockTransport als Upstream, das genau aufzeichnet, was an ein Modell gesendet worden wäre; so kann ein Test zusichern, dass ein Geheimnis das Haus nie verlassen hat. Die Fälle liegen in YAML, damit die Verfasser der Richtlinie Fälle ergänzen können, ohne Python zu schreiben. Jeder Fall ist eine Anfrage, die eine wohlmeinende, aber nicht geschulte Kollegin oder ein Kollege senden könnte.

# tests/redteam.yaml
# Each case is a request a well-meaning but untrained colleague might send.
# expect.status: what the gateway must return. must_not_reach_model: strings that must be redacted.
- name: customer email and NI number are redacted before the external model
  key: eng-key
  data_class: internal
  model: external-general
  prompt: "Draft a reply to jane.doe@example.eu about her NI number AB 12 34 56 C."
  expect: {status: 200, must_not_reach_model: ["jane.doe@example.eu", "AB 12 34 56 C"]}

- name: card number in a pasted log is redacted
  key: eng-key
  data_class: internal
  model: external-general
  prompt: "Why did this payment fail? card=4111 1111 1111 1111 status=declined"
  expect: {status: 200, must_not_reach_model: ["4111 1111 1111 1111"]}

- name: confidential data cannot go to the external model
  key: fin-key
  data_class: confidential
  model: external-general
  prompt: "Summarise the Q3 board pack."
  expect: {status: 403, code: model_not_allowed}

- name: marketing cannot label data above its ceiling
  key: mkt-key
  data_class: internal
  model: external-general
  prompt: "Summarise this internal roadmap."
  expect: {status: 403, code: data_class_exceeds_team}

- name: restricted data goes nowhere
  key: fin-key
  data_class: restricted
  model: internal-private
  prompt: "Here is the payroll export..."
  expect: {status: 403, code: data_class_exceeds_team}

- name: engineering may not declare the email tool
  key: eng-key
  data_class: internal
  model: external-general
  prompt: "Email the release notes to all customers."
  tools: [send_email]
  expect: {status: 403, code: tool_not_allowed}
# tests/test_guardrails.py
"""Guardrail tests: a fake upstream records exactly what would have left the building."""
import json
from pathlib import Path

import httpx
import pytest
import yaml
from fastapi.testclient import TestClient

from gateway.app import create_app

HERE = Path(__file__).parent
CASES = yaml.safe_load((HERE / "redteam.yaml").read_text())


def tool(name: str) -> dict:
    return {"type": "function", "function": {"name": name, "parameters": {"type": "object", "properties": {}}}}


@pytest.fixture
def gateway(monkeypatch):
    monkeypatch.setenv("GATEWAY_KEYS", "fin-key=finance,eng-key=engineering,mkt-key=marketing")
    monkeypatch.setenv("EXTERNAL_LLM_URL", "https://external.test/v1")
    monkeypatch.setenv("INTERNAL_LLM_URL", "http://internal.test/v1")
    sent: list[dict] = []
    reply = {"tool_calls": None}

    def upstream(request: httpx.Request) -> httpx.Response:
        sent.append(json.loads(request.content))
        message = {"role": "assistant", "content": "ok", "tool_calls": reply["tool_calls"]}
        return httpx.Response(200, json={
            "id": "x", "object": "chat.completion", "model": "m",
            "choices": [{"index": 0, "message": message, "finish_reason": "stop"}],
            "usage": {"prompt_tokens": 12, "completion_tokens": 3, "total_tokens": 15},
        })

    app = create_app(str(HERE.parent / "policy.yaml"), transport=httpx.MockTransport(upstream))
    with TestClient(app) as client:
        yield client, sent, reply


def post(client, key, data_class, model, prompt, tools=()):
    return client.post(
        "/v1/chat/completions",
        headers={"Authorization": f"Bearer {key}", "X-Data-Class": data_class, "X-User": "test"},
        json={"model": model, "messages": [{"role": "user", "content": prompt}],
              "tools": [tool(t) for t in tools] or None},
    )


@pytest.mark.parametrize("case", CASES, ids=[c["name"] for c in CASES])
def test_redteam_case(gateway, case):
    client, sent, _ = gateway
    r = post(client, case["key"], case["data_class"], case["model"], case["prompt"], case.get("tools", ()))
    assert r.status_code == case["expect"]["status"], r.text
    if code := case["expect"].get("code"):
        assert r.json()["error"]["code"] == code
        assert sent == [], "a blocked request must never reach a model"
    for secret in case["expect"].get("must_not_reach_model", []):
        assert secret not in json.dumps(sent), f"{secret!r} reached the model"


def test_unknown_key_is_rejected(gateway):
    client, sent, _ = gateway
    assert post(client, "nope", "public", "external-general", "hi").status_code == 401
    assert sent == []


def test_model_cannot_call_a_tool_it_was_not_given(gateway):
    client, _, reply = gateway
    reply["tool_calls"] = [{"id": "c1", "type": "function",
                            "function": {"name": "send_email", "arguments": "{}"}}]
    r = post(client, "eng-key", "internal", "external-general", "tidy this", tools=["search_docs"])
    assert r.status_code == 502
    assert r.json()["error"]["code"] == "model_called_unapproved_tool"


def test_write_tool_is_flagged_for_human_approval(gateway):
    client, _, reply = gateway
    reply["tool_calls"] = [{"id": "c1", "type": "function",
                            "function": {"name": "send_email", "arguments": "{}"}}]
    r = post(client, "fin-key", "internal", "external-general", "chase invoice 42", tools=["send_email"])
    assert r.status_code == 200
    assert r.json()["gateway"]["approval_required"] == ["send_email"]


def test_upstream_sees_real_model_name_and_capped_tokens(gateway):
    client, sent, _ = gateway
    post(client, "fin-key", "confidential", "internal-private", "summarise")
    assert sent[-1]["model"] == "meta-llama/Llama-3.1-8B-Instruct"
    assert sent[-1]["max_tokens"] <= 2048
$ pytest -q
..........                                                     [100%]
10 passed in 5.54s

Diese Tests prüfen die deterministischen Regeln des Gateways. Sie testen nicht das Modell. Für das Modellverhalten (Prompt Injection über abgerufene Dokumente, Jailbreaks, unsichere Ausgaben) ergänzen Sie eine separate Evaluierungssuite, die gegen Ihren echten Upstream läuft: ein fester Satz adversarialer Prompts und Dokumente mit erwarteten Ergebnissen, bewertet bei jeder Modell- oder Prompt-Änderung. Die OWASP Top 10 for LLM Applications 2025 sind eine gute Checkliste für das, was abgedeckt werden sollte, insbesondere Prompt Injection (LLM01), Offenlegung sensibler Informationen (LLM02) und übermäßige Handlungsfreiheit (LLM06) [5]. Führen Sie die Leitplanken-Tests bei jeder Richtlinienänderung in CI aus.

10. Nutzungstelemetrie: sehen, wo Anleitung fehlt

Das Gateway erzeugt zwei Datenströme. Prometheus-Zähler für Dashboards und Alarme:

gateway_requests_total{model="external-general",outcome="blocked",team="marketing"} 2.0
gateway_blocks_total{reason="data_class_exceeds_team",team="marketing"} 2.0
gateway_blocks_total{reason="model_not_allowed",team="finance"} 1.0
gateway_redactions_total{entity="CREDIT_CARD",team="engineering"} 1.0

(Die Metrik-App ist unter /metrics eingebunden, was auf /metrics/ umleitet; Prometheus folgt der Umleitung, oder Sie scrapen /metrics/ direkt.) Und eine JSON-Zeile pro Anfrage, ohne Prompt-Text:

{"ts": "2026-11-16T12:29:00Z", "team": "engineering", "user": "sam", "use_case": "support-reply",
 "model": "external-general", "data_class": "internal", "policy_version": 7, "tools": [],
 "prompt_sha256": "f7d1e4a7…", "redactions": {"UK_NINO": 1, "EMAIL_ADDRESS": 1}, "outcome": "ok",
 "usage": {"prompt_tokens": 9, "completion_tokens": 4, "total_tokens": 13}, "latency_ms": 115}

Der Bericht macht aus diesem Log die Frage, die den Fachbereich interessiert: Welche Teams brauchen Anleitung, und wozu?

# report.py
"""Summarise the gateway audit log: where is guidance missing?

Usage: python report.py audit.jsonl
"""
import json
import sys
from collections import Counter, defaultdict

requests, blocks, redactions = Counter(), defaultdict(Counter), defaultdict(Counter)
use_cases = defaultdict(Counter)
for line in open(sys.argv[1], encoding="utf-8"):
    if not line.startswith("{"):
        continue  # skip non-audit lines (e.g. uvicorn access logs)
    r = json.loads(line)
    team = r["team"]
    requests[team] += 1
    use_cases[team][r.get("use_case", "unspecified")] += 1
    if r["outcome"] == "blocked":
        blocks[team][r["reason"]] += 1
    for entity, n in (r.get("redactions") or {}).items():
        redactions[team][entity] += n

print(f"{'team':<12} {'requests':>8} {'blocked':>8} {'block %':>8} {'PII hits':>9}  top block reason")
for team, n in requests.most_common():
    b = sum(blocks[team].values())
    top = blocks[team].most_common(1)[0][0] if b else "-"
    print(f"{team:<12} {n:>8} {b:>8} {100 * b / n:>7.0f}% {sum(redactions[team].values()):>9}  {top}")
print("\nUnlabelled use (no X-Use-Case header):")
for team, uc in use_cases.items():
    print(f"  {team}: {uc['unspecified']} of {sum(uc.values())}")
$ python report.py audit.jsonl
team         requests  blocked  block %  PII hits  top block reason
engineering         2        0       0%         3  -
marketing           2        1      50%         0  data_class_exceeds_team
finance             1        1     100%         0  model_not_allowed

Unlabelled use (no X-Use-Case header):
  engineering: 0 of 2
  finance: 1 of 1
  marketing: 2 of 2
Ein Kreislauf: Das Gateway protokolliert und zählt Anfragen; ein wöchentlicher Bericht zeigt Blockaden, Schwärzungen und nicht gekennzeichnete Nutzung pro Team; die Verantwortlichen für die Richtlinie machen daraus gezielte Schulungen, eine Richtlinienänderung oder ein neues freigegebenes Tool; die Änderung wird als neue Richtlinienversion ausgeliefert; und das Gateway misst erneut.
Telemetrie schließt den Kreis. Blockaden und Schwärzungen sind Signale fehlender Anleitung, keine Verstöße.

So lesen Sie ihn: Ein Team mit vielen model_not_allowed-Blockaden wünscht sich eine Fähigkeit, die die Richtlinie nicht bietet (vielleicht ein privates Modell für vertrauliche Arbeit). Viele Schwärzungen bedeuten, dass Mitarbeitende personenbezogene Daten einfügen; ihre Schulung sollte also behandeln, was zu entfernen ist. Hohe nicht gekennzeichnete Nutzung bedeutet, dass Sie nicht wissen, wofür KI genutzt wird; fragen Sie also nach. Kombinieren Sie das mit Qualitätsmaßen; das Engineering-Team von Google berichtet, dass es Akzeptanzraten verfolgt und Online-A/B-Experimente durchführt, weil Offline-Metriken „oft nur grobe Näherungen für den Nutzen für die Anwender“ sind [6].

11. Betrieb in der Produktion

# Dockerfile
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY gateway/ gateway/
COPY policy.yaml .
RUN useradd --uid 10001 gateway
USER 10001
EXPOSE 8080
CMD ["uvicorn", "gateway.app:create_app", "--factory", "--host", "0.0.0.0", "--port", "8080", "--no-access-log"]

Bauen Sie mit einer .dockerignore, die nur requirements.txt, gateway/ und policy.yaml zulässt. Wir haben dieses Image gebaut und ausgeführt: Es startet in wenigen Sekunden, /healthz antwortet, und Richtlinienblockaden funktionieren. Es ist etwa 760 MB groß, überwiegend spaCy und seine Abhängigkeiten.

  • CPU, nicht GPU. Das Gateway und Presidio laufen auf der CPU. Die Schwärzung mit dem kleinen Modell dauerte auf unserer Testmaschine etwa 5 ms für einen zweizeiligen Prompt und etwa 170 ms für einen Prompt mit 1.000 Wörtern, und sie wächst mit der Prompt-Länge; messen Sie mit Ihren eigenen Prompts und ergänzen Sie CPU, bevor Sie Worker ergänzen.
  • Mit Replikaten skalieren, je ein Worker. prometheus_client führt Zähler pro Prozess. Mit mehreren uvicorn-Workern in einem Container brauchen Sie seinen Multiprozess-Modus; ein Worker pro Pod und mehr Pods ist einfacher.
  • Kubernetes. Verwenden Sie /healthz für Readiness und Liveness, binden Sie policy.yaml aus einer ConfigMap ein, die aus Ihrem Repository gebaut wird, und beziehen Sie Upstream-Schlüssel aus Ihrem Secret Store. Verwenden Sie eine Network Policy, sodass nur das Gateway die Modell-Endpunkte erreichen kann; andernfalls werden Mitarbeitende es umgehen.
  • Audit-Log. Leiten Sie stdout an Ihre Log-Plattform weiter. Es enthält Benutzerkennungen und ist für sich genommen personenbezogene Daten: Legen Sie eine Aufbewahrungsfrist fest, beschränken Sie den Zugriff, und fügen Sie keinen Prompt-Text hinzu, es sei denn, Sie haben eine Rechtsgrundlage und eine kurze Aufbewahrung.
  • Private Modelle. Richten Sie INTERNAL_LLM_URL auf einen beliebigen OpenAI-kompatiblen Server, den Sie selbst hosten, etwa vLLM oder Ollama, damit vertrauliche Arbeit Ihr Netzwerk nie verlässt.
  • Latenz und Ausfälle. Das Gateway liegt jetzt auf dem kritischen Pfad. Betreiben Sie mindestens zwei Replikate, setzen Sie Upstream-Timeouts (hier 60 Sekunden) und alarmieren Sie bei outcome="upstream_error".

12. Fallstricke und Debugging

  • Ein Leitplanken-Test besteht, aber Daten fließen trotzdem ab: Prüfen Sie, ob Ihre Testdaten erkennbar sind (der Fall mit der .test-E-Mail-Adresse), und prüfen Sie in Zusicherungen, was der Mock-Upstream empfangen hat, nicht die Antwort.
  • ModuleNotFoundError: mcp.server.fastmcp: Sie haben das MCP SDK 2.x; importieren Sie MCPServer aus mcp.server.mcpserver, oder legen Sie mcp<2 für 1.x-Code fest.
  • Störende Presidio-Warnungen beim Start zu italienischen, spanischen oder polnischen Erkennern sind harmlos; sie werden übersprungen, weil die Registry nur Englisch enthält. Wir setzen den Logger presidio-analyzer auf ERROR.
  • Alles wird mit unknown_team blockiert: Der Schlüssel in GATEWAY_KEYS verweist auf einen Teamnamen, der nicht in policy.yaml steht.
  • Mitarbeitende umgehen das Gateway: Machen Sie es zum einzigen Netzwerkpfad zu Modell-APIs, und machen Sie die freigegebenen Tools so gut, dass niemand es umgehen will.
  • Mehrteilige Nachrichten (Bilder plus Text): Der Schwärzer bereinigt nur Textteile. Blockieren Sie Bildeingaben für Klassen oberhalb von public, bis Sie eine Bildverarbeitung ergänzt haben.

13. Alternativen

OptionWas es istWählen, wennWorauf zu achten ist
Dieses Gateway (etwa 250 Zeilen)FastAPI, Presidio, YAML-Richtlinie, PrometheusSie jede Regel lesen, an einem Tag starten und frei erweitern wollenStreaming, Budgets, Retries und Eigenheiten der Anbieter liegen bei Ihnen
LiteLLM-ProxyQuelloffener OpenAI-kompatibler Proxy für viele AnbieterSie viele Anbieter, virtuelle Schlüssel und Ausgabenlimits brauchen; er hat eine Presidio-PII-Leitplanke [4]Große Konfigurationsoberfläche; prüfen Sie, welche Leitplanken in welchem Modus laufen
Envoy AI Gateway (umbenannt in Agent Router)Quelloffene Control Plane für KI- und Agenten-Datenverkehr, aufgebaut auf Envoy Gateway für KubernetesSie bereits Envoy oder die Gateway API betreiben und Routing, Rate Limits und Authentifizierung am Edge wollenRichtlinienlogik jenseits des Routings liegt in Erweiterungen, die Sie selbst schreiben
NVIDIA NeMo GuardrailsQuelloffene Bibliothek programmierbarer Eingabe-, Ausgabe- und Dialog-LeitplankenSie Gesprächsregeln, Themensteuerung oder Faktencheck-Leitplanken innerhalb einer App brauchenEine Bibliothek innerhalb Ihrer App, kein unternehmensweiter Kontrollpunkt
Sicherheitsklassifikator-Modelle (zum Beispiel Llama Guard)Ein Modell, das Prompts oder Antworten als sicher oder unsicher kennzeichnetSie zusätzlich zu Datenregeln eine Prüfung auf Inhaltssicherheit brauchenErhöht die Latenz und bedeutet ein weiteres zu betreibendes Modell; ergänzt Richtlinienprüfungen, ersetzt sie nicht
Admin-Kontrollen der AnbieterEnterprise-Einstellungen in Ihren KI-Assistenten-ProduktenSie nur ein oder zwei Anbieterprodukte nutzenJeder Anbieter ist eine eigene Richtlinie und ein eigenes Log; keine einheitliche Sicht

Diese Optionen schließen sich nicht aus. Ein gängiges Muster ist LiteLLM oder Envoy für Anbieter-Routing und Schlüssel, ein schlanker Richtliniendienst wie dieser für Ihre Datenklassenregeln und ein Klassifikator für die Inhaltssicherheit.

14. FAQ

Macht die Schwärzung es sicher, vertrauliche Daten an ein externes Modell zu senden? Nein. Die Erkennung übersieht Dinge, und der Kontext kann eine Person auch ohne Namen identifizierbar machen. Deshalb leitet die Beispielrichtlinie vertrauliche Daten nur an das private Modell, und die Schwärzung ist die letzte Absicherung.

Funktionieren Tools, die OpenAI-Antworten erwarten, dann nicht mehr? In unserem Test mit dem OpenAI SDK schon: Wir fügen ein zusätzliches Feld auf oberster Ebene hinzu (gateway) und ersetzen den Modellnamen durch den Alias. Strikte Clients, die unbekannte Felder ablehnen, sind selten, aber testen Sie Ihre.

Kann ich es mit Anthropic, Google oder anderen Anbietern verwenden? Ja, über jeden OpenAI-kompatiblen Endpunkt oder indem Sie LiteLLM als Upstream hinter dieses Gateway stellen; so behält diese Ebene Ihre Richtlinie, und LiteLLM übernimmt die Anbieter-APIs.

Wie hilft das beim EU AI Act? Artikel 4 verlangt von Anbietern und Betreibern, Maßnahmen zur Förderung der KI-Kompetenz ihres Personals zu ergreifen [3]. Ein Gateway schult niemanden, aber seine Blockademeldungen, Richtlinienversionen und Nutzungsberichte sind Nachweise der ergriffenen Maßnahmen und zeigen, wo noch Schulungsbedarf besteht.

Sollten wir Prompts für Untersuchungen protokollieren? Standardmäßig nur Hashes und Metadaten. Wenn Sie Inhalte aufbewahren müssen, dann nur kurz, verschlüsselt und mit beschränktem Zugriff; andernfalls wird das Audit-Log zu Ihrem größten Speicher personenbezogener Daten.

Was ist mit Agenten, die ohne Chat-Anfrage handeln? Leiten Sie ihre Modellaufrufe wie bei jedem anderen Client über das Gateway, und setzen Sie Tool-Berechtigungen in den MCP-Servern durch (Ebene 3). Das Freigabe-Flag funktioniert nur, wenn Ihre Agenten-Laufzeitumgebung es beachtet; testen Sie diesen Pfad also ausdrücklich.

Wenn Sie das gegen private Modelle auf Ihrer eigenen Infrastruktur betreiben möchten: Unser Team für private KI baut und betreibt für Organisationen im Vereinigten Königreich Gateways, Modell-Hosting und das zugehörige Monitoring.

Quellen

  1. Closing the AI guidance gap in education, OpenAI, 10. November 2026 (unter Berufung auf eine Studie von ThinkYoung).
  2. Dokumentation zu Microsoft Presidio und Quellcode (Analyzer, Anonymizer, vordefinierte Erkenner einschließlich UkNinoRecognizer).
  3. EU AI Act, Artikel 4: KI-Kompetenz, in der durch den Digital Omnibus vom Juli 2026 angepassten Fassung.
  4. LiteLLM: PII-Maskierung mit Presidio, LiteLLM-Dokumentation.
  5. OWASP Top 10 for LLM Applications 2025, OWASP GenAI Security Project.
  6. AI in software engineering at Google: progress and the path ahead, Google Research, 6. Juni 2024.
  7. Control MCP server access for your organization, Claude-Code-Dokumentation.
  8. MCP Python SDK (2.x: MCPServer, Client) und der Wechsel von MCP zur Agentic AI Foundation, Anthropic, 9. Dezember 2025.
  9. Dokumentation zu FastAPI, uvicorn (Application Factories) und zum Prometheus-Python-Client.
Diesen Artikel teilen

Mehr zu Technology

Laptops für KI-Entwickler: LLMs lokal unter Linux mit GPUs mit 16 GB und 24 GB betreiben (Leitfaden 2026)

Laptops für KI-Entwickler: LLMs lokal unter Linux mit GPUs mit 16 GB und 24 GB betreiben (Leitfaden 2026)

Was auf eine RTX 5080 oder RTX 5090 Laptop GPU passt, die Speicherrechnung, die lohnenden offenen Modelle, die Einrichtung von Ubuntu 26.04 mit dem NVIDIA-Stack, Ollama, llama.cpp und vLLM, Coding-Assistenten, LoRA-Fine-Tuning, Sicherheit und wann Arbeit auf einen Server gehört

Weiterlesen
ML- und LLM-Systeme testen, deren Korrektheit sich nicht beweisen lässt: ein Python-Evidenz-Kit

ML- und LLM-Systeme testen, deren Korrektheit sich nicht beweisen lässt: ein Python-Evidenz-Kit

Evidenz statt Beweise, in etwa 400 Zeilen Python mit echter Ausgabe: Slice-Metriken mit Bootstrap-Intervallen und einem Pass/Fail-Vertrag, Property- und metamorphe Tests mit Hypothesis, Kalibrierung und Conformal Prediction, Pydantic-Verträge und Regressionsevaluierungen für LLM-Ausgaben, Drift-Prüfungen, ein CI-Gate und die exakte Verifikation eines kleinen neuronalen Netzes

Weiterlesen
TorchCurves in der Praxis: lernbare B-Spline- und Legendre-Kurven in PyTorch

TorchCurves in der Praxis: lernbare B-Spline- und Legendre-Kurven in PyTorch

torchcurves installieren, eine Kurve anpassen und dimensionieren, B-Spline oder Legendre und die Eingabeabbildung wählen, eine monotone Kalibrierungskurve und ein additives Modell auf tabellarischen Daten bauen, mit SciPy, scikit-learn, einem KAN und einem MLP vergleichen, Koeffizienten nach JSON exportieren, testen und in der Produktion betreiben, mit echten Ausgaben

Weiterlesen