Comparaison des SDK d’Agent : Un tutoriel pratique pour créer des applications intelligentes

Introduction : L’essor des agents intelligents et de leurs SDK

Dans le domaine en évolution rapide de l’intelligence artificielle, les agents intelligents deviennent de plus en plus essentiels à une large gamme d’applications. Des chatbots de service client et assistants personnels aux outils d’analyse de données sophistiqués et systèmes autonomes, les agents sont conçus pour percevoir leur environnement, raisonner sur leurs observations et prendre des mesures pour atteindre des objectifs spécifiques. Cependant, la création de ces agents nécessite des cadres et des outils solides, souvent fournis sous forme de kits de développement logiciel (SDK).

Un SDK d’agent offre généralement une collection de bibliothèques, d’API et d’outils de développement qui simplifient le processus de création, de déploiement et de gestion des agents intelligents. Ces SDK masquent une grande partie de la complexité sous-jacente, permettant aux développeurs de se concentrer sur la logique de l’agent, la représentation des connaissances et les modèles d’interaction. Avec une multitude de SDK disponibles, choisir le bon pour votre projet peut être une tâche décourageante. Ce tutoriel vise à démystifier ce processus en comparant certains SDK d’agents populaires à travers des exemples pratiques, vous aidant ainsi à prendre une décision éclairée.

Nous explorerons les fonctionnalités, les forces et les cas d’utilisation idéaux de plusieurs SDK de premier plan, fournissant des extraits de code et des explications pour illustrer leur application pratique. Notre objectif est de vous doter des connaissances nécessaires pour sélectionner et utiliser efficacement un SDK d’agent afin de donner vie à vos applications intelligentes.

Considérations clés lors du choix d’un SDK d’agent

Avant d’explorer des SDK spécifiques, il est crucial de comprendre les critères qui devraient guider votre sélection :

• Support des langages de programmation : Le SDK prend-il en charge votre langage préféré (Python, Java, JavaScript, etc.) ?
• Paradigme de l’agent : Est-il aligné avec le type d’agent que vous construisez (par exemple, réactif, délibératif, BDI) ?
• Scalabilité et performance : Peut-il gérer la charge et la complexité attendues de votre système d’agent ?
• Facilité d’utilisation et courbe d’apprentissage : À quel point est-il simple de commencer et de développer avec le SDK ?
• Communauté et documentation : Existe-t-il un soutien communautaire actif et une documentation complète ?
• Capacités d’intégration : Comment s’intègre-t-il avec d’autres outils et services (bases de données, plateformes cloud, bibliothèques NLP) ?
• Extensibilité : Pouvez-vous facilement étendre ses fonctionnalités ou intégrer des composants personnalisés ?
• Licences et coût : Est-il open-source, commercial ou a-t-il des conditions de licence spécifiques ?

SDK 1 : Rasa – La puissance de l’IA conversationnelle

Présentation

Rasa est un cadre d’apprentissage automatique open-source pour des conversations automatisées par texte et par voix. Il est particulièrement bien adapté pour créer des chatbots sophistiqués et des assistants virtuels. Rasa fournit une boîte à outils complète pour la compréhension du langage naturel (NLU), la gestion des dialogues et la génération de réponses, permettant aux développeurs de créer des agents conversationnels hautement contextuels et intelligents.

Caractéristiques clés

• Compréhension du langage naturel (NLU) : Extrait les intentions et les entités des messages des utilisateurs.
• Gestion des dialogues : Gère le flux de la conversation, suit le contexte et décide de la prochaine action.
• Actions personnalisées : Permet l’intégration avec des API et des bases de données externes.
• Gestion des données d’entraînement : Outils pour créer et gérer des exemples d’entraînement.
• Scalabilité : Conçu pour les déploiements en production.

Exemple pratique : Un simple bot météo

Créons un bot météo basique en utilisant Rasa. Tout d’abord, vous devrez installer Rasa :

pip install rasa

