De shop is live

Wij bouwen Workstation AI-machines voor websites, AI-agents en LLM-training — configureer en koop online.

Bekijk handelsprijzen
AI-producten
AI LabsOpenAI-agentsClaude-agentsGrok-botWorkstation AI native CRMMarketingAlle producten
AI-oplossingen
Toegepaste AIAI-agentsGeneratieve AIAI-automatiseringAI-bijscholingAI-pakketten voor het mkbEnterprise AI LabAI-werkstationsNVIDIA-hardware en -softwareNVIDIA Accelerated ComputingPrivate AIGPU private cloudGPU-clustersEdge AIAI per sector
AI-diensten
PlatformmoderniseringDigitale engineeringDatafundamenten en AIAutonome operatiesAI-adviesDevOps-automatiseringCybersecuritySoftwareontwikkelingAgentontwikkelingMLOps-opzetGPU-leasingGPU private cloud
Over ons
BedrijfOns verhaalPartnersKlantverhalen
AI-datacenters
AI-datacentersGPU private cloudGPU-clustersGPU-leasing
AI-inzichtenJev-reeksBenchmarklabModelkeuze
Technische notities
Documentatie
Linux-OSUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
AI-cloudplatformsAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryGPU-clouds en -marktplaatsen
Private AI-datacentersVoor advocatenkantorenVoor accountantskantorenOn-premises platformsVolledig beveiligde cloud
ToolsRing PromoterJobshout
Nieuws
Blog
Neem contact opInloggen

AI-werkstations, AI multi-agent software, GPU-infrastructuur en intelligente agentoplossingen voor moderne bedrijven.

Neem contact op

AI-oplossingen

Toegepaste AIAI-agentsGeneratieve AIAI-automatiseringAI-bijscholingAI-pakketten voor het mkbEnterprise AI LabAI per sector

Producten

Alle productenWorkstation AI-native CRM & ERPMarketingOpenAI-agentsRing PromoterJobshout

Bedrijf

Over onsBedrijfAI-datacentersWaarom WorkstationPartnersKlantverhalenPrijzenContactTenthMatrix

Bronnen

AI-inzichtenTechnische notitiesDocumentatieLinux-OSAI-cloudplatformsPrivate AI-datacentersBlogZoekenSitemap
Kantoor België
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Ma - Vr: 9:00 - 18:00 CET
+32 492 45 67 46
Hoofdkantoor VK
77-79 Marlowes, Hemel Hempstead HP1 1LFRoute: neem afrit 20 van de M25, Outer LondonBedrijfsnummer: 11641870Ma - Vr: 9:00 - 18:00 GMT
+44 7515 356 146
Kantoor India
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Kantoor Taiwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Ma - Vr: 9:00 - 18:00 Taiwanese tijd (GMT+8)
+886 926 892 701+32 492 45 67 46
Kantoor Estland
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaMa - vr: 9:00 - 18:00 uur Estse tijd (EET)
+32 492 45 67 46

© 2026 Workstation AI. Alle rechten voorbehouden.

PrivacyGegevensverwijderingCookiesServicevoorwaardenWebsite-sitemap

NVIDIA, het NVIDIA-logo, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX en HGX zijn handelsmerken en/of gedeponeerde handelsmerken van NVIDIA Corporation in de VS en andere landen. AMD, het AMD Arrow-logo, EPYC, Instinct, Ryzen en Threadripper zijn handelsmerken van Advanced Micro Devices, Inc. Dell en PowerEdge zijn handelsmerken van Dell Inc. of haar dochterondernemingen. Intel en Xeon zijn handelsmerken van Intel Corporation of haar dochterondernemingen. AMAX, AceleMax en LiquidMax zijn handelsmerken van AMAX Engineering Corporation. Alle andere productnamen, logo's en merken zijn eigendom van hun respectieve eigenaren. Wij gebruiken ze uitsluitend om de producten aan te duiden die wij beschrijven, leveren of ondersteunen; het gebruik ervan betekent niet dat de eigenaren ons onderschrijven.

