Tutoriel de comparaison des SDK d’agent : Construire des applications intelligentes avec des exemples pratiques

Introduction aux SDK d’Agent

Le domaine de l’intelligence artificielle évolue rapidement, avec une attention croissante portée aux agents intelligents capables d’effectuer des tâches complexes, d’interagir avec les utilisateurs et de s’adapter à des environnements dynamiques. Construire de tels agents à partir de zéro peut être une tâche ardue, nécessitant une expertise en traitement du langage naturel, apprentissage automatique, représentation des connaissances, et plus encore. C’est ici que les SDK d’Agent (Kits de Développement Logiciel) entrent en jeu. Les SDK d’Agent fournissent aux développeurs des composants, des frameworks et des outils pré-construits pour accélérer le développement d’agents intelligents, masquant une grande partie de la complexité sous-jacente.

Un SDK d’Agent propose généralement des fonctionnalités pour définir les comportements des agents, gérer les flux de conversation, s’intégrer à des outils et API externes, gérer la mémoire et le contexte, et inclut souvent des fonctionnalités pour le déploiement et la surveillance. Choisir le bon SDK d’Agent est crucial pour le succès de votre projet, car différents SDK répondent à divers cas d’utilisation, langages de programmation et niveaux d’abstraction. Ce tutoriel vise à fournir une comparaison pratique de plusieurs SDK d’Agent populaires, illustrant leurs forces et faiblesses à travers des exemples concrets.

Fonctionnalités Clés à Considérer dans un SDK d’Agent

• Support de Langage : Prend-il en charge votre langage de programmation préféré (Python, JavaScript, Java, etc.) ?
• Facilité d’Utilisation et Courbe d’Apprentissage : Quelle rapidité pour un nouveau développeur pour devenir productif avec le SDK ?
• Capacités d’Intégration : Peut-il s’intégrer facilement à d’autres services, API, bases de données et systèmes existants ?
• Gestion d’État et Mémoire : Comment gère-t-il le contexte conversationnel et la mémoire à long terme pour l’agent ?
• Orchestration et Flux de Travail : Fournit-il des outils pour définir des comportements complexes des agents, la prise de décision et les processus multi-étapes ?
• Scalabilité et Performance : Peut-il gérer un volume élevé d’interactions et des calculs complexes ?
• Options de Déploiement : Quels sont les environnements de déploiement pris en charge (cloud, sur site, sans serveur) ?
• Communauté et Documentation : Existe-t-il une communauté active et une documentation complète pour aider durant le développement ?
• Extensibilité : Quelle facilité pour étendre les fonctionnalités du SDK avec des composants personnalisés ?

Comparer les SDK d’Agent : LangChain vs. LlamaIndex vs. Microsoft Semantic Kernel

Pour ce tutoriel, nous allons nous concentrer sur trois SDK d’Agent proéminents et largement utilisés : LangChain, LlamaIndex et Microsoft Semantic Kernel. Chacun d’eux propose une approche unique pour construire des agents intelligents, en particulier ceux utilisant des modèles de langage de grande taille (LLMs).

1. LangChain : L’Orchestrateur pour les Applications Basées sur des LLM

LangChain a rapidement émergé comme un framework dominant pour développer des applications soutenues par de grands modèles de langage. Sa philosophie fondamentale repose sur l’idée de « chaîner » différents composants ensemble pour créer des flux de travail complexes. Il propose un ensemble complet d’abstractions pour interagir avec les LLM, gérer les prompts, traiter la mémoire conversationnelle, s’intégrer à des outils externes (Agents), et récupérer des informations à partir de diverses sources de données (Retrieval).

Fonctionnalités Clés de LangChain :

• Chaînes : Définir des séquences d’appels, par exemple, modèles de prompt + LLM + parseur de sortie.
• Agents : Permettre aux LLM de choisir une séquence d’actions à réaliser, utilisant souvent des outils.
• Mémoire : Stocker et récupérer des informations sur les interactions passées.
• Chargeurs : Charger des données de diverses sources (PDF, sites web, bases de données).
• Vectorstores : Stocker et interroger des embeddings pour la recherche sémantique.
• Outils : Fonctionnalités externes qu’un agent peut utiliser (par exemple, moteurs de recherche, calculatrices, API personnalisées).

