Introduction aux RAG (Retrieval Augmented Generation) avec LangChain et Ollama

1. Pourquoi parle-t-on des RAG aujourd’hui ?

Les modèles d’IA générative (comme GPT, Claude, ou encore LLaMA) sont capables de produire du texte fluide et pertinent. Mais ils ont une limite majeure : ils ne savent répondre qu’avec ce qu’ils ont appris lors de leur entraînement. Ils peuvent donc :

• Fournir des informations obsolètes.
• Inventer des faits inexistants (hallucinations).
• Ignorer des données spécifiques à une entreprise ou un domaine.

C’est là qu’interviennent les RAG (Retrieval Augmented Generation) : ils combinent la puissance des modèles génératifs avec une base de connaissances externe (documents, bases de données, fichiers internes, etc.).

En clair : avant de générer une réponse, le modèle va chercher les informations pertinentes dans vos données, puis il s’appuie dessus pour formuler une réponse précise.

Remarque : certains outils comme ChatGPT avec navigation web ou Perplexity donnent l’impression que le modèle connaît Internet en temps réel. En réalité, ils combinent un modèle génératif avec un mécanisme externe de recherche en ligne. Ce fonctionnement s’apparente déjà à une forme de RAG, mais appliqué au web public. L’intérêt des RAG personnalisés est de pouvoir appliquer le même principe… sur vos propres données privées (documents internes, bases clients, rapports, etc.).

2. Le principe d’un RAG

Un pipeline RAG fonctionne en trois étapes :

1. Indexation des documents
   On découpe vos textes en petits morceaux (chunks), puis on les transforme en vecteurs numériques (embeddings) afin de pouvoir les rechercher efficacement.
2. Recherche contextuelle
   Lors d’une question, le système cherche dans vos documents les passages les plus pertinents grâce à une base vectorielle.
3. Génération augmentée
   Le modèle de langage prend ces passages comme contexte et génère une réponse plus fiable, avec éventuellement les sources utilisées.

3. Les outils que nous allons utiliser

Pour notre exemple, nous allons construire un petit RAG avec :

• LangChain : un framework Python qui facilite la création de chaînes IA (LLM + retrieval + mémoire…).
• Ollama : un outil qui permet de télécharger et exécuter facilement des modèles de langage en local (par exemple LLaMA, Mistral, Gemma). Dans notre code, nous utilisons un petit modèle local gemma3:1b.
• FAISS : une librairie de Meta pour gérer les recherches vectorielles.
• HuggingFace Embeddings : pour transformer nos textes en vecteurs numériques.

ℹ️ Il n’est pas obligatoire d’utiliser Ollama ou des modèles ouverts, vous pouvez choisir le modèle de votre choix : open source (LLaMA, Mistral, Gemma…) ou fermé (GPT, Claude, etc.).

4. Mise en pratique pas à pas

Nous allons partir d’un fichier doc.txt (notre base de connaissances). Voici le fichier que nous utilisons ici pour l’exemple :

Bio of a Fictional Person

Name: Clara Mendoza
Age: 34
Location: Barcelona, Spain
Profession: Environmental Policy Analyst

Clara Mendoza is a passionate environmental policy analyst dedicated to shaping sustainable urban development. With over a decade of experience in climate policy and renewable energy initiatives, she has worked with NGOs, municipal governments, and international organizations to design strategies that balance economic growth with environmental preservation.

She holds a master’s degree in Environmental Policy and Governance from the London School of Economics, where her thesis focused on community-driven renewable energy projects in Southern Europe. Fluent in Spanish, English, and French, Clara has presented her work at global conferences, advocating for greener cities and stronger cross-border collaborations.

Beyond her professional life, Clara is an avid traveler and amateur photographer. Her weekends often involve hiking in the Pyrenees, experimenting with plant-based recipes, or capturing urban landscapes through her camera lens. She also volunteers as a mentor for young women entering the field of environmental science and policy.

