Translate

Affichage des articles dont le libellé est gouvernance-IA. Afficher tous les articles
Affichage des articles dont le libellé est gouvernance-IA. Afficher tous les articles

samedi 3 octobre 2026

Prospective sur l’évolution des métiers de l’IA et de leur gouvernance.

Synthèse : les trois couches d’ingénierie IA et l’émergence d’un nouveau métier.

Ce texte met en évidence une transformation profonde : on passe du Prompt Engineering (interaction directe) → au Context Engineering (mémoire, RAG, connaissances) → au Harness Engineering (orchestration d’agents, outils, workflows).

https://gouver2020.blogspot.com/2026/09/mieux-surveiller-et-parametrer-les.html

Ces trois couches ne sont pas des spécialités isolées mais les niveaux d’un même métier, celui de l’Architecte des Systèmes Cognitifs IA, capable de concevoir des systèmes complets combinant :

  1. prompts robustes,

  2. contextes métier structurés,

  3. mémoire et taxonomies,

  4. agents IA autonomes,

  5. outils et APIs,

  6. gouvernance, sécurité, observabilité.

Le texte décrit également une pyramide de compétences allant du Prompt Engineer (L1) au niveau expert L5 : Architecte des Systèmes Cognitifs.

Prospective : comment ces métiers vont évoluer (2026–2035).

1. De l’ingénierie du prompt à l’ingénierie des boucles autonomes

La tendance déjà visible dans votre page — loop engineering — va s’accélérer.

Évolution probable

Les prompts deviennent des composants, non plus des artefacts humains. Les systèmes IA génèrent eux-mêmes leurs instructions internes. Le métier se déplace vers la conception de boucles autonomes (analyse → action → vérification → amélioration).

Conséquence métier

Le Prompt Engineer disparaît comme rôle autonome. Il devient une compétence de base, intégrée dans des rôles plus larges.

2. L’ère des systèmes cognitifs orchestrés

Le Harness Engineering devient le cœur de la valeur économique.

Évolution probable

  1. Les entreprises déploient des systèmes multi‑agents supervisés.

  2. Les workflows deviennent auto‑adaptatifs (agents qui modifient leurs propres stratégies).

  3. Les connecteurs MCP deviennent un standard d’interopérabilité.

  4. Les systèmes IA sont intégrés dans les chaînes d’exécution métier (ITSM, DevOps, finance, juridique, santé).

Conséquence métier

Apparition de rôles spécialisés :

  1. AI Orchestration Engineer (opérationnel)

  2. Agentic Systems Engineer (systèmes autonomes)

  3. Cognitive Systems Architect (vision stratégique)

Ces titres deviennent les nouveaux standards du marché.

3. La gouvernance devient une discipline centrale

Votre page insiste sur la gouvernance, la sécurité, la conformité, l’auditabilité.

Évolution probable

Les IA devront être auditables, traçables, explicables. Les organisations devront prouver la non‑hallucination et la non‑déviation des agents. Les logs signés (SHA256), les journaux d’exécution, les validations humaines obligatoires deviennent normatifs. Les rôles de gouvernance IA se professionnalisent.

Conséquence métier

Émergence de nouveaux rôles :

  1. Responsable de la Gouvernance IA

  2. Auditeur IA / NIS2 / ISO 42001

  3. Architecte de Conformité IA

  4. Superviseur Human‑in‑the‑Loop

4. L’IA devient une infrastructure : naissance du “CognitiveOps”

Comme DevOps a structuré le cloud, CognitiveOps structurera l’IA.

Évolution probable

  1. Pipelines IA versionnés, testés, monitorés.

  2. Observabilité IA (LangSmith, Phoenix, W&B) devient obligatoire.

  3. Les agents IA sont déployés comme des microservices.

  4. Les entreprises créent des centres de contrôle IA (IA Control Rooms).

Conséquence métier

Nouveaux métiers :

  • CognitiveOps Engineer

  • Agent Reliability Engineer (ARE)

  • LLM FinOps Manager (optimisation des coûts d’inférence)

5. L’IA devient un collaborateur : montée des rôles hybrides

Les agents IA deviennent des “collègues numériques”.

Évolution probable

  1. Chaque métier aura son agent spécialisé (IT, RH, juridique, finance).

  2. Les humains deviennent superviseurs, validateurs, architectes.

  3. Les compétences IA deviennent transversales : comme Excel dans les années 2000.

Conséquence métier

Apparition de rôles hybrides :

  • Business Agent Designer

  • AI Workflow Analyst

  • Cognitive Product Owner

6. Vers une certification internationale des métiers IA

Ma page propose déjà une grille L1 → L5.

https://gouver2020.blogspot.com/2026/09/mieux-surveiller-et-parametrer-les.html

GOUVERNANCES.: Cartographie des formations adaptées à la nouvelle génération de métiers de l’IA

https://gouver2020.blogspot.com/p/cartographie-des-formations-adaptees-la.html

Évolution probable

  • Normalisation ISO 42001 (management IA).

  • Certifications professionnelles structurées (comme AWS Architect).

  • Parcours de formation standardisé : Prompt → Context → Harness → Architecture → Gouvernance.

Conséquence métier

Les entreprises recruteront sur des niveaux de maturité IA plutôt que sur des diplômes.

Synthèse prospective (en une phrase)

Les métiers de l’IA évoluent d’une logique d’écriture de prompts vers une ingénierie complète des systèmes cognitifs autonomes, où l’orchestration, la gouvernance, la sécurité et l’auditabilité deviennent les compétences centrales, donnant naissance à une nouvelle famille de professions : Architectes Cognitifs, Orchestrateurs IA, Ingénieurs Agentiques et Experts en Gouvernance IA.


GOUVERNANCES.: Cartographie des formations adaptées à la nouvelle génération de métiers de l’IA

https://gouver2020.blogspot.com/p/cartographie-des-formations-adaptees-la.html

Pierre Erol GIRAUDY — UGAIA / AFEES
Références : profil de gouvernance « Andorre » v2.2 et matrice de traçabilité RGPD / AI Act v2.5 (documents de travail) ; article initial du 19 juillet 2026 sur GOUVERNANCES.
www.ugaia.eu · gouver2020.blogspot.com · about.me/giraudyerol



vendredi 2 octobre 2026

Agents autonomes et gouvernance de l'IA suite et améliorations


Un agent autonome peut administrer un plan de gouvernance de l'IA, à condition de ne jamais le gouverner, et à condition que chaque protection invoquée soit appliquée là où elle ne peut pas être contournée.