Ensuite, initialisez un nouveau projet Rasa :

rasa init --no-prompt

Cela crée une structure de projet de base. Nous allons modifier data/nlu.yml, data/stories.yml, et domain.yml.

data/nlu.yml (Données d’entraînement NLU)

version: "3.1"
nlu:
- intent: greet
 examples: |
 - hi
 - hello
 - good morning
- intent: ask_weather
 examples: |
 - what's the weather like
 - tell me the weather
 - is it sunny in [London](city)
 - how's the weather in [Paris](city)
- intent: thank_you
 examples: |
 - thank you
 - thanks
- intent: goodbye
 examples: |
 - goodbye
 - bye

data/stories.yml (Histoires de dialogue)

version: "3.1"
stories:
- story: happy path
 steps:
 - intent: greet
 - action: utter_greet
 - intent: ask_weather
 - action: utter_ask_city
 - intent: ask_weather
 entities:
 - city: "New York"
 - action: action_fetch_weather
 - intent: thank_you
 - action: utter_you_welcome
 - intent: goodbye
 - action: utter_goodbye

domain.yml (Domaine de l’agent)

version: "3.1"
intents:
 - greet
 - ask_weather
 - thank_you
 - goodbye

entities:
 - city

slots:
 city:
 type: text
 influence_conversation: true
 mappings:
 - type: from_entity
 entity: city

responses:
 utter_greet:
 - text: "Hello! How can I help you today?"
 utter_ask_city:
 - text: "Which city are you interested in?"
 utter_you_welcome:
 - text: "You're welcome!"
 utter_goodbye:
 - text: "Goodbye! Have a great day."

actions:
 - action_fetch_weather

session_config:
 session_expiration_time: 60
 carry_over_slots_to_new_session: true

actions.py (Action personnalisée)

from typing import Any, Text, Dict, List

from rasa_sdk import Action, Tracker
from rasa_sdk.executor import CollectingDispatcher
from rasa_sdk.events import SlotSet

import requests # Pour récupérer des données météorologiques réelles, ou simuler pour la simplicité

class ActionFetchWeather(Action):

 def name(self) -> Text:
 return "action_fetch_weather"

 def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
 domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:

 city = tracker.get_slot("city")

 if not city:
 dispatcher.utter_message(text="Je n'ai pas compris la ville. Pourriez-vous me dire quelle ville ?")
 return []

 # Dans une application réelle, vous appelleriez une API météo ici.
 # Pour cet exemple, nous utiliserons une réponse simulée.
 weather_data = {
 "London": "Il fait nuageux avec une chance de pluie.",
 "Paris": "Ensoleillé et chaud.",
 "New York": "Un peu frais, autour de 10 degrés Celsius."
 }

 response = weather_data.get(city, f"Désolé, je n'ai pas d'informations météorologiques pour {city} en ce moment.")
 dispatcher.utter_message(text=response)

 return [SlotSet("city", None)] # Efface le slot de la ville après avoir fourni la météo

Pour exécuter cela, entraînez le modèle Rasa :

rasa train

Ensuite, démarrez le serveur Rasa et le serveur d’actions (dans des terminaux séparés) :

rasa run -m models --enable-api --cors "*"
rasa run actions

Vous pouvez ensuite interagir avec votre bot via la ligne de commande :

rasa shell

Forces : Excellent pour l’IA conversationnelle, forte NLU et gestion des dialogues, open-source, communauté active.
Faiblesses : Courbe d’apprentissage plus raide pour les tâches non conversationnelles, principalement axé sur l’interaction texte/voix.
Cas d’utilisation idéal : Chatbots, assistants virtuels, interfaces conversationnelles pour des applications.

SDK 2 : AIMA Python – Agents IA classiques pour l’éducation et la recherche

Présentation