Exemple Pratique de LangChain : Un Agent Conversationnel Simple avec Utilisation d’Outils

Construisons un agent LangChain capable de répondre à des questions générales et d’utiliser un outil de calculatrice si une opération mathématique est détectée.

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_core.tools import Tool
from langchain.chains import LLMMathChain

# 1. Initialiser le LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")

# 2. Définir les Outils
# Outil de calculatrice
llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
calculator = Tool(
 name="Calculator",
 func=llm_math_chain.run,
 description="Utile pour répondre à des questions sur les mathématiques."
)

tools = [calculator]

# 3. Obtenir le prompt depuis LangChain Hub (style ReAct)
# Le prompt ReAct guide le LLM pour penser, observer et agir.
prompt = hub.pull("hwchase17/react")

# 4. Créer l'agent ReAct
agent = create_react_agent(llm, tools, prompt)

# 5. Créer l'Exécuteur d'Agent
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 6. Exécuter l'agent
print(agent_executor.invoke({"input": "Quelle est la capitale de la France ?"}))
print(agent_executor.invoke({"input": "Quel est 1234 * 5678 ?"}))

Explication :

• Nous initialisons un modèle de chat OpenAI.
• Nous définissons un outil Calculator en utilisant LLMMathChain de LangChain.
• Nous tirons un prompt ReAct standard depuis LangChain Hub. ReAct (Raisonnement et Action) est un paradigme qui permet aux LLM d’effectuer un raisonnement dynamique et une planification d’action.
• create_react_agent combine le LLM, les outils et le prompt pour créer un agent.
• AgentExecutor est responsable de l’exécution de l’agent, de la gestion de son processus de pensée et de l’exécution des outils.
• Lorsque l’on demande la capitale de la France, le LLM répond directement. Lorsqu’on pose une question mathématique, il reconnait le besoin de la calculatrice, appelle l’outil et fournit le résultat.

2. LlamaIndex : Framework de Données pour les Applications LLM

Alors que LangChain se concentre fortement sur l’orchestration et le chaînage des appels LLM, LlamaIndex (anciennement GPT Index) se spécialise dans l’ingestion de données, l’indexation et la récupération pour les applications LLM. Son objectif principal est de faciliter la connexion des LLM avec des sources de données personnalisées, permettant des applications puissantes de RAG (Retrieval-Augmented Generation). LlamaIndex excelle à construire des bases de connaissances et à les rendre interrogeables par les LLM.

Fonctionnalités Clés de LlamaIndex :

• Connecteurs de Données : Ingesta des données de diverses sources (documents, bases de données, API).
• Indexation de Données : Structurer et stocker des données de manière optimisée pour les requêtes LLM (par exemple, magasins de vecteurs, graphes de connaissances).
• Moteurs de Requête : Récupérer des informations pertinentes à partir des index et synthétiser des réponses en utilisant les LLM.
• Agents : Combiner des moteurs de requête avec des outils et des LLM pour un raisonnement plus complexe et multi-étape sur les données.
• Contexte de Service : Gérer le LLM, le modèle d’embedding et d’autres configurations de service.

Exemple Pratique de LlamaIndex : Interroger un Document Personnalisé

Créons une simple application LlamaIndex capable de répondre à des questions basées sur un fichier texte local.

# Tout d'abord, créer un fichier fictif : 'policy.txt'
# Contenu :
# "La politique de congés de notre entreprise accorde aux employés 15 jours de congé payé par an. 
# Après 5 ans de service, les employés reçoivent 5 jours supplémentaires. 
# Les jours de congé non utilisés ne sont pas reportés à l'année suivante."

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
import os

# Définir la clé API OpenAI (assurez-vous qu'elle est dans vos variables d'environnement)
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