Home / Technische notities / Technology
AISecurityArchitectureAI Agents

AI-gebruiksbeleid als code: bouw een LLM-gateway met PII-redactie, tool-allowlists en telemetrie

Dicht het tekort aan AI-richtlijnen in code: een geversioneerd beleidsbestand, een OpenAI-compatibele FastAPI-gateway, redactie met Presidio, allowlists voor tools en MCP per team, red-team-tests, een auditlog, Prometheus-metrics en een gebruiksrapport

16 november 2026Technology29 min read

De meeste organisaties hebben al medewerkers die AI gebruiken zonder richtlijnen, en veel organisaties rollen nu interne assistenten en agents uit. Deze technote zet een AI-gebruiksbeleid om in code die u kunt draaien: een kleine OpenAI-compatibele gateway in Python die elk verzoek toetst aan een geversioneerd beleidsbestand, persoonsgegevens redigeert met Microsoft Presidio, tools en MCP-servers per team op een allowlist zet, elke beslissing logt en het gebruik telt, zodat u ziet waar nog richtlijnen ontbreken. Alle code hieronder is op 16 november 2026 uitgevoerd en getest.

Een beleidsbestand in YAML dat een gateway voedt die verzoeken controleert, redigeert en logt voordat ze externe of private modellen bereiken.

Samenvatting. Plaats één gateway tussen uw mensen, apps en agents en elk model dat ze gebruiken. Schrijf het beleid als een YAML-bestand dat net als code wordt gereviewd: welke teams welke dataklassen naar welke modellen mogen sturen, en welke tools elk team aan een agent mag geven. De gateway dwingt het af, vervangt e-mailadressen, National Insurance-nummers, kaartnummers en dergelijke door placeholders voordat er iets naar buiten gaat, blokkeert met een melding die naar het beleid linkt en schrijft per verzoek een JSON-auditregel en Prometheus-metrics. Red-team-tests in pytest bewijzen dat de regels standhouden, en een kort rapport laat zien welke teams tegen blokkades aanlopen of persoonsgegevens plakken: daar moet de training vervolgens naartoe. Ongeveer 250 regels Python; de tabel met alternatieven behandelt wanneer u beter LiteLLM, Envoy AI Gateway of NeMo Guardrails kunt gebruiken.

Deze technote hoort bij onze blogpost The AI guidance gap: use outpaces training at school and at work, die het onderzoek behandelt (79% van de leerlingen gebruikt AI voor huiswerk, 47% kreeg uitleg hoe, volgens onderzoek van ThinkYoung dat OpenAI aanhaalt [1]) en het zakelijke draaiboek. Hier bouwen we de technische helft.

Voor wie dit is, wat u bouwt, vereisten

Voor wie het is: platform-, ML- en security-engineers die de opdracht krijgen om "mensen veilig AI te laten gebruiken" in een bedrijf, of om guardrails rond een interne assistent of agent te zetten voordat die echte gebruikers bereikt.

Wat u bouwt:

  • policy.yaml: het AI-gebruiksbeleid als code (dataklassen, modellen, teams, tools, limieten).
  • Een FastAPI-gateway die /v1/chat/completions aanbiedt, zodat elke OpenAI-compatibele SDK, IDE-plug-in of agentframework werkt door alleen de base-URL te wijzigen.
  • Redactie van persoonsgegevens met Presidio, inclusief de recogniser voor het Britse National Insurance-nummer.
  • Controles op tools en MCP: allowlists van tools per team, een controle op de tools die het model daadwerkelijk aanroept, een vlag voor menselijke goedkeuring bij schrijvende tools en een read-only MCP-server.
  • Red-team-tests in pytest, een JSON-auditlog, Prometheus-metrics en een rapport "waar ontbreken richtlijnen".
  • Een container-image en notities voor productie.

