La boutique est ouverte

Nous construisons les machines Workstation AI pour les sites web, les agents IA et l'entraînement de LLM — configurez-les et achetez-les en ligne.

Obtenir les prix pro
Produits IA
Labs IAAgents OpenAIAgents ClaudeGrok BotCRM natif Workstation AIMarketingTous les produits
Solutions IA
IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseStations de travail IAMatériel et logiciels NVIDIACalcul accéléré NVIDIAIA privéeCloud privé GPUClusters GPUIA en périphérieIA par secteur
Services IA
Modernisation des plateformesIngénierie numériqueFondations data et IAOpérations autonomesConseil IAAutomatisation DevOpsCybersécuritéDéveloppement logicielCréation d'agentsMise en place MLOpsLocation de GPUCloud privé GPU
À propos
EntrepriseNotre histoirePartenairesTémoignages clients
Centres de données IA
Centres de données IACloud privé GPUClusters GPULocation de GPU
Analyses IASérie JevLabo de benchmarksChoix de modèles
Notes techniques
Documentation
OS LinuxUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
Plateformes cloud d'IAAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryClouds et places de marché GPU
Centres de données IA privésPour les cabinets d'avocatsPour les cabinets comptablesPlateformes sur siteCloud entièrement sécurisé
OutilsRing PromoterJobshout
Actualités
Blog
Nous contacterSe connecter

Stations de travail IA, logiciels multi-agents IA, infrastructure GPU et solutions d'agents intelligents pour les entreprises modernes.

Nous contacter

Solutions IA

IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseIA par secteur

Produits

Tous les produitsCRM & ERP natifs Workstation AIMarketingAgents OpenAIRing PromoterJobshout

Entreprise

À proposEntrepriseCentres de données IAPourquoi WorkstationPartenairesTémoignages clientsTarifsContactTenthMatrix

Ressources

Analyses IANotes techniquesDocumentationOS LinuxPlateformes cloud d'IACentres de données IA privésBlogRechercherPlan du site
Bureau de Belgique
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Lun - Ven : 9h00 - 18h00 CET
+32 492 45 67 46
Siège social au Royaume-Uni
77-79 Marlowes, Hemel Hempstead HP1 1LFItinéraire : prenez la sortie 20 de la M25, Outer LondonN° d'entreprise: 11641870Lun - Ven : 9h00 - 18h00 GMT
+44 7515 356 146
Bureau de l'Inde
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Bureau de Taïwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Lun - Ven : 9 h 00 - 18 h 00, heure de Taïwan (GMT+8)
+886 926 892 701+32 492 45 67 46
Bureau en Estonie
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaLun - Ven : 9 h 00 - 18 h 00, heure d’Estonie (EET)
+32 492 45 67 46

© 2026 Workstation AI. Tous droits réservés.

ConfidentialitéSuppression des donnéesCookiesConditions d'utilisationPlan du site web

NVIDIA, le logo NVIDIA, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX et HGX sont des marques commerciales et/ou des marques déposées de NVIDIA Corporation aux États-Unis et dans d'autres pays. AMD, le logo AMD Arrow, EPYC, Instinct, Ryzen et Threadripper sont des marques commerciales d'Advanced Micro Devices, Inc. Dell et PowerEdge sont des marques commerciales de Dell Inc. ou de ses filiales. Intel et Xeon sont des marques commerciales d'Intel Corporation ou de ses filiales. AMAX, AceleMax et LiquidMax sont des marques commerciales d'AMAX Engineering Corporation. Tous les autres noms de produits, logos et marques appartiennent à leurs propriétaires respectifs. Nous les utilisons uniquement pour identifier les produits que nous décrivons, fournissons ou prenons en charge ; leur utilisation ne signifie pas que leurs propriétaires nous cautionnent.

Accueil / Notes techniques / Technology
AISecurityArchitectureAI Agents

Politique d'utilisation de l'IA sous forme de code : construire une passerelle LLM avec caviardage des données personnelles, listes d'autorisation d'outils et télémétrie

