Que sont les components dans LlamaIndex ?

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.

RAG

Maintenant, pensez à comment Alfred fonctionne :

  1. Vous demandez à Alfred d’aider à planifier un dîner
  2. Alfred doit vérifier votre calendrier, vos préférences alimentaires et les menus précédents réussis
  3. Le QueryEngine aide Alfred à trouver ces informations et à les utiliser pour planifier le dîner

Cela 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.

Créer un pipeline RAG en utilisant des components

Vous pouvez suivre le code dans ce *notebook* que vous pouvez exécuter avec Google Colab.

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 :

  1. Chargement : cela se réfère à obtenir vos données d’où elles vivent — qu’il s’agisse de fichiers texte, de PDFs, d’un autre site web, d’une base de données, ou d’une API — dans votre workflow. LlamaHub fournit des centaines d’intégrations parmi lesquelles choisir.
  2. Indexation : cela signifie créer une structure de données qui permet d’interroger les données. Pour les LLMs, cela signifie presque toujours créer des embeddings vectoriels. Ce sont des représentations numériques de la signification des données. L’indexation peut également se référer à de nombreuses autres stratégies de métadonnées pour faciliter la recherche de données contextuellement pertinentes basées sur les propriétés.
  3. Stockage : une fois vos données indexées, vous voudrez stocker votre index, ainsi que d’autres métadonnées, pour éviter de devoir le ré-indexer.
  4. Requête : pour toute stratégie d’indexation donnée, il y a de nombreuses façons d’utiliser les LLMs et les structures de données LlamaIndex pour faire des requêtes, incluant des sous-requêtes, des requêtes multi-étapes et des stratégies hybrides.
  5. Évaluation : une étape critique dans tout flux est de vérifier son efficacité par rapport à d’autres stratégies, ou lorsque vous apportez des modifications. L’évaluation fournit des mesures objectives de la précision, de la fidélité et de la rapidité de vos réponses aux requêtes.

Ensuite, voyons comment nous pouvons reproduire ces étapes en utilisant des components.

Chargement et intégration des documents

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 :

  1. SimpleDirectoryReader : Un loader intégré pour divers types de fichiers d’un répertoire local.
  2. LlamaParse : LlamaParse, l’outil officiel de LlamaIndex pour l’analyse de PDFs, disponible comme une API gérée.
  3. LlamaHub : Un registre de centaines de bibliothèques de chargement de données pour ingérer des données de n’importe quelle source.
Familiarisez-vous avec les *loaders* *LlamaHub* et le *parser* *LlamaParse* pour des sources de données plus complexes.

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.

  1. SentenceSplitter divise les documents en morceaux gérables en les divisant aux limites naturelles des phrases.
  2. 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()])

Stockage et indexation des documents

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.

Installer ChromaDB

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,
)
Un aperçu des différents *vector stores* peut être trouvé dans la documentation LlamaIndex.

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.

Interroger un VectorStoreIndex avec des prompts et des LLMs

Avant de pouvoir interroger notre index, nous devons le convertir en interface de requête. Les options de conversion les plus courantes sont :

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 42

Traitement des réponses

Sous 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 :

Prenez un contrôle fin de vos *workflows* de requête avec l'API de composition de bas niveau. Cette API vous permet de personnaliser et d'ajuster finement chaque étape du processus de requête pour correspondre à vos besoins exacts, ce qui se marie également très bien avec les *Workflows*

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.

Évaluation et observabilité

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 :

Vous voulez en savoir plus sur l'observabilité et l'évaluation des agents ? Continuez votre parcours avec l'Unité Bonus 2.
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.passing

Mê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.

Installer LlamaTrace

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"
)
Vous voulez en savoir plus sur les *components* et comment les utiliser ? Continuez votre parcours avec les *Guides* des *Components* ou le *Guide* sur le *RAG*.

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 !

< > Update on GitHub