Vous vous souvenez d’Alfred, notre agent majordome serviable de l’unité 1 ? Pour nous aider efficacement, Alfred doit comprendre nos demandes et préparer, trouver et utiliser les informations pertinentes pour aider à accomplir les tâches. C’est là que les components de LlamaIndex entrent en jeu.
Bien que LlamaIndex ait de nombreux components, nous nous concentrerons spécifiquement sur le component QueryEngine.
Pourquoi ? Parce qu’il peut être utilisé comme un tool de Retrieval-Augmented Generation (RAG) pour un agent.
Alors, qu’est-ce que le RAG ? Les LLMs sont entraînés sur d’énormes corpus de données pour apprendre les connaissances générales. Cependant, ils peuvent ne pas être entraînés sur des données pertinentes et à jour. Le RAG résout ce problème en trouvant et récupérant des informations pertinentes de vos données et en les donnant au LLM.

Maintenant, pensez à comment Alfred fonctionne :
QueryEngine aide Alfred à trouver ces informations et à les utiliser pour planifier le dînerCela fait du QueryEngine un component clé pour construire des workflows RAG agentiques dans LlamaIndex.
Tout comme Alfred a besoin de rechercher dans les informations de votre maison pour être utile, tout agent a besoin d’un moyen de trouver et comprendre des données pertinentes.
Le QueryEngine fournit exactement cette capacité.
Maintenant, approfondissons un peu les components et voyons comment vous pouvez combiner les components pour créer un pipeline RAG.
Il y a cinq étapes clés dans le RAG, qui feront partie de la plupart des applications plus importantes que vous construirez. Ce sont :
Ensuite, voyons comment nous pouvons reproduire ces étapes en utilisant des components.
Comme mentionné précédemment, LlamaIndex peut fonctionner au-dessus de vos propres données, cependant, avant d’accéder aux données, nous devons les charger. Il y a trois façons principales de charger des données dans LlamaIndex :
SimpleDirectoryReader : Un loader intégré pour divers types de fichiers d’un répertoire local.LlamaParse : LlamaParse, l’outil officiel de LlamaIndex pour l’analyse de PDFs, disponible comme une API gérée.LlamaHub : Un registre de centaines de bibliothèques de chargement de données pour ingérer des données de n’importe quelle source.La façon la plus simple de charger des données est avec SimpleDirectoryReader.
Ce component polyvalent peut charger divers types de fichiers d’un dossier et les convertir en objets Document avec lesquels LlamaIndex peut travailler.
Voyons comment nous pouvons utiliser SimpleDirectoryReader pour charger des données d’un dossier.
from llama_index.core import SimpleDirectoryReader
reader = SimpleDirectoryReader(input_dir="path/to/directory")
documents = reader.load_data()Après avoir chargé nos documents, nous devons les diviser en plus petites parties appelées objets Node.
Un Node est juste un morceau de texte du document original qui est plus facile à traiter pour l’IA, tout en conservant des références à l’objet Document original.
L’IngestionPipeline nous aide à créer ces nodes grâce à deux transformations clés.
SentenceSplitter divise les documents en morceaux gérables en les divisant aux limites naturelles des phrases.HuggingFaceEmbedding convertit chaque morceau en embeddings numériques - des représentations vectorielles qui capturent la signification sémantique d’une façon que l’IA peut traiter efficacement.Ce processus nous aide à organiser nos documents d’une manière qui est plus utile pour la recherche et l’analyse.
from llama_index.core import Document
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core.node_parser import SentenceSplitter
from llama_index.core.ingestion import IngestionPipeline
# create the pipeline with transformations
pipeline = IngestionPipeline(
transformations=[
SentenceSplitter(chunk_overlap=0),
HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5"),
]
)
nodes = await pipeline.arun(documents=[Document.example()])Après avoir créé nos objets Node, nous devons les indexer pour les rendre recherchables, mais avant de pouvoir le faire, nous avons besoin d’un endroit pour stocker nos données.
Puisque nous utilisons un pipeline d’ingestion, nous pouvons directement attacher un vector store au pipeline pour le remplir.
Dans ce cas, nous utiliserons Chroma pour stocker nos documents.
Comme introduit dans la section sur le LlamaHub, nous pouvons installer le vector store ChromaDB avec la commande suivante :
pip install llama-index-vector-stores-chroma
import chromadb
from llama_index.vector_stores.chroma import ChromaVectorStore
db = chromadb.PersistentClient(path="./alfred_chroma_db")
chroma_collection = db.get_or_create_collection("alfred")
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
pipeline = IngestionPipeline(
transformations=[
SentenceSplitter(chunk_size=25, chunk_overlap=0),
HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5"),
],
vector_store=vector_store,
)C’est là que les embeddings vectoriels entrent en jeu - en intégrant à la fois la requête et les nodes dans le même espace vectoriel, nous pouvons trouver des correspondances pertinentes.
Le VectorStoreIndex s’occupe de cela pour nous, en utilisant le même modèle d’embedding que nous avons utilisé pendant l’ingestion pour assurer la cohérence.
Voyons comment créer cet index à partir de notre vector store et embeddings :
from llama_index.core import VectorStoreIndex
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5")
index = VectorStoreIndex.from_vector_store(vector_store, embed_model=embed_model)Toutes les informations sont automatiquement persistées dans l’objet ChromaVectorStore et le chemin du répertoire passé.
Parfait ! Maintenant que nous pouvons sauvegarder et charger notre index facilement, explorons comment l’interroger de différentes manières.
Avant de pouvoir interroger notre index, nous devons le convertir en interface de requête. Les options de conversion les plus courantes sont :
as_retriever : Pour la récupération basique de documents, retournant une liste d’objets NodeWithScore avec des scores de similaritéas_query_engine : Pour les interactions question-réponse simples, retournant une réponse écriteas_chat_engine : Pour les interactions conversationnelles qui maintiennent la mémoire à travers plusieurs messages, retournant une réponse écrite utilisant l’historique de chat et le contexte indexéNous nous concentrerons sur le query engine car il est plus commun pour les interactions de type agent. Nous passons également un LLM au query engine à utiliser pour la réponse.
from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
llm = HuggingFaceInferenceAPI(model_name="Qwen/Qwen2.5-Coder-32B-Instruct")
query_engine = index.as_query_engine(
llm=llm,
response_mode="tree_summarize",
)
query_engine.query("What is the meaning of life?")
# The meaning of life is 42Sous le capot, le query engine n’utilise pas seulement le LLM pour répondre à la question mais utilise également un ResponseSynthesizer comme stratégie pour traiter la réponse.
Encore une fois, c’est entièrement personnalisable mais il y a trois stratégies principales qui fonctionnent bien prêtes à l’emploi :
refine : créer et affiner une réponse en parcourant séquentiellement chaque morceau de texte récupéré. Cela fait un appel LLM séparé par Node/morceau récupéré.compact (par défaut) : similaire à l’affinement mais concaténant les morceaux au préalable, résultant en moins d’appels LLM.tree_summarize : créer une réponse détaillée en parcourant chaque morceau de texte récupéré et créant une structure d’arbre de la réponse.Le modèle de langage ne performera pas toujours de manière prévisible, donc nous ne pouvons pas être sûrs que la réponse que nous obtenons soit toujours correcte. Nous pouvons gérer cela en évaluant la qualité de la réponse.
LlamaIndex fournit des outils d’évaluation intégrés pour évaluer la qualité des réponses. Ces évaluateurs exploitent les LLMs pour analyser les réponses à travers différentes dimensions. Regardons les trois évaluateurs principaux disponibles :
FaithfulnessEvaluator : Évalue la fidélité de la réponse en vérifiant si la réponse est supportée par le contexte.AnswerRelevancyEvaluator : Évalue la pertinence de la réponse en vérifiant si la réponse est pertinente par rapport à la question.CorrectnessEvaluator : Évalue la correction de la réponse en vérifiant si la réponse est correcte.from llama_index.core.evaluation import FaithfulnessEvaluator
query_engine = # from the previous section
llm = # from the previous section
# query index
evaluator = FaithfulnessEvaluator(llm=llm)
response = query_engine.query(
"What battles took place in New York City in the American Revolution?"
)
eval_result = evaluator.evaluate_response(response=response)
eval_result.passingMême sans évaluation directe, nous pouvons obtenir des insights sur la performance de notre système grâce à l’observabilité. Ceci est particulièrement utile quand nous construisons des workflows plus complexes et que nous voulons comprendre comment chaque component performe.
Comme introduit dans la section sur le LlamaHub, nous pouvons installer le callback LlamaTrace d’Arize Phoenix avec la commande suivante :
pip install -U llama-index-callbacks-arize-phoenix
De plus, nous devons définir la variable d’environnement PHOENIX_API_KEY avec notre clé API LlamaTrace. Nous pouvons l’obtenir en :
import llama_index
import os
PHOENIX_API_KEY = "<PHOENIX_API_KEY>"
os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"api_key={PHOENIX_API_KEY}"
llama_index.core.set_global_handler(
"arize_phoenix",
endpoint="https://llamatrace.com/v1/traces"
)Nous avons vu comment utiliser les components pour créer un QueryEngine. Maintenant, voyons comment nous pouvons utiliser le QueryEngine comme un tool pour un agent !