Vereisten: Python 3.12 (spaCy, dat Presidio gebruikt, liet zich bij onze test niet installeren op Python 3.15), basiskennis van FastAPI en een OpenAI-compatibel modelendpoint (een gehoste API, of vLLM of Ollama voor private modellen) of het mockmodel hieronder. Voor de gateway zelf is geen GPU nodig. Geteste versies: FastAPI 0.163.1, uvicorn 0.54.0, httpx 0.28.1, presidio-analyzer en presidio-anonymizer 2.2.366, spaCy 3.8.18 met en_core_web_sm 3.8.0, prometheus-client 0.26.0, mcp 2.3.0, pytest 9.2.0.

1. Architectuur

Elk verzoek doorloopt in de gateway vier stappen: de aanroeper authenticeren en diens team bepalen; het beleid controleren; redigeren wat de dataklasse vereist; doorsturen naar het juiste upstream-model. Het antwoord komt terug via een vijfde stap die controleert welke tools het model wilde aanroepen. Elk verzoek levert één auditregel op en werkt tellers bij.

Clients zoals SDK's, IDE-assistenten en agents sturen verzoeken naar de gateway, die authenticeert, het beleid controleert, redigeert en routeert naar een extern of een privé model; elk verzoek schrijft naar een auditlog en Prometheus-metrics.
Eén gateway tussen elke client en elk model. Het beleidsbestand is de enige plek waar regels staan.

Waarom een gateway en geen regels in elke app? Omdat het tekort aan richtlijnen een organisatorisch probleem is. Als tien teams elk een assistent bouwen, krijgt u tien interpretaties van het beleid en geen centraal overzicht van het gebruik. Een gateway geeft één handhavingspunt, één log en één set cijfers, en bestaande tools hebben alleen een andere base-URL nodig.

2. Het project opzetten

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

De laatste regel van requirements.txt installeert het kleine Engelse spaCy-model als vastgepinde wheel, zodat builds reproduceerbaar zijn en geen python -m spacy download tijdens runtime nodig hebben. De download is ongeveer 13 MB; het grote model (en_core_web_lg, enkele honderden MB) vindt namen betrouwbaarder en is het testen waard als u PERSON redigeert.

3. Het beleid als code schrijven

Het beleid is ingedeeld per dataklasse, niet per tool, omdat tools maandelijks veranderen en dataklassen niet. Elke klasse noemt de modelaliassen die ze mag gebruiken en de entiteitstypen die moeten worden geredigeerd. Teams krijgen een plafond (de hoogste dataklasse die ze mogen versturen) en een lijst met tools. Gebruikers zien aliassen zoals external-general; de echte naam van het upstream-model is configuratie die u kunt wijzigen zonder iemand opnieuw te trainen.

# 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

Behandel dit bestand als code: wijzigingen lopen via een pull request met goedkeuring van een eigenaar, het version-nummer gaat omhoog, en de tests in sectie 8 draaien in CI voordat het live gaat. Elke auditregel legt de beleidsversie vast, zodat u maanden later kunt beantwoorden "welke regels golden voor dit verzoek?".

4. Het beleid laden en afdwingen

Policy valideert het bestand bij het opstarten (onbekende namen van modellen, klassen of tools falen meteen in plaats van bij het eerste verzoek) en decide() geeft een Decision of een PolicyError terug met een stabiele redencode. Die codes worden labels van metrics, dus houd ze kort en vast.

# 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,
        )
Beslisstroom: is het team bekend, valt de dataklasse binnen het plafond van het team, is het model toegestaan voor de dataklasse, staan alle gedeclareerde tools op de lijst van het team; elk nee geeft een 403 met een redencode en een link naar het beleid; allemaal ja leidt tot redactie en doorsturen.
De volgorde van de controles in decide(). Elk "nee" heeft een eigen redencode, en die telt het gebruiksrapport later.

5. Persoonsgegevens redigeren met Presidio