Combler le fossé des consignes sur l'IA dans le code : un fichier de politique versionné, une passerelle FastAPI compatible OpenAI, le caviardage avec Presidio, des listes d'autorisation d'outils et de serveurs MCP par équipe, des tests de red team, un journal d'audit, des métriques Prometheus et un rapport d'utilisation

16 novembre 2026Technology32 min read

La plupart des organisations ont déjà des collaborateurs qui utilisent l'IA sans aucune consigne, et beaucoup déploient désormais des assistants et des agents internes. Cette note technique transforme une politique d'utilisation de l'IA en code exécutable : une petite passerelle compatible OpenAI écrite en Python, qui contrôle chaque requête au regard d'un fichier de politique versionné, caviarde les données personnelles avec Microsoft Presidio, établit des listes d'autorisation d'outils et de serveurs MCP par équipe, journalise chaque décision et comptabilise l'utilisation, afin que vous puissiez voir où des consignes font encore défaut. Tout le code ci-dessous a été exécuté et testé le 16 novembre 2026.

Un fichier de politique en YAML alimentant une passerelle qui contrôle, caviarde et journalise les requêtes avant qu'elles n'atteignent des modèles externes ou privés.

Synthèse. Placez une passerelle unique entre vos collaborateurs, vos applications et vos agents d'une part, et tous les modèles qu'ils utilisent d'autre part. Rédigez la politique sous forme de fichier YAML relu comme du code : quelles équipes peuvent envoyer quelles classes de données à quels modèles, et quels outils chaque équipe peut confier à un agent. La passerelle l'applique, remplace par des marqueurs les adresses e-mail, numéros de National Insurance, numéros de carte et données similaires avant que quoi que ce soit ne sorte, bloque avec un message renvoyant à la politique, et écrit une ligne d'audit JSON et des métriques Prometheus pour chaque requête. Des tests de red team avec pytest prouvent que les règles tiennent, et un court rapport montre quelles équipes se heurtent à des blocages ou collent des données personnelles : c'est là que la formation doit porter en priorité. Environ 250 lignes de Python ; le tableau des alternatives indique quand utiliser plutôt LiteLLM, Envoy AI Gateway ou NeMo Guardrails.

Cette note technique accompagne notre article de blog Le fossé des consignes sur l'IA : l'usage dépasse la formation, à l'école comme au travail, qui présente les études (79 % des élèves utilisent l'IA pour leurs devoirs, 47 % ont appris à le faire, selon une étude de ThinkYoung citée par OpenAI [1]) et le guide d'action pour les entreprises. Nous construisons ici la partie technique.

À qui s'adresse ce guide, ce que vous allez construire, prérequis

À qui il s'adresse : ingénieurs plateforme, ML et sécurité à qui l'on a demandé de « permettre aux gens d'utiliser l'IA en toute sécurité » dans toute l'entreprise, ou de poser des garde-fous autour d'un assistant ou d'un agent interne avant qu'il n'atteigne de vrais utilisateurs.

Ce que vous allez construire :

  • policy.yaml : la politique d'utilisation de l'IA sous forme de code (classes de données, modèles, équipes, outils, limites).
  • Une passerelle FastAPI exposant /v1/chat/completions, de sorte que n'importe quel SDK compatible OpenAI, plug-in d'IDE ou framework d'agents fonctionne en changeant simplement son URL de base.
  • Le caviardage des données personnelles avec Presidio, y compris le module de reconnaissance du numéro de National Insurance britannique.
  • Des contrôles des outils et de MCP : listes d'autorisation d'outils par équipe, vérification des outils réellement appelés par le modèle, indicateur d'approbation humaine pour les outils d'écriture, et un serveur MCP en lecture seule.
  • Des tests de red team avec pytest, un journal d'audit JSON, des métriques Prometheus et un rapport « où les consignes font-elles défaut ».
  • Une image de conteneur et des notes pour la production.

