Construire un système RAG de A à Z : Tutoriel pratique

Le RAG (Retrieval-Augmented Generation) est l'architecture la plus populaire pour construire des applications LLM. Ce tutoriel pratique construit un système RAG complet de A à Z.

Ce que nous construisons

Un système de questions-réponses sur documents capable de répondre à des questions sur vos PDF, fichiers markdown ou tout document texte.

Prérequis

• Python 3.10+
• Clé API OpenAI (ou toute API LLM)
• Notions de base en Python

Étape 1 : Configuration

mkdir rag-system && cd rag-system
python -m venv venv
source venv/bin/activate
pip install openai chromadb tiktoken pypdf

Étape 2 : Ingestion de documents

import os
from typing import List
from pypdf import PdfReader

def load_documents(folder_path: str) -> List[str]:
    documents = []
    for filename in os.listdir(folder_path):
        if filename.endswith('.pdf'):
            reader = PdfReader(os.path.join(folder_path, filename))
            text = ""
            for page in reader.pages:
                text += page.extract_text()
            documents.append(text)
        elif filename.endswith('.txt') or filename.endswith('.md'):
            with open(os.path.join(folder_path, filename), 'r') as f:
                documents.append(f.read())
    return documents

Étape 3 : Découpage en chunks

def chunk_text(text: str, chunk_size=500, overlap=50) -> List[str]:
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunks.append(text[start:end])
        start = end - overlap
    return chunks

Étape 4 : Créer les embeddings et stocker

import chromadb
from openai import OpenAI

client = OpenAI()
chroma_client = chromadb.Client()
collection = chroma_client.create_collection(name="documents")

def index_documents(chunks: List[str]):
    for i, chunk in enumerate(chunks):
        response = client.embeddings.create(
            model="text-embedding-3-small",
            input=chunk
        )
        embedding = response.data[0].embedding
        collection.add(
            embeddings=[embedding],
            documents=[chunk],
            ids=[str(i)]
        )

Étape 5 : Récupération et génération

def query_rag(question: str) -> str:
    # Embedder la question
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=question
    )
    query_embedding = response.data[0].embedding
    
    # Récupérer les chunks pertinents
    results = collection.query(
        query_embeddings=[query_embedding],
        n_results=3
    )
    
    context = "

".join(results['documents'][0])
    
    # Générer la réponse
    completion = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "Répondez à la question en vous basant sur le contexte fourni."},
            {"role": "user", "content": f"Contexte :
{context}

Question : {question}"}
        ]
    )
    return completion.choices[0].message.content

Étape 6 : Déployer comme API

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/query', methods=['POST'])
def query():
    data = request.json
    answer = query_rag(data['question'])
    return jsonify({'answer': answer})

if __name__ == '__main__':
    app.run(port=5000)

Prochaines étapes

• Ajoutez un re-ranking pour une meilleure récupération
• Implémentez la recherche hybride (mots-clés + sémantique)
• Ajoutez des citations de sources aux réponses
• Essayez différentes stratégies de découpage

Notre programme « Build with LLMs » couvre les techniques avancées de RAG et le déploiement en production.