Le manuel ‘Artificial Intelligence: A Modern Approach’ (AIMA) de Russell et Norvig est une pierre angulaire de l’éducation en IA. Le dépôt de code Python qui l’accompagne, souvent appelé AIMA Python, fournit des implémentations de nombreux algorithmes IA classiques et cadres d’agents discutés dans le livre. Bien qu’il ne s’agisse pas d’un SDK de production à part entière, c’est une ressource inestimable pour comprendre les concepts fondamentaux des agents et prototyper des systèmes intelligents simples.

Caractéristiques clés

• Architectures d’agents classiques : Implémentations d’agents réflexes simples, d’agents réflexes basés sur des modèles, d’agents basés sur des objectifs et d’agents basés sur l’utilité.
• Algorithmes de recherche : Divers algorithmes de recherche (BFS, DFS, A*, etc.) pour la résolution de problèmes.
• Logique et planification : Outils de base pour la logique propositionnelle, la logique du premier ordre et la planification.
• Accent éducatif : Conçu pour illustrer les principes fondamentaux de l’IA.

Exemple pratique : Un agent réflexe simple (Monde de l’aspirateur)

Implémentons un agent réflexe simple pour le classique monde de l’aspirateur. Cet agent perçoit son emplacement actuel et s’il est sale, puis agit en fonction d’un ensemble de règles prédéfini.

Tout d’abord, vous devrez cloner ou télécharger le dépôt AIMA Python :

git clone https://github.com/aimacode/aima-python.git

Accédez au répertoire et vous pourrez utiliser ses modules. Nous allons définir un environnement et un agent.

vacuum_agent.py

from agents import Agent, Environment, Percept, TraceAgent, SimpleReflexAgent

class VacuumEnvironment(Environment):
 """L'environnement pour le monde de l'aspirateur."""
 def __init__(self, A='clean', B='clean'):
 super().__init__()
 self.status = {'A': A, 'B': B}
 self.percepts = {'A': None, 'B': None}
 self.location = 'A'

 def percept(self, agent):
 """Renvoie la perception de l'agent sur l'environnement."""
 return (self.location, self.status[self.location])

 def execute_action(self, agent, action):
 """Exécute l'action de l'agent dans l'environnement."""
 if action == 'Right':
 self.location = 'B'
 elif action == 'Left':
 self.location = 'A'
 elif action == 'Suck':
 if self.status[self.location] == 'dirty':
 self.status[self.location] = 'clean'
 # print(f"Agent {agent.name} a effectué {action}. Env: {self.status}, Loc: {self.location}")

 def default_location(self, agent):
 return 'A'

 def default_percept(self):
 return ('A', 'clean') # Perception par défaut pour l'environnement


def SimpleVacuumAgent():
 """Un agent réflexe simple pour le monde de l'aspirateur."""
 return SimpleReflexAgent({
 (('A', 'dirty'), 'Suck'),
 (('B', 'dirty'), 'Suck'),
 (('A', 'clean'), 'Right'),
 (('B', 'clean'), 'Left')
 })


if __name__ == '__main__':
 # Créer un environnement avec de la saleté
 env = VacuumEnvironment(A='dirty', B='dirty')

 # Créer l'agent
 agent = SimpleVacuumAgent()

 # Ajouter l'agent à l'environnement
 env.add_agent(agent)

 # Exécuter la simulation pendant quelques étapes
 print("Environnement initial :", env.status, "Emplacement :", env.location)
 env.run(steps=10)
 print("Environnement final :", env.status, "Emplacement :", env.location)

 # Un autre scénario
 env2 = VacuumEnvironment(A='clean', B='dirty')
 agent2 = SimpleVacuumAgent()
 env2.add_agent(agent2)
 print("\nEnvironnement initial (2) :", env2.status, "Emplacement :", env2.location)
 env2.run(steps=5)
 print("Environnement final (2) :", env2.status, "Emplacement :", env2.location)

Ce script définit un VacuumEnvironment et un SimpleVacuumAgent utilisant la classe SimpleReflexAgent du cadre Python AIMA. Les règles de l’agent dictent ses actions en fonction uniquement de sa perception actuelle (emplacement et statut de saleté).