C'est la thèse de cet article, qui reprend et corrige celui du 19 juillet 2026, « Pourquoi des agents autonomes peuvent administrer la gouvernance IA ? ».

Depuis juillet, le dispositif qui sous-tend cette thèse a été révisé. Le profil de gouvernance « Andorre » est passé en version 2.2. Les briques de l'écosystème SMF Works ont été confrontées à leurs dépôts publics. La matrice de traçabilité RGPD / AI Act est passée de 46 à 68 lignes. Plusieurs affirmations de l'article initial ne tenaient plus : je les corrige ici, et je montre comment le profil et la matrice s'articulent.

Une précision de statut : le profil et la matrice sont des documents de travail, non diffusés. Cet article en expose la méthode et les conclusions ; il ne vaut ni déclaration de conformité ni qualification juridique.

1. La thèse maintenue : administrer sans gouverner

La gouvernance de l'IA est d'abord une charge documentaire : registre de l'article 30, analyses d'impact, durées de conservation, matrices de risques, journaux à relire, preuves à conserver. Rien de cela n'est intellectuellement difficile ; tout cela se dégrade dès qu'on cesse de s'en occuper. C'est le terrain naturel d'un agent.

Le partage des rôles ne change pas :

La direction (COMEX, DPO, RSSI) L'agent autonome
Définit les politiques, les seuils de risque, les responsabilitésApplique les politiques et refuse ce qui les enfreint
Qualifie le système au sens de l'AI ActSurveille les actions, les modèles, les données manipulées
Approuve les actions conséquentesMet en file les actions SEND et DESTRUCTIVE
Arbitre, sanctionne, décideDocumente, alerte, produit les preuves

Aucune action juridique, éthique ou disciplinaire n'est déléguée à un agent. Douze agents, un par domaine du plan de classement COWORK2026, exécutent ce travail sous une supervision humaine qui reste entière.

2. Ce que nous corrigeons

Sept affirmations de l'article de juillet sont retirées ou reformulées. Toutes procèdent de la même erreur : attribuer au logiciel une garantie que seul le système d'exploitation, le réseau ou une décision humaine peut apporter.

L'article de juillet affirmait Ce qu'il faut lire
Un « pare-feu d'exfiltration » garantit l'absence de fuiteLe pare-feu d'egress de Praxis refuse qu'une action relaie un contenu signalé comme injection. Ce n'est pas un filtrage réseau. L'absence d'exfiltration ne se garantit qu'au niveau OS : aucune route sortante, aucune résolution DNS.
Les rapports portent des « signatures Ed25519 »Les artefacts sont vérifiés par hachage et portent des visas de revue humaine. Une empreinte prouve l'intégrité d'un document, pas son auteur.
« Conformité automatique », « auditabilité totale »La conformité ne s'automatise pas : elle suppose une qualification juridique préalable et une supervision humaine effective. L'agent produit des preuves, pas la conformité.
Praxis se gouverne lui-même, donc il peut gouverner l'entrepriseUn système qui agit et produit les preuves de ses propres actions est juge et partie. L'agent d'audit doit être cloisonné des agents opérationnels.
L'écosystème SMF Works forme un ensemble sous un broker uniqueSelon leur propre documentation, quatre briques sur six s'exécutent hors du broker Praxis. Deux rôles étaient mal décrits et un nom était erroné.
« 46 obligations, 25 couvertes »La matrice compte 68 lignes, dont 10 points bloquants (détail au §6).
Les douze agents sont tous « non décisionnels »Certains usages déclarés peuvent faire basculer le système en haut risque au sens de l'Annexe III de l'AI Act.
La conclusion de l'article initial, elle, devient la règle de lecture de celui-ci : un agent qui prétend tout couvrir n'est pas un outil de conformité, c'est un risque de conformité déguisé.

3. Le principe : trois couches d'application

Le profil « Andorre » repose sur une phrase : le confinement se réalise au niveau du système d'exploitation et du réseau ; Praxis documente, classe, retient et journalise, il ne confine pas. Une souveraineté qui ne repose que sur un fichier de configuration n'est pas opposable en audit.

Couche Nature Ce qu'elle porte Comment on le vérifie
1 — Réseau / OSContraignante, opposableAucune route sortante, DNS neutralisé, Ollama en boucle locale, sandbox Docker sans réseau, journal exporté hors d'atteinte de l'agentUn curl sortant depuis l'UID de service échoue ; une écriture dans le journal est refusée
2 — PraxisDocumentée, vérifiableClassification READ / DRAFT / SEND / DESTRUCTIVE, approbation humaine, double approbation, kill-switch, frontière d'injection, politique RegoUne action SEND reste en file sans approbation ; une double approbation par le même compte est refusée
3 — OrganisationnelleHumaine, non délégablePolitiques, qualification, approbateurs nommés, revue trimestrielle du journal par le DPO et le RSSIProcès-verbaux datés, notes de qualification signées

Le choix d'Ollama et de modèles à poids ouverts ne suffit pas : une installation neuve de Praxis expose sept surfaces réseau (recherche web, mode Research, navigateur, Microsoft 365, MCP, A2A, passerelles de messagerie) qu'il faut désactiver une à une. Et toute plateforme agentique tierce est écartée si elle introduit une surface réseau ou un second orchestrateur : un seul broker, un seul journal, une seule file d'approbation.

4. Le prompt exprime, le contexte filtre, le harness contraint, l'OS garantit

Une règle écrite dans une consigne système n'est pas un contrôle : elle ne le devient que lorsqu'elle est appliquée en couche 1 ou 2. C'est l'apport principal de la version 2.2 du profil. Mon article de septembre, « Mieux surveiller et paramétrer les modèles d'intelligence artificielle », décrivait trois niveaux d'ingénierie — Prompt, Context, Harness — qui disent où une règle est exprimée. Les trois couches disent où elle devient contraignante. Les deux axes ne se recouvrent pas.

Niveaux d'ingénierie × couches d'application — profil « Andorre » v2.2, §3 ter

La ligne Prompt est vide de contrôles, et c'est voulu : un texte piégé glissé dans un ticket ou un document suffit à neutraliser une consigne. Tout ce que le profil garantit provient des cases colorées.

D'où un registre des garde-fous : chaque garde-fou est rattaché à son point d'application ; sans point d'application, il est présenté comme une recommandation, jamais comme une protection. Exemples tirés d'un SKILL « Support IT & DevOps » :

