Tutoriel de comparaison de l’Agent SDK : Construire des applications intelligentes avec des exemples pratiques

Introduction aux SDK d’Agent

L’espace de l’intelligence artificielle évolue rapidement, avec un accent croissant sur les 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 depuis le début peut être une tâche décourageante, nécessitant une expertise en traitement du langage naturel, apprentissage automatique, représentation des connaissances, et plus encore. C’est là qu’interviennent les SDK d’Agent (kits de développement logiciel). Les SDK d’Agent fournissent aux développeurs des composants prédéfinis, des frameworks et des outils pour accélérer le développement d’agents intelligents, en abstraisant une grande partie de la complexité sous-jacente.

Un SDK d’Agent offre 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 APIs 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.

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

• Support Linguistique : Prend-il en charge votre langage de programmation préféré (Python, JavaScript, Java, etc.) ?
• Facilité d’Utilisation et Courbe d’Apprentissage : À quelle vitesse un nouveau développeur peut-il devenir productif avec le SDK ?
• Capacités d’Intégration : Peut-il s’intégrer facilement avec d’autres services, APIs, bases de données et systèmes existants ?
• Gestion de l’État et Mémoire : Comment gère-t-il le contexte de conversation et la mémoire à long terme de l’agent ?
• Orchestration et Workflow : 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 supportés (cloud, sur site, sans serveur) ?
• Communauté et Documentation : Existe-t-il une communauté active et une documentation complète pour aider pendant le développement ?
• Extensibilité : Quelle est la facilité d’extension des 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 prominents 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 Alimentées par LLM

LangChain a rapidement émergé comme un cadre dominant pour développer des applications alimentées par de grands modèles de langage. Sa philosophie centrale tourne autour de la ‘chaînage’ de différents composants pour créer des flux de travail complexes. Il fournit un ensemble complet d’abstractions pour interagir avec les LLMs, gérer les invites, traiter la mémoire conversationnelle, s’intégrer à des outils externes (Agents), et récupérer des informations de diverses sources de données (Récupération).

Caractéristiques Clés de LangChain :

• Chaînes : Définir des séquences d’appels, par exemple, modèles d’invite + LLM + analyseur de sortie.
• Agents : Permettre aux LLMs de choisir une séquence d’actions à entreprendre, souvent en utilisant des outils.
• Mémoire : Stocker et récupérer des informations sur les interactions passées.
• Chargeurs : Charger des données depuis 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, APIs personnalisées).

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

Créons un agent LangChain capable de répondre à des questions générales et d’utiliser un outil de calcul, 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 calcul
llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
calculator = Tool(
 name="Calculator",
 func=llm_math_chain.run,
 description="Utile lorsque vous devez répondre à des questions sur les mathématiques."
)

tools = [calculator]

# 3. Obtenir l'invite depuis LangChain Hub (style ReAct)
# L'invite ReAct guide le LLM à 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'Agent Executor
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": "Quelle est 1234 * 5678 ?"}))

Explication :

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

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

Tandis que LangChain se concentre fortement sur l’orchestration et le chaînage d’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 LLMs avec des sources de données personnalisées, permettant des applications RAG (Récupération-Augmentée par Génération) puissantes. LlamaIndex excelle dans la construction de bases de connaissances et leur rendabilité interrogable par les LLMs.

Caractéristiques Clés de LlamaIndex :

• Connecteurs de Données : Ingestion de données provenant de diverses sources (documents, bases de données, APIs).
• Indexation des Données : Structurer et stocker les données d’une manière optimisée pour les requêtes LLM (par exemple, magasins de vecteurs, graphiques de connaissances).
• Moteurs de Requête : Récupérer des informations pertinentes à partir des index et synthétiser des réponses en utilisant des LLMs.
• Agents : Combiner des moteurs de requête avec des outils et des LLMs pour un raisonnement plus complexe 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 application LlamaIndex simple capable de répondre à des questions basées sur un fichier texte local.

# D'abord, créez un fichier factice : 'policy.txt'
# Contenu :
# "La politique de vacances 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 se reportent pas à 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 courant)
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 obtiennent-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 incruste 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êtes 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 Alimentées par l’IA 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’IA dans leurs applications en utilisant des langages de programmation existants (C#, Python, Java). Il se concentre sur l’habilitation des applications à orchestrer des interactions avec des LLMs et du code traditionnel, en mettant l’accent sur une architecture de ‘plugin’. SK est particulièrement adapté pour les développeurs déjà dans l’écosystème Microsoft ou ceux à la recherche d’un cadre solide, de niveau entreprise.

Caractéristiques Clés du Semantic Kernel :

• Kernel : Le moteur central d’orchestration pour l’IA et le code traditionnel.
• Compétences/Plugins : Collections de fonctions sémantiques (prompts LLM) et de fonctions natives (code traditionnel) que l’IA peut invoquer.
• Fonctions Sémantiques : Prompts 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 contexteConversationnel.
• Planificateurs : Permettent à l’IA de planifier et d’exécuter une séquence de compétences pour atteindre un objectif.

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

Créons une application Kernel Sémantique qui peut saluer l’utilisateur et effectuer une simple opération arithmétique en utilisant 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 comme une 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.", name="Add")
 def add(self, num1: float, num2: float) -> float:
 return num1 + num2

 @kernel_function(description="Multiplie deux nombres.", 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 un prompt simple qui peut être invoqué directement ou utilisé 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 la fonction de chat directement
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Bonjour, que peux-tu faire pour moi ?"))
 print(f"Réponse du chat : {result}")

 # 7. Utiliser un planificateur pour orchestrer des actions, y compris notre MathPlugin
 # Pour un planning complexe, vous utiliseriez un planificateur dédié comme SequentialPlanner
 # Pour cet exemple simple, nous allons démontrer un appel direct via un prompt avec des capacités d'appel de fonction
 
 # Le LLM, lorsqu'il est invoqué avec le bon prompt, 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 en tant que 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 enregistrées (plugins) pour atteindre l’objectif. SK gère la traduction de l’appel de fonction du LLM en invocations de méthodes réelles et renvoie ensuite le résultat au LLM.

Choisir le Bon SDK Agent

Le choix de l’SDK Agent dépend fortement des besoins spécifiques de votre projet et de votre pile technologique 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 dynamique d’outils, et des agents conversationnels.
  • Vous appréciez une grande communauté active et de nombreux exemples.
• Choisissez LlamaIndex si :
  • Votre objectif principal est de connecter les LLMs à vos données personnalisées (documents, bases de données, APIs) pour le RAG.
  • Vous avez besoin de solides capacités d’ingestion de données, d’indexation, et de récupération.
  • Vous construisez des systèmes de questions/réponses de base de connaissances, des résumés de documents, ou des agents sensibles aux données.
  • Vous privilégiez 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 harmonieusement l’IA dans des applications existantes.
  • Vous voulez un cadre solide et prêt pour l’entreprise de Microsoft.
  • Vous devez combiner les capacités des LLM (fonctions sémantiques) avec le code traditionnel (fonctions natives/plugins) 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 pour agents sont des outils indispensables pour construire des applications d’IA sophistiquées. LangChain, LlamaIndex et Microsoft Semantic Kernel offrent chacun des fonctionnalités puissantes adaptées à différents aspects du développement de l’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 et la génération augmentée par la récupération de données. Semantic Kernel fournit une base solide pour intégrer l’IA dans des applications existantes avec une architecture de plugins robuste, en particulier pour les 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 sélectionner le bon SDK afin de donner vie à vos idées d’agents intelligents.

🕒 Published: March 27, 2026