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.
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/completionsbereitstellt, 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.
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,
)
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.testwird nicht erkannt, weil.testkein öffentliches Suffix ist;jane.doe@example.eudagegen 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_KEYSordnet 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äßiginternal. 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.
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
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_clientfü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
/healthzfür Readiness und Liveness, binden Siepolicy.yamlaus 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_URLauf 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 SieMCPServerausmcp.server.mcpserver, oder legen Siemcp<2fü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-analyzerauf ERROR. - Alles wird mit
unknown_teamblockiert: Der Schlüssel inGATEWAY_KEYSverweist auf einen Teamnamen, der nicht inpolicy.yamlsteht. - 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
| Option | Was es ist | Wählen, wenn | Worauf zu achten ist |
|---|---|---|---|
| Dieses Gateway (etwa 250 Zeilen) | FastAPI, Presidio, YAML-Richtlinie, Prometheus | Sie jede Regel lesen, an einem Tag starten und frei erweitern wollen | Streaming, Budgets, Retries und Eigenheiten der Anbieter liegen bei Ihnen |
| LiteLLM-Proxy | Quelloffener OpenAI-kompatibler Proxy für viele Anbieter | Sie 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 Kubernetes | Sie bereits Envoy oder die Gateway API betreiben und Routing, Rate Limits und Authentifizierung am Edge wollen | Richtlinienlogik jenseits des Routings liegt in Erweiterungen, die Sie selbst schreiben |
| NVIDIA NeMo Guardrails | Quelloffene Bibliothek programmierbarer Eingabe-, Ausgabe- und Dialog-Leitplanken | Sie Gesprächsregeln, Themensteuerung oder Faktencheck-Leitplanken innerhalb einer App brauchen | Eine Bibliothek innerhalb Ihrer App, kein unternehmensweiter Kontrollpunkt |
| Sicherheitsklassifikator-Modelle (zum Beispiel Llama Guard) | Ein Modell, das Prompts oder Antworten als sicher oder unsicher kennzeichnet | Sie zusätzlich zu Datenregeln eine Prüfung auf Inhaltssicherheit brauchen | Erhöht die Latenz und bedeutet ein weiteres zu betreibendes Modell; ergänzt Richtlinienprüfungen, ersetzt sie nicht |
| Admin-Kontrollen der Anbieter | Enterprise-Einstellungen in Ihren KI-Assistenten-Produkten | Sie nur ein oder zwei Anbieterprodukte nutzen | Jeder 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
- Closing the AI guidance gap in education, OpenAI, 10. November 2026 (unter Berufung auf eine Studie von ThinkYoung).
- Dokumentation zu Microsoft Presidio und Quellcode (Analyzer, Anonymizer, vordefinierte Erkenner einschließlich UkNinoRecognizer).
- EU AI Act, Artikel 4: KI-Kompetenz, in der durch den Digital Omnibus vom Juli 2026 angepassten Fassung.
- LiteLLM: PII-Maskierung mit Presidio, LiteLLM-Dokumentation.
- OWASP Top 10 for LLM Applications 2025, OWASP GenAI Security Project.
- AI in software engineering at Google: progress and the path ahead, Google Research, 6. Juni 2024.
- Control MCP server access for your organization, Claude-Code-Dokumentation.
- MCP Python SDK (2.x: MCPServer, Client) und der Wechsel von MCP zur Agentic AI Foundation, Anthropic, 9. Dezember 2025.
- Dokumentation zu FastAPI, uvicorn (Application Factories) und zum Prometheus-Python-Client.