Garde-fou Exprimé au niveau Point d'application réel
Pas de commande destructive sans validationPromptClasse DESTRUCTIVE du broker, double approbation
Pas de secret en clairPromptExpurgation du broker ; coffre de secrets hors de portée de l'agent
Exclusion des zones de données personnellesContextDroits du système de fichiers par identité d'agent
Retrait des données personnelles des logsContextPipeline Presidio obligatoire en amont, taux de détection mesuré
Aucune exfiltrationAucunCouche 1 uniquement

Deux précisions de vocabulaire suivent de la même logique. Un traitement Presidio est une pseudonymisation, non une anonymisation : les logs restent des données personnelles au sens du RGPD. Et un SKILL rédigé pour un déploiement standard, avec connecteurs MCP vers ServiceNow, Okta ou GitHub, n'est pas transposable tel quel au profil souverain, qui interdit ces connecteurs.

5. Un exemple concret : le classement COWORK2026 de mon poste

Mon propre poste applique le principe des zones, et en montre aussi la limite : le nom d'un dossier exprime sa sensibilité, ses droits d'accès le protègent, son emplacement décide de la souveraineté. L'arborescence ci-dessous est l'état actuel d'un classement qui a évolué depuis la taxonomie présentée en juillet.

Arborescence 14-CO-WORK2026 sur le poste de travail

Arborescence 14-CO-WORK2026 sur le poste de travail — état actuel d'un classement en évolution

Le dossier racine 14-CO-WORK2026 range les documents en trois familles :

FamilleDossiersCe qui en découle pour les agents
Zones de sensibilité et cycle de vie01_DCP, 02_CONFIDENTIEL, 03_CONFORMITE, 04_TECHNIQUE, 05_PUBLICATIONS, 06_ARCHIVESDroits d'accès par agent : les zones 01 et 02 sont fermées à tout agent qui n'en a pas l'usage (TR-066) ; 06 relève de l'agent archiviste
Fournisseurs et infrastructure07_ANTHROPIC, 08_OVH, 09_MICROSOFT, 10_SERVEURS_SLMUn dossier par fournisseur alimente la due diligence de la chaîne d'approvisionnement : contrats, juridiction, dépendances
Métiers et productions11_METIERS, RESULTATSSorties de travail, à rattacher à une zone avant toute diffusion

Quatre enseignements en découlent.

  1. Le numérotage des zones est la bonne base. Un agent de support technique peut être cantonné aux zones 03 à 05 et exclu des zones 01 et 02. Mais tant que cette exclusion n'existe que dans sa consigne, c'est une recommandation. Elle devient un contrôle quand les droits NTFS du compte de service de l'agent ferment ces dossiers.
  2. L'emplacement compte autant que le nom. L'arborescence est dans OneDrive : chaque dossier, y compris 01_DCP et 02_CONFIDENTIEL, est synchronisé avec le cloud de Microsoft, et la plupart sont « disponibles en ligne uniquement ». Pour ces deux zones, c'est une sortie du périmètre souverain et un transfert à documenter au sens du chapitre V du RGPD. Le profil exige qu'elles restent sur un stockage local ou souverain, hors synchronisation.
  3. Ce qui n'est pas classé n'est pas gouverné. RESULTATS et les trois fichiers à la racine (un script Python, deux versions de la matrice de ressources) n'appartiennent à aucune zone : l'agent archiviste ne sait pas quelle durée de conservation leur appliquer. Deux versions côte à côte sans statut posent aussi la question de celle qui fait foi.
  4. Zone et domaine sont deux axes complémentaires. La matrice rattache chaque obligation à un domaine fonctionnel de la taxonomie de juillet (gouvernance, conformité, audit…), qui désigne l'agent responsable. Le disque, lui, est désormais organisé par zone de sensibilité, qui décide des droits d'accès. Une table de correspondance zone × domaine doit relier les deux.

C'est le principe de la section précédente, appliqué à un dossier : le nom exprime, les droits contraignent, l'emplacement garantit.

6. Les agents à usage sensible et la séparation des tâches

Un agent « opérationnel » peut faire basculer tout le système en haut risque par le seul usage qu'on en fait. Trois des douze agents exigent donc une borne de finalité écrite, et inscrite dans les outils qui leur sont donnés, pas seulement dans leur consigne.

Agent Usage déclaré Ce qui ferait basculer la qualification Borne exigée
07 — Partenariats & ConsentementsClasser CV, photos, profilsSélectionner, filtrer ou évaluer des personnes : AI Act, Annexe III, point 4 (emploi)Classement documentaire seul ; aucun outil de notation ; point bloquant
08 — Assurance IA & RisquesVérifier la conformité des « décisions assurantielles »Évaluer ou tarifer des personnes en assurance vie et santé : Annexe III, point 5(c)Documentation des risques IA de l'organisation ; aucune donnée d'assuré individuel
10 — Visuel & ConsentementDétecter et flouter les visagesIdentifier ou catégoriser des personnes : AI Act art. 5 et Annexe III, point 1 ; RGPD art. 9Détection aux seules fins de floutage ; ni gabarit, ni comparaison ; modèle nommé

L'agent 12 (Archiviste) n'appelle pas de qualification particulière, mais ses purges sont des actions DESTRUCTIVE : double approbation, et certificat de suppression produit par un composant distinct de celui qui supprime.

La séparation des tâches est le second point bloquant. Dans l'architecture des douze agents, l'agent 01 supervise les autres et l'agent 06 audite l'ensemble, depuis la même instance que les agents qu'ils contrôlent. Les preuves seraient alors produites par le système qu'elles évaluent. Le profil v2.2 exige :

  • une identité système (UID) distincte pour les agents 01 et 06, ou une instance séparée ;
  • un accès en lecture seule au journal d'audit exporté, jamais en écriture ;
  • aucun outil d'envoi ou de suppression, aucun droit d'approbation ;
  • un visa humain des rapports d'audit par une personne distincte de l'approbateur des actions auditées.

7. La matrice de traçabilité : ce qui est démontré, ce qui ne l'est pas

Sur 68 obligations RGPD et AI Act, 25 sont couvertes par un contrôle attesté, 13 restent à vérifier, 27 ne relèvent d'aucune capacité technique et 3 sont portées par une instance. Dix points bloquent toute diffusion. La matrice (version 2.5) est le pivot du dispositif : chaque obligation y est rattachée à un contrôle, à sa couche, à sa source et à sa preuve.