De analyzer van Presidio combineert een spaCy-model voor named entities met patroonherkenners (reguliere expressies plus checksums of contextwoorden) en geeft spans met betrouwbaarheidsscores terug; de anonymizer vervangt ze [2]. We vragen alleen om de entiteitstypen die de dataklasse noemt, wat de meeste false positives voorkomt.

# 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

Drie dingen die we bij het testen ontdekten, allemaal de moeite waard om te weten voordat u erop vertrouwt:

  • De recogniser voor het Britse National Insurance-nummer wordt met Presidio meegeleverd, maar niet standaard geladen. Dat geldt ook voor de andere Britse recognisers (paspoort, rijbewijs, postcode, kenteken). Voeg toe wat u nodig hebt met registry.add_recognizer(), zoals hierboven.
  • De e-mailrecogniser valideert het topleveldomein. jane.doe@example.test wordt niet herkend omdat .test geen publiek suffix is; jane.doe@example.eu wel. Gebruik realistische testdata, anders slagen uw tests om de verkeerde reden.
  • Het kleine spaCy-model is onrustig als u om alles vraagt. Zonder entiteitenlijst markeerde het "Email" als persoon en delen van een telefoonnummer als datums. Beperk de entiteiten per dataklasse en houd een scoredrempel aan (wij gebruiken 0.4). Een Brits mobiel nummer in internationale notatie (eerst de landcode, met spaties) werd bij die drempel in onze test niet gevangen, dus beschouw de redactie van telefoonnummers niet als volledig.

6. De gateway

De gateway spreekt het chat-completions-formaat van OpenAI, omdat bijna elke SDK, IDE-assistent en elk agentframework ernaar kan verwijzen. Hij hasht de prompt voor het auditlog in plaats van die op te slaan, begrenst max_tokens, vervangt de alias door de echte modelnaam en controleert de tool calls in het antwoord, niet alleen de tools die de client declareerde.

# 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

Toelichting bij de keuzes:

  • Authenticatie. GATEWAY_KEYS koppelt een sleutel aan een team, zodat u het binnen enkele minuten kunt uitproberen. Zet de gateway in productie achter uw identity provider (bijvoorbeeld oauth2-proxy of uw API-gateway die een OIDC-token valideert) en haal team en gebruiker uit geverifieerde claims, niet uit headers.
  • Dataklasse. De aanroeper declareert die in X-Data-Class, standaard internal. Dat is eerlijk over een lastig probleem: alleen de aanroepende app weet wat hij verstuurt. Geef waar mogelijk elke app een eigen sleutel met een vaste klasse, en gebruik redactie als vangnet, niet als primaire controle.
  • Streaming wordt geweigerd met een duidelijke foutmelding. Tool calls controleren en gebruik loggen bij een stream vereist dat het antwoord wordt gebufferd of tijdens het doorstromen wordt geparsed; voeg dat toe zodra de basis werkt.
  • Geblokkeerde verzoeken bereiken nooit een model, en de foutmelding bevat de reden, de beleidsversie en een link naar de richtlijnen. Die melding is training op het moment dat die nodig is.

7. Lokaal draaien

Gebruik om het zonder API-sleutel uit te proberen een vervangend model dat terugstuurt wat het ontving, zodat u precies ziet wat het gebouw zou hebben verlaten.

# 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."}]}'

Verwachte output (ingekort). Het model zag alleen placeholders:

{
  "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}
}

Stuur nu als finance vertrouwelijke data naar het externe model:

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}}

Bestaande code heeft alleen een nieuwe base-URL nodig. Met de officiële OpenAI Python SDK (wij testten 3.51.0) is het extra veld gateway van de gateway beschikbaar via model_extra:

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}, …}

Valkuil: op onze testmachine luisterde al een ander proces via IPv6 op poort 8080, waardoor curl localhost:8080 de verkeerde server bereikte en de SDK een 404 kreeg. Gebruik bij lokaal testen 127.0.0.1 en een vrije poort.