Forces : Excellent pour apprendre les fondamentaux de l’IA, mises en œuvre claires des algorithmes classiques, léger.
Faiblesses : Pas conçu pour la production, fonctionnalités limitées par rapport aux SDK complets, principalement pour un usage académique.
Cas d’utilisation idéal : Éducation, recherche, prototypage d’agents IA conceptuels, compréhension des paradigmes d’agents.

SDK 3 : Microsoft Bot Framework – Développement de bots de niveau entreprise

Aperçu

Microsoft Bot Framework est une plateforme complète pour créer, connecter, déployer et gérer des bots intelligents sur divers canaux. Elle fournit des outils, des SDK et des services qui permettent aux développeurs de créer des interfaces conversationnelles capables de comprendre le langage naturel, de s’engager dans un dialogue et de s’intégrer à des systèmes backend. Elle est particulièrement performante pour les applications d’entreprise et utilise d’autres services Microsoft Azure tels que Azure Cognitive Services (par exemple, LUIS pour le NLU).

Caractéristiques clés

• Support multi-canal : Se connecte à des canaux populaires tels que Teams, Slack, Facebook Messenger, chat web, etc.
• SDKs de Bot Builder : Disponibles pour C#, JavaScript, Python et Java.
• Dialogues adaptatifs : Gestion avancée des dialogues pour des flux conversationnels complexes.
• Compréhension du langage (LUIS) : Le service NLU de Microsoft pour la reconnaissance d’intentions et d’entités.
• QnA Maker : Service pour créer rapidement des bots capables de répondre à des questions fréquentes.
• Intégration avec Azure : intégration fluide avec d’autres services Azure pour l’intelligence, le stockage et le calcul.

Exemple pratique : Un bot écho simple (Python)

Créons un bot écho de base en utilisant le SDK Microsoft Bot Framework pour Python. Ce bot répète simplement ce que l’utilisateur dit.

Tout d’abord, installez le SDK :

pip install botbuilder-core botbuilder-schema botbuilder-dialogs aiohttp

Créez un fichier nommé app.py :

import asyncio
from datetime import datetime

from aiohttp import web
from botbuilder.core import BotFrameworkAdapter, BotFrameworkAdapterSettings, TurnContext
from botbuilder.schema import Activity, ActivityTypes

# L'APP_ID et le APP_PASSWORD de votre bot peuvent être configurés ici.
# Pour les tests locaux, ceux-ci peuvent souvent être laissés vides.
SETTINGS = BotFrameworkAdapterSettings(
 app_id="",
 app_password=""
)

# Créer un adaptateur. L'adaptateur est responsable de la gestion des requêtes HTTP entrantes
# et de la création d'un TurnContext pour chaque appel.
adapter = BotFrameworkAdapter(SETTINGS)

async def on_error(context: TurnContext, error: Exception):
 """Callback pour les erreurs durant un tour."""
 print(f"\n [on_error] erreur non gérée : {error}")

 # Envoyer un message à l'utilisateur
 await context.send_activity("Le bot a rencontré une erreur ou un bogue.")
 await context.send_activity("Pour continuer à exécuter ce bot, veuillez corriger le code du bot.")

 # Envoyer une activité de trace
 trace_activity = Activity(
 label="TurnError",
 name="on_error Exception",
 timestamp=datetime.utcnow(),
 type=ActivityTypes.trace,
 value=f"Exception : {error}",
 value_type="https://schema.org/Exception",
 )
 await context.send_activity(trace_activity)

adapter.on_turn_error = on_error

