Guide de démarrage RAG

La génération augmentée par récupération (RAG) est un framework d'IA qui combine les capacités des LLM et des systèmes de récupération d'informations. Elle permet de répondre à des questions ou de générer du contenu en exploitant des connaissances externes. Le RAG comporte deux étapes principales :

1. Récupération : récupérer les informations pertinentes depuis une base de connaissances ou une source externe, par exemple en utilisant des embeddings de texte stockés dans une base vectorielle.
2. Génération : insérer les informations pertinentes dans le prompt pour que le LLM génère l'information.

Dans ce guide, nous allons parcourir un exemple très basique de RAG. Vous trouverez des guides plus approfondis dans nos cookbooks.

Un guide simple pour construire un RAG from scratch

Cette section vise à vous guider dans le processus de construction d'un RAG basique from scratch. Nous avons deux objectifs : premièrement, offrir aux utilisateurs une compréhension complète du fonctionnement interne du RAG et démystifier les mécanismes sous-jacents ; deuxièmement, vous fournir les fondations essentielles pour construire un RAG avec un minimum de dépendances requises.

La première étape consiste à installer les packages mistralai et faiss-cpu et importer les packages nécessaires :

from mistralai.client import Mistral
import requests
import numpy as np
import faiss
import os
from getpass import getpass

api_key= getpass("Type your API Key")
client = Mistral(api_key=api_key)

from mistralai.client import Mistral
import requests
import numpy as np
import faiss
import os
from getpass import getpass

api_key= getpass("Type your API Key")
client = Mistral(api_key=api_key)

Dans cet exemple très simple, nous récupérons des données à partir d'un essai écrit par Paul Graham :

response = requests.get('https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt')
text = response.text

response = requests.get('https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt')
text = response.text

Nous pouvons également enregistrer l'essai dans un fichier local :

f = open('essay.txt', 'w')
f.write(text)
f.close()

f = open('essay.txt', 'w')
f.write(text)
f.close()

Dans un système RAG, il est essentiel de diviser le document en chunks plus petits afin d'identifier et de récupérer plus efficacement les informations les plus pertinentes lors du processus de récupération ultérieur. Dans cet exemple, nous divisons simplement notre texte par caractère, regroupons 2048 caractères dans chaque chunk, et nous obtenons 37 chunks.

chunk_size = 2048
chunks = [text[i:i + chunk_size] for i in range(0, len(text), chunk_size)]
len(chunks)

chunk_size = 2048
chunks = [text[i:i + chunk_size] for i in range(0, len(text), chunk_size)]
len(chunks)

Pour chaque chunk de texte, nous devons ensuite créer des embeddings de texte, qui sont des représentations numériques du texte dans l'espace vectoriel. Les mots ayant des significations similaires sont censés être à proximité ou avoir une distance plus courte dans l'espace vectoriel. Pour créer un embedding, utilisez le endpoint d'API d'embeddings de Mistral AI et le modèle d'embedding mistral-embed. Nous créons une fonction get_text_embedding pour obtenir l'embedding d'un seul chunk de texte, puis nous utilisons une compréhension de liste pour obtenir les embeddings de texte pour tous les chunks de texte.

def get_text_embedding(input):
    embeddings_batch_response = client.embeddings.create(
          model="mistral-embed",
          inputs=input
      )
    return embeddings_batch_response.data[0].embedding
text_embeddings = np.array([get_text_embedding(chunk) for chunk in chunks])

def get_text_embedding(input):
    embeddings_batch_response = client.embeddings.create(
          model="mistral-embed",
          inputs=input
      )
    return embeddings_batch_response.data[0].embedding
text_embeddings = np.array([get_text_embedding(chunk) for chunk in chunks])

Une fois que nous obtenons les embeddings de texte, une pratique courante consiste à les stocker dans une base de données vectorielle pour un traitement et une récupération efficaces. Il existe plusieurs bases de données vectorielles parmi lesquelles choisir. Dans notre exemple simple, nous utilisons une base de données vectorielle open-source Faiss, qui permet une recherche de similarité efficace.