8. Agents en MCP: tools op een allowlist met afgebakende rechten

Een agent is een model dat tools kan aanroepen, en het Model Context Protocol (MCP) is de gangbare manier om tools aan te sluiten. Agents hebben drie controlelagen nodig, omdat geen enkele laag alles ziet.

Drie controlelagen voor agents: de client laadt alleen MCP-servers op de allowlist; de gateway controleert gedeclareerde tools en de tools die het model daadwerkelijk aanroept, en markeert schrijvende tools voor goedkeuring; elke MCP-server draait met minimale rechten, zoals een read-only databaseverbinding.
Defence in depth voor agents. De gateway ziet de intentie (tool calls); alleen de eigen credentials van de MCP-server begrenzen wat er werkelijk gebeurt.

Laag 1, de client: beperk welke MCP-servers assistenten mogen laden. Voor Claude Code stellen beheerders een allowlist in via managed settings; met allowManagedMcpServersOnly kunnen gebruikers die niet verruimen, en remote servers moeten overeenkomen met een serverUrl-patroon [7]:

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

Dezelfde documentatie waarschuwt dat matchen op serverName geen beveiligingsmaatregel is, omdat gebruikers de naam kiezen; match in plaats daarvan op URL of commando [7]. Andere clients hebben hun eigen equivalenten; controleer die vóór de uitrol.

Laag 2, de gateway: zit al in de code hierboven. Een verzoek dat een tool buiten de lijst van het team declareert, krijgt 403 tool_not_allowed; een antwoord waarin het model een tool aanroept die het niet had gekregen, wordt vervangen door 502 model_called_unapproved_tool; en een aanroep van een tool die is gemarkeerd met requires_approval wordt teruggegeven met approval_required ingesteld, die uw agent-runtime vóór uitvoering naar een mens moet routeren.

Laag 3, de tool zelf: geef elke MCP-server de minimale credentials die werken. Deze read-only documentatieserver gebruikt de MCP Python SDK 2.x. Let op: 2.x hernoemde FastMCP naar MCPServer en gebruikt veldnamen in snake_case, dus veel 1.x-voorbeelden online laten zich niet meer importeren.

# 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")

De annotatie read_only_hint vertelt clients dat de tool niets wijzigt, maar het is een hint. De garantie is mode=ro: het proces kan niet schrijven, zelfs niet als het model daarom vraagt. Test het in het geheugen, zonder netwerk:

# 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'}]}

Draai het als dienst met python docs_mcp.py; standaard serveert het streamable HTTP op http://127.0.0.1:8000/mcp, dat we ook met succes aanriepen met mcp.Client [8].

9. Testen: guardrail- en red-team-tests

Guardrails die u niet hebt getest, zijn gissingen. De tests hieronder gebruiken httpx.MockTransport als upstream, die precies vastlegt wat naar een model zou zijn gestuurd, zodat een test kan vaststellen dat een geheim nooit naar buiten ging. De cases staan in YAML, zodat mensen die het beleid schrijven cases kunnen toevoegen zonder Python te schrijven. Elke case is een verzoek dat een goedbedoelende maar ongetrainde collega zou kunnen sturen.

# 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

Deze tests controleren de deterministische regels van de gateway. Ze testen het model niet. Voeg voor modelgedrag (prompt injection via opgehaalde documenten, jailbreaks, onveilige output) een aparte evaluatiesuite toe die tegen uw echte upstream draait: een vaste set adversariële prompts en documenten met verwachte uitkomsten, gescoord bij elke wijziging van model of prompt. De OWASP Top 10 for LLM Applications 2025 is een goede checklist voor wat u moet dekken, met name prompt injection (LLM01), openbaarmaking van gevoelige informatie (LLM02) en excessive agency (LLM06) [5]. Draai de guardrail-tests in CI bij elke beleidswijziging.