25
attestées
13
à vérifier
27
non couvertes
3
organisationnelles
10
bloquants

Chaque ligne suit la même chaîne : obligation → contrôle mobilisé → couche d'application → source qui l'atteste → preuve produite → méthode de vérification → statut → responsable. Trois lignes en montrent la logique :

ID Obligation Contrôle Couche Preuve attendue Statut
TR-001AI Act art. 14 — supervision humaine effectiveMode enforced : actions SEND et DESTRUCTIVE retenues pour approbation2 — PraxisJournal d'approbation horodaté avec l'identité de l'approbateurAttesté
TR-066RGPD art. 25 et 32 — accès limité par défautZones 01_DCP et 02_CONFIDENTIEL fermées par les droits du système de fichiers, par agent1 — Réseau / OSLecture d'un fichier témoin depuis l'UID de l'agent → refusNon couvert
TR-064RGPD art. 5.2, AI Act art. 14 et 17 — preuves indépendantesAgent d'audit cloisonné, journal en lecture seule, aucun droit d'action1 + 2 + 3Schéma de cloisonnement visé par le RSSINon couvert

Les statuts ont un sens précis. « À vérifier » n'est pas un manquement : c'est une affirmation non encore confrontée au code. « Non couvert » n'est pas une faute tant que la mesure humaine compensatoire est en place et documentée. Le risque d'audit naît d'un « à vérifier » présenté comme acquis.

Les dix points bloquants :

ID Objet Responsable
TR-010Analyse d'impact (RGPD art. 35) signée avant le traitementDPO
TR-011Qualification du système au sens de l'AI Act (art. 6, Annexe III)Conseil juridique
TR-047Un seul orchestrateur : attestation d'architecture signéeRSSI
TR-049Aucun transfert hors UE : test en environnement sans route sortanteRSSI
TR-054Toute action d'un agent du swarm passe par le broker uniqueRSSI
TR-056Exclusion de la brique dépendant de NotebookLMExploitant
TR-058smfworks-skills : exclusion ou sous-ensemble épinglé sous brokerRSSI
TR-059smf-forgewright : navigateur automatisé, surface réseau interditeRSSI
TR-062Agent 07 : finalité bornée au classement documentaireConseil juridique
TR-064Agent d'audit cloisonné des agents opérationnelsRSSI

Trois de ces dix points (TR-010, TR-011, TR-062) ne seront jamais couverts par un outil : ils relèvent d'une décision humaine signée. C'est la limite honnête de l'automatisation.

8. Ce que le dispositif garantit, et ce qu'il ne garantit pas

Garanti, sous réserve que la couche 1 soit correctement posée

  • aucune connexion sortante possible depuis le processus agent ;
  • une inférence exclusivement locale ;
  • aucune action conséquente sans approbation humaine tracée ;
  • une exécution de code confinée en conteneur jetable sans réseau ;
  • un journal d'audit attribuable, hors d'atteinte en écriture de l'agent.

Non garanti

  • l'absence d'exfiltration par un canal hors couche 1 (support amovible, copie manuelle, capture d'écran) ;
  • l'exactitude des sorties du modèle, que la citation obligatoire et la détection de contradictions réduisent sans l'annuler ;
  • l'effet d'un garde-fou écrit seulement en consigne système ;
  • l'indépendance des preuves d'audit, tant que le cloisonnement de l'agent d'audit n'est pas attesté ;
  • la conformité juridique, qui suppose une qualification préalable et une supervision humaine effective, non simulée.

Conclusion

L'article de juillet avait raison sur l'essentiel et tort sur les preuves. Un agent autonome est un excellent bras opérationnel pour la gouvernance de l'IA. Il ne devient défendable qu'à trois conditions :

  1. ses garanties reposent sur l'OS et le réseau, pas sur sa consigne ;
  2. il ne contrôle jamais ses propres actions ;
  3. ce qu'il ne couvre pas est nommé, avec un responsable humain en face.

Sur 68 obligations, nous en démontrons 25. Les 43 autres sont identifiées, assignées, et ne sont pas présentées comme acquises.


Pierre Erol GIRAUDY — UGAIA / AFEES
Références : profil de gouvernance « Andorre » v2.2 et matrice de traçabilité RGPD / AI Act v2.5 (documents de travail) ; article initial du 19 juillet 2026 sur GOUVERNANCES.
www.ugaia.eu · gouver2020.blogspot.com · about.me/giraudyerol

Mon CV Dynamique https://gouver2020.blogspot.com/p/mon-cv-dynamique.html

lundi 2 mars 2026

PRESIDIO avec LiteLLM + SIEM

LiteLLM : QQOQCC.



LiteLLM, dans sa version Proxy Server, sert essentiellement à centraliser, sécuriser et simplifier l’accès à tous les modèles d’IA derrière une seule API compatible OpenAI. Il sera un pivot dans cette architecture. Je positionne cette configuration sur Docker car ensuite, il sera possible de la migrer vers Kubernetes et avoir des fermes en pré production, puis production. 

Représentation du projet d'architecture sécurisée et IA P2DS.


LiteLLM, dans sa version Proxy Server, sert essentiellement à centraliser, sécuriser et simplifier l’accès à tous les modèles d’IA derrière une seule API compatible OpenAI.

Voici une explication simple et structurée, basée sur le blog.stephane-robert.info.


🧩 Ce que fait LiteLLM (en version simple)

LiteLLM joue le rôle de passerelle unique entre vos applications et des dizaines de fournisseurs de modèles IA (OpenAI, Anthropic, Azure, Bedrock, Hugging Face…).
Au lieu de gérer plusieurs API, formats, clés et règles, vous passez toujours par LiteLLM, qui s’occupe du reste.


⚙️ Les fonctions essentielles (explication simple)

1) Accès unifié à 100+ modèles

  • Vous appelez toujours la même API (format OpenAI).
  • LiteLLM traduit automatiquement vers le bon fournisseur.
  • Vous pouvez changer de modèle sans changer votre code.

2) Compatibilité totale OpenAI

  • Endpoints /chat/completions, /embeddings, /batches.
  • Vos outils existants fonctionnent sans modification.

3) Clés virtuelles pour utilisateurs/équipes

  • Vous créez des API keys internes pour vos équipes.
  • Vous contrôlez qui utilise quoi, et combien.
  • Vous évitez de distribuer vos vraies clés OpenAI/Anthropic.

