Pourquoi Maison Code en parle

Chez Maison Code Paris, nous agissons comme la conscience architecturale de nos clients. Nous héritons souvent de stacks “modernes” construites sans compréhension fondamentale de l’échelle.

Nous abordons ce sujet car il représente un point de pivot critique dans la maturité de l’ingénierie. Une mise en œuvre correcte différencie un MVP fragile d’une plateforme résiliente de niveau entreprise.

L’évolution de l’interface

Au cours des 40 dernières années, le paradigme fondamental de l’interaction homme-machine (HCI) a été le « commandement et contrôle ». Vous cliquez sur un bouton, l’ordinateur fait exactement une chose. Vous tapez une commande, l’ordinateur exécute exactement une fonction. Même avec l’essor de GenAI et ChatGPT, le paradigme est resté largement conversationnel. Vous posez une question, la machine récupère une réponse. C’est un moteur de recherche sophistiqué.

Les agents IA représentent un passage du « Chat » à « Action ». Un agent ne sait pas seulement des choses. Il fait des choses. C’est la différence entre un Wikipédia qui peut répondre « Comment réserver un vol ? » et un concierge qui dit “J’ai réservé votre vol”.

Pourquoi Maison Code mise sur les agents

Nous pensons que le « site Web » tel que nous le connaissons est en train de mourir. Dans 5 ans, les utilisateurs ne cliqueront plus sur 10 pages pour trouver un produit. Ils diront à leur agent personnel : « Achetez-moi une chemise bleue ». Nous construisons des API prêtes pour les agents. Nous veillons à ce que les données de nos clients soient structurées de manière à ce que les agents IA (Google Gemini, OpenAI, Siri) puissent les lire et effectuer des transactions. Si votre site n’est pas Agent-Ready, vous êtes invisible pour le plus gros consommateur de la prochaine décennie : l’IA.

1. Le modèle ReAct : anatomie d’un agent

L’article révolutionnaire « ReAct : Synergizing Reasoning and Acting in Language Models » (Yao et al., 2022) a tout changé. Avant ReAct, les LLM n’étaient que des prédicteurs de texte. ReAct leur a donné un « Monologue intérieur » et un ensemble de « Mains » (Outils).

La boucle ressemble à ceci :

Réflexion : L’Agent analyse la demande de l’utilisateur et planifie une étape. (“L’utilisateur veut la météo à Paris. Je dois trouver la température actuelle.”)
Action : L’agent sélectionne un outil dans sa boîte à outils. (“J’appellerai weather_api.get('Paris').”)
Observation : L’agent lit la sortie de l’outil. (“L’API a renvoyé 20°C.”)
Raisonnement : L’agent met à jour sa compréhension. (“D’accord, j’ai la température. Maintenant je peux répondre à l’utilisateur.”)
Réponse finale : L’agent répond. (“Il fait 20°C à Paris.”)

Cette boucle permet à l’agent de résoudre des problèmes en plusieurs étapes pour lesquels il n’a jamais été explicitement formé.

2. Implémentation du code (LangChain / TypeScript)

Voici comment implémenter un agent ReAct de base à l’aide des fonctions LangChain et OpenAI.

importer { ChatOpenAI } depuis "@langchain/openai" ;
importer { AgentExecutor, createOpenAIFunctionsAgent } depuis "langchain/agents" ;
importer {Pull} depuis "langchain/hub" ;
importer { z } depuis "zod" ;
importer { outil } depuis "@langchain/core/tools" ;

// 1. Définir les outils
// Les "Mains" de l'agent. Soyez très descriptif dans le champ 'description',
// car le LLM l'utilise pour décider quand appeler l'outil.

const searchTool = outil (
  asynchrone ({ requête }) => {
    console.log(`Recherche : ${query}`);
    // Simuler une recherche Google
    return "Il fait 20 degrés Celsius à Paris avec de légères pluies.";
  },
  {
    nom : "search_web",
    description: "Rechercher sur Internet des événements et des données actuels.",
    schéma : z.object({
      requête : z.string().describe("La requête de recherche"),
    }),
  }
);

