RAG Ollama : questions-réponses sur base de connaissances privée locale
Dans ce chapitre, nous combinons les capacités d'embedding, de récupération et de génération apprises précédemment dans une application réellement utilisable : fournissez vos documents à un modèle local et laissez-le répondre à des questions en se basant uniquement sur vos documents, avec les sources citées.
Le code complet fait moins de 100 lignes, n’a aucune dépendance externe à une base de données vectorielle et peut s’exécuter en le copiant simplement.
Décomposition des exigences et sélection des technologies
Commençons par clarifier le problème : le LLM ne connaît pas les documents sur votre disque dur, et lui demander directement ne donnera que des réponses inventées. L’idée du RAG (Retrieval-Augmented Generation) est un « examen à livre ouvert » — d’abord récupérer les passages pertinents de vos documents, les insérer dans le prompt, puis laisser le modèle répondre en s’appuyant sur eux.
La sélection des technologies suit le principe des « dépendances minimales » :
| Étape | Tri par sélection | Raison |
|---|---|---|
| Modèle d’embedding | embeddinggemma | Taille réduite, rapide en local ; alternative : qwen3-embedding |
| Modèle de génération | qwen3.5:4b | Bon en chinois, peut tourner avec 16GB de RAM |
| Stockage vectoriel | Liste Python + similarité cosinus | Zéro dépendance, clair pour l’enseignement ; passer à des bibliothèques professionnelles comme Chroma pour de grands volumes |
| Format du document | txt / md | Le texte brut suffit pour expliquer les principes ; voir la fin de l'article pour l'extension PDF |
Vous devez récupérer deux modèles :
ollama pull embeddinggemma ollama pull qwen3.5:4b
EmbeddingGemma est un modèle léger d'embedding de texte multilingue publié en open source par Google, spécialement conçu pour convertir du texte en vecteurs. Il est très adapté à un déploiement hors ligne sur des appareils locaux. Ollama a déjà adapté et empaqueté ce modèle, vous pouvez donc le récupérer et l'utiliser directement.
Étape 1 : analyse et découpage du document
Le contexte du modèle est limité, et un document entier ne peut pas y tenir, il doit donc être découpé en petits segments. La stratégie de découpage utilise l'approche la plus basique « longueur fixe + chevauchement » : chaque segment fait 300 caractères, les segments adjacents se chevauchant de 50 caractères pour éviter de couper des phrases clés.
Exemple
import os
def load_chunks(folder, size=300, overlap=50):
"""Lire tous les fichiers txt/md du dossier, les découper en segments avec des marqueurs de source"""
chunks = []
for name in sorted(os.listdir(folder)):
if not name.endswith(('.txt', '.md')):
continue
path = os.path.join(folder, name)
text = open(path, encoding='utf-8').read().strip()
# Découpage par fenêtre glissante : taille du pas = size - overlap
step = size - overlap
for i in range(0, len(text), step):
piece = text[i:i + size].strip()
if len(piece) > 20: # Écarter les fragments trop courts
chunks.append({'file': name, 'text': piece})
return chunks
Étape 2 : Vectorisation et récupération
Convertissez tous les segments et la question de l'utilisateur en vecteurs, puis utilisez la similarité cosinus pour trouver les top-k segments les plus pertinents pour la question.
Exemple
EMBED_MODEL = 'embeddinggemma'
def embed(texts):
"""Générer des vecteurs par lots (entrée : une liste, sortie : une liste de vecteurs)"""
result = ollama.embed(model=EMBED_MODEL, input=textes)
return result['embeddings']
def cosine(a, b):
"""Similarité cosinus : plus la valeur est proche de 1, plus c'est similaire"""
dot = sum(x * y for x, y in zip(a, b))
na = sum(x * x for x in a) ** 0.5
nb = sum(x * x for x in b) ** 0.5
return dot / (na * nb)
def search(question, chunks, vectors, top_k=3):
"""Récupération : retourner les k segments les plus pertinents et leurs similarités"""
q_vec = embed([question])[0]
scored = [
(cosine(q_vec, v), c)
for v, c in zip(vectors, chunks)
]
scored.sort(key=lambda x: -x[0])
return scored[:top_k]
embeddinggemma produit des vecteurs normalisés L2 ; la formule complète du cosinus est toutefois conservée ici pour rendre le principe évident au premier coup d'œil ; la remplacer par le produit scalaire donne le même résultat.
Étape 3 : Assemblage du prompt et génération des réponses avec citations
Écrivez les segments récupérés ainsi que les numéros de source dans le prompt, et exigez explicitement du modèle qu'il « réponde uniquement à partir des documents » et marque les citations.
Exemple
GEN_MODEL = 'qwen3.5:4b'
def answer(question, chunks, vectors):
hits = search(question, chunks, vectors, top_k=3)
# Concaténer les segments et les numéros de source dans le contexte
context = '\n\n'.join(
f'[Source {idx}] (de {c["file"]})\n{c["text"]}'
for idx, (score, c) in enumerate(hits, 1)
)
prompt = f'''Répondez à la question en vous basant uniquement sur les documents suivants, et indiquez quels numéros de source ont été utilisés.
Si les documents sont insuffisants pour répondre, dites directement que vous ne savez pas.
Documents :
{context}
Question : {question}'''
response = chat(
model=GEN_MODEL,
messages=[{'role': 'user', 'content': prompt}],
options={'temperature': 0.2}, # Température basse, réduit la liberté créative
)
print(response.message.content)
print('\nRéférences : ')
for idx, (score, c) in enumerate(hits, 1):
print(f' [Source {idx}] {c["file"]} (similarité {score:.3f})')
Exécution complète : Entrée du programme principal
Exemple
if __name__ == '__main__':
folder = 'docs' # Mettez vos documents txt/md dans le dossier docs
chunks = load_chunks(folder)
# Indexation hors ligne : vectoriser tous les chunks en une seule fois
print(f'Indexation de {len(chunks)} chunks...')
vectors = embed([c['text'] for c in chunks])
print('Indexation terminée.'\n')
# Boucle de questions-réponses en ligne
while True:
q = input('Question (tapez exit pour quitter) : ').strip()
if q.lower() == 'exit':
break
if q:
réponse(q, segments, vecteurs)
print()
Préparez le matériel et exécutez :
mkdir docs cp EXAMPLE-python-notes.md docs/ python rag.py
Sortie :
$ python rag.py 正在索引 42 个片段... 索引完成。 问题(exit 退出):Python 的切片是什么? Python 切片是用 [start:stop:step] 从序列截取子序列的语法 [资料1]。 例如 s[1:4] 取索引 1 到 3 的字符 [资料2]。 参考来源: [资料1] EXAMPLE-python-notes.md(相似度 0.712) [资料2] EXAMPLE-python-notes.md(相似度 0.668)
Notez les citations des sources à la fin de la réponse : chaque phrase peut être retracée jusqu'à un fichier spécifique dans votre répertoire docs. C'est exactement la valeur fondamentale du RAG par rapport à « demander directement au modèle ».
Optimisation des performances et problèmes courants
Si les performances du RAG sont médiocres, le problème se situe généralement au stade de la récupération plutôt qu'à celui de la génération. Les leviers de réglage, classés par impact :
| Levier | Valeur par défaut | Direction d'ajustement |
|---|---|---|
| Taille de segment | 300 caractères | Augmentez si les réponses sont trop fragmentées ; une valeur trop grande rend la récupération imprécise ; plage empirique 200~500 |
| Chevauchement | 50 caractères | Augmentez lorsque les phrases sont fréquemment coupées |
| Nombre d'éléments récupérés top_k | 3 | Augmentez lorsque les documents sont denses, mais cela consommera plus de contexte |
| Seuil de similarité | Non activé | Filtrer les segments avec une similarité trop faible pour réduire les interférences non pertinentes |
| Température de génération | 0.2 | Gardez-la basse ; une base de connaissances n'a pas besoin de créativité |
Référence rapide pour les problèmes courants :
| Symptôme | Cause | Solution |
|---|---|---|
| La réponse n'a aucun rapport avec les documents | Récupération manquée | Vérifiez si les segments sont trop petits/grands et confirmez que la langue de la question est cohérente avec les documents |
| Le modèle invente encore des réponses | Contraintes du prompt | Renforcez la formulation « en se basant uniquement sur les documents » ; lorsque rien n'est récupéré, répondez directement « Je ne sais pas » |
| L'indexation est très lente | Trop de chunks sont encodés un par un | Utilisez l'embedding par lots ; passez à des bases de données vectorielles professionnelles et à l'indexation incrémentale lorsque le volume de documents est important |
| Les réponses se dégradent pour les documents longs | Les informations clés sont fragmentées | Segmentez selon des frontières sémantiques telles que les titres/paragraphes au lieu d'une longueur fixe pure |
Autres extensionsFeuille de route de production : lorsque vous avez des dizaines de milliers de documents ou que vous avez besoin d'analyser des PDF, remplacez le « list vector store » par une base de données vectorielle professionnelle comme Chroma (qui assure la persistance et une recherche efficace des plus proches voisins), utilisez pypdf pour extraire le texte des PDF, et conservez le reste du squelette de code inchangé — c'est exactement l'intérêt de découpler chaque étape dans cet article.