Créer des agents LLM pour RAG à partir de zéro et au-delà : un guide complet

Les LLM comme GPT-3, GPT-4 et leur homologue open source ont souvent du mal à récupérer des informations à jour et peuvent parfois générer des hallucinations ou des informations incorrectes.

Génération augmentée par récupération (RAG) est une technique qui combine la puissance des LLM avec la récupération de connaissances externes. RAG nous permet de fonder les réponses LLM sur des informations factuelles et à jour, améliorant ainsi considérablement la précision et la fiabilité du contenu généré par l'IA.

Dans cet article de blog, nous explorerons comment créer des agents LLM pour RAG de A à Z, en approfondissant l'architecture, les détails d'implémentation et les techniques avancées. Nous aborderons tous les aspects, des bases de RAG à la création d'agents sophistiqués capables de raisonnements complexes et d'exécution de tâches.

Avant de nous lancer dans la création de notre agent LLM, comprenons ce qu'est RAG et pourquoi il est important.

RAG, ou Retrieval-Augmented Generation, est une approche hybride qui combine la récupération d'informations et la génération de texte. Dans un système RAG :

• Une requête est utilisée pour récupérer des documents pertinents à partir d'une base de connaissances.
• Ces documents sont ensuite introduits dans un modèle de langage avec la requête d'origine.
• Le modèle génère une réponse basée à la fois sur la requête et sur les informations récupérées.

CHIFFON

Cette approche a de nombreux avantages:

• Précision améliorée: En fondant les réponses sur les informations récupérées, RAG réduit les hallucinations et améliore l'exactitude factuelle.
• Information à jour: La base de connaissances peut être régulièrement mise à jour, permettant au système d'accéder aux informations actuelles.
• Transparence: Le système peut fournir des sources pour ses informations, augmentant ainsi la confiance et permettant la vérification des faits.

Comprendre les agents LLM

Agents propulsés par LLM

Lorsque vous êtes confronté à un problème sans réponse simple, vous devez souvent suivre plusieurs étapes, réfléchir attentivement et vous rappeler ce que vous avez déjà essayé. Les agents LLM sont conçus exactement pour ce genre de situations dans les applications de modèles de langage. Ils combinent une analyse approfondie des données, une planification stratégique, une récupération de données et la capacité de tirer les leçons des actions passées pour résoudre des problèmes complexes.

Que sont les agents LLM ?

Les agents LLM sont des systèmes d'IA avancés conçus pour créer des textes complexes nécessitant un raisonnement séquentiel. Ils peuvent anticiper, se souvenir des conversations passées et utiliser différents outils pour ajuster leurs réponses en fonction de la situation et du style requis.

Considérez une question dans le domaine juridique telle que : « Quelles sont les conséquences juridiques potentielles d’un type spécifique de rupture de contrat en Californie ? » Un LLM de base avec un système de génération augmentée de récupération (RAG) peut récupérer les informations nécessaires à partir de bases de données juridiques.

Pour un scénario plus détaillé : « Compte tenu des nouvelles lois sur la confidentialité des données, quels sont les défis juridiques les plus courants auxquels les entreprises sont confrontées et comment les tribunaux les ont-ils abordés ? » Cette question va au-delà de la simple recherche de faits. Il s'agit de comprendre les nouvelles règles, leur impact sur les différentes entreprises et les réponses des tribunaux. Un agent LLM décomposerait cette tâche en sous-tâches, telles que la recherche des lois les plus récentes, l'analyse des affaires historiques, la synthèse des documents juridiques et la prévision des tendances en fonction des schémas.

Composants des agents LLM

Les agents LLM se composent généralement de quatre éléments :

1. Agent/Cerveau: Le modèle linguistique de base qui traite et comprend le langage.
2. Planification: La capacité de raisonner, de décomposer les tâches et d'élaborer des plans spécifiques.
3. Mémoire: Conserve des enregistrements des interactions passées et en tire des leçons.
4. Utilisation de l'outil: Intègre diverses ressources pour effectuer des tâches.

Agent/Cerveau

Au cœur d'un agent LLM se trouve un modèle de langage qui traite et comprend le langage en fonction de grandes quantités de données sur lesquelles il a été formé. Vous commencez par lui donner une invite spécifique, guidant l'agent sur la manière de répondre, les outils à utiliser et les objectifs à viser. Vous pouvez personnaliser l'agent avec un personnage adapté à des tâches ou des interactions particulières, améliorant ainsi ses performances.

Mémoire

Le composant mémoire aide les agents LLM à gérer des tâches complexes en conservant un enregistrement des actions passées. Il existe deux principaux types de mémoire :

• Mémoire à court terme: Agit comme un bloc-notes, gardant une trace des discussions en cours.
• Memoire à long terme: Fonctionne comme un journal, stockant les informations des interactions passées pour apprendre des modèles et prendre de meilleures décisions.

En mélangeant ces types de mémoire, l'agent peut proposer des réponses plus personnalisées et mémoriser les préférences de l'utilisateur au fil du temps, créant ainsi une interaction plus connectée et plus pertinente.