const emailTool = outil (
  async ({ à, corps }) => {
    console.log(`Envoi d'e-mail à ${to}`);
    // Simuler SMTP
    return "E-mail envoyé avec succès.";
  },
  {
    nom : "send_email",
    description: "Envoyer un email à un utilisateur.",
    schéma : z.object({
      à : z.string().email(),
      corps : z.string(),
    }),
  }
);

const tools = [searchTool, emailTool];

// 2. Initialiser le cerveau (LLM)
modèle const = nouveau ChatOpenAI ({
  Nom du modèle : "gpt-4-turbo",
  température : 0, // Gardez-le déterministe pour les actions
});

// 3. Créer l'agent
// Nous extrayons une invite ReAct standard du hub LangChain
const prompt = wait Pull.pull("hwchase17/openai-functions-agent");

const agent = attendre createOpenAIFunctionsAgent ({
  llm : modèle,
  des outils,
  rapide,
});

const agentExecutor = nouveau AgentExecutor({
  mandataire,
  des outils,
});

// 4. Exécution
// Requête utilisateur : "Découvrez la météo à Paris et envoyez-la par email à boss@company.com"
résultat const = attendre agentExecutor.invoke({
  saisie : "Découvrez la météo à Paris et envoyez-la par email à boss@company.com",
});

console.log(result.output);

Procédure pas à pas de l’exécution :

Saisie : “Connaître la météo…”
Décision LLM : Le LLM voit qu’il ne connaît pas la météo. Il examine les « outils ». Il voit search_web. Il décide de l’appeler.
Sortie de l’outil : “Le temps à Paris est de 20 degrés…”
Décision LLM : Il contient désormais les informations. Mais la demande disait également « envoyez-le par e-mail ». Il examine les « outils ». Il voit « send_email ».
Action : Il construit une charge utile JSON {"to": "boss@company.com", "body": "Le temps est de 20°C"}.
Sortie de l’outil : “E-mail envoyé.”
Réponse finale : « J’ai envoyé l’e-mail. »

Cela automatise l’ensemble du flux de travail. Le développeur a écrit 0 ligne de logique « Météo vers e-mail ». L’IA l’a compris.

3. La zone dangereuse : boucles infinies et hallucinations

Donner des « mains » à une IA est dangereux. Et s’il reste coincé dans une boucle ?

Pensée : Je dois acheter un billet.
Action : Acheter un billet.
Observation : Erreur : Carte de crédit refusée.
Pensée : Je devrais réessayer.
Action : Acheter un billet.
Observation : Erreur…
(Répéter 1000 fois).

Les garde-corps sont obligatoires.

Max Itérations : limitez strictement la boucle ReAct à 5 ou 10 étapes. Si le problème n’est pas résolu d’ici là, abandonnez.
Human in the Loop : Pour les actions sensibles (Achat, Suppression, Emailing), forcez l’Agent à demander une confirmation.
- Agent : “Je suis sur le point d’envoyer cet e-mail. Continuer ? [O/N]”
Validation du schéma Zod : forcez les entrées de l’outil à correspondre à des types rigoureux. Si le LLM génère une chaîne où un nombre est requis, lancez une erreur de validation avant l’exécution de l’outil.

4. Le problème de mémoire (état du vecteur)

Les LLM standard ont une mémoire à court terme (fenêtre contextuelle). Si vous parlez à un agent pendant 1 heure, il oublie le début de la conversation. Pour créer un « collègue » vraiment utile, il lui faut de la mémoire à long terme. Nous utilisons des bases de données vectorielles (Pinecone, Milvus) pour stocker des « souvenirs ».

Action : l’agent stocke le résumé de la réunion dans la base de données.
Récupération : la semaine prochaine, lorsque vous demandez « De quoi avons-nous discuté à propos du projet X ? », l’agent interroge la base de données Vector, récupère le morceau pertinent et l’injecte dans le contexte. Il s’agit du RAG (Retrieval Augmented Generation) appliqué à l’état de l’agent.

