IA agentique : les 7 piliers d'une architecture robuste

Comprendre les fondements d'un système d'IA agentique

Dans cet article, nous allons explorer les sept composants clés qui différencient un système d'IA agentique de production d'un simple script de démonstration. Ces composants sont essentiels pour assurer une intégration fluide dans la boucle de rétroaction centrale de l'agent.

Les composants essentiels à analyser

Nous allons examiner les éléments suivants :

• Le rôle spécifique de chaque composant, à savoir la perception, la mémoire, le raisonnement et la planification, l'exécution d'outils, l'orchestration, les garde-fous, et l'observabilité.

• Les vulnérabilités potentielles de chaque composant dans les systèmes réels et l'importance de maintenir leur séparation.

• Un exemple de code Python illustrant la responsabilité individuelle de chaque composant.

Introduction à l'architecture agentique

La plupart des tutoriels sur la création d'un agent IA se contentent de présenter un script de 40 lignes qui appelle un LLM dans une boucle, concluant ainsi le processus. Bien que cela suffise pour une démonstration, ce type de script ne résiste pas à des scénarios plus complexes, comme l'interaction avec plusieurs utilisateurs simultanés, une API instable, ou des tâches nécessitant de nombreuses étapes.

La différence entre une démonstration et un système de production réside dans l'architecture. Les systèmes d'IA agentique de production reposent sur un ensemble cohérent de composants interconnectés : perception, raisonnement, planification, mémoire, exécution d'outils, orchestration, et garde-fous. Cette structure est courante dans les analyses architecturales sérieuses, les articles de recherche et les rapports post-mortem de production publiés récemment, indépendamment du cadre ou du fournisseur.

La boucle fondamentale reste constante : Objectif → Perception → Raisonnement → Planification → Action → Observation → Mise à jour de la mémoire → retour au Raisonnement. Cette séquence se répète jusqu'à ce que l'objectif soit atteint, qu'une condition d'arrêt soit remplie, ou que l'agent décide qu'une intervention humaine est nécessaire. Cet article examine chaque élément de cette boucle comme un composant distinct, en détaillant ses responsabilités, ses points faibles, et en fournissant un extrait de code pour illustrer concrètement ses fonctions. Chaque élément est présenté isolément, ce qui est également la manière dont vous devriez envisager votre propre système lors de la décision de ce dont il a besoin.

Aperçu des sept composants

Les enquêtes architecturales convergent vers un ensemble de base : Perception, Mémoire, Raisonnement/Planification, Exécution d'outils, et Orchestration forment une boucle de rétroaction fermée — le cycle qui fonctionne réellement, étape par étape. Les garde-fous et l'observabilité enveloppent cette boucle entière en tant que préoccupations transversales plutôt que comme étapes à l'intérieur de la séquence. Vous ne « faites » pas de garde-fous à l'étape 4 ; les garde-fous se situent entre chaque action proposée et le monde, surveillant chaque étape.

Cette distinction façonne le reste de cet article. Les cinq premières sections parcourent la boucle dans l'ordre dans lequel les données y circulent réellement. Les deux dernières sections couvrent les couches de protection qui rendent la boucle survivable une fois que de l'argent réel, des clients réels et de véritables effets secondaires sont impliqués.

Transformer les entrées brutes en données exploitables

Le rôle de la perception est de transformer les entrées brutes — qu'il s'agisse de texte, de voix, de charges utiles d'API, de données de capteurs ou de téléchargements de fichiers — en une représentation structurée que le moteur de raisonnement peut traiter. Ce composant est souvent négligé dans les tutoriels, car dans une démonstration, « l'utilisateur tape simplement du texte » et il n'y a rien à normaliser. Cependant, dans les systèmes réels, les entrées proviennent de webhooks, d'appels d'API structurés, de téléchargements de fichiers, et de plusieurs canaux simultanément. Chacune de ces entrées doit être normalisée avant que tout traitement ultérieur puisse lui faire confiance.