Prérequis : Python 3.12 (spaCy, qu'utilise Presidio, ne s'installait pas sous Python 3.15 lors de nos tests), des bases de FastAPI, et soit un endpoint de modèle compatible OpenAI (une API hébergée, ou vLLM ou Ollama pour des modèles privés), soit le modèle factice ci-dessous. La passerelle elle-même n'a besoin d'aucun GPU. Versions testées : FastAPI 0.163.1, uvicorn 0.54.0, httpx 0.28.1, presidio-analyzer et presidio-anonymizer 2.2.366, spaCy 3.8.18 avec en_core_web_sm 3.8.0, prometheus-client 0.26.0, mcp 2.3.0, pytest 9.2.0.

1. Architecture

Chaque requête passe par quatre étapes dans la passerelle : authentifier l'appelant et identifier son équipe ; contrôler la politique ; caviarder ce qu'exige la classe de données ; transmettre au bon modèle en amont. La réponse revient par une cinquième étape qui vérifie quels outils le modèle a demandé d'appeler. Chaque requête produit une ligne d'audit et met à jour des compteurs.

Des clients tels que des SDK, des assistants d'IDE et des agents envoient des requêtes à la passerelle, qui authentifie, contrôle la politique, caviarde et achemine vers un modèle externe ou un modèle privé ; chaque requête écrit dans un journal d'audit et dans des métriques Prometheus.
Une passerelle unique entre chaque client et chaque modèle. Le fichier de politique est le seul endroit où résident les règles.

Pourquoi une passerelle plutôt que des règles dans chaque application ? Parce que le fossé des consignes est organisationnel. Si dix équipes construisent chacune un assistant, vous obtenez dix interprétations de la politique et aucune vue d'ensemble de l'utilisation. Une passerelle offre un point d'application unique, un journal unique et un seul jeu de chiffres, et les outils existants n'ont besoin que d'un changement d'URL de base.

2. Mettre en place le projet

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

La dernière ligne de requirements.txt installe le petit modèle spaCy anglais sous forme de wheel figée, de sorte que les builds sont reproductibles et ne nécessitent pas python -m spacy download à l'exécution. Le téléchargement fait environ 13 Mo ; le grand modèle (en_core_web_lg, plusieurs centaines de Mo) détecte les noms de manière plus fiable et mérite d'être testé si vous caviardez PERSON.

3. Écrire la politique sous forme de code

La politique est organisée par classe de données, et non par outil, car les outils changent tous les mois, pas les classes de données. Chaque classe liste les alias de modèles qu'elle peut utiliser et les types d'entités à caviarder. Les équipes se voient attribuer un plafond (la classe de données la plus élevée qu'elles peuvent envoyer) et une liste d'outils. Les utilisateurs voient des alias comme external-general ; le nom réel du modèle en amont relève de la configuration, que vous pouvez modifier sans avoir à reformer qui que ce soit.

# 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

Traitez ce fichier comme du code : les modifications passent par une pull request approuvée par un responsable, le numéro de version est incrémenté, et les tests de la section 8 s'exécutent en CI avant la mise en production. Chaque ligne d'audit enregistre la version de la politique, ce qui vous permet de répondre des mois plus tard à la question « quelles règles s'appliquaient à cette requête ? ».

4. Charger et appliquer la politique

Policy valide le fichier au démarrage (des noms de modèle, de classe ou d'outil inconnus provoquent un échec immédiat plutôt qu'à la première requête) et decide() renvoie soit une Decision, soit une PolicyError avec un code de motif stable. Ces codes deviennent des libellés de métriques : gardez-les courts et fixes.

# 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,
        )
Logique de décision : l'équipe est-elle connue, la classe de données est-elle sous le plafond de l'équipe, le modèle est-il autorisé pour la classe de données, tous les outils déclarés figurent-ils sur la liste de l'équipe ; toute réponse négative renvoie une erreur 403 avec un code de motif et un lien vers la politique ; si tout est positif, la requête est caviardée et transmise.
L'ordre des contrôles dans decide(). Chaque « non » a son propre code de motif, que le rapport d'utilisation comptabilise ensuite.

5. Caviarder les données personnelles avec Presidio

L'analyseur de Presidio combine un modèle spaCy de reconnaissance d'entités nommées et des modules de reconnaissance par motifs (expressions régulières plus sommes de contrôle ou mots de contexte) et renvoie des segments avec des scores de confiance ; l'anonymiseur les remplace [2]. Nous ne demandons que les types d'entités listés par la classe de données, ce qui évite la plupart des faux positifs.

