Qu’est-ce qu’un RAG ?

RAG signifie Retrieval-Augmented Generation, une technique puissante conçue pour améliorer les performances des grands modèles de langage (LLM) en leur fournissant un contexte spécifique et pertinent sous forme de documents. Contrairement aux LLM traditionnels qui génèrent des réponses uniquement basées sur leurs connaissances pré-entraînées, RAG vous permet d'aligner plus étroitement les résultats du modèle avec les résultats souhaités en récupérant et en utilisant des données en temps réel ou des informations spécifiques au domaine.

RAG vs réglage fin

Alors que RAG et le réglage fin visent tous deux à améliorer les performances des LLM, RAG est souvent une méthode plus efficace et plus respectueuse des ressources. Le réglage fin implique de recycler un modèle sur un ensemble de données spécialisé, ce qui nécessite des ressources informatiques, du temps et une expertise importants. RAG, d'autre part, récupère dynamiquement les informations pertinentes et les intègre dans le processus de génération, permettant une adaptation plus flexible et plus rentable aux nouvelles tâches sans recyclage approfondi.

Construire un agent RAG

Installation des exigences

Installer Ollama

Ollama fournit l'infrastructure backend nécessaire pour exécuter LLaMA localement. Pour commencer, rendez-vous sur le site Web d'Ollama et téléchargez l'application. Suivez les instructions pour le configurer sur votre ordinateur local.

Installer les exigences de LangChain

LangChain est un framework Python conçu pour fonctionner avec divers LLM et bases de données vectorielles, ce qui le rend idéal pour créer des agents RAG. Installez LangChain et ses dépendances en exécutant la commande suivante :

pip install langchain

Codage de l'agent RAG

Créer une fonction API

Tout d'abord, vous aurez besoin d'une fonction pour interagir avec votre instance LLaMA locale. Voici comment le configurer :

from requests import post as rpost

def call_llama(prompt):
    headers = {"Content-Type": "application/json"}
    payload = {
        "model": "llama3.1",
        "prompt": prompt,
        "stream": False,
    }

    response = rpost(
        "http://localhost:11434/api/generate",
        headers=headers,
        json=payload
    )
    return response.json()["response"]

Créer un LLM LangChain

Ensuite, intégrez cette fonction dans une classe LLM personnalisée dans LangChain :

from langchain_core.language_models.llms import LLM

class LLaMa(LLM):
    def _call(self, prompt, **kwargs):
        return call_llama(prompt)

    @property
    def _llm_type(self):
        return "llama-3.1-8b"

Intégration de l'agent RAG

Configuration du Retriever

Le récupérateur est chargé de récupérer les documents pertinents en fonction de la requête de l'utilisateur. Voici comment le configurer à l'aide de FAISS pour le stockage vectoriel et des intégrations pré-entraînées de HuggingFace :

from langchain.vectorstores import FAISS
from langchain_huggingface import HuggingFaceEmbeddings

documents = [
    {"content": "What is your return policy? ..."},
    {"content": "How long does shipping take? ..."},
    # Add more documents as needed
]

texts = [doc["content"] for doc in documents]

retriever = FAISS.from_texts(
    texts,
    HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
).as_retriever(k=5)

Créer le modèle d'invite

Définissez le modèle d'invite que l'agent RAG utilisera pour générer des réponses basées sur les documents récupérés :

from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

faq_template = """
You are a chat agent for my E-Commerce Company. As a chat agent, it is your duty to help the human with their inquiry and make them a happy customer.

Help them, using the following context:

{context}

"""

faq_prompt = ChatPromptTemplate.from_messages([
    ("system", faq_template),
    MessagesPlaceholder("messages")
])

Créer des chaînes de documents et de récupération

Combinez la récupération de documents et la génération LLaMA en une chaîne cohérente :

from langchain.chains.combine_documents import create_stuff_documents_chain

document_chain = create_stuff_documents_chain(LLaMa(), faq_prompt)

def parse_retriever_input(params):
    return params["messages"][-1].content

retrieval_chain = RunnablePassthrough.assign(
    context=parse_retriever_input | retriever
).assign(answer=document_chain)

Démarrez votre serveur Ollama

Avant d'exécuter votre agent RAG, assurez-vous que le serveur Ollama est opérationnel. Démarrez le serveur avec la commande suivante :

ollama serve

Invitez votre agent RAG

Vous pouvez désormais tester votre agent RAG en envoyant une requête :

from langchain.schema import HumanMessage

response = retrieval_chain.invoke({
    "messages": [
        HumanMessage("I received a damaged item. I want my money back.")
    ]
})

print(response)

Réponse:
"Je suis vraiment désolé d'apprendre que vous avez reçu un article endommagé. Conformément à notre politique, si vous recevez un article endommagé, veuillez contacter immédiatement notre équipe de service client avec des photos des dommages. Nous organiserons un remplacement ou un remboursement pour vous. Souhaitez-vous que je vous aide à obtenir un remboursement ? J'aurai besoin de certaines informations de votre part, telles que votre numéro de commande et des détails sur l'article endommagé, pouvez-vous les fournir afin que je puisse vous aider à traiter votre demande ? » 

En suivant ces étapes, vous pouvez créer un agent RAG local entièrement fonctionnel capable d'améliorer les performances de votre LLM avec un contexte en temps réel. Cette configuration peut être adaptée à divers domaines et tâches, ce qui en fait une solution polyvalente pour toute application où la génération contextuelle est cruciale.