10. Gebruikstelemetrie: zie waar richtlijnen ontbreken

De gateway produceert twee stromen. Prometheus-tellers voor dashboards en alerts:

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

(De metrics-app is gemount op /metrics, dat doorverwijst naar /metrics/; Prometheus volgt de redirect, of scrape /metrics/ direct.) En één JSON-regel per verzoek, zonder prompttekst:

{"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}

Het rapport maakt van dat log de vraag waar de business om geeft: welke teams hebben richtlijnen nodig, en waarover?

# 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
Een kringloop: de gateway logt en telt verzoeken; een wekelijks rapport toont blokkades, redacties en ongelabeld gebruik per team; de beleidseigenaar zet dat om in gerichte training, een beleidswijziging of een nieuwe goedgekeurde tool; de wijziging gaat live als nieuwe beleidsversie; en de gateway meet opnieuw.
Telemetrie sluit de kringloop. Blokkades en redacties zijn signalen van ontbrekende richtlijnen, geen overtredingen.

Hoe u het leest: een team met veel model_not_allowed-blokkades wil een mogelijkheid die het beleid niet biedt (misschien een privé model voor vertrouwelijk werk). Veel redacties betekenen dat mensen persoonsgegevens plakken, dus hun training moet behandelen wat ze moeten weghalen. Veel ongelabeld gebruik betekent dat u niet weet waarvoor AI wordt gebruikt, dus vraag het. Combineer dit met kwaliteitsmaten; het engineeringteam van Google meldt dat het acceptatiepercentages bijhoudt en online A/B-experimenten draait, omdat offline metrics "are often only rough proxies of user value" [6].

11. In productie draaien

# 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"]

Bouw met een .dockerignore die alleen requirements.txt, gateway/ en policy.yaml toelaat. We hebben dit image gebouwd en gedraaid: het start in enkele seconden, /healthz antwoordt en beleidsblokkades werken. Het is ongeveer 760 MB, grotendeels spaCy en zijn afhankelijkheden.

  • CPU, geen GPU. De gateway en Presidio draaien op CPU. Redactie met het kleine model kostte op onze testmachine ongeveer 5 ms voor een prompt van twee regels en ongeveer 170 ms voor een prompt van 1.000 woorden, en het groeit met de lengte van de prompt; meet met uw eigen prompts en voeg CPU toe voordat u workers toevoegt.
  • Schaal met replica's, elk met één worker. prometheus_client houdt tellers per proces bij. Met meerdere uvicorn-workers in één container hebt u de multiprocess-modus nodig; één worker per pod en meer pods is eenvoudiger.
  • Kubernetes. Gebruik /healthz voor readiness en liveness, mount policy.yaml vanuit een ConfigMap die uit uw repository wordt gebouwd, en haal upstream-sleutels uit uw secret store. Gebruik een network policy zodat alleen de gateway de modelendpoints kan bereiken; anders gaan mensen eromheen.
  • Auditlog. Stuur stdout naar uw logplatform. Het bevat gebruikers-ID's en is daarmee zelf persoonsgegevens: stel een bewaartermijn in, beperk de toegang en voeg geen prompttekst toe, tenzij u een rechtmatige grondslag en een korte bewaartermijn hebt.
  • Private modellen. Laat INTERNAL_LLM_URL verwijzen naar een OpenAI-compatibele server die u zelf host, zoals vLLM of Ollama, zodat vertrouwelijk werk uw netwerk nooit verlaat.
  • Latency en storingen. De gateway ligt nu op het kritieke pad. Draai minstens twee replica's, stel upstream-timeouts in (hier 60 seconden) en alert op outcome="upstream_error".

12. Valkuilen en debuggen

  • Een guardrail-test slaagt, maar er lekt nog steeds data: controleer of uw testdata detecteerbaar is (het geval met het .test-e-mailadres) en toets op wat de mock-upstream ontving, niet op het antwoord.
  • ModuleNotFoundError: mcp.server.fastmcp: u hebt de MCP SDK 2.x; importeer MCPServer uit mcp.server.mcpserver, of pin mcp<2 voor 1.x-code.
  • Luidruchtige Presidio-waarschuwingen bij het opstarten over Italiaanse, Spaanse of Poolse recognisers zijn onschuldig; ze worden overgeslagen omdat het register alleen Engels is. Wij zetten de logger presidio-analyzer op ERROR.
  • Alles wordt geblokkeerd met unknown_team: de sleutel in GATEWAY_KEYS verwijst naar een teamnaam die niet in policy.yaml staat.
  • Mensen gaan om de gateway heen: maak die het enige netwerkpad naar model-API's, en maak de goedgekeurde tools goed genoeg dat niemand dat wil.
  • Berichten uit meerdere delen (afbeeldingen plus tekst): de redactor schoont alleen tekstdelen op. Blokkeer afbeeldingsinput voor klassen boven public totdat u afbeeldingsverwerking toevoegt.

13. Alternatieven

OptieWat het isKies het wanneerLet op
Deze gateway (ongeveer 250 regels)FastAPI, Presidio, YAML-beleid, PrometheusU elke regel wilt kunnen lezen, binnen een dag wilt starten en vrij wilt uitbreidenStreaming, budgetten, retries en eigenaardigheden van providers zijn uw verantwoordelijkheid
LiteLLM proxyOpen-source OpenAI-compatibele proxy voor veel providersU veel providers, virtuele sleutels en uitgavenlimieten nodig hebt; het heeft een Presidio-PII-guardrail [4]Groot configuratieoppervlak; controleer welke guardrails in welke modus draaien
Envoy AI Gateway (hernoemd tot Agent Router)Open-source control plane voor AI- en agentverkeer, gebouwd op Envoy Gateway voor KubernetesU al Envoy of de Gateway API draait en routering, rate limits en authenticatie aan de rand wiltBeleidslogica buiten routering zit in extensies die u zelf schrijft
NVIDIA NeMo GuardrailsOpen-source library met programmeerbare input-, output- en dialoograilsU conversatieregels, onderwerpcontrole of factcheck-rails binnen één app nodig hebtEen library binnen uw app, geen bedrijfsbreed knelpunt
Veiligheidsclassifiers (bijvoorbeeld Llama Guard)Een model dat prompts of antwoorden als veilig of onveilig labeltU naast dataregels ook screening op contentveiligheid nodig hebtVoegt latency en een extra te draaien model toe; vult beleidscontroles aan, vervangt ze niet
Beheerinstellingen van leveranciersEnterprise-instellingen in uw AI-assistentproductenU maar één of twee producten van leveranciers gebruiktElke leverancier is een apart beleid en log; geen centraal overzicht

Deze opties sluiten elkaar niet uit. Een gangbaar patroon is LiteLLM of Envoy voor routering naar providers en sleutels, een dunne beleidsdienst zoals deze voor uw regels per dataklasse, en een classifier voor contentveiligheid.

14. Veelgestelde vragen

Maakt redactie het veilig om vertrouwelijke data naar een extern model te sturen? Nee. Detectie mist dingen, en context kan een persoon identificeren, zelfs zonder naam. Daarom routeert het voorbeeldbeleid vertrouwelijke data alleen naar het private model, en is redactie het vangnet.

Gaan tools die OpenAI-antwoorden verwachten erdoor stuk? Niet in onze test met de OpenAI SDK: we voegen één extra veld op het hoogste niveau toe (gateway) en vervangen de modelnaam door de alias. Strikte clients die onbekende velden weigeren zijn zeldzaam, maar test de uwe.

Kan ik het gebruiken met Anthropic, Google of andere providers? Ja, via elk OpenAI-compatibel endpoint, of door LiteLLM als upstream achter deze gateway te zetten, zodat deze laag uw beleid bewaakt en LiteLLM de API's van de providers afhandelt.

Hoe helpt dit bij de EU AI Act? Artikel 4 vraagt aanbieders en gebruiksverantwoordelijken maatregelen te nemen om de AI-geletterdheid van hun personeel te ondersteunen [3]. Een gateway traint niemand, maar de blokkademeldingen, beleidsversies en gebruiksrapporten zijn bewijs van de maatregelen die u hebt genomen en laten zien waar nog training nodig is.

Moeten we prompts loggen voor onderzoeken? Ga standaard uit van hashes en metadata. Als u inhoud moet bewaren, bewaar die dan kort, versleuteld en met beperkte toegang; anders wordt het auditlog uw grootste opslag van persoonsgegevens.

Hoe zit het met agents die handelen zonder chatverzoek? Routeer hun modelaanroepen via de gateway zoals elke andere client, en dwing toolscopes af in de MCP-servers (laag 3). De goedkeuringsvlag werkt alleen als uw agent-runtime die respecteert, dus test dat pad expliciet.

Wilt u dit laten draaien tegen private modellen op uw eigen infrastructuur, dan bouwt en beheert ons team voor private AI gateways, modelhosting en de monitoring daarachter voor Britse organisaties.

Referenties

  1. Closing the AI guidance gap in education, OpenAI, 10 november 2026 (met verwijzing naar onderzoek van ThinkYoung).
  2. Documentatie van Microsoft Presidio en broncode (analyzer, anonymizer, vooraf gedefinieerde recognisers, waaronder UkNinoRecognizer).
  3. EU AI Act, artikel 4: AI-geletterdheid, zoals bijgesteld door de Digital Omnibus van juli 2026.
  4. LiteLLM: PII masking with Presidio, documentatie van LiteLLM.
  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, documentatie van Claude Code.
  8. MCP Python SDK (2.x: MCPServer, Client) en de overdracht van MCP aan de Agentic AI Foundation, Anthropic, 9 december 2025.
  9. Documentatie van FastAPI, uvicorn (application factories) en de Prometheus Python client.
Deel dit artikel

Meer in Technology

AI-developerlaptops: LLM's lokaal draaien onder Linux met GPU's van 16 GB en 24 GB (gids 2026)

AI-developerlaptops: LLM's lokaal draaien onder Linux met GPU's van 16 GB en 24 GB (gids 2026)

Wat er past op een RTX 5080 of RTX 5090 Laptop GPU, de geheugenberekening, de open modellen die de moeite waard zijn, Ubuntu 26.04 inrichten met de NVIDIA-stack, Ollama, llama.cpp en vLLM, codeerassistenten, LoRA-fine-tuning, beveiliging, en wanneer werk naar een server moet

Lees meer
ML- en LLM-systemen testen die u niet correct kunt bewijzen: een Python-kit voor bewijsmateriaal

ML- en LLM-systemen testen die u niet correct kunt bewijzen: een Python-kit voor bewijsmateriaal

Bewijsmateriaal in plaats van bewijzen, in ongeveer 400 regels Python met echte output: slice-metrics met bootstrap-intervallen en een pass/fail-contract, property- en metamorfe tests met Hypothesis, kalibratie en conformal prediction, Pydantic-contracten en regressie-evals voor LLM-output, driftcontroles, een CI-gate en exacte verificatie van een klein neuraal netwerk

Lees meer
TorchCurves in de praktijk: leerbare B-spline- en Legendre-curves in PyTorch

TorchCurves in de praktijk: leerbare B-spline- en Legendre-curves in PyTorch

torchcurves installeren, een curve fitten en dimensioneren, kiezen tussen B-spline en Legendre en de input map, een monotone kalibratiecurve en een additief model op tabeldata bouwen, vergelijken met SciPy, scikit-learn, een KAN en een MLP, coëfficiënten naar JSON exporteren, testen en in productie draaien, met echte output

Lees meer