4) Suivi des coûts

  • LiteLLM calcule automatiquement les dépenses :
    • par modèle
    • par utilisateur
    • par équipe
  • Très utile pour éviter les mauvaises surprises.

5) Budgets et limites

  • Vous fixez des quotas :
    ex : 20€ par mois pour l’équipe marketing, 1000 requêtes/jour pour un service.

6) Interface d’administration

  • Une UI web pour gérer :
    • utilisateurs
    • équipes
    • clés
    • modèles
    • budgets
    • logs

7) Fallbacks et load balancing

  • Si un modèle tombe en panne, LiteLLM bascule vers un autre.
  • Vous pouvez répartir la charge entre plusieurs fournisseurs.

8) Cache Redis

  • Réduit les coûts et accélère les réponses.
  • Très utile pour les prompts répétitifs.

9) Alertes

  • Notifications Slack / Teams / Email quand :
    • un budget est dépassé
    • un incident survient

Fonctions avancées (version Enterprise)

Toujours en explication simple :

Authentification avancée

  • SSO, OIDC, Azure AD, Keycloak.
  • Gestion automatique des tokens temporaires.

Gestion d’organisations

  • Structure hiérarchique : organisations → équipes → utilisateurs.
  • Admins délégués.
  • Modèles privés par équipe.

Observabilité avancée

  • Métriques Prometheus.
  • Logging vers Datadog, S3, GCS, Azure Data Lake.

Sécurité renforcée

  • Guardrails (politiques de contenu).
  • Rotation automatique des clés.

Comment ça fonctionne (simplement)

LiteLLM est un reverse proxy intelligent :

  1. Votre application envoie une requête au format OpenAI.
  2. LiteLLM la reçoit et regarde quel modèle utiliser.
  3. Il transforme la requête pour le fournisseur choisi.
  4. Il renvoie la réponse au format OpenAI.

Vous n’avez donc jamais à gérer les différences entre fournisseurs.


Pourquoi les entreprises l’utilisent

  • Pour centraliser l’accès aux IA.
  • Pour sécuriser les clés et les accès.
  • Pour maîtriser les coûts.
  • Pour éviter le shadow IT.
  • Pour changer de fournisseur facilement (multi-sourcing).
  • Pour industrialiser l’usage des LLM.
  • Pour ma part créer une architecture plus renforcée

Architecture D2S – Version RSSI (DMZ, Double Firewall, Flux contrôlés).

L’ajout d’un SIEM dans mon architecture :

c’est une exigence DSI/DPO/RSSI dès qu’on manipule des données sensibles, qu’on expose des API internes/externes, et qu’on introduit des briques comme LiteLLM, Presidio, Open WebUI ou des modèles IA.

L’idée clé : le SIEM n’est pas là pour l’IA, il est là pour la sécurité du SI dans lequel l’IA s’insère.

Pourquoi un SIEM dans cette architecture

1) Détection d’incidents de sécurité

Les flux IA (LiteLLM, Open WebUI, API Gateway, Presidio) deviennent de nouveaux vecteurs d’attaque :

  • tentatives d’accès non autorisé

  • exfiltration de données via prompts

  • appels massifs anormaux (DoS applicatif)

  • utilisation frauduleuse de clés virtuelles

  • contournement des règles DPO (ex : envoi de PII vers un modèle cloud)

Le SIEM permet de corréler ces événements avec le reste du SI.

2) Traçabilité réglementaire (DPO / RSSI)

Dans un contexte RGPD, santé, OIV ou souveraineté, il faut pouvoir répondre à :

  • Qui a accédé à quoi ?

  • Quand ?

  • Depuis où ?

  • Avec quel modèle ?

  • Sur quelles données ?

LiteLLM génère des logs riches (requêtes, modèles, coûts, utilisateurs). Presidio génère des logs de détection PII. Open WebUI génère des logs d’accès.

Le SIEM centralise et conserve ces traces pour audit.

3) Supervision de la chaîne IA (DSI)

L’IA devient une chaîne de production :

  • API Gateway

  • Presidio

  • LiteLLM

  • Providers (Cloud / On‑Prem / Ollama)

  • Open WebUI

  • Grafana / Prometheus

Le SIEM permet de détecter :

  • un modèle qui répond trop lentement

  • un provider qui tombe

  • un pic de consommation anormal

  • un comportement utilisateur suspect

C’est la vision transverse que Grafana seul ne fournit pas.

4) Conformité et souveraineté

Pour un DPO/RSSI, le SIEM est indispensable pour :

  • prouver que les données sensibles n’ont pas quitté le périmètre autorisé

  • tracer les appels vers les modèles cloud

  • détecter les violations de politiques (ex : modèle non autorisé)

  • conserver les logs pour les audits CNIL / internes

Sans SIEM, tu n’as aucune preuve en cas d’incident.

5) Corrélation avec les autres couches du SI

L’IA n’est qu’un composant du SI, le SIEM permet de corréler :

  • logs réseau

  • logs firewall

  • logs IAM / SSO

  • logs applicatifs

  • logs LiteLLM / Presidio / WebUI

Exemple :

Un utilisateur se connecte via SSO → appelle Open WebUI → envoie un prompt suspect → Presidio détecte des PII → LiteLLM bloque → SIEM corrèle → alerte RSSI.

Comment le SIEM s’intègre dans mon schéma

Dans mon architecture, la brique Supervision & Audit inclut :

  • Grafana (métriques)

  • Logs (Loki / Elastic)

  • SIEM (corrélation + sécurité)

Le SIEM il est obligatoire dès que vous avez :

  • des données sensibles (santé, RH, finance)

  • des flux externes

  • des API exposées

  • des modèles IA (risque d’exfiltration)

  • des obligations réglementaires (RGPD, HDS, OIV)

Synthèse en une phrase

Le SIEM est indispensable pour détecter, corréler, tracer et auditer tous les événements de sécurité liés à la chaîne IA, et pour garantir la conformité DPO/RSSI dans un environnement où les modèles peuvent devenir des vecteurs d’attaque ou de fuite de données.

PRESIDIO → LiteLLM

Fiche d'Intégration Opérationnelle — Architecture IA Souveraine UGAIA

 

Version

1.0 — Mars 2026

Statut

Appliquer dès Phase 2 (J+30)

Classification

Données N3/N4 — Confidentiel

Prérequis

Ollama + Phi-4 installés, LiteLLM Gateway opérationnel

Objectif

Anonymisation PII obligatoire avant tout flux vers le modèle d'inférence

 

🎯  Contexte UGAIA

