Que vous construisiez des applications d'IA ou que vous automatisiez des tâches complexes, faire fonctionner un agent d'IA avec les données et les outils appropriés peut s'avérer difficile. Les systèmes d'IA simples ont souvent du mal lorsqu'ils doivent raisonner, récupérer des informations ou gérer des tâches à partir de sources différentes. Les agents LlamaIndex facilitent cela en connectant les modèles d'IA à des outils, des données et des systèmes de récupération pour traiter les tâches plus efficacement. Lisez cet article pour apprendre à créer et déployer un workflow d'agent LlamaIndex pour des applications d'IA plus intelligentes et plus flexibles.
Qu'est-ce qu'un agent LlamaIndex ?
Un agent LlamaIndex est un système d'IA capable de raisonner sur une tâche et de décider des étapes nécessaires pour l'accomplir. Il peut décomposer une requête complexe en tâches plus petites, sélectionner des outils et utiliser des données externes en cas de besoin. Les agents peuvent également se souvenir des étapes précédentes et utiliser les informations récupérées pour améliorer leurs réponses. Cela leur permet de traiter des tâches qui vont au-delà d'une simple réponse à une question.
Comment fonctionnent les agents LlamaIndex ?
Les agents LlamaIndex permettent aux applications basées sur des LLM d'aller au-delà de la simple réponse aux questions, en permettant aux modèles de raisonner sur les tâches, de sélectionner des outils et d'accomplir des workflows en plusieurs étapes. Au lieu de suivre un pipeline fixe, un agent décide dynamiquement des actions nécessaires en fonction de l'objectif de l'utilisateur et des capacités disponibles.
Un workflow type d'agent LlamaIndex suit ce processus :
User request
↓
Understand the task
↓
Select tools
↓
Execute actions
↓
Process results
↓
Return final responseComprendre les objectifs de l'utilisateur
Lorsqu'un agent reçoit une requête, le LLM sous-jacent analyse la tâche, le contexte disponible et les outils connectés pour déterminer la meilleure approche.
Pour les requêtes simples, l'agent peut générer directement une réponse. Pour les tâches complexes, il peut décomposer la requête en étapes plus petites et décider des opérations nécessaires.
Sélectionner et utiliser des outils
Les outils étendent les capacités d'un agent au-delà du LLM lui-même. Les agents LlamaIndex peuvent se connecter à des fonctions Python personnalisées, des moteurs de requête, des API, des bases de données et des systèmes de récupération via des outils tels que FunctionTool et QueryEngineTool.
Par exemple, un agent peut utiliser un outil de recherche pour collecter des informations, un outil de base de données pour récupérer des enregistrements, ou une fonction personnalisée pour effectuer des calculs.
Exécuter les tâches via une boucle d'agent
Après avoir sélectionné un outil, l'agent exécute l'action, observe le résultat et décide de l'étape suivante. Cette boucle de raisonnement-action permet aux agents de gérer des workflows complexes nécessitant plusieurs opérations.
Reason → Act → Observe → RepeatSi la tâche n'est pas terminée, l'agent peut continuer à appeler des outils ou à affiner son approche jusqu'à ce qu'il génère une réponse finale.
Gérer le contexte et les workflows
Les agents LlamaIndex conservent le contexte pertinent tout au long du processus d'exécution, ce qui les aide à gérer des tâches en plusieurs étapes et à utiliser les résultats des étapes précédentes. Pour des applications plus complexes, les développeurs peuvent utiliser des workflows et des architectures multi-agents pour coordonner plusieurs agents, chacun prenant en charge un rôle ou une tâche spécifique.
Par exemple :
Research Agent
↓
Analysis Agent
↓
Writing AgentCela rend les agents react LlamaIndex adaptés à des applications telles que les assistants de recherche IA, les systèmes de connaissances d'entreprise et les workflows de données automatisés.
Composants principaux des agents LlamaIndex
Les multi-agents LlamaIndex combinent plusieurs composants pour transformer un LLM en un système capable de raisonner, d'utiliser des fonctions externes et de maintenir un contexte. Chaque composant a un rôle différent, mais ils fonctionnent ensemble pour aider l'agent à traiter les tâches plus efficacement. Voici quelques-uns de ses composants principaux :
LLM : le moteur de raisonnement des agents
Le LLM agit comme le principal moteur de raisonnement qui interprète les requêtes de l'utilisateur et décide de la suite à donner. Il peut analyser le contexte disponible et déterminer s'il doit répondre directement ou utiliser un outil. LlamaIndex prend en charge différents fournisseurs de LLM, permettant aux développeurs de choisir un modèle selon les besoins de leur application. Le LLM contrôle donc la prise de décision et la génération de réponses de l'agent.
Outils : étendre les capacités de l'agent
Les outils permettent à un agent d'effectuer des actions qui vont au-delà de la simple génération de texte. Il peut s'agir de fonctions Python simples ou d'outils spécialisés pour travailler avec des API, des moteurs de requête et d'autres services externes. L'agent décide quel outil utiliser et fournit les entrées requises en fonction de la demande de l'utilisateur. Les résultats des outils sont ensuite ajoutés à la conversation afin que l'agent puisse les utiliser à l'étape suivante.
Mémoire : maintenir le contexte
La mémoire permet aux agents LlamaIndex de conserver les informations pertinentes pendant l'exécution d'une tâche. Par défaut, les agents utilisent un ChatMemoryBuffer, qui conserve l'historique de la conversation disponible pendant l'exécution. Les développeurs peuvent également personnaliser la configuration de la mémoire, par exemple en définissant une limite de tokens selon l'application. Cela aide les agents à maintenir le contexte et à gérer des tâches nécessitant plusieurs étapes.
Types d'agents LlamaIndex
LlamaIndex propose différents types d'agents pour traiter les tâches selon le niveau de raisonnement, d'utilisation des outils et de contrôle requis. Voyons les principaux types et leurs différences :
| Type d'agent | Fonctionnement | Fonctionnalités clés | Meilleurs cas d'usage |
|---|---|---|---|
| FunctionAgent | Utilise les capacités d'appel de fonctions des LLM modernes pour sélectionner et exécuter des outils prédéfinis en fonction des demandes de l'utilisateur. | Appel de fonctions natif Entrées et sorties structurées Exécution fiable des outils Implémentation simple | Assistants IA Workflows d'automatisation métier Applications basées sur des API Agents orientés tâches |
| ReActAgent | Utilise l'approche Reasoning + Acting, où l'agent raisonne de manière itérative sur une tâche, effectue des actions, observe les résultats, et continue jusqu'à la finalisation. | Raisonnement étape par étape Sélection dynamique des outils Gère les tâches multi-étapes Résolution de problèmes flexible | Assistants de recherche Réponses à des questions complexes Exploration de données Workflows ouverts |
| CodeActAgent | Permet aux agents de résoudre des tâches en générant et en exécutant du code lorsque le raisonnement basé sur le code est plus efficace. | Génération et exécution de code Résolution de problèmes par programmation Adapté aux tâches computationnelles | Analyse de données Workflows scientifiques Assistants de programmation |
| Systèmes multi-agents | Utilise plusieurs agents spécialisés qui collaborent, délèguent des tâches et accomplissent ensemble des workflows complexes. | Collaboration entre agents Délégation de tâches Spécialisation des rôles Workflows évolutifs | Pipelines de recherche automatisés Workflows d'entreprise Processus métier complexes |
Ces agents offrent aux développeurs la flexibilité de choisir la bonne approche pour différentes tâches et workflows. Une fois le type d'agent sélectionné, l'étape suivante consiste à le connecter à un backend LLM capable d'alimenter son raisonnement et son utilisation des outils. Voyons comment créer des agents d'IA avec LlamaIndex et l'API Kimi.
Comment créer des agents d'IA avec LlamaIndex et l'API Kimi ?
Connecter LlamaIndex à une API de LLM donne à l'agent la puissance de raisonnement nécessaire pour comprendre les requêtes et choisir les bonnes actions. Les étapes suivantes montrent comment configurer un agent d'IA avec LlamaIndex et l'API Kimi, depuis la configuration du modèle jusqu'à l'exécution de l'agent :
Étape 1 : Prérequis
Avant de commencer, assurez-vous de disposer des éléments suivants :
Python 3.9+ installé
Une clé API Kimi valide obtenue depuis Moonshot AI Platform
Une bonne connaissance des agents LlamaIndex et des concepts RAG
Étape 2 : Installer les dépendances
L'exemple original utilise llama-index-llms-ollama. Remplacez-le par llama-index-llms-openai pour vous connecter à l'API compatible OpenAI de Kimi. Conservez le package d'embedding HuggingFace pour des embeddings locaux et gratuits.
pip install llama-index llama-index-llms-openai llama-index-embeddings-huggingfaceÉtape 3 : Configurer les variables d'environnement
Stockez votre clé API Kimi de manière sécurisée à l'aide d'une variable d'environnement. Ne l'insérez pas directement dans vos scripts.
export KIMI_API_KEY = "your-kimi-api-key-here"Sur Windows (PowerShell) :
$env:KIMI_API_KEY = "your-kimi-api-key-here"Étape 4 : Créer l'agent de base avec l'API Kimi
Créez un fichier nommé starter_kimi.py. Cela remplace le LLM Ollama par Kimi tout en conservant la même logique d'agent et les mêmes définitions d'outils.
from llama_index.core.agent.workflow import FunctionAgent; import os
from llama_index.llms.openai import OpenAI; import asyncio
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core import Settings
# Configure global settings
Settings.llm = OpenAI(
model="kimi-latest", # Or: kimi-k2, kimi-k2.5, etc.
api_key=os.getenv("KIMI_API_KEY"),
api_base="https://api.moonshot.ai/v1",
temperature=0.3,
request_timeout=120.0,
)
Settings.embed_model = HuggingFaceEmbedding(
model_name="BAAI/bge-base-en-v1.5"
)
# Define a calculator tool
def multiply(a: float, b: float) -> float:
"""Useful for multiplying two numbers."""
return a * b
# Create the agent
agent = FunctionAgent(
tools=[multiply],
llm=Settings.llm,
system_prompt="You are a helpful assistant that can multiply two numbers.",
)
async def main():
response = await agent.run("What is 1234 * 4567?")
print(str(response))
if __name__ == "__main__":
asyncio.run(main())Exécutez le script :
python starter_kimi.pyRésultat attendu :
The answer to 1234 * 4567 is 5635678.Étape 5 : Ajouter l'historique de conversation (contexte)
Pour permettre des conversations multi-tours, passez un objet Context. L'agent conservera la mémoire entre les appels.
from llama_index.core.workflow import Context
# Create context
ctx = Context(agent)
# Run agent with context
response = await agent.run("My name is Logan", ctx=ctx)
print(response)
response = await agent.run("What is my name?", ctx=ctx)
print(response)Étape 6 : Ajouter des capacités RAG avec l'API Kimi
Améliorez l'agent avec la récupération de documents. L'étape d'embedding reste locale, tandis que la génération passe par Kimi.
Préparer des données d'exemple
mkdir data
wget https://raw.githubusercontent.com/run-llama/llama_index/main/docs/examples/data/paul_graham/paul_graham_essay.txt -O data/paul_graham_essay.txtScript complet de l'agent doté de RAG
Créez starter_kimi_rag.py :
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings; import os
from llama_index.core.agent.workflow import AgentWorkflow; import asyncio
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
# Global settings
Settings.embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-base-en-v1.5")
Settings.llm = OpenAI(
model="kimi-k3",
api_key=os.getenv("KIMI_API_KEY"),
api_base="https://api.moonshot.ai/v1",
temperature=0.3,
)
# Load documents and build index
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
# Define tools
def multiply(a: float, b: float) -> float:
"""Useful for multiplying two numbers."""
return a * b
async def search_documents(query: str) -> str:
"""Useful for answering natural language questions about Paul Graham's essay."""
response = await query_engine.aquery(query)
return str(response)
# Create enhanced agent
agent = AgentWorkflow.from_tools_or_functions(
[multiply, search_documents],
llm=Settings.llm,
system_prompt="""You are a helpful assistant that can perform calculations
and search through documents to answer questions.""",
)
async def main():
response = await agent.run(
"What did the author do in college? Also, what's 7 * 8?"
)
print(response)
if __name__ == "__main__":
asyncio.run(main())Exécutez le script :
python starter_kimi_rag.pypython starter_kimi_rag.pyÉtape 7 : Persister l'index RAG
Pour éviter de retraiter les documents à chaque exécution, persistez l'index vectoriel sur disque.
# Save the index
index.storage_context.persist("storage")
# Later, load the index
from llama_index.core import StorageContext, load_index_from_storage
storage_context = StorageContext.from_defaults(persist_dir="storage")
index = load_index_from_storage(storage_context)
query_engine = index.as_query_engine()# Save the index
index.storage_context.persist("storage")
# Later, load the index
from llama_index.core import StorageContext, load_index_from_storage
storage_context = StorageContext.from_defaults(persist_dir="storage")
index = load_index_from_storage(storage_context)
query_engine = index.as_query_engine()Dépannage
Si vous rencontrez des problèmes lors de la configuration de l'agent, quelques soucis courants peuvent affecter l'authentification, la connectivité, l'installation des packages ou la vitesse d'embedding. Le tableau ci-dessous présente les erreurs les plus fréquentes et leurs solutions, afin de résoudre rapidement les problèmes de configuration :
| Problème | Cause | Solution |
|---|---|---|
AuthenticationError | Clé API invalide ou manquante | Vérifiez que KIMI_API_KEY est correctement exportée |
Connection timeout | Latence réseau vers api.moonshot.ai | Augmentez request_timeout à 300.0 ou plus |
ModuleNotFoundError | Package manquant | Relancez pip install llama-index-llms-openai |
| L'embedding est lent sur CPU | Modèle Hugging Face exécuté sur CPU | Utilisez un modèle plus petit ou activez l'accélération GPU |
Avantages de l'utilisation de l'API Kimi
Une fois l'agent connecté et fonctionnel, la combinaison de LlamaIndex et de l'API Kimi offre plusieurs avantages concrets pour créer des applications d'IA performantes. Voici quelques avantages clés de l'utilisation de l'API Kimi avec les agents LlamaIndex :
Créer des agents IA plus performants : l'API Kimi renforce les agents LlamaIndex grâce à de solides capacités de compréhension du langage et de raisonnement, ce qui aide les agents à choisir les outils, traiter les informations et accomplir les tâches plus efficacement.
Améliorer la récupération et l'analyse des données : associé au framework de données de LlamaIndex, Kimi peut exploiter des documents privés et des bases de connaissances pour générer des réponses plus précises et contextualisées.
Permettre des workflows d'IA flexibles : LlamaIndex connecte les agents à des outils, des API et des moteurs de requête, tandis que Kimi apporte l'intelligence nécessaire pour décider quand et comment utiliser ces capacités.
Prendre en charge des applications d'IA complexes : grâce à sa compréhension de contextes longs et à ses capacités d'agent, l'API Kimi associée à LlamaIndex convient à la création d'assistants de recherche, d'agents de connaissance et d'applications d'analyse de documents.
Applications concrètes des agents LlamaIndex
Les agents LlamaIndex peuvent être utilisés pour un large éventail de tâches où l'IA doit raisonner, accéder à des informations et agir. Leur capacité à connecter les LLM à des outils et des données les rend utiles dans la recherche, les activités professionnelles, l'analytique et le support client. Voici quelques applications concrètes :
Assistant de recherche IA
Un assistant de recherche IA peut parcourir des documents, récupérer des informations pertinentes et aider à répondre à des questions complexes. Il peut décomposer une tâche de recherche en étapes plus petites et utiliser différents outils selon les besoins. Cela facilite l'analyse de grandes quantités d'informations et la préparation de réponses détaillées.
Agent de connaissance en entreprise
Un agent de connaissance en entreprise peut mettre les employés en relation avec des documents internes, des bases de données et des bases de connaissances. Il peut récupérer les informations pertinentes de l'entreprise et fournir des réponses basées sur les données métier disponibles. Cela aide les employés à trouver l'information plus rapidement sans avoir à fouiller manuellement dans plusieurs systèmes.
Agent d'analyse de données
Un agent d'analyse de données peut travailler avec des jeux de données et utiliser des outils pour traiter, analyser et interpréter les informations. Il peut effectuer des calculs, identifier des tendances et aider à expliquer les résultats de manière simple. Il est ainsi utile pour des tâches telles que les rapports, l'exploration de données et l'analyse commerciale.
Agent de service client
Un agent de service client peut accéder aux informations sur les produits, aux FAQ et aux ressources d'assistance pour répondre aux questions des clients. Il peut utiliser des outils pour récupérer les détails pertinents et traiter les demandes en fonction du contexte disponible. Cela permet d'automatiser les tâches d'assistance courantes tout en fournissant des réponses plus rapides et cohérentes.
Conclusion
Les agents LlamaIndex offrent un moyen concret de créer des systèmes d'IA capables de raisonner, d'utiliser des outils et de travailler avec des informations pertinentes. Leur flexibilité les rend utiles pour créer des applications qui vont au-delà de simples conversations. Avec le bon modèle de langage en arrière-plan, ces agents peuvent être adaptés à différentes tâches et workflows. Essayez Kimi API avec LlamaIndex pour créer et tester votre propre agent IA. Explorez Kimi et découvrez ce que vous pouvez créer avec.