# 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

Trois constats faits pendant nos tests, tous utiles à connaître avant de vous y fier :

  • Le module de reconnaissance du numéro de National Insurance britannique est fourni avec Presidio, mais n'est pas chargé par défaut. Les autres modules britanniques (passeport, permis de conduire, code postal, immatriculation) non plus. Ajoutez ceux dont vous avez besoin avec registry.add_recognizer(), comme ci-dessus.
  • Le module de reconnaissance des e-mails valide le domaine de premier niveau. jane.doe@example.test n'est pas détecté, car .test n'est pas un suffixe public ; jane.doe@example.eu l'est. Utilisez des données de test réalistes, sinon vos tests réussiront pour de mauvaises raisons.
  • Le petit modèle spaCy produit beaucoup de bruit si vous lui demandez tout. Sans liste d'entités, il a étiqueté « Email » comme une personne et des parties d'un numéro de téléphone comme des dates. Limitez les entités par classe de données et conservez un seuil de score (nous utilisons 0,4). Un numéro de mobile britannique écrit au format international (indicatif du pays en premier, avec des espaces) n'a pas été détecté à ce seuil lors de notre test : ne considérez donc pas le caviardage des numéros de téléphone comme exhaustif.

6. La passerelle

La passerelle utilise le format chat-completions d'OpenAI, car presque tous les SDK, assistants d'IDE et frameworks d'agents peuvent s'y connecter. Elle enregistre une empreinte du prompt dans le journal d'audit au lieu de le stocker, plafonne max_tokens, remplace l'alias par le nom réel du modèle et vérifie les appels d'outils dans la réponse, et pas seulement les outils déclarés par le client.

# 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

Remarques sur les choix effectués :

  • Authentification. GATEWAY_KEYS associe une clé à une équipe, ce qui permet d'essayer en quelques minutes. En production, placez la passerelle derrière votre fournisseur d'identité (par exemple oauth2-proxy ou votre passerelle d'API validant un jeton OIDC) et prenez l'équipe et l'utilisateur dans des claims vérifiées, pas dans des en-têtes.
  • Classe de données. L'appelant la déclare dans X-Data-Class, avec internal par défaut. C'est une réponse honnête à un problème difficile : seule l'application appelante sait ce qu'elle envoie. Attribuez si possible à chaque application sa propre clé avec une classe fixe, et considérez le caviardage comme un filet de sécurité, pas comme le contrôle principal.
  • Le streaming est refusé avec une erreur explicite. Contrôler les appels d'outils et journaliser l'utilisation sur un flux exige de mettre la réponse en mémoire tampon ou de l'analyser au fil de l'eau ; ajoutez-le une fois les bases en place.
  • Les requêtes bloquées n'atteignent jamais un modèle, et l'erreur indique le motif, la version de la politique et un lien vers les consignes. Ce message est une formation dispensée au moment précis où elle est nécessaire.

7. L'exécuter en local

Pour essayer sans clé d'API, utilisez un modèle de substitution qui renvoie ce qu'il a reçu : vous verrez exactement ce qui serait sorti de l'entreprise.

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

Sortie attendue (abrégée). Le modèle n'a jamais vu que des marqueurs :

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

Envoyez maintenant des données confidentielles au modèle externe en tant qu'équipe finance :

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

Le code existant n'a besoin que d'une nouvelle URL de base. Avec le SDK Python officiel d'OpenAI (nous avons testé la version 3.51.0), le champ supplémentaire gateway de la passerelle est disponible dans 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}, …}

Piège : sur notre machine de test, un autre processus écoutait déjà sur le port 8080 en IPv6, si bien que curl localhost:8080 atteignait le mauvais serveur et que le SDK recevait une erreur 404. Utilisez 127.0.0.1 et un port libre pour vos tests en local.

8. Agents et MCP : outils sur liste d'autorisation avec des permissions limitées

Un agent est un modèle capable d'appeler des outils, et le Model Context Protocol (MCP) est le moyen courant de brancher ces outils. Les agents nécessitent trois niveaux de contrôle, car aucun niveau ne voit tout à lui seul.

Trois niveaux de contrôle pour les agents : le client ne charge que les serveurs MCP figurant sur la liste d'autorisation ; la passerelle vérifie les outils déclarés et ceux que le modèle appelle réellement, et signale les outils d'écriture pour approbation ; chaque serveur MCP s'exécute avec des identifiants au moindre privilège, comme une connexion à une base de données en lecture seule.
Défense en profondeur pour les agents. La passerelle voit l'intention (les appels d'outils) ; seuls les propres identifiants du serveur MCP limitent ce qui se passe réellement.