Presidio s'intègre comme middleware dans LiteLLM Proxy, garantissant qu'aucune donnée personnelle (PII) ne transite en clair vers Ollama/Phi-4. Les journaux produits sont « audit-ready » dès leur création — conformité RGPD Art. 5, règle des 48h CNIL, et assurabilité cyber.

 

1. Architecture de la chaîne d'anonymisation

Le schéma suivant représente le flux Zero Trust IA avec Presidio en position de garde-frontière :

 

  Utilisateur

      |  (prompt brut — peut contenir PII N3/N4)

      v

  Open WebUI

      |

      v

  [ PRESIDIO — Anonymisation PII ]  <===  MIDDLEWARE LiteLLM

      |  (prompt anonymisé : <NOM_PERSONNE>, <EMAIL>, <NIR>...)

      v

  LiteLLM Proxy (Gateway)

      |  (corrélation : mlflow_run_id injecté)

      v

  Ollama / Phi-4  (inférence locale — zéro dépendance cloud)

      |

      v

  OpenTelemetry Collector

      |

      +----> ELK Stack  (journaux anonymisés — preuves forensiques)

      |

      +----> Langfuse   (observabilité LLM — traçabilité prompt/réponse)

      |

      +----> MLflow     (registre modèle — version + run_id)

 

⚠️  Règle d'or — Audit-by-Design

Aucune donnée nominative ne doit figurer dans les journaux d'audit. Presidio filtre le flux en mémoire vive avant tout écrit dans ELK ou Langfuse.

 

2. Installation de Presidio (Python)

Prérequis système : Python 3.9+, pip, accès Docker optionnel. Déploiement recommandé en on-premise.

 

2.1 Installation des packages

# Installation des composants Presidio

pip install presidio-analyzer presidio-anonymizer

 

# Modèle NLP français (support N3/N4 textes RH, santé, finance)

python -m spacy download fr_core_news_lg

 

# Optionnel : modèle anglais pour documents bilingues

python -m spacy download en_core_web_lg

 

2.2 Test de validation post-install

from presidio_analyzer import AnalyzerEngine

from presidio_anonymizer import AnonymizerEngine

 

analyzer  = AnalyzerEngine()

anonymizer = AnonymizerEngine()

 

test_text = "Jean Dupont, né le 15/03/1982, NIR : 1 82 03 75 108 045 28"

results   = analyzer.analyze(text=test_text, language='fr')

output    = anonymizer.anonymize(text=test_text, analyzer_results=results)

 

print(output.text)

# Attendu : <PERSON>, né le <DATE_TIME>, NIR : <FR_NIR>

 

✅  Cible de détection

Taux de détection cible : > 95% sur jeu de données représentatif métier. Valider impérativement avant mise en production N3/N4.

 

3. Configuration du middleware LiteLLM

Presidio s'intègre comme hook de pré-traitement (pre-call hook) dans LiteLLM. Les données sont filtrées en mémoire avant routage vers Ollama.

 

3.1 Classe middleware Presidio

# presidio_middleware.py

from presidio_analyzer import AnalyzerEngine

from presidio_anonymizer import AnonymizerEngine

from presidio_anonymizer.entities import OperatorConfig

import litellm

 

class PresidioMiddleware:

    def __init__(self):

        self.analyzer  = AnalyzerEngine()

        self.anonymizer = AnonymizerEngine()

 

    def anonymize(self, text: str, level: str = 'N3') -> dict:

        """

        Anonymise le texte et retourne le texte filtré

        + la liste des entités détectées pour journalisation.

        """

        results = self.analyzer.analyze(

            text=text,

            language='fr',

            entities=[

                'PERSON', 'EMAIL_ADDRESS', 'PHONE_NUMBER',

                'IBAN_CODE', 'CREDIT_CARD', 'DATE_TIME',

                'LOCATION', 'IP_ADDRESS', 'NRP',

                'FR_NIR',   # Numéro de sécurité sociale FR

                'MEDICAL_LICENSE',

            ]

        )

 

        # Stratégie de masquage selon niveau de classification

        operators = {

            'PERSON':        OperatorConfig('replace', {'new_value': '<NOM_PERSONNE>'}),

            'EMAIL_ADDRESS': OperatorConfig('replace', {'new_value': '<EMAIL>'}),

            'PHONE_NUMBER':  OperatorConfig('replace', {'new_value': '<TEL>'}),

            'IBAN_CODE':     OperatorConfig('hash',    {'hash_type': 'sha256'}),

            'CREDIT_CARD':   OperatorConfig('mask',    {'masking_char': '*', 'chars_to_mask': 12}),

            'FR_NIR':        OperatorConfig('hash',    {'hash_type': 'sha256'}),

            'DATE_TIME':     OperatorConfig('replace', {'new_value': '<DATE>'}),

            'LOCATION':      OperatorConfig('replace', {'new_value': '<LOCALISATION>'}),

            'IP_ADDRESS':    OperatorConfig('replace', {'new_value': '<IP>'}),

        }

 

        anonymized = self.anonymizer.anonymize(

            text=text,

            analyzer_results=results,

            operators=operators

        )

 

        return {

            'anonymized_text': anonymized.text,

            'detected_entities': [r.entity_type for r in results],

            'pii_detected': len(results) > 0,

        }

 

3.2 Hook LiteLLM — pré-traitement du prompt

# litellm_config.py

import litellm

import mlflow

import json

from presidio_middleware import PresidioMiddleware

from datetime import datetime

 

presidio = PresidioMiddleware()

 

def pre_call_hook(kwargs, result, start_time, end_time):

    """

    Hook exécuté avant chaque appel LiteLLM.

    Anonymise le prompt et journalise les métadonnées d'audit.

    """

    messages = kwargs.get('messages', [])

    run_id = mlflow.active_run().info.run_id if mlflow.active_run() else 'no_run'

 

    for msg in messages:

        if msg.get('role') == 'user':

            raw_text = msg['content']

            result   = presidio.anonymize(raw_text)

 

            # Remplacement du contenu par la version anonymisée

            msg['content'] = result['anonymized_text']

 

            # Journalisation des métadonnées uniquement (jamais le texte brut)

            audit_meta = {

                'mlflow_run_id':     run_id,

                'timestamp':         datetime.utcnow().isoformat(),

                'pii_detected':      result['pii_detected'],

                'entities_detected': result['detected_entities'],

                'anonymized':        True,

            }

            # Envoi vers Langfuse / ELK (via OpenTelemetry)

            print(json.dumps(audit_meta))  # remplacer par otel_logger

 