Avec Faiss, nous instancions une instance de la classe Index, qui définit la structure d'indexation de la base de données vectorielle. Nous ajoutons ensuite les embeddings de texte à cette structure d'indexation.

import faiss

d = text_embeddings.shape[1]
index = faiss.IndexFlatL2(d)
index.add(text_embeddings)

import faiss

d = text_embeddings.shape[1]
index = faiss.IndexFlatL2(d)
index.add(text_embeddings)

Lorsque les utilisateurs posent une question, nous devons également créer des embeddings pour cette question en utilisant les mêmes modèles d'embedding qu'auparavant.

question = "What were the two main things the author worked on before college?"
question_embeddings = np.array([get_text_embedding(question)])

question = "What were the two main things the author worked on before college?"
question_embeddings = np.array([get_text_embedding(question)])

Nous pouvons effectuer une recherche sur la base de données vectorielle avec index.search, qui prend deux arguments : le premier est le vecteur des embeddings de la question, et le second est le nombre de vecteurs similaires à récupérer. Cette fonction renvoie les distances et les indices des vecteurs les plus similaires au vecteur de la question dans la base de données vectorielle. Ensuite, sur la base des indices renvoyés, nous pouvons récupérer les chunks de texte pertinents réels qui correspondent à ces indices.

D, I = index.search(question_embeddings, k=2) # distance, index
retrieved_chunk = [chunks[i] for i in I.tolist()[0]]

D, I = index.search(question_embeddings, k=2) # distance, index
retrieved_chunk = [chunks[i] for i in I.tolist()[0]]

Enfin, nous pouvons fournir les chunks de texte récupérés comme informations de contexte dans le prompt. Voici un template de prompt où nous pouvons inclure à la fois le texte récupéré et la question de l'utilisateur dans le prompt.

prompt = f"""
Context information is below.
---------------------
{retrieved_chunk}
---------------------
Given the context information and not prior knowledge, answer the query.
Query: {question}
Answer:
"""

prompt = f"""
Context information is below.
---------------------
{retrieved_chunk}
---------------------
Given the context information and not prior knowledge, answer the query.
Query: {question}
Answer:
"""

Ensuite, nous pouvons utiliser l'API de chat completion de Mistral pour interagir avec un modèle Mistral (par exemple, mistral-medium-latest) et générer des réponses basées sur la question de l'utilisateur et le contexte de la question.

def run_mistral(user_message, model="mistral-large-latest"):
    messages = [
        {
            "role": "user", "content": user_message
        }
    ]
    chat_response = client.chat.complete(
        model=model,
        messages=messages
    )
    return (chat_response.choices[0].message.content)

run_mistral(prompt)

def run_mistral(user_message, model="mistral-large-latest"):
    messages = [
        {
            "role": "user", "content": user_message
        }
    ]
    chat_response = client.chat.complete(
        model=model,
        messages=messages
    )
    return (chat_response.choices[0].message.content)

run_mistral(prompt)

Retrouvez de nombreux cookbooks RAG explorant divers sujets et solutions dans notre cookbook communautaire.

Parmi eux, vous pouvez découvrir comment effectuer…

• RAG avec LangChain : consultez notre cookbook Adaptive RAG avec LangChain pour découvrir comment utiliser LangGraph de LangChain avec l'API Mistral. Ces cookbooks couvrent diverses implémentations, notamment l'adaptive RAG, le corrective RAG et le self-RAG, montrant comment intégrer les capacités de LangChain pour une génération augmentée par récupération améliorée.
• RAG avec LlamaIndex : consultez notre cookbook Utiliser Mistral AI avec LlamaIndex pour apprendre comment utiliser LlamaIndex avec l'API Mistral pour effectuer des requêtes complexes sur plusieurs documents en utilisant un agent ReAct, un agent autonome alimenté par LLM capable d'utiliser des outils.
• RAG avec Haystack : consultez notre cookbook Utiliser Mistral AI avec Haystack pour explorer comment utiliser Haystack avec l'API Mistral pour des fonctionnalités de chat avec des documents.