# 1. Configurer le LLM et le Modèle d'Embedding (optionnel, mais bonne pratique)
Settings.llm = OpenAI(model="gpt-4o", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")

# 2. Charger des documents depuis un répertoire
documents = SimpleDirectoryReader("data").load_data() # En supposant que 'policy.txt' est dans un répertoire 'data'

# 3. Créer un index à partir des documents (VectorStoreIndex est commun)
index = VectorStoreIndex.from_documents(documents)

# 4. Créer un moteur de requête
query_engine = index.as_query_engine()

# 5. Interroger le moteur
response = query_engine.query("Combien de jours de congé les employés ont-ils par an ?")
print(response)

response = query_engine.query("Que se passe-t-il avec les jours de congé non utilisés ?")
print(response)

Explication :

• Nous créons d’abord un fichier policy.txt dans un répertoire data.
• Nous configurons le LLM et le modèle d’embedding via Settings.
• SimpleDirectoryReader charge le fichier texte.
• VectorStoreIndex.from_documents traite les documents, les divise en morceaux, les intègre, et les stocke dans une base de données vectorielle (en mémoire par défaut).
• index.as_query_engine() crée une interface pour interroger l’index.
• Lorsqu’une requête est faite, le moteur de requête récupère des morceaux de documents pertinents en fonction de la similarité sémantique, puis utilise le LLM pour synthétiser une réponse à partir de ces morceaux.

3. Microsoft Semantic Kernel : L’Orchestrateur pour les Applications AI avec Plugins

Microsoft Semantic Kernel (SK) est un SDK open-source qui permet aux développeurs d’intégrer de grands modèles de langage (LLMs) et d’autres capacités d’intelligence artificielle dans leurs applications en utilisant des langages de programmation existants (C#, Python, Java). Il se concentre sur la possibilité pour les applications d’orchestrer des interactions avec les LLM et du code traditionnel, en mettant l’accent sur une architecture de « plugin ». SK est particulièrement robuste pour les développeurs déjà dans l’écosystème Microsoft ou ceux cherchant un cadre solide de niveau entreprise.

Fonctionnalités Clés de Semantic Kernel :

• Kernel : Le moteur central d’orchestration pour l’IA et le code traditionnel.
• Compétences/Plugins : Collections de fonctions sémantiques (invites LLM) et de fonctions natives (code traditionnel) que l’IA peut invoquer.
• Fonctions Sémantiques : Invites qui définissent ce que le LLM doit faire.
• Fonctions Natives : Méthodes de code traditionnel exposées à l’IA, lui permettant d’interagir avec des systèmes externes.
• Mémoire : Stocker et récupérer des informations pour le contexte de conversation.
• Planificateurs : Permettent à l’IA de planifier et d’exécuter une séquence de compétences afin d’atteindre un objectif.

Exemple Pratique de Kernel Sémantique : Un Planificateur Simple avec Plugin Personnalisé

Créons une application Kernel Sémantique qui peut saluer l’utilisateur et effectuer également une opération arithmétique simple à l’aide d’une fonction native personnalisée (plugin).

import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function
import asyncio

# 1. Initialiser le Kernel
kernel = sk.Kernel()

# 2. Configurer le service LLM
# Assurez-vous que votre OPENAI_API_KEY est défini en tant que variable d'environnement
kernel.add_service(
 OpenAIChatCompletion(
 service_id="chat_completion",
 ai_model_id="gpt-4o",
 ),
)

# 3. Définir un plugin natif personnalisé (Compétences dans SK)
class MathPlugin:
 @kernel_function(description="Ajoute deux nombres ensemble.", name="Add")
 def add(self, num1: float, num2: float) -> float:
 return num1 + num2

 @kernel_function(description="Multiplie deux nombres ensemble.", name="Multiply")
 def multiply(self, num1: float, num2: float) -> float:
 return num1 * num2

# 4. Importer le plugin dans le kernel
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")

# 5. Définir une fonction sémantique (pour la conversation générale)
# C'est une invite simple qui peut être invoquée directement ou utilisée par un planificateur
prompt_template = "{{$input}}"
chat_function = kernel.create_function_from_prompt(
 prompt_template=prompt_template,
 plugin_name="ChatPlugin",
 function_name="Chat"
)

async def main():
 # 6. Invoquer directement la fonction de chat
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Bonjour, que peux-tu faire pour moi ?"))
 print(f"Réponse de chat : {result}")

 # 7. Utiliser un planificateur pour orchestrer des actions, y compris notre MathPlugin
 # Pour une planification complexe, vous utiliseriez un planificateur dédié comme SequentialPlanner
 # Pour cet exemple simple, nous allons montrer un appel direct via une invite avec des capacités d'appel de fonction
 
 # Le LLM, lorsqu'il est invoqué avec la bonne invite, reconnaîtra et utilisera les plugins enregistrés.
 # Créons un objectif pour le LLM à atteindre en utilisant les plugins disponibles.
 
goal = "J'ai besoin de connaître la somme de 10 et 20, puis de multiplier ce résultat par 3."

 # Le mécanisme d'appel de fonction de SK permet au LLM de choisir la bonne fonction.
 # Nous allons utiliser un service de complétion de chat directement, lui permettant d'utiliser des outils.
 history = kernel.create_chat_history()
 history.add_user_message(goal)

 response = await kernel.get_service("chat_completion").get_chat_message_content(
 history=history,
 settings=sk.OpenAIChatCompletionSettings(function_call="auto")
 )
 print(f"Réponse du planificateur : {response}")

if __name__ == "__main__":
 asyncio.run(main())

Explication :

• Nous initialisons le Kernel et ajoutons un service de complétion de chat OpenAI.
• Nous définissons une classe MathPlugin avec des décorateurs @kernel_function, exposant add et multiply comme fonctions natives.
• Nous importons ce plugin dans le kernel.
• Une fonction sémantique simple chat_function est créée pour une interaction directe avec le LLM.
• Dans main(), nous invoquons d’abord la fonction de chat directement.
• Ensuite, pour l’exemple de planification, nous créons un historique de chat avec un objectif. En utilisant function_call="auto" dans les paramètres, le LLM est en mesure de décider s’il doit répondre directement ou appeler l’une des fonctions natives (plugins) enregistrées pour atteindre l’objectif. SK gère la traduction de l’appel de fonction du LLM en véritables invocations de méthodes et renvoie ensuite le résultat au LLM.

Choisir le Bon SDK d’Agent

Le choix du SDK d’Agent dépend fortement des besoins spécifiques de votre projet et de votre technologie existante :

• Choisissez LangChain si :
  • Vous avez besoin d’une orchestration LLM étendue, d’un comportement agentique complexe et d’une chaîne flexible de composants.
  • Vous souhaitez intégrer une large variété de LLMs, d’outils et de types de mémoire.
  • Vous construisez des applications qui impliquent un raisonnement en plusieurs étapes, une sélection d’outils dynamique et des agents conversationnels.
  • Vous appréciez une communauté large et active ainsi que des exemples étendus.
• Choisissez LlamaIndex si :
  • Votre principal objectif est de connecter les LLMs à vos données personnalisées (documents, bases de données, APIs) pour le RAG.
  • Vous avez besoin de bonnes capacités d’ingestion de données, d’indexation et de récupération.
  • Vous construisez des systèmes de questions-réponses basés sur une base de connaissances, des résumeurs de documents ou des agents conscients des données.
  • Vous priorisez une gestion des données efficace et évolutive pour les LLMs.
• Choisissez Microsoft Semantic Kernel si :
  • Vous êtes un développeur C#, Python ou Java cherchant à intégrer l’IA en douceur dans des applications existantes.
  • Vous voulez un cadre solide, prêt pour l’entreprise, de Microsoft.
  • Vous avez besoin de combiner les capacités des LLM (fonctions sémantiques) avec du code traditionnel (fonctions/plugins natives) de manière structurée.
  • Vous construisez des applications qui nécessitent que l’IA interagisse avec vos systèmes internes et APIs.

Conclusion

Les SDK d’Agent sont des outils indispensables pour construire des applications IA sophistiquées. LangChain, LlamaIndex et Microsoft Semantic Kernel offrent chacun des fonctionnalités puissantes adaptées à différents aspects du développement IA. LangChain excelle dans l’orchestration de flux de travail LLM complexes et le raisonnement agentique. LlamaIndex est le choix idéal pour l’intégration de données et la génération augmentée par récupération. Semantic Kernel fournit une solide fondation pour intégrer l’IA dans des applications existantes avec une architecture de plugins solide, en particulier pour des cas d’utilisation en entreprise. En comprenant leurs forces fondamentales et en les voyant en action à travers des exemples pratiques, vous êtes désormais mieux équipé pour choisir le bon SDK afin de donner vie à vos idées d’agents intelligents.

🕒 Published: March 27, 2026