litellm.pre_call_hook = pre_call_hook

 

3.3 Configuration litellm_config.yaml

# litellm_config.yaml

model_list:

  - model_name: phi4-local

    litellm_params:

      model: ollama/phi4

      api_base: http://localhost:11434

 

general_settings:

  presidio_enabled: true

  presidio_language: fr

  pii_masking: true

  log_decision_process: true    # Traçabilité audit CNIL

 

litellm_settings:

  success_callback: ["langfuse", "mlflow"]

  failure_callback: ["langfuse"]

  telemetry: true

 

4. Workflow opérationnel — 5 étapes

 

1

Réception du prompt brut

Open WebUI reçoit la requête utilisateur. Le texte peut contenir des PII N3/N4 non contrôlées.

 

2

Anonymisation Presidio (< 50ms)

Le middleware analyse le texte, détecte les entités PII, applique le masquage configuré. Le prompt anonymisé remplace le texte original en mémoire.

 

3

Injection du mlflow_run_id

Un identifiant unique est généré et injecté dans les métadonnées de la requête. Ce run_id devient l'identifiant pivot de toute la chaîne d'audit.

 

4

Inférence Ollama / Phi-4

Le modèle reçoit uniquement le prompt anonymisé. Zéro PII ne transite vers le moteur d'inférence. Conformité RGPD Art. 5 (minimisation) garantie.

 

5

Journalisation audit-ready

ELK et Langfuse reçoivent uniquement les métadonnées anonymisées + mlflow_run_id. Les logs sont immédiatement utilisables pour réponse CNIL 48h ou rapport assureur.

 

5. Validation et contrôle qualité

5.1 Suite de tests de non-régression

# test_presidio_validation.py

import pytest

from presidio_middleware import PresidioMiddleware

 

pii = PresidioMiddleware()

 

TEST_CASES = [

    # (description, texte_brut, entités_attendues)

    ('Nom complet FR',

     'Mme Marie Curie signe le contrat.',

     ['PERSON']),

    ('Email professionnel',

     'Contactez pierre.martin@entreprise.fr pour confirmation.',

     ['EMAIL_ADDRESS']),

    ('NIR sécurité sociale',

     'Mon numéro est 1 82 03 75 108 045 28.',

     ['FR_NIR']),

    ('IBAN bancaire',

     'Virement sur FR76 3000 6000 0112 3456 7890 189.',

     ['IBAN_CODE']),

    ('Donnée de santé composée',

     'Dr. Benoit, né le 12/06/1975, consultation le 03/03/2026.',

     ['PERSON', 'DATE_TIME']),

]

 

@pytest.mark.parametrize('desc, text, expected_entities', TEST_CASES)

def test_detection(desc, text, expected_entities):

    result = pii.anonymize(text)

    assert result['pii_detected'], f'Aucune PII détectée pour : {desc}'

    for entity in expected_entities:

        assert entity in result['detected_entities'], \

            f'{entity} non détecté pour : {desc}'

 

def test_no_pii_preserved():

    """Vérifie qu'aucun PII ne subsiste après anonymisation."""

    text = 'Marie Dupont, née le 01/01/1990'

    result = pii.anonymize(text)

    assert 'Marie Dupont' not in result['anonymized_text']

    assert '01/01/1990' not in result['anonymized_text']

 

5.2 Matrice de conformité RGPD

 

Exigence RGPD

Sans Presidio

Avec Presidio

Art. 5 — Minimisation des données

❌ Non conforme

✅ Conforme

Art. 25 — Privacy by Design

❌ Risque élevé

✅ Implémenté

Art. 32 — Sécurité du traitement

⚠️ Partiel

✅ Garanti

Art. 33 — Notification 72h ANSSI

❌ Impossible

✅ Prêt

Règle 48h CNIL — Dossier d'audit

❌ Manuel (jours)

✅ Automatique

Assurabilité cyber 2026

❌ < 50 pts

✅ +15 pts score

 

6. Contribution au Score de Résilience UGAIA

L'intégration de Presidio comme middleware actif contribue directement au score de résilience. Le tableau ci-dessous détaille les points acquis par composant UGAIA :

 

Composant UGAIA

Sans Presidio

Avec Presidio

C1 — Journalisation & Traçabilité

6/12

11/12

C2 — Protection des Données (RGPD)

4/15

13/15

C3 — Sécurité des Accès

6/10

8/10

C4 — Gouvernance & Conformité

5/13

11/13

C5 — Résilience Technique

8/15

12/15

TOTAL / 100

44/100 ⚠️ Non assurable

78/100 ✅ Assurable

 

🏆  Seuils d'assurabilité 2026

Score ≥ 75/100 : éligibilité assurance cyber. Score ≥ 80/100 : statut SOUVERAIN+. L'intégration de Presidio fait passer l'organisation de 44/100 (non assurable) à 78/100 (assurable).

 

7. Résolution des problèmes courants

Symptôme

Cause probable

Solution

Noms FR non détectés

Modèle spaCy EN chargé

Installer fr_core_news_lg et spécifier language='fr'

Latence > 200ms

Modèle NLP trop lourd

Utiliser fr_core_news_md ou migrer vers rs-presidio (Rust)

NIR non reconnu

Reconnaisseur FR_NIR manquant

Ajouter recognizer FR personnalisé (regex NIR)

Hook LiteLLM ignoré

Version LiteLLM < 1.30

Mettre à jour : pip install --upgrade litellm

mlflow_run_id absent

MLflow non initialisé

Appeler mlflow.start_run() avant le hook

Taux détection < 90%

Jargon métier non reconnu

Ajouter des reconnaisseurs personnalisés (contrats, IDs internes)

 

8. Checklist de mise en production

 

VALIDATION PRE-PRODUCTION N3/N4

Toutes les cases doivent être cochées avant activation

 

▶  Installation

•        ☐  presidio-analyzer et presidio-anonymizer installés (pip)

•        ☐  Modèle spaCy fr_core_news_lg téléchargé et validé

•        ☐  Test unitaire de base exécuté avec succès

 

▶  Configuration

•        ☐  PresidioMiddleware instancié et configuré (entités FR activées)

•        ☐  Hook pre_call_hook enregistré dans LiteLLM

•        ☐  litellm_config.yaml : presidio_enabled: true et log_decision_process: true

•        ☐  mlflow_run_id injecté dans les métadonnées de chaque requête

 

▶  Validation

