Architecture d'un agent IA : composants et sécurité

Introduction : au-delà du modèle de langage

Avec la généralisation des solutions comme Microsoft Copilot, les Copilot Agents et les architectures agentiques basées sur Azure OpenAI, la compréhension fine de ce qu'est réellement un agent IA est devenue une compétence fondamentale pour les professionnels IT.

Un agent IA n'est pas un simple modèle de langage exposé via une interface. Il constitue un système distribué qui orchestre des modèles de fondation, des mécanismes de mémoire, des outils d'action et des connecteurs vers des systèmes externes. Chaque brique de cette chaîne présente des implications fonctionnelles et sécuritaires qu'il est impératif de maîtriser, que vous soyez architecte solutions, ingénieur IA ou responsable de la cybersécurité.

Le flux de bout en bout d'un agent IA

L'architecture d'un agent IA suit une chaîne logique et séquentielle. Comprendre ce flux est la première étape pour anticiper les points de défaillance et les vecteurs d'attaque.

De la requête utilisateur à l'action concrète

Voici les étapes clés du traitement agentique :

• Entrée utilisateur : l'utilisateur soumet un objectif, une requête ou une instruction en langage naturel.
• Orchestration : l'agent reçoit cette entrée et joue le rôle de chef d'orchestre. Il décompose l'objectif en sous-tâches, détermine quels outils mobiliser et dans quel ordre.
• Raisonnement (LLM) : le modèle de langage constitue le « cerveau » du dispositif. Il interprète le contexte, raisonne sur les étapes à suivre et génère les instructions ou réponses appropriées.
• Mémoire et contexte : l'agent consulte et met à jour ses différentes couches de mémoire pour maintenir la cohérence des échanges.
• Appel aux outils : selon les besoins, l'agent invoque des outils externes via des connecteurs standardisés.
• Résultat et action : l'agent restitue une réponse, exécute une tâche ou déclenche un processus métier.

1flowchart LR
2    U([Utilisateur]) --> O[Orchestrateur / Agent]
3    O --> L[LLM - Raisonnement]
4    L --> M[(Mémoire)]
5    L --> T[Outils & Connecteurs]
6    T --> E[Systèmes externes]
7    E --> O
8    O --> R([Résultat / Action])

Modèles de fondation et couches de mémoire

Les modèles de fondation

Les modèles de fondation (GPT-4o, Phi-3, Mistral, etc.) fournissent les capacités de compréhension du langage naturel, de raisonnement logique et de génération de contenu. Dans l'écosystème Microsoft, ces modèles sont accessibles via Azure OpenAI Service avec des garanties de résidence des données et de confidentialité des entreprises.

Le choix du modèle impacte directement :

• La qualité du raisonnement en plusieurs étapes (chain-of-thought)
• Les capacités multimodales (texte, image, code)
• La fenêtre de contexte disponible
• Le coût d'inférence par token

Les types de mémoire agentique

La mémoire d'un agent ne se limite pas à l'historique de conversation. Elle se structure en plusieurs niveaux :

Le pattern RAG (Retrieval Augmented Generation)

La mémoire vectorielle est au cœur du pattern RAG, qui permet d'enrichir les réponses du modèle avec des données propriétaires sans nécessiter de fine-tuning. Dans Microsoft 365, ce pattern est notamment mis en œuvre dans Microsoft Copilot via l'index sémantique de Microsoft Graph.

Voici un exemple simplifié d'implémentation RAG avec le SDK Python d'Azure AI Search :

1from azure.search.documents import SearchClient
2from azure.core.credentials import AzureKeyCredential
3from openai import AzureOpenAI
4 
5# Initialisation du client Azure AI Search
6search_client = SearchClient(
7    endpoint="https://<your-search-service>.search.windows.net",
8    index_name="knowledge-base",
9    credential=AzureKeyCredential("<your-api-key>")
10)
11 
12# Initialisation du client Azure OpenAI
13openai_client = AzureOpenAI(
14    azure_endpoint="https://<your-openai-resource>.openai.azure.com",
15    api_key="<your-api-key>",
16    api_version="2024-02-01"
17)
18 
19def rag_query(user_query: str) -> str:
20    # Etape 1 : Recherche sémantique dans la base de connaissances
21    results = search_client.search(
22        search_text=user_query,
23        query_type="semantic",
24        semantic_configuration_name="default",
25        top=3
26    )
27    context = "\n".join([doc["content"] for doc in results])
28 
29    # Etape 2 : Génération augmentée avec le contexte récupéré
30    response = openai_client.chat.completions.create(
31        model="gpt-4o",
32        messages=[
33            {"role": "system", "content": f"Utilisez le contexte suivant pour répondre :\n{context}"},
34            {"role": "user", "content": user_query}
35        ]
36    )
37    return response.choices[0].message.content

Outils et connecteurs : l'interface avec le monde réel