Planification

La planification permet aux agents LLM de raisonner, de décomposer les tâches en parties gérables et d'adapter les plans à mesure que les tâches évoluent. La planification comprend deux étapes principales :

• Formulation du plan: Décomposer une tâche en sous-tâches plus petites.
• Réflexion sur le plan: Examiner et évaluer l'efficacité du plan, en intégrant les commentaires pour affiner les stratégies.

Des méthodes telles que la chaîne de pensée (CoT) et l'arbre de pensée (ToT) aident dans ce processus de décomposition, permettant aux agents d'explorer différentes voies pour résoudre un problème.

Pour approfondir le monde des agents IA, y compris leurs capacités et leur potentiel actuels, pensez à lire « Auto-GPT et GPT-Engineer : un guide détaillé des principaux agents d'IA d'aujourd'hui »

Configuration de l'environnement

Pour créer notre agent RAG, nous devons configurer notre environnement de développement. Nous utiliserons Python et plusieurs bibliothèques clés :

• LangChaîne: Pour orchestrer nos composants LLM et de récupération
• Chroma: En tant que magasin vectoriel pour l'intégration de documents
• Les modèles GPT d'OpenAI: Comme notre LLM de base (vous pouvez le remplacer par un modèle open source si vous préférez)
• API rapide: Pour créer une API simple pour interagir avec notre agent

Commençons par configurer notre environnement :

# Create a new virtual environment
python -m venv rag_agent_env
source rag_agent_env/bin/activate # On Windows, use `rag_agent_env\Scripts\activate`

# Install required packages
pip install langchain chromadb openai fastapi uvicorn

Maintenant, créons un nouveau fichier Python appelé rag_agent.py et importons les bibliothèques nécessaires :

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
import os

# Set your OpenAI API key
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

Construire un système RAG simple

Maintenant que notre environnement est configuré, construisons un système RAG de base. Nous commencerons par créer une base de connaissances à partir d'un ensemble de documents, puis nous l'utiliserons pour répondre aux requêtes.

Étape 1 : Préparer les documents

Tout d'abord, nous devons charger et préparer nos documents. Pour cet exemple, supposons que nous disposons d'un fichier texte appelé knowledge_base.txt contenant des informations sur l'IA et le machine learning.

# Load the document
loader = TextLoader("knowledge_base.txt")
documents = loader.load()

# Split the documents into chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# Create embeddings
embeddings = OpenAIEmbeddings()

# Create a vector store
vectorstore = Chroma.from_documents(texts, embeddings)

Étape 2 : Créer une chaîne d'assurance qualité basée sur la récupération

Maintenant que nous avons notre magasin de vecteurs, nous pouvons créer une chaîne d'assurance qualité basée sur la récupération :

# Create a retrieval-based QA chain
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever())

Étape 3 : interroger le système

Nous pouvons maintenant interroger notre système RAG :

query = "What are the main applications of machine learning?"
result = qa.run(query)
print(result)

Étape 4 : Création d'un agent LLM

Bien que notre système RAG simple soit utile, il est assez limité. Améliorez-le en créant un agent LLM capable d'effectuer des tâches plus complexes et d'analyser les informations récupérées.

Un agent LLM est un système d'IA capable d'utiliser des outils et de prendre des décisions sur les actions à entreprendre. Nous allons créer un agent capable non seulement de répondre à des questions, mais aussi d'effectuer des recherches sur le web et des calculs de base.

Tout d’abord, définissons quelques outils pour notre agent :

from langchain.agents import Tool
from langchain.tools import DuckDuckGoSearchRun
from langchain.tools import BaseTool
from langchain.agents import initialize_agent
from langchain.agents import AgentType

# Define a calculator tool
class CalculatorTool(BaseTool):
name = "Calculator"
description = "Useful for when you need to answer questions about math"

def _run(self, query: str) 
    try:
        return str(eval(query))
    except:
        return "I couldn't calculate that. Please make sure your input is a valid mathematical expression."

# Create tool instances
search = DuckDuckGoSearchRun()
calculator = CalculatorTool()

# Define the tools
tools = [Tool(name="Search",func=search.run,description="Useful for when you need to answer questions about current events"),
Tool(name="RAG-QA",func=qa.run,description="Useful for when you need to answer questions about AI and machine learning"),
Tool(name="Calculator",func=calculator._run,description="Useful for when you need to perform mathematical calculations")
]

# Initialize the agent
agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)

Nous disposons désormais d'un agent capable d'utiliser notre système RAG, d'effectuer des recherches sur le Web et des calculs. Testons-le :

result = agent.run("What's the difference between supervised and unsupervised learning? Also, what's 15% of 80?")
print(result)

Cet agent démontre un avantage clé des agents LLM : ils peuvent combiner plusieurs outils et étapes de raisonnement pour répondre à des requêtes complexes.

Améliorer l'agent avec des techniques RAG avancées

Bien que notre système RAG actuel fonctionne bien, il existe plusieurs techniques avancées que nous pouvons utiliser pour améliorer ses performances :

a) Recherche sémantique avec récupération de passages denses (DPR)