Niveau 1, le client : limitez les serveurs MCP que les assistants peuvent charger. Pour Claude Code, les administrateurs définissent une liste d'autorisation dans les paramètres gérés ; avec allowManagedMcpServersOnly, les utilisateurs ne peuvent pas l'élargir, et les serveurs distants doivent correspondre à un motif serverUrl [7] :

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

La même documentation avertit que la correspondance sur serverName n'est pas un contrôle de sécurité, puisque ce sont les utilisateurs qui choisissent le nom ; utilisez plutôt l'URL ou la commande [7]. Les autres clients disposent de leurs propres équivalents ; vérifiez-les avant le déploiement.

Niveau 2, la passerelle : déjà présent dans le code ci-dessus. Une requête déclarant un outil absent de la liste de l'équipe reçoit 403 tool_not_allowed ; une réponse dans laquelle le modèle appelle un outil qui ne lui a pas été fourni est remplacée par 502 model_called_unapproved_tool ; et un appel à un outil marqué requires_approval est renvoyé avec approval_required activé, que votre environnement d'exécution d'agents doit soumettre à une personne avant exécution.

Niveau 3, l'outil lui-même : donnez à chaque serveur MCP les identifiants les plus restreints qui fonctionnent. Ce serveur de documentation en lecture seule utilise le SDK Python MCP 2.x. Notez que la version 2.x a renommé FastMCP en MCPServer et utilise des noms de champs en snake_case, si bien que de nombreux exemples 1.x trouvés en ligne ne s'importent plus.

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

L'annotation read_only_hint indique aux clients que l'outil ne modifie rien, mais ce n'est qu'une indication. La garantie vient de mode=ro : le processus ne peut pas écrire, même si le modèle le lui demande. Testez-le en mémoire, sans réseau :

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

Exécutez-le comme un service avec python docs_mcp.py ; il sert du HTTP streamable sur http://127.0.0.1:8000/mcp par défaut, que nous avons également appelé avec succès via mcp.Client [8].

9. Le tester : tests de garde-fous et de red team

Des garde-fous non testés ne sont que des suppositions. Les tests ci-dessous utilisent httpx.MockTransport comme service amont, qui enregistre exactement ce qui aurait été envoyé à un modèle : un test peut ainsi vérifier qu'un secret n'est jamais sorti. Les cas sont décrits en YAML afin que les rédacteurs de la politique puissent en ajouter sans écrire de Python. Chacun correspond à une requête qu'un collègue bien intentionné mais non formé pourrait envoyer.

# 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

Ces tests vérifient les règles déterministes de la passerelle. Ils ne testent pas le modèle. Pour le comportement du modèle (injection de prompt via des documents récupérés, jailbreaks, sorties dangereuses), ajoutez une suite d'évaluation distincte exécutée contre votre véritable service amont : un ensemble fixe de prompts et de documents malveillants avec les résultats attendus, évalué à chaque modification de modèle ou de prompt. Le Top 10 OWASP pour les applications LLM 2025 est une bonne liste de contrôle de ce qu'il faut couvrir, en particulier l'injection de prompt (LLM01), la divulgation d'informations sensibles (LLM02) et l'autonomie excessive (LLM06) [5]. Exécutez les tests de garde-fous en CI à chaque modification de la politique.

10. Télémétrie d'utilisation : voir où les consignes font défaut

La passerelle produit deux flux. Des compteurs Prometheus pour les tableaux de bord et les alertes :

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

