Construire un agent RAG simple avec LlamaIndex

LlamaIndex est un framework permettant de créer des applications d'IA générative augmentées par le contexte avec des LLM.

Qu’est-ce que l’augmentation de contexte ?

L'augmentation de contexte fait référence à une technique dans laquelle des informations ou un contexte pertinents supplémentaires sont fournis à un modèle LLM, améliorant ainsi sa compréhension et ses réponses à une requête donnée. Cette augmentation implique généralement la récupération, l'intégration ou l'attachement de sources de données externes telles que des documents, des intégrations, à l'entrée du modèle. L'objectif est de rendre le modèle plus informé en lui fournissant le contexte nécessaire qui l'aide à donner des réponses meilleures, plus précises et nuancées. La génération augmentée de récupération (RAG) est l'exemple le plus populaire d'augmentation de contexte.

Que sont les agents ?

Les agents sont des moteurs de raisonnement et de décision automatisés alimentés par des LLM qui utilisent des outils pour effectuer des recherches, des extractions de données, des recherches sur le Web et bien d'autres tâches. Ils peuvent être utilisés pour des cas d'utilisation simples comme la réponse à des questions basées sur les données ou pour pouvoir décider et prendre des mesures afin d'accomplir des tâches.

Dans cet article, nous allons créer un agent RAG simple en utilisant LlamaIndex.

Construire un agent RAG

Installation des dépendances

Nous utiliserons Python pour créer un agent RAG simple à l'aide de LlamaIndex. Installons d'abord les dépendances requises comme ci-dessous :

pip install llama-index python-dotenv

Mise en place du LLM et chargement des documents

Nous utiliserons le gpt-4o-mini d'OpenAI comme LLM. Vous devez mettre la clé API dans le fichier de variables d'environnement. Vous pouvez en savoir plus sur la mise en place d'un LLM local à l'aide de LLamaIndex ici.

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex, Settings
from llama_index.llms.openai import OpenAI
from dotenv import load_dotenv

# Load environment variables (e.g., OPENAI_API_KEY)
load_dotenv()

# Configure OpenAI model
Settings.llm = OpenAI(model="gpt-4o-mini")

# Load documents from the local directory
documents = SimpleDirectoryReader("./data").load_data()

# Create an index from documents for querying
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()

• Nous configurons d'abord le modèle LLM en utilisant OpenAI et en spécifiant le modèle gpt-4o-mini. Vous pouvez passer à d'autres modèles/LLM disponibles en fonction de vos besoins.
• Ensuite, nous utilisons SimpleDirectoryReader pour charger les documents depuis le répertoire local ./data. Ce lecteur parcourt le répertoire, lit les fichiers et structure les données pour les interrogations.
• Ensuite, nous créons un index de magasin vectoriel à partir des documents chargés, ce qui nous permet d'effectuer une récupération efficace basée sur les vecteurs lors de l'exécution de la requête.

Création de fonctions personnalisées pour l'agent

Définissons maintenant quelques fonctions de base que l'agent peut utiliser pour effectuer des tâches.

def multiply(a: float, b: float) -> float:
    """Multiply two numbers and returns the product"""
    return a * b

def add(a: float, b: float) -> float:
    """Add two numbers and returns the sum"""
    return a + b

Création d'outils pour l'agent

Ensuite, nous allons créer des outils à partir des fonctions et du moteur de requête que nous avons défini précédemment, que l'agent utilisera pour effectuer des tâches. Ces outils agissent comme des utilitaires que l'agent peut exploiter lors du traitement de différents types de requêtes.

from llama_index.core.tools import FunctionTool, QueryEngineTool

# Wrap functions as tools
add_tool = FunctionTool.from_defaults(fn=add)
multiply_tool = FunctionTool.from_defaults(fn=multiply)

# Create a query engine tool for document retrieval
space_facts_tool = QueryEngineTool.from_defaults(
    query_engine,
    name="space_facts_tool",
    description="A RAG engine with information about fun space facts."
)

• Le FunctionTool enveloppe les fonctions d'addition et de multiplication et les expose en tant qu'outils. L'agent peut désormais accéder à ces outils pour effectuer des calculs.
• Le QueryEngineTool encapsule le query_engine pour permettre à l'agent d'interroger et de récupérer des informations à partir du magasin de vecteurs. Nous l'avons nommé space_facts_tool avec une description, indiquant que cet outil peut récupérer des informations sur les faits spatiaux. Vous pouvez ingérer n'importe quoi et personnaliser l'outil en fonction des données ingérées.

Création de l'agent

Nous allons maintenant créer l'agent à l'aide de ReActAgent. L'agent sera responsable de décider quand utiliser les outils et comment répondre aux requêtes.

from llama_index.core.agent import ReActAgent

# Create the agent with the tools
agent = ReActAgent.from_tools(
    [multiply_tool, add_tool, space_facts_tool], verbose=True
)

Cet agent utilise le framework ReAct, qui permet au modèle de raisonner et d'agir en utilisant les outils donnés dans une séquence logique. L'agent est initialisé avec les outils que nous avons créés et l'indicateur verbose=True affichera des informations détaillées sur la façon dont l'agent raisonne et exécute les tâches.

Exécution de l'agent

Enfin, exécutons l'agent dans une boucle interactive où il traite les requêtes des utilisateurs jusqu'à ce que nous quittions.

while True:
    query = input("Query: ")

    if query == "/bye":
        exit()

    response = agent.chat(query)
    print(response)
    print("-" * 10)

Comment fonctionne l'agent RAG ?

• Lorsque vous posez une question relative aux documents que vous avez ingérés, le space_facts_tool, c'est-à-dire l'outil de stockage vectoriel, récupère les informations pertinentes à l'aide du query_engine.
• Lorsque vous demandez des calculs, l'agent utilise add_tool ou multiplie_tool pour effectuer ces tâches.
• L'agent décide à la volée quel outil utiliser en fonction de la requête de l'utilisateur et fournit le résultat.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!