class MyBot:
 """Bot écho de base qui répète ce que l'utilisateur dit."""
 async def on_turn(self, turn_context: TurnContext):
 if turn_context.activity.type == ActivityTypes.message:
 await turn_context.send_activity(f"Vous avez dit : {turn_context.activity.text}")
 elif turn_context.activity.type == ActivityTypes.conversation_update:
 # Gérer les mises à jour de conversation, par exemple, lorsqu'un utilisateur rejoint la conversation
 if turn_context.activity.members_added:
 for member in turn_context.activity.members_added:
 if member.id != turn_context.activity.recipient.id:
 await turn_context.send_activity("Bonjour et bienvenue !")
 else:
 await turn_context.send_activity(f"[{turn_context.activity.type} événement détecté]")


# Créer l'instance du bot
BOT = MyBot()

async def messages(request):
 """Point d'entrée principal pour les messages du bot."""
 if "application/json" in request.headers["Content-Type"]:
 body = await request.json()
 else:
 return web.Response(status=415)

 activity = Activity().deserialize(body)
 auth_header = request.headers["Authorization"] if "Authorization" in request.headers else ""

 try:
 # Traiter l'activité avec la logique du bot
 response = await adapter.process_activity(activity, auth_header, BOT.on_turn)
 if response:
 return web.json_response(data=response.body, status=response.status)
 return web.Response(status=200)
 except Exception as e:
 return web.Response(status=500, text=str(e))

app = web.Application()
app.router.add_post("/api/messages", messages)

if __name__ == "__main__":
 try:
 web.run_app(app, host="localhost", port=3978)
 except Exception as e:
 print(f"Erreur lors du démarrage du serveur : {e}")

Exécutez l’application :

python app.py

Pour tester cela localement, vous aurez besoin de l’Émulateur Bot Framework. Téléchargez-le depuis le site officiel de Microsoft Bot Framework. Une fois installé, ouvrez l’émulateur et connectez-vous à http://localhost:3978/api/messages.

Forces : Prêt pour l’entreprise, documentation extensive, support multi-canal, intégration étroite avec les services Azure (NLU, Audio, QnA), gestion des dialogues solide.
Faiblesses : Peut être complexe pour des bots simples, liens forts avec l’écosystème Microsoft, peut entraîner des coûts Azure.
Cas d’utilisation idéal : Chatbots d’entreprise, bots de service client, assistants organisationnels internes, applications conversationnelles complexes nécessitant évolutivité et intégration avec d’autres services Microsoft.

SDK 4 : LangChain – L’orchestrateur pour les agents alimentés par LLM

Aperçu

LangChain est un cadre en évolution rapide conçu pour simplifier la création d’applications alimentées par de grands modèles de langage (LLM). Bien que ce ne soit pas un SDK d’Agent au sens traditionnel des agents BDI (Croyance-Désir-Intention), LangChain offre une couche d’abstraction puissante et un ensemble d’outils pour construire des agents sophistiqués pilotés par LLM. Ces agents peuvent raisonner, utiliser des outils et interagir avec diverses sources de données, ce qui en fait un cadre crucial pour la nouvelle génération d’applications IA.

Caractéristiques clés

• Chains : Combinez des LLM avec d’autres composants (par exemple, modèles de prompt, analyseurs) pour former des séquences d’opérations.
• Agents : LLMs qui peuvent raisonner sur quels outils utiliser et dans quel ordre pour atteindre un objectif.
• Mémoire : Ajoutez de la persistance aux chaînes et aux agents, leur permettant de se souvenir des interactions passées.
• Outils : Abstractions pour les ressources externes et les API avec lesquelles les agents peuvent interagir (par exemple, moteurs de recherche, calculatrices, bases de données).
• Document Loaders & Embeddings : Outils pour ingérer et traiter des données pour une génération augmentée par récupération.

Exemple pratique : Un agent de recherche simple sur Wikipedia

Créons un agent LangChain qui peut utiliser Wikipedia pour répondre à des questions. Vous aurez besoin d’une clé API OpenAI pour le LLM.

Tout d’abord, installez LangChain et les dépendances nécessaires :

pip install langchain openai wikipedia