# perception.py
# Prérequis : aucun au-delà de la bibliothèque standard de Python
# Exécution : python perception.py
from dataclasses import dataclass, field
from typing import Any
from enum import Enum
import json
from datetime import datetime, timezone

class InputSource(Enum):
    USER_TEXT = "user_text"
    WEBHOOK = "webhook"
    FILE_UPLOAD = "file_upload"

@dataclass
class AgentInput:
    """
    La forme interne normalisée que chaque composant en aval consomme,
    peu importe d'où provient l'entrée brute. C'est tout l'intérêt d'une couche de perception : tout ce qui se trouve après ce point
    ne voit jamais que cette structure unique.
    """
    source: InputSource
    content: str
    metadata: dict[str, Any] = field(default_factory=dict)
    received_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())

def perceive_user_text(raw_text: str) -> AgentInput:
    """Entrée de chat brute -- le cas le plus simple, mais elle nécessite toujours une normalisation."""
    return AgentInput(
        source=InputSource.USER_TEXT,
        content=raw_text.strip(),
        metadata={"channel": "chat"},
    )

def perceive_webhook(raw_payload: str) -> AgentInput:
    """
    Un webhook livre du JSON structuré, pas du texte brut. La perception extrait
    la partie que l'agent doit raisonner et élimine le bruit au niveau du transport comme les en-têtes et les signatures.
    """
    payload = json.loads(raw_payload)
    event_type = payload.get("event_type", "unknown")
    description = payload.get("description", "")
    return AgentInput(
        source=InputSource.WEBHOOK,
        content=f"Événement '{event_type}' reçu : {description}",
        metadata={"event_type": event_type, "raw_payload": payload},
    )

def perceive_file_upload(filename: str, file_size_bytes: int, mime_type: str) -> AgentInput:
    """
    Un événement de téléchargement de fichier n'a pas de contenu en langage naturel du tout -- la perception
    doit construire quelque chose que le moteur de raisonnement peut réellement utiliser.
    """
    return AgentInput(
        source=InputSource.FILE_UPLOAD,
        content=f"L'utilisateur a téléchargé le fichier '{filename}' ({mime_type}, {file_size_bytes} octets)",
        metadata={"filename": filename, "mime_type": mime_type, "size_bytes": file_size_bytes},
    )

if __name__ == "__main__":
    text_input = perceive_user_text("  Quel est le statut de mon remboursement ?  ")
    webhook_input = perceive_webhook(json.dumps({
        "event_type": "payment_failed",
        "description": "Carte refusée pour la commande #4821",
    }))
    file_input = perceive_file_upload("invoice_q3.pdf", 184320, "application/pdf")

    for inp in [text_input, webhook_input, file_input]:
        print(f"[{inp.source.value}] content='{inp.content}'")
        print(f"  metadata keys: {list(inp.metadata.keys())}\n")

Pour exécuter : python perception.py, aucune dépendance requise.

Trois formes brutes complètement différentes — texte brut, charge utile JSON de webhook, et événement de téléchargement de fichier — se transforment toutes en la même structure AgentInput. Le composant de raisonnement en aval n'a jamais besoin de savoir ou de se soucier par quel canal quelque chose est arrivé. C'est toute la valeur de traiter la perception comme son propre composant plutôt que d'intégrer un parsing ad hoc là où l'entrée entre dans le système.

Contexte de travail contre ce qui persiste réellement

La mémoire est le composant le plus nuancé, et celui que le code de démonstration se trompe souvent en considérant simplement comme « la conversation jusqu'à présent ». Dans une architecture de mémoire de production, il est crucial de distinguer entre la mémoire de travail — la fenêtre de contexte immédiate pour la tâche actuelle — et la mémoire à long terme, qui se divise elle-même en mémoire épisodique (ce qui s'est passé), mémoire sémantique (faits appris), et mémoire procédurale (compétences et savoir-faire). La mémoire à court terme vit dans le contexte et est essentiellement gratuite ; la mémoire à long terme vit généralement dans un vector store, indexée pour une récupération sémantique plutôt que pour une correspondance exacte.

La distinction opérationnelle est importante : la mémoire de travail est rapide.