5. Étude de cas : L’agent de support client autonome

Chez Maison Code, nous avons déployé un agent de support L2 pour un marchand Shopify à gros volume. Le problème : 40 % des billets étaient « Où est ma commande ? » (WISMO). Les agents humains ont passé 5 minutes par ticket :

Lisez le courrier électronique.
Copiez l’ID de commande.
Ouvrez Shopify.
Vérifiez l’état.
Ouvrez le tableau de bord Courier (FedEx).
Vérifiez le suivi.
Écrivez un e-mail.

La solution pour agents : Nous avons construit un Agent avec trois outils :

shopify_lookup_order(id)
fedex_track_package(tracking_number)
gmail_reply(texte)

Le résultat :

Résolution zéro contact : l’agent a résolu de manière autonome 85 % des tickets WISMO en < 30 secondes.
Disponibilité 24h/24 et 7j/7 : les clients ont obtenu des réponses à 3 heures du matin.
Coût : 0,05 € par ticket contre 2,50 € pour un agent humain.

Cependant, nous avons rencontré des cas extrêmes. Un client a demandé : « Où est ma commande ? » mais je n’en avais pas encore placé. L’agent a halluciné un numéro de commande. Nous avons résolu ce problème en ajoutant une étape « Vérifier l’identité de l’utilisateur » avant toute recherche.

6. Systèmes multi-agents (LangGraph / CrewAI)

Les agents uniques sont puissants. Les équipes d’agents sont révolutionnaires. LangGraph vous permet d’orchestrer plusieurs agents avec différents “Personas”.

Agent chercheur : possède google_search. Parcourez le Web à la recherche de données.
Agent Writer : possède markdown_formatter. Prend la recherche et rédige un article de blog.
Agent éditeur : Possède critique_tool. Examine le message et le rejette s’il est trop court.

Vous créez un graphique : Chercheur -> Écrivain -> Éditeur -> (Réussite) -> Publier. Chercheur -> Écrivain -> Éditeur -> (Rejeter) -> Écrivain.

Cela imite un véritable flux de travail d’équipe humaine. L’« Éditeur » contrôle le « Écrivain ».

7. Le coût de l’autonomie (Token Economics)

Les agents coûtent cher. Une seule requête simple peut déclencher 10 appels LLM internes (Pensée -> Action -> Pensée -> Action). Si vous utilisez GPT-4, cela coûte 0,30 € par exécution. Stratégie d’optimisation :

Modèle de routeur : utilisez un modèle bon marché (GPT-3.5) pour la logique de routage (“Quel outil dois-je utiliser ?”).
Modèle Solver : Utilisez un modèle coûteux (GPT-4) pour la génération complexe (“Écrire l’e-mail”).
Mise en cache : mettez en cache les résultats d’appels d’outils coûteux (par exemple, requêtes SQL). L’économie dictera l’adoption.

8. L’avenir : 2026 et au-delà

On passe du « Prompt Engineering » (parler au bot) au « Flow Engineering » (concevoir le graphe des agents). En 2026, les logiciels ne seront plus un ensemble de boutons statiques. Il s’agira d’un « système d’exploitation axé sur les objectifs ». Vous direz à votre ordinateur : « Planifiez un voyage au Japon à moins de 5 000 € » et il agira. Il parcourra Expedia. Il vérifiera votre calendrier. Il négociera par e-mail. Nous construisons l’interface universelle.

9. Conclusion

Les agents de construction constituent le défi d’ingénierie le plus passionnant de notre décennie. Cela nécessite un mélange d’ingénierie dure (fiabilité des API, mise en cache, types) et de psychologie douce (invites, boucles de raisonnement). Commencez petit. Donnez à votre agent un outil. Regardez ça fonctionner. Alors donnez-en un autre. Bientôt, vous n’écrirez plus de logiciels. C’est vous qui le gérerez.

Besoin d’une main d’œuvre autonome ?

Nous construisons des flottes d’agents IA sécurisées et déterministes pour automatiser les opérations, le support et les ventes.

Engagez mes agents. Engagez nos Architectes.