Définissez votre clé API OpenAI en tant que variable d’environnement (ou directement dans le code, bien que la variable d’env soit recommandée).

export OPENAI_API_KEY='YOUR_OPENAI_API_KEY'

wikipedia_agent.py

import os

from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.llms import OpenAI

# Initialiser le LLM (par exemple, OpenAI's GPT-3.5-turbo)
llm = OpenAI(temperature=0)

# Charger les outils que l'agent utilisera
# L'outil 'wikipedia' permet de rechercher sur Wikipedia
# 'llm-math' est un outil de calcul simple
tools = load_tools(["wikipedia", "llm-math"], llm=llm)

# Initialiser l'agent avec le LLM et les outils
# AgentType.ZERO_SHOT_REACT_DESCRIPTION est un type d'agent courant
# qui utilise le LLM pour décider quel outil utiliser et quel input lui donner.
agent = initialize_agent(
 tools,
 llm,
 agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
 verbose=True # Réglez sur True pour voir le processus de pensée de l'agent
)

# Exemples de questions pour l'agent
questions = [
 "Quelle est la capitale de la France?",
 "Combien de personnes vivent à Paris?",
 "Qui était le 44e président des États-Unis?",
 "Quel est 123 * 456?"
]

for q in questions:
 print(f"\n--- Question: {q} ---")
 try:
 agent.run(q)
 except Exception as e:
 print(f"Une erreur est survenue : {e}")

Lorsque vous exécutez ce script, vous’observerez le ‘processus de pensée’ de l’agent si verbose=True. Il analysera la question, décidera d’utiliser l’outil ‘wikipedia’, formulera une requête de recherche, exécutera l’outil, puis utilisera les informations récupérées pour répondre à la question.

Forces: Excellent pour les applications alimentées par des LLM, modulaire et flexible, écosystème riche d’intégrations (outils, chargeurs de données), communauté en développement rapide.
Faiblesses: Évolution rapide (les API peuvent changer), nécessite une compréhension des concepts LLM, peut être gourmande en ressources (appels d’API).
Cas d’utilisation idéal: Construire des agents intelligents qui utilisent des LLM pour le raisonnement, la récupération d’informations, l’automatisation de tâches complexes et l’interaction avec des services externes.

Conclusion: Choisir le Bon Outil pour Votre Voyage Agentique

Comme nous l’avons vu, le monde des SDK d’agents est diversifié, chaque cadre offrant des forces uniques et répondant à différents cas d’utilisation. Il n’y a pas de solution unique; le meilleur SDK pour votre projet dépend fortement de vos besoins spécifiques, du type d’agent que vous envisagez et de votre écosystème de développement.

• Rasa excelle dans l’IA conversationnelle solide, offrant des capacités NLU approfondies et la gestion du dialogue pour les chatbots et les assistants virtuels.
• AIMA Python est un outil éducatif et de recherche inestimable pour comprendre les concepts fondamentaux des agents d’IA, parfait pour le prototypage et l’exploration académique.
• Microsoft Bot Framework propose une solution de niveau entreprise pour construire des bots évolutifs et multicanaux, surtout lorsqu’il est intégré dans l’écosystème Azure plus large.
• LangChain est à l’avant-garde du développement d’agents alimentés par des LLM, permettant un raisonnement complexe, l’utilisation d’outils et l’interaction avec diverses sources de données pour créer des systèmes hautement intelligents et adaptatifs.

Avant de vous engager dans un SDK, envisagez de prototyper avec quelques options, en évaluant leur courbe d’apprentissage, le soutien de la communauté et la manière dont ils s’intègrent à votre technologie existante. Les exemples fournis dans ce tutoriel devraient servir de point de départ pratique pour explorer ces outils puissants. En pesant soigneusement vos besoins par rapport aux capacités de chaque SDK, vous pouvez vous engager avec confiance dans la construction d’agents intelligents qui transforment vos applications et expériences utilisateur.

🕒 Published: March 27, 2026