(L'application de métriques est montée sur /metrics, qui redirige vers /metrics/ ; Prometheus suit la redirection, ou collectez directement /metrics/.) Et une ligne JSON par requête, sans le texte du prompt :

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

Le rapport transforme ce journal en réponse à la question qui intéresse l'entreprise : quelles équipes ont besoin de consignes, et sur quoi ?

# 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
Une boucle : la passerelle journalise et comptabilise les requêtes ; un rapport hebdomadaire montre les blocages, les caviardages et l'utilisation non étiquetée par équipe ; le responsable de la politique en tire une formation ciblée, une modification de la politique ou un nouvel outil approuvé ; la modification est publiée sous forme de nouvelle version de la politique ; et la passerelle mesure à nouveau.
La télémétrie boucle la boucle. Les blocages et les caviardages sont des signaux de consignes manquantes, pas des infractions.

Comment le lire : une équipe qui subit de nombreux blocages model_not_allowed a besoin d'une capacité que la politique ne fournit pas (peut-être un modèle privé pour le travail confidentiel). De nombreux caviardages signifient que des personnes collent des données personnelles : leur formation doit couvrir ce qu'il faut retirer. Une utilisation non étiquetée élevée signifie que vous ne savez pas à quoi sert l'IA : posez la question. Associez ces indicateurs à des mesures de qualité ; l'équipe d'ingénierie de Google indique suivre les taux d'acceptation et mener des expériences A/B en ligne, car les métriques hors ligne « are often only rough proxies of user value » (ne sont souvent que des approximations grossières de la valeur pour l'utilisateur) [6].

11. L'exécuter en production

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

Construisez l'image avec un .dockerignore qui n'admet que requirements.txt, gateway/ et policy.yaml. Nous avons construit et exécuté cette image : elle démarre en quelques secondes, /healthz répond et les blocages de la politique fonctionnent. Elle pèse environ 760 Mo, principalement à cause de spaCy et de ses dépendances.

  • CPU, pas GPU. La passerelle et Presidio s'exécutent sur CPU. Le caviardage avec le petit modèle a pris environ 5 ms pour un prompt de deux lignes et environ 170 ms pour un prompt de 1 000 mots sur notre machine de test, et la durée augmente avec la longueur du prompt ; mesurez avec vos propres prompts et ajoutez du CPU avant d'ajouter des workers.
  • Passez à l'échelle avec des réplicas, un worker chacun. prometheus_client tient des compteurs par processus. Avec plusieurs workers uvicorn dans un même conteneur, il vous faut son mode multiprocessus ; un worker par pod et davantage de pods, c'est plus simple.
  • Kubernetes. Utilisez /healthz pour les sondes de disponibilité et de vivacité, montez policy.yaml depuis une ConfigMap construite à partir de votre dépôt, et récupérez les clés des services amont dans votre coffre de secrets. Utilisez une network policy pour que seule la passerelle puisse atteindre les endpoints des modèles ; sinon, les gens la contourneront.
  • Journal d'audit. Envoyez stdout vers votre plateforme de journalisation. Il contient des identifiants d'utilisateurs et constitue en soi des données personnelles : fixez une durée de conservation, restreignez l'accès et n'ajoutez pas le texte des prompts sans base légale et sans durée de conservation courte.
  • Modèles privés. Faites pointer INTERNAL_LLM_URL vers n'importe quel serveur compatible OpenAI que vous hébergez, comme vLLM ou Ollama, afin que le travail confidentiel ne quitte jamais votre réseau.
  • Latence et pannes. La passerelle est désormais sur le chemin critique. Exécutez au moins deux réplicas, définissez des délais d'expiration vers les services amont (60 secondes ici) et alertez sur outcome="upstream_error".

12. Pièges et débogage

  • Un test de garde-fou réussit mais des données fuient quand même : vérifiez que vos données de test sont détectables (le cas de l'e-mail en .test) et faites porter l'assertion sur ce que le service amont factice a reçu, pas sur la réponse.
  • ModuleNotFoundError: mcp.server.fastmcp : vous avez le SDK MCP 2.x ; importez MCPServer depuis mcp.server.mcpserver, ou figez mcp<2 pour du code 1.x.
  • Les avertissements bruyants de Presidio au démarrage concernant les modules de reconnaissance italiens, espagnols ou polonais sont sans conséquence ; ils sont ignorés car le registre est uniquement anglais. Nous avons réglé le logger presidio-analyzer sur ERROR.
  • Tout est bloqué avec unknown_team : la clé dans GATEWAY_KEYS correspond à un nom d'équipe absent de policy.yaml.
  • Les gens contournent la passerelle : faites-en le seul chemin réseau vers les API des modèles, et rendez les outils approuvés suffisamment bons pour que personne n'ait envie de la contourner.
  • Messages en plusieurs parties (images plus texte) : le module de caviardage ne nettoie que les parties textuelles. Bloquez les entrées d'images pour les classes supérieures à public jusqu'à ce que vous ajoutiez la prise en charge des images.

13. Alternatives

OptionDe quoi s'agit-ilÀ choisir quandPoints de vigilance
Cette passerelle (environ 250 lignes)FastAPI, Presidio, politique YAML, PrometheusVous voulez lire chaque règle, démarrer en une journée et étendre librementLe streaming, les budgets, les nouvelles tentatives et les particularités des fournisseurs sont à votre charge
Proxy LiteLLMProxy open source compatible OpenAI pour de nombreux fournisseursVous avez besoin de nombreux fournisseurs, de clés virtuelles et de plafonds de dépenses ; il dispose d'un garde-fou de données personnelles basé sur Presidio [4]Surface de configuration importante ; vérifiez quels garde-fous s'exécutent dans quel mode
Envoy AI Gateway (renommé Agent Router)Plan de contrôle open source pour le trafic d'IA et d'agents, construit sur Envoy Gateway pour KubernetesVous exploitez déjà Envoy ou Gateway API et voulez le routage, la limitation de débit et l'authentification en périphérieLa logique de politique au-delà du routage réside dans des extensions que vous écrivez
NVIDIA NeMo GuardrailsBibliothèque open source de garde-fous programmables en entrée, en sortie et sur le dialogueVous avez besoin de règles conversationnelles, de contrôle des sujets ou de garde-fous de vérification des faits au sein d'une applicationUne bibliothèque au sein de votre application, pas un point de contrôle à l'échelle de l'entreprise
Modèles classificateurs de sécurité (par exemple Llama Guard)Un modèle qui étiquette les prompts ou les réponses comme sûrs ou dangereuxVous avez besoin d'un filtrage de la sécurité des contenus en plus des règles sur les donnéesAjoute de la latence et un modèle à exploiter ; complète les contrôles de politique sans les remplacer
Contrôles d'administration des éditeursParamètres entreprise de vos produits d'assistant IAVous n'utilisez qu'un ou deux produits d'éditeursChaque éditeur est une politique et un journal distincts ; aucune vue d'ensemble

Ces options ne s'excluent pas. Un schéma courant associe LiteLLM ou Envoy pour le routage vers les fournisseurs et les clés, un service de politique léger comme celui-ci pour vos règles par classe de données, et un classificateur pour la sécurité des contenus.

14. FAQ

Le caviardage permet-il d'envoyer sans risque des données confidentielles à un modèle externe ? Non. La détection laisse passer des éléments, et le contexte peut identifier une personne même sans son nom. C'est pourquoi la politique d'exemple n'achemine les données confidentielles que vers le modèle privé, le caviardage servant de filet de sécurité.

Cela va-t-il casser les outils qui attendent des réponses OpenAI ? Pas lors de notre test avec le SDK OpenAI : nous ajoutons un champ supplémentaire de premier niveau (gateway) et remplaçons le nom du modèle par l'alias. Les clients stricts qui rejettent les champs inconnus sont rares, mais testez le vôtre.

Puis-je l'utiliser avec Anthropic, Google ou d'autres fournisseurs ? Oui, via n'importe quel endpoint compatible OpenAI, ou en plaçant LiteLLM derrière cette passerelle comme service amont : cette couche conserve votre politique et LiteLLM gère les API des fournisseurs.

En quoi cela aide-t-il pour l'AI Act de l'UE ? L'article 4 demande aux fournisseurs et aux déployeurs de prendre des mesures pour favoriser la maîtrise de l'IA par leur personnel [3]. Une passerelle ne forme personne, mais ses messages de blocage, ses versions de politique et ses rapports d'utilisation attestent des mesures prises et montrent où la formation reste nécessaire.

Faut-il journaliser les prompts pour les enquêtes ? Par défaut, conservez des empreintes et des métadonnées. Si vous devez conserver le contenu, gardez-le peu de temps, chiffrez-le et restreignez l'accès ; sinon, le journal d'audit devient votre plus grand stock de données personnelles.

Qu'en est-il des agents qui agissent sans requête de chat ? Faites passer leurs appels au modèle par la passerelle comme pour tout autre client, et appliquez les périmètres des outils dans les serveurs MCP (niveau 3). L'indicateur d'approbation ne fonctionne que si votre environnement d'exécution d'agents le respecte : testez explicitement ce chemin.

Si vous souhaitez faire fonctionner ce dispositif avec des modèles privés sur votre propre infrastructure, notre équipe IA privée conçoit et exploite des passerelles, l'hébergement de modèles et la supervision associée pour les organisations britanniques.

Références

  1. Closing the AI guidance gap in education, OpenAI, 10 novembre 2026 (citant une étude de ThinkYoung).
  2. Documentation de Microsoft Presidio et code source (analyseur, anonymiseur, modules de reconnaissance prédéfinis, dont UkNinoRecognizer).
  3. AI Act de l'UE, article 4 : maîtrise de l'IA, tel que réajusté par l'Omnibus numérique de juillet 2026.
  4. LiteLLM : masquage des données personnelles avec Presidio, documentation de LiteLLM.
  5. Top 10 OWASP pour les applications LLM 2025, OWASP GenAI Security Project.
  6. AI in software engineering at Google: progress and the path ahead, Google Research, 6 juin 2024.
  7. Control MCP server access for your organization, documentation de Claude Code.
  8. SDK Python MCP (2.x : MCPServer, Client) et le transfert de MCP à l'Agentic AI Foundation, Anthropic, 9 décembre 2025.
  9. Documentation de FastAPI, d'uvicorn (fabriques d'applications) et du client Python Prometheus.
Partager cet article

Plus dans Technology

Portables pour développeurs IA : exécuter des LLM en local sous Linux avec des GPU de 16 GB et 24 GB (guide 2026)

Portables pour développeurs IA : exécuter des LLM en local sous Linux avec des GPU de 16 GB et 24 GB (guide 2026)

Ce qui tient sur un GPU RTX 5080 ou RTX 5090 Laptop, le calcul de mémoire, les modèles ouverts qui valent la peine, la configuration d'Ubuntu 26.04 avec la pile NVIDIA, Ollama, llama.cpp et vLLM, les assistants de code, l'affinage LoRA, la sécurité, et quand passer le travail sur un serveur

Lire la suite
Tester des systèmes ML et LLM impossibles à prouver corrects : une boîte à outils Python d'éléments probants

Tester des systèmes ML et LLM impossibles à prouver corrects : une boîte à outils Python d'éléments probants

Des éléments probants à la place des preuves, en environ 400 lignes de Python avec une sortie réelle : métriques par segment avec intervalles bootstrap et contrat de réussite ou d'échec, tests de propriétés et métamorphiques avec Hypothesis, calibration et prédiction conforme, contrats Pydantic et évaluations de non-régression pour les sorties LLM, contrôles de dérive, barrière en CI et vérification exacte d'un petit réseau de neurones

Lire la suite
TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

Installer torchcurves, ajuster et dimensionner une courbe, choisir entre B-spline et Legendre ainsi que l’application d’entrée, construire une courbe de calibration monotone et un modèle additif sur des données tabulaires, comparer avec SciPy, scikit-learn, un KAN et un MLP, exporter les coefficients en JSON, tester et exploiter en production, avec des sorties réelles

Lire la suite