•        ☐  Suite pytest complète : taux de détection ≥ 95% sur jeu de test métier

•        ☐  Contrôle : aucun PII en clair dans les logs ELK et Langfuse

•        ☐  Test règle 48h : dossier d'audit généré automatiquement sans donnée brute

•        ☐  Fallback testé : désactivation Presidio = rejet de la requête (pas de bypass)

 

▶  Documentation

•        ☐  Fiche de procédure archivée dans le système de gestion documentaire

•        ☐  Score de résilience UGAIA recalculé et validé (≥ 75/100)

•        ☐  Rapport d'audit CNIL préparé avec preuves d'anonymisation

 


 

Références et ressources

 

Documentation officielle

https://microsoft.github.io/presidio/ 

API Reference

https://microsoft.github.io/presidio/api-docs/api-docs.html

Démo Hugging Face

https://huggingface.co/spaces/presidio/presidio_demo

ModernBERT PII classifier

https://huggingface.co/llm-semantic-router/pii_classifier_modernbert-base_presidio_token_model

rs-presidio (Rust)

https://github.com/posidron/rs-presidio

LiteLLM Proxy docs

https://docs.litellm.ai/docs/proxy/quick_start

Blog GOUVERNANCES. — Art. 1

https://gouver2020.blogspot.com/2026/02/microsoft-presidio-est-le-framework.html

Blog GOUVERNANCES. — Art. 2

https://gouver2020.blogspot.com/2026/02/tests-installation-de-presidio.html

Blog GOUVERNANCES. — Art. 3

https://gouver2020.blogspot.com/2026/03/pii-de-identification-avec-microsoft.html

Guide UGAIA V10 — Chapitre 5

Gouv˙IA-Secu-Audit-IA_V10_2026.docx

 

📋  Intégration dans le Passeport Souveraineté UGAIA V4

Cette fiche répond directement à la Question 6 du Passeport : traçabilité complète prompt → modèle → accès → évaluation qualité. Le mlflow_run_id est l'identifiant pivot. Sa présence dans chaque enregistrement ELK, Langfuse et MLflow constitue la preuve technique d'intégrité exigée par les auditeurs et les assureurs.

 











Successfully installed PyJWT-2.11.0 apscheduler-3.11.2 azure-core-1.38.2 azure-identity-1.25.2 azure-storage-blob-12.28.0 backoff-2.2.1 boto3-1.40.76 botocore-1.40.76 cffi-2.0.0 croniter-6.0.0 cryptography-46.0.5 dnspython-2.8.0 email-validator-2.3.0 fastapi-0.132.0 fastapi-sso-0.16.0 gunicorn-23.0.0 httpx-sse-0.4.3 isodate-0.7.2 jmespath-1.1.0 litellm-enterprise-0.1.32 litellm-proxy-extras-0.4.46 mcp-1.26.0 msal-1.34.0 msal-extensions-1.3.1 oauthlib-3.3.1 orjson-3.11.7 polars-1.38.1 polars-runtime-32-1.38.1 pycparser-3.0 pydantic-settings-2.13.1 pynacl-1.6.2 python-multipart-0.0.22 pywin32-311 redis-7.2.0 rich-13.7.1 rq-2.7.0 s3transfer-0.14.0 soundfile-0.12.1 sse-starlette-3.2.0 starlette-0.52.1 tzlocal-5.3.1 websockets-15.0.1
PS C:\> litellm --model gpt-4o
INFO:     Started server process [15012]
INFO:     Waiting for application startup.

Ollama peut être utilisé à l’intérieur de LiteLLM comme un fournisseur de modèles locaux.

LiteLLM = Proxy multi‑fournisseurs + gouvernance + coûts

LiteLLM sert à :

  • unifier l’accès à tous les modèles (OpenAI, Anthropic, Azure, Bedrock, Ollama…)

  • gérer les clés virtuelles, quotas, budgets, équipes

  • suivre les coûts et les logs

  • appliquer des politiques de sécurité

  • faire du load balancing et du fallback

  • exposer une API OpenAI unique

LiteLLM n’exécute pas les modèles : il orchestrationne.


Ollama = Serveur local de modèles open‑source

Ollama sert à :

  • télécharger et exécuter des modèles localement (Llama, Mistral, Phi, Qwen…)
  • gérer le chargement en RAM, le quantization, le GPU
  • fournir une API simple pour interroger un modèle local

Ollama n’a pas :

  • de gestion d’utilisateurs
  • de quotas
  • de budgets
  • de logs avancés
  • de multi‑fournisseurs
  • de compatibilité OpenAI complète
  • de load balancing
  • de sécurité d’entreprise

Comment ils s’articulent ensemble

Le schéma réel dans les entreprises

Code
Application → LiteLLM → (OpenAI / Anthropic / Azure / Bedrock / Ollama local)

LiteLLM devient la couche de gouvernance, Ollama devient un fournisseur parmi d’autres.

Conclusion simple

  • Ollama = moteur local

  • LiteLLM = gouvernance + proxy multi‑modèles

Ollama ne remplace pas LiteLLM. Ollama complète LiteLLM.

1) Démarrer LiteLLM Proxy avec Docker, c'est fait

Autrement si tu as déjà téléchargé l’image.

Lance-la :

docker run -p 4000:4000 -e LITELLM_LOG=info docker.litellm.ai/berriai/litellm:main-latest

Cela démarre le proxy LiteLLM sur :

http://localhost:4000   voir copie écran ci-dessus

2) Tester avec l’API OpenAI (via LiteLLM)

Exemple :

curl http://localhost:4000/v1/chat/completions `
  -H "Content-Type: application/json" `
  -H "Authorization: Bearer votrecledetest" `
  -d "{""model"":""gpt-4o-mini"", ""messages"":[{""role"":""user"",""content"":""Bonjour""}]}"

3) Ajouter Ollama comme fournisseur local (si tu veux)

Si tu as Ollama installé :

ollama run mistral

Puis dans LiteLLM, tu peux appeler :

curl http://localhost:4000/v1/chat/completions `
  -H "Content-Type: application/json" `
  -d "{""model"":""ollama/mistral"", ""messages"":[{""role"":""user"",""content"":""Bonjour""}]}"

Résumé clair

  • La ligne “Application → LiteLLM → …” était un schéma, pas une commande.
  • PowerShell a essayé de l’exécuter → erreur normale.
  • Tu as bien installé LiteLLM.
  • Prochaine étape : lancer le proxy et tester une requête.