Au lieu d'utiliser une simple récupération basée sur l'intégration, nous pouvons implémenter DPR pour une recherche sémantique plus précise :

from transformers import DPRQuestionEncoder, DPRContextEncoder

question_encoder = DPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
context_encoder = DPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")

# Function to encode passages
def encode_passages(passages):
return context_encoder(passages, max_length=512, return_tensors="pt").pooler_output

# Function to encode query
def encode_query(query):
return question_encoder(query, max_length=512, return_tensors="pt").pooler_output

b) Expansion des requêtes

Nous pouvons utiliser l'expansion des requêtes pour améliorer les performances de récupération :

from transformers import T5ForConditionalGeneration, T5Tokenizer

model = T5ForConditionalGeneration.from_pretrained("t5-small")
tokenizer = T5Tokenizer.from_pretrained("t5-small")

def expand_query(query):
input_text = f"expand query: {query}"
input_ids = tokenizer.encode(input_text, return_tensors="pt")
outputs = model.generate(input_ids, max_length=50, num_return_sequences=3)
expanded_queries = [tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
return expanded_queries

c) Raffinement itératif

Nous pouvons mettre en œuvre un processus de raffinement itératif dans lequel l'agent peut poser des questions de suivi pour clarifier ou développer sa récupération initiale :

def iterative_retrieval(initial_query, max_iterations=3):
query = initial_query
for _ in range(max_iterations):
result = qa.run(query)
clarification = agent.run(f"Based on this result: '{result}', what follow-up question should I ask to get more specific information?")
if clarification.lower().strip() == "none":
break
query = clarification
return result

# Use this in your agent's process

Implémentation d'un système multi-agents

Pour gérer des tâches plus complexes, nous pouvons mettre en œuvre un système multi-agents où différents agents se spécialisent dans différents domaines. Voici un exemple simple :

class SpecialistAgent:
def __init__(self, name, tools):
self.name = name
self.agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

def run(self, query):
return self.agent.run(query)

# Create specialist agents
research_agent = SpecialistAgent("Research", [Tool(name="RAG-QA", func=qa.run, description="For AI and ML questions")])
math_agent = SpecialistAgent("Math", [Tool(name="Calculator", func=calculator._run, description="For calculations")])
general_agent = SpecialistAgent("General", [Tool(name="Search", func=search.run, description="For general queries")])

class Coordinator:
def __init__(self, agents):
self.agents = agents

def run(self, query):
# Determine which agent to use
if "calculate" in query.lower() or any(op in query for op in ['+', '-', '*', '/']):
return self.agents['Math'].run(query)
elif any(term in query.lower() for term in ['ai', 'machine learning', 'deep learning']):
return self.agents['Research'].run(query)
else:
return self.agents['General'].run(query)

coordinator = Coordinator({'Research': research_agent, 'Math': math_agent, 'General': general_agent})

# Test the multi-agent system
result = coordinator.run("What's the difference between CNN and RNN? Also, calculate 25% of 120.")
print(result)

Ce système multi-agents permet la spécialisation et peut traiter plus efficacement un plus large éventail de requêtes.

Évaluation et optimisation des agents RAG

Pour garantir que notre agent RAG fonctionne correctement, nous devons mettre en œuvre des mesures d'évaluation et des techniques d'optimisation :

a) Évaluation de la pertinence

Nous pouvons utiliser des métriques comme BLEU, ROUGE ou BERTScore pour évaluer la pertinence des documents récupérés :

from bert_score import score

def evaluate_relevance(query, retrieved_doc, generated_answer):
P, R, F1 = score([generated_answer], [retrieved_doc], lang="en")
return F1.mean().item()

b) Évaluation de la qualité des réponses

Nous pouvons utiliser une évaluation humaine ou des mesures automatisées pour évaluer la qualité des réponses :

from nltk.translate.bleu_score import sentence_bleu

def evaluate_answer_quality(reference_answer, generated_answer):
return sentence_bleu([reference_answer.split()], generated_answer.split())

# Use this to evaluate your agent's responses

Orientations futures et défis

Alors que nous envisageons l’avenir des agents RAG, plusieurs orientations et défis passionnants émergent :

a) RAG multimodal: extension de RAG pour incorporer des données d’image, audio et vidéo.

b) RAG fédéré: Implémentation de RAG sur des bases de connaissances distribuées et préservant la confidentialité.

c) Apprentissage continu: Développer des méthodes permettant aux agents RAG de mettre à jour leurs bases de connaissances et leurs modèles au fil du temps.

d) Considérations éthiques: Lutter contre les préjugés, l’équité et la transparence dans les systèmes RAG.

e) Évolutivité: Optimisation de RAG pour des applications en temps réel à grande échelle.

Conclusion

Créer des agents LLM pour RAG de A à Z est un processus complexe, mais enrichissant. Nous avons abordé les bases de RAG, implémenté un système simple, créé un agent LLM, l'avons amélioré avec des techniques avancées, exploré les systèmes multi-agents et discuté des stratégies d'évaluation et d'optimisation.