Technical Tutorials

L'intelligence artificielle évolue rapidement, mais les grands modèles de langage (LLM) souffrent toujours d'une limitation critique : ils ne connaissent que ce sur quoi ils ont été entraînés. Cela crée un écart significatif lors du traitement de données propriétaires, d'événements récents ou de connaissances spécifiques à un domaine. La génération augmentée par récupération (RAG) comble cet écart en permettant à l'IA de récupérer des informations pertinentes à partir de sources externes avant de générer une réponse. Dans ce guide, nous explorerons comment construire un pipeline RAG robuste en utilisant LangChain et les bases de données vectorielles.

Comprendre l'architecture RAG

Au cœur d'un système RAG se trouvent deux phases principales : l'indexation et la récupération. Lors de la phase d'indexation, vous ingérez des données non structurées (telles que des PDF, des fichiers markdown ou des enregistrements de base de données) et les convertissez en représentations numériques appelées embeddings. Ces embeddings sont stockés dans une base de données vectorielle, ce qui permet une recherche par similarité. Lors de la phase de récupération, lorsqu'un utilisateur pose une question, le système convertit la requête en un embedding, trouve les documents les plus similaires dans la base de données et les fournit comme contexte au LLM pour générer une réponse précise et fondée.

Configuration de l'environnement

Avant de plonger dans le code, assurez-vous d'avoir Python installé. Nous aurons besoin de plusieurs bibliothèques clés : langchain pour le framework d'orchestration, langchain-community pour les intégrations spécifiques, et un magasin vectoriel. Pour cet exemple, nous utiliserons faiss-cpu pour le stockage local, bien que les environnements de production utilisent souvent Pinecone, Weaviate ou Elasticsearch.

Installez les dépendances à l'aide de pip :

pip install langchain langchain-community langchain-openai faiss-cpython python-dotenv

Créez un fichier .env pour stocker de manière sécurisée votre clé API OpenAI :

OPENAI_API_KEY=votre_clé_api_ici

Étape 1 : Chargement et fractionnement des documents

Les LLM ont des limites de fenêtre de contexte, nous devons donc diviser nos documents en morceaux plus petits. Nous utiliserons RecursiveCharacterTextSplitter pour décomposer le texte en morceaux gérables, en veillant à préserver le sens sémantique.

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader

# Charger les documents
loader = PyPDFLoader("example.pdf")
documents = loader.load()

# Diviser en morceaux
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
chunks = text_splitter.split_documents(documents)

Étape 2 : Embeddings et stockage vectoriel

Ensuite, nous devons convertir ces morceaux de texte en vecteurs. Nous utiliserons le modèle d'embeddings d'OpenAI et un magasin vectoriel FAISS. Cette étape crée la « mémoire » de notre chatbot.

from langchain.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

Étape 3 : Construction du récupérateur et de la chaîne

Maintenant, nous définissons comment le chatbot récupérera les informations. Nous créons un récupérateur à partir de notre magasin vectoriel et le combinons avec un LLM pour former la chaîne finale. C'est ici que se produit la partie « Génération » du RAG. Le LLM reçoit le contexte récupéré et la question de l'utilisateur pour formuler une réponse.

from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# Créer la chaîne QA de récupération
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

Étape 4 : Interaction avec le chatbot

Finalement, nous pouvons interroger notre système RAG. Lorsqu'un utilisateur pose une question, le système récupère les morceaux pertinents du PDF, les fournit au LLM et renvoie une réponse basée strictement sur le texte fourni.

query = "Quelles sont les principales conclusions du document ?"
result = qa_chain.invoke({"query": query})
print(result["result"])

Conclusion

Construire un chatbot alimenté par RAG transforme les LLM statiques en assistants dynamiques et conscients des connaissances. En tirant parti des bases de données vectorielles et de LangChain, les développeurs peuvent créer des applications qui sont non seulement intelligentes, mais aussi précises et à jour. Bien que cet exemple utilise FAISS et des PDF locaux, les mêmes principes s'appliquent aux lacs de données à l'échelle de l'entreprise et aux bases de données en temps réel. À mesure que vous affinerez votre implémentation, envisagez d'expérimenter différents modèles d'embeddings, stratégies de fractionnement et techniques de récupération pour optimiser les performances selon votre cas d'utilisation spécifique.