C'est la capacité d'agir qui distingue fondamentalement un agent IA d'un chatbot conventionnel. Un agent peut invoquer des outils pour interagir avec des systèmes tiers, exécuter du code ou déclencher des workflows métier.

Catalogue des outils agentiques

Voici les catégories d'outils les plus couramment intégrées :

• Recherche et navigation : recherche web (Bing Search API), exploration de contenu en ligne
• Exécution de code : interpréteur Python, scripts PowerShell, sandboxes sécurisées
• Gestion de fichiers : lecture/écriture sur SharePoint, OneDrive, Azure Blob Storage
• Communication : envoi d'e-mails via Microsoft Graph, publication sur Teams
• Données structurées : requêtes SQL, accès à Dataverse, appels vers des APIs REST
• Transactions et automatisation : déclenchement de Power Automate, appels à des systèmes ERP

Le protocole MCP (Model Context Protocol)

Le Model Context Protocol (MCP), initié par Anthropic et rapidement adopté par Microsoft, standardise la façon dont les agents IA se connectent aux outils et aux sources de données. Il définit un contrat d'interface unifié entre l'orchestrateur agentique et les services externes.

1{
2  "mcpVersion": "1.0",
3  "server": {
4    "name": "sharepoint-connector",
5    "version": "0.1.0"
6  },
7  "tools": [
8    {
9      "name": "search_documents",
10      "description": "Recherche des documents dans SharePoint Online",
11      "inputSchema": {
12        "type": "object",
13        "properties": {
14          "query": {
15            "type": "string",
16            "description": "Requête de recherche en langage naturel"
17          },
18          "site_url": {
19            "type": "string",
20            "description": "URL du site SharePoint cible"
21          }
22        },
23        "required": ["query"]
24      }
25    }
26  ]
27}

Dans l'écosystème Microsoft, MCP est désormais supporté nativement dans Azure AI Foundry et dans Copilot Studio, facilitant l'intégration d'outils tiers sans développement de connecteurs propriétaires.

Sécurité agentique : cartographier la surface d'attaque

Chaque composant de l'architecture agentique représente un vecteur d'attaque potentiel. Ignorer cette réalité lors de la conception expose l'organisation à des risques significatifs.

Les principales menaces par composant

Implémenter une défense en profondeur

1# Exemple : attribution d'un rôle restreint à une Managed Identity pour Azure AI Foundry
2New-AzRoleAssignment \
3  -ObjectId "<managed-identity-object-id>" \
4  -RoleDefinitionName "Cognitive Services User" \
5  -Scope "/subscriptions/<sub-id>/resourceGroups/<rg>/providers/Microsoft.CognitiveServices/accounts/<aoai-resource>"

1from azure.ai.contentsafety import ContentSafetyClient
2from azure.ai.contentsafety.models import AnalyzeTextOptions
3from azure.core.credentials import AzureKeyCredential
4 
5client = ContentSafetyClient(
6    endpoint="https://<your-content-safety>.cognitiveservices.azure.com",
7    credential=AzureKeyCredential("<your-key>")
8)
9 
10def is_safe_input(user_input: str) -> bool:
11    request = AnalyzeTextOptions(text=user_input)
12    response = client.analyze_text(request)
13    # Bloquer si un score de sévérité dépasse le seuil acceptable
14    return all(cat.severity < 2 for cat in response.categories_analysis)

Gouvernance des agents IA en entreprise

La sécurisation technique des composants est nécessaire, mais insuffisante. Une gouvernance structurée des agents IA repose sur trois piliers complémentaires :

• Inventaire et classification : documenter chaque agent déployé, ses sources de données, ses outils et son niveau de sensibilité. Dans Microsoft 365, Microsoft Purview offre des capacités de classification applicables aux agents Copilot.
• Revue de conception (AI Design Review) : intégrer une revue de sécurité dédiée dans le cycle de développement des agents, à l'image d'une Threat Model review pour les applications traditionnelles.
• Monitoring continu : implémenter des alertes sur les comportements anormaux (volume inhabituel d'appels API, accès à des données hors périmètre, latences anormales) via Microsoft Sentinel et les workbooks Azure Monitor.

Conclusion

Comprendre l'architecture d'un agent IA dans sa globalité — du modèle de fondation aux connecteurs en passant par les couches de mémoire — est un prérequis indispensable pour tout professionnel IT impliqué dans la conception, le déploiement ou la sécurisation de ces systèmes.

La surface d'attaque d'un agent est proportionnelle à ses capacités : plus il est puissant et intégré, plus il expose de vecteurs de compromission potentiels. Cette réalité ne doit pas freiner l'adoption, mais inciter à adopter une démarche de sécurité by design dès les premières phases du projet.

Les équipes qui investissent dès maintenant dans la compréhension de ces architectures et dans la mise en place de contrôles adaptés seront mieux positionnées pour tirer parti des gains de productivité offerts par les agents IA, sans compromettre la posture de sécurité de leur organisation.