a) Charger le document

from langchain.docstore.document import Document

# Ouverture du document
with open("./doc.txt", "r", encoding="utf-8") as f:
    input_doc = f.read()

document = Document(page_content=input_doc)

Ici, on lit notre fichier texte et on le convertit en un objet Document utilisable par LangChain.

b) Découper le texte en morceaux (chunks)

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(chunk_size=150, chunk_overlap=40)
chunks = splitter.split_documents([document])

On segmente le document en petits morceaux de 150 caractères, avec un recouvrement de 40 caractères pour éviter de couper une idée en deux.

c) Créer la base vectorielle

from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS

embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
vector_store = FAISS.from_documents(chunks, embeddings)

Chaque chunk est transformé en vecteur numérique grâce à un modèle de HuggingFace, puis stocké dans une base vectorielle FAISS.

d) Construire la chaîne RAG

from langchain_ollama.llms import OllamaLLM
from langchain.chains import RetrievalQA

qa_chain = RetrievalQA.from_chain_type(
    llm=OllamaLLM(model="gemma3:1b"),  # modèle local exécuté avec Ollama
    retriever=vector_store.as_retriever(),
    return_source_documents=True,
    chain_type="stuff",
)

Ici, on assemble tout :

• Le LLM (gemma3:1b via Ollama).
• Le moteur de recherche vectoriel.
• Une chaîne qui envoie les passages trouvés au modèle.

e) Poser une question

result = qa_chain.invoke({"query": "What languages does Clara speak ?"})
print("Answer:", result['result'])

print("\nSource Documents:")
for doc in result['source_documents']:
    print(f"- {doc.page_content}")

Quand on pose la question « What languages does Clara speak ? », le système va chercher dans notre doc.txt et donner la réponse :

Answer: Clara speaks Spanish, English, and French.
Source Documents:
- Clara Mendoza est une analyste en politiques environnementales [...]
  Elle parle couramment espagnol, anglais et français.

5. Code complet

Voici le module Python complet que vous pouvez exécuter directement :

from langchain.docstore.document import Document
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from langchain_ollama.llms import OllamaLLM
from langchain.chains import RetrievalQA

# Ouverture du document (base de connaissances pour le RAG)
with open("./doc.txt", "r", encoding="utf-8") as f:
    input_doc = f.read()

document = Document(page_content=input_doc)

# Séparation automatique en morceaux (chunks)
splitter = RecursiveCharacterTextSplitter(chunk_size=150, chunk_overlap=40)
chunks = splitter.split_documents([document])

# Transformations des chunks en vecteurs (embeddings)
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
vector_store = FAISS.from_documents(chunks, embeddings)

qa_chain = RetrievalQA.from_chain_type(
    llm=OllamaLLM(model="gemma3:1b"),  # On utilise le modèle gemma3:1b installé en local
    retriever=vector_store.as_retriever(),
    return_source_documents=True,
    chain_type="stuff",
)

# Prompt et récupération de la réponse (et des sources)
result = qa_chain.invoke({"query": "What languages does Clara speak ?"})
print("Answer:", result['result'])
print("\nSource Documents:")
for doc in result['source_documents']:
    print(f"- {doc.page_content}")

6. Conclusion

Les RAG permettent de transformer un modèle de langage générique en assistant spécialisé, capable de s’appuyer sur vos propres données.

• Les applications sont nombreuses : chatbots d’entreprise, assistants de recherche, outils pédagogiques…
• Grâce à des frameworks comme LangChain et des outils comme Ollama, il devient facile de monter un prototype fonctionnel.

Et surtout, vous gardez le contrôle : vous pouvez choisir vos propres données et vos propres modèles (open source ou fermés).

Pour aller plus loin, découvrez notre article autour de l’automatisation et de l’IA agentique.

Ressources utiles :

• LangChain
• Ollama
• FAISS
• HuggingFace Sentence Transformers