Demandez à Claude des informations sur votre entreprise, vos notes ou vos fichiers, et il reste muet. Il ne les a jamais vus. Il ne connaît que ce qu'il a appris lors de son entraînement, et vos données n'en faisaient pas partie.
Un système RAG résout ce problème. Au lieu de répondre de mémoire, Claude commence par chercher dans vos documents, extrait les passages pertinents et répond à partir de ce qu'il a réellement trouvé. Vos données sont sa source, pas de supposition.
Pourquoi c'est mieux que de simplement coller des fichiers dans le chat :
Ça passe à l'échelle. L'intégralité de votre base de connaissances ne tient pas dans un seul chat. Le RAG stocke tout et ne récupère que ce dont chaque question a besoin.
C'est moins cher. Coller un fichier oblige Claude à le relire en entier à chaque question. Le RAG le lit une fois, puis ne récupère que la partie pertinente. Au lieu d'envoyer un manuel de 10 000 tokens à chaque fois, il peut envoyer 500 tokens de la section exacte dont vous avez besoin. Les configurations réelles réduisent la consommation de tokens de 80 % ou plus.
C'est plus précis. Donnez à un modèle un énorme mur de texte et il perd les détails au milieu. Donnez-lui quelques passages précis et les réponses deviennent plus exactes.
C'est toujours à jour. Mettez à jour vos fichiers une fois et le système utilise la version la plus récente. Plus besoin de recoller.
À la fin de ce guide, vous en aurez un qui fonctionne sur vos propres fichiers, étape par étape, sans avoir besoin d'un doctorat.
Ce dont vous aurez besoin
Avant de toucher au code, voici la liste complète. Bonne nouvelle : cette version ne nécessite qu'une seule clé API, et tout le reste fonctionne gratuitement sur votre machine.
1. Python 3.9 ou plus récent. Pour vérifier si vous l'avez, ouvrez votre terminal (Terminal sur Mac, Invité de commandes sur Windows) et tapez python --version. Si vous voyez quelque chose comme 3.11, vous êtes bon. Sinon, téléchargez-le depuis python.org et exécutez l'installateur. Sur Windows, cochez la case "Add Python to PATH" lors de l'installation, sinon les commandes ci-dessous ne fonctionneront pas.
2. Une clé API Claude, plus un petit solde de crédit. C'est la seule clé et le seul argent dont ce guide a besoin. Voici le chemin exact, clic par clic :
Allez sur platform.claude.com, et connectez-vous (ou inscrivez-vous).
L'API a besoin d'un solde positif pour fonctionner, donc ajoutez d'abord des fonds. Lorsque vous y êtes invité, choisissez si les crédits sont pour vous-même ou pour une entreprise, puis vous arrivez sur l'écran de paiement. Choisissez l'option 5 $ "Starting out". C'est suffisant : tout le reste de ce guide est gratuit et local, donc Claude est la seule chose qui coûte de l'argent, et chaque question ne vous coûte qu'une fraction de centime. Les crédits expirent un an après l'achat.
Après le paiement, vous atterrirez sur votre tableau de bord Console. Vous devriez voir votre solde (par exemple 5,00 $) en haut à gauche sous "Organization credits".
Maintenant, récupérez la clé. Cliquez sur Get API key (en haut à droite), puis Create Key. Donnez-lui le nom que vous voulez (par exemple ma-cle-rag) et laissez l'espace de travail sur Default. Cliquez sur créer, puis copiez la chaîne qui s'affiche. Elle commence par sk-ant- et vous ne la voyez qu'une fois, alors collez-la quelque part en sécurité pour le moment.
C'est toute la configuration.
Étape 1 : Ajoutez votre clé et chargez vos fichiers
1. Créez le dossier du projet. Créez un nouveau dossier sur votre Bureau et nommez-le rag-project. Tout va ici.
2. Ouvrez votre terminal. Sur Mac : Cmd+Espace, tapez Terminal, entrez. Sur Windows : bouton Démarrer, tapez cmd, entrez.
3. Pointez le terminal vers votre dossier. Tapez cd suivi d'un espace, puis faites glisser le dossier rag-project sur la fenêtre du terminal et appuyez sur Entrée. Toutes les commandes ci-dessous sont exécutées depuis ce dossier.
1cd Desktop/rag-project
4. Installez les outils. Collez ceci dans votre terminal et appuyez sur Entrée (la première exécution peut prendre une minute) :
1pip install anthropic chromadb sentence-transformers pypdf python-dotenv
Si vous obtenez pip : command not found, utilisez pip3 à la place de pip. Lorsque le terminal affiche une nouvelle ligne sans erreurs rouges, c'est terminé.
5. Créez votre fichier de code. Dans rag-project, créez un fichier vide nommé exactement rag.py. Ouvrez-le dans n'importe quel éditeur de texte.
6. Créez votre fichier de clé. Dans le même dossier, créez un fichier nommé exactement .env (commence par un point, pas de nom avant). Collez ceci à l'intérieur, avec la vraie clé que vous avez créée lors de la configuration après le =, sans espaces, sans guillemets :
1ANTHROPIC_API_KEY=sk-ant-collez-votre-vraie-cle-ici
Garder la clé dans .env au lieu de dans votre code évite qu'elle ne fuite si vous partagez le script ou le mettez sur GitHub.
7. Chargez la clé. Mettez ceci en haut de rag.py :
1import os2from dotenv import load_dotenv34load_dotenv() # lit votre fichier .env5api_key = os.getenv("ANTHROPIC_API_KEY")
8. Créez votre base de connaissances. Dans rag-project, créez un dossier nommé documents. Déposez-y tous les fichiers .txt, .md ou .pdf : vos notes, un document produit, des résumés de réunions, tout ce que vous voulez.
8.1. Si vous n'avez pas encore de fichiers, utilisez ce fichier de test. Créez notes.txt dans le dossier documents et collez-y ceci :
Le projet Northstar est notre outil interne de suivi des retours clients. Il a été lancé en mars 2026 et est maintenu par l'équipe plateforme. L'ingénieur principal est Dana Reyes. Les retours sont examinés tous les vendredis. Northstar a remplacé l'ancien système de tableur que nous utilisions jusqu'en 2025.
À la fin, vous demanderez à Claude à propos de Northstar et vous le verrez répondre à partir de ce fichier exact.
9. Ajoutez le code qui lit vos fichiers. En dessous du code de l'étape 7, dans rag.py :
1from pathlib import Path2from pypdf import PdfReader34def load_documents(folder="documents"):5 docs = []6 for file in Path(folder).iterdir():7 if file.suffix in [".txt", ".md"]:8 text = file.read_text(encoding="utf-8")9 docs.append({"source": file.name, "text": text})10 elif file.suffix == ".pdf":11 reader = PdfReader(str(file))12 text = "\n".join(page.extract_text() or "" for page in reader.pages)13 docs.append({"source": file.name, "text": text})14 return docs1516documents = load_documents()17print(f"Loaded {len(documents)} document(s).")
10. Exécutez-le. Sauvegardez rag.py, puis dans votre terminal :
1python rag.py
Vous devriez voir :
Loaded 1 document(s)
Si vous voyez Loaded 0 document(s), le dossier documents est vide ou au mauvais endroit. Il doit se trouver directement dans rag-project, à côté de rag.py.
Étape 2 : Divisez vos fichiers en morceaux
Actuellement, chaque fichier est un gros bloc de texte. Avant de pouvoir le rechercher, nous devons le découper en morceaux plus petits appelés chunks. Voici pourquoi : quand quelqu'un pose une question, le système trouve les chunks qui correspondent et n'envoie que ceux-là à Claude. Si vos chunks sont des documents entiers de 50 pages, vous en envoyez beaucoup trop. Si ce sont des phrases uniques, elles perdent le contexte. Les petits paragraphes sont le juste milieu.
1. Ajoutez le code de découpage. En dessous du code de l'étape 10, dans rag.py :
1def chunk_text(text, chunk_size=500, overlap=100):2 words = text.split()3 chunks = []4 start = 05 while start < len(words):6 end = start + chunk_size7 chunk = " ".join(words[start:end])8 chunks.append(chunk)9 start = end - overlap # recule un peu pour que les chunks se chevauchent10 return chunks
Deux nombres à comprendre ici, en termes simples :
- chunk_size=500 signifie que chaque chunk fait environ 500 mots. Assez grand pour contenir une idée complète, assez petit pour rester précis.
- overlap=100 signifie que chaque chunk répète les 100 derniers mots du précédent. C'est important car une réponse peut se situer exactement à la jonction de deux chunks. Sans chevauchement, une phrase coupée en deux pourrait être perdue. Le chevauchement garantit qu'aucune idée ne tombe dans l'oubli.
2. Transformez chaque document en chunks. Ajoutez ceci en dessous :
1all_chunks = []2for doc in documents:3 for chunk in chunk_text(doc["text"]):4 all_chunks.append({"source": doc["source"], "text": chunk})56print(f"Created {len(all_chunks)} chunk(s) from {len(documents)} document(s).")
Remarquez que chaque chunk porte sa source (le nom du fichier dont il provient). Nous la conservons tout au long du processus, afin que lorsque Claude répondra plus tard, il puisse vous dire de quel fichier provient la réponse.
3. Exécutez-le. Sauvegardez rag.py, puis dans votre terminal :
1python rag.py
Vous devriez voir quelque chose comme :
Loaded 1 document(s).
Created 1 chunk(s) from 1 document(s).
Le petit fichier de test devient un seul chunk car il est court. Les vrais documents en produiront plusieurs. Si vous avez déposé un long PDF dans le dossier, vous pourriez voir des dizaines ou des centaines de chunks, ce qui est exactement ce que vous voulez.
Étape 3 : Transformez vos chunks en embeddings
C'est l'étape qui permet à l'ordinateur de rechercher par sens plutôt que par mots exacts. Chaque chunk est converti en une liste de nombres (un embedding) qui capture ce qu'il signifie. Les chunks avec des significations similaires aboutissent à des nombres similaires. Plus tard, quand une question arrive, nous transformons également la question en nombres et trouvons les correspondances les plus proches.
Le modèle qui fait cela s'exécute localement sur votre machine. Il se télécharge une fois, puis fonctionne hors ligne et gratuitement, et vos fichiers ne quittent jamais votre ordinateur.
1. Chargez le modèle d'embedding. En dessous du code de l'étape 2, dans rag.py :
1from sentence_transformers import SentenceTransformer23print("Loading the embedding model (first run downloads it, about 90 MB)...")4embedder = SentenceTransformer("all-MiniLM-L6-v2")
La toute première fois que vous exécutez ceci, il télécharge le modèle, donc patientez un instant. Toutes les exécutions suivantes sont instantanées car il est déjà sur votre machine.
2. Transformez chaque chunk en embedding. Ajoutez ceci en dessous :
1chunk_texts = [chunk["text"] for chunk in all_chunks]2embeddings = embedder.encode(chunk_texts)34print(f"Created {len(embeddings)} embedding(s).")5print(f"Each embedding is a list of {len(embeddings[0])} numbers.")
embedder.encode(...) prend votre liste de textes de chunks et renvoie un embedding par chunk. C'est tout ce qu'il faut.
3. Exécutez-le. Sauvegardez rag.py, puis dans votre terminal :
1python rag.py
La première exécution marque une pause pendant le téléchargement du modèle, puis vous devriez voir quelque chose comme :
Loaded 1 document(s).
Created 1 chunk(s) from 1 document(s).
Loading the embedding model (first run downloads it, about 90 MB)...
Created 1 embedding(s).
Each embedding is a list of 384 numbers.
Cette ligne "384 numbers" est l'idée entière rendue visible : votre texte est maintenant une rangée de nombres que l'ordinateur peut comparer. Vous n'avez pas besoin de lire ou de comprendre ces nombres vous-même. La base de données de l'étape suivante s'occupe de toutes les comparaisons pour vous.
Si le téléchargement échoue avec une erreur de connexion, relancez simplement la commande. Elle reprend là où elle s'est arrêtée.
Étape 4 : Stockez tout dans votre base de données vectorielle
Maintenant, nous mettons les chunks et leurs embeddings dans Chroma, votre base de données locale. C'est ce qui rend la recherche rapide : au lieu de comparer votre question à chaque chunk manuellement à chaque fois, Chroma les stocke prêts à l'emploi et effectue la correspondance pour vous. Il enregistre dans un dossier sur votre machine, donc vous ne le construisez qu'une seule fois.
1. Configurez la base de données. En dessous du code de l'étape 3, dans rag.py :
1import chromadb23client = chromadb.PersistentClient(path="chroma_db")4collection = client.get_or_create_collection("my_documents")
PersistentClient(path="chroma_db") dit à Chroma de sauvegarder dans un dossier appelé chroma_db (il le crée automatiquement, juste à côté de votre script). Comme il est sauvegardé sur le disque, vos données survivent après la fin du script. Une collection est simplement la boîte nommée dans laquelle vivent vos chunks.
2. Ajoutez vos chunks à la base de données. Ajoutez ceci en dessous :
1collection.add(2 ids=[str(i) for i in range(len(all_chunks))],3 embeddings=[emb.tolist() for emb in embeddings],4 documents=[chunk["text"] for chunk in all_chunks],5 metadatas=[{"source": chunk["source"]} for chunk in all_chunks],6)78print(f"Stored {collection.count()} chunk(s) in the database.")
Voici ce que chaque ligne donne à Chroma, en termes simples : ids donne à chaque chunk une étiquette unique (0, 1, 2...), embeddings sont les nombres de l'étape 3, documents est le texte réel du chunk, et metadatas porte le nom du fichier pour pouvoir montrer la source plus tard. Chroma garde les quatre liés ensemble.
3. Exécutez-le. Sauvegardez rag.py, puis dans votre terminal :
1python rag.py
Vous devriez voir :
Stored 1 chunk(s) in the database.
Une chose à savoir pour plus tard. Chaque fois que vous exécutez le script maintenant, il ajoute à nouveau les chunks, donc les comptes peuvent augmenter (1, puis 2, puis 3...) lors des exécutions répétées. C'est normal pendant que nous construisons. Pour repartir de zéro, supprimez le dossier chroma_db et exécutez une fois de plus. Dans la version finale, nous gérerons cela correctement pour éviter les doublons.
Étape 5 : Recherchez dans vos documents
C'est la partie "récupération" du RAG, le R dans le nom. Nous prenons une question, la transformons en embedding de la même manière que nous l'avons fait pour les chunks, et demandons à Chroma les chunks dont le sens est le plus proche. Ces chunks correspondants sont ce que nous donnerons à Claude à l'étape suivante.
1. Ajoutez la fonction de recherche. En dessous du code de l'étape 4, dans rag.py :
1def search(question, n_results=3):2 question_embedding = embedder.encode([question])[0]3 results = collection.query(4 query_embeddings=[question_embedding.tolist()],5 n_results=n_results,6 )7 return results
Ce que cela fait, ligne par ligne en termes simples : il transforme la question en nombres avec le même modèle que vous avez utilisé sur vos chunks (c'est important, les deux doivent parler le même "langage numérique"), puis demande à Chroma les correspondances les plus proches. n_results=3 signifie "donne-moi les 3 chunks les plus pertinents." Trois est une bonne valeur par défaut : assez de contexte, pas trop pour ne pas gaspiller de tokens.
2. Essayez une recherche. Ajoutez ceci en dessous pour tester :
1question = "Who runs Northstar and when is feedback reviewed?"2results = search(question)34for i, doc in enumerate(results["documents"][0]):5 source = results["metadatas"][0][i]["source"]6 print(f"\n--- Match {i+1} (from {source}) ---")7 print(doc)
Cela exécute une vraie question sur votre base de données et affiche les chunks trouvés, chacun avec le nom du fichier dont il provient.
3. Exécutez-le. Sauvegardez rag.py, puis dans votre terminal :
1python rag.py
Avec le fichier de test Northstar, vous devriez le voir renvoyer le chunk correspondant, quelque chose comme :
--- Match 1 (from notes.txt) ---
Le projet Northstar est notre outil interne de suivi des retours clients. Il a été lancé en mars 2026 et est maintenu par l'équipe plateforme. L'ingénieur principal est Dana Reyes. Les retours sont examinés tous les vendredis. Northstar a remplacé l'ancien système de tableur que nous utilisions jusqu'en 2025.
Remarquez ce qui vient de se passer : votre question utilisait les mots "who runs" et "reviewed", mais le fichier dit "ingénieur principal" et "examinés tous les vendredis". Il a tout de même trouvé la correspondance, car la recherche fonctionne sur le sens, pas sur les mots exacts. C'est tout l'intérêt des embeddings, et c'est pourquoi cela bat une simple recherche par mots-clés (Ctrl+F) dans vos fichiers.
Si vous avez plus de fichiers, vous verrez les 3 meilleurs chunks provenant de tous, triés par leur degré de correspondance.
Étape 6 : Faites répondre Claude à partir de ce qu'il a trouvé
C'est la partie "génération", le G dans RAG. Nous prenons les chunks de l'étape 5, les donnons à Claude Opus 4.8 avec la question, et lui disons de répondre en utilisant uniquement ce contexte. C'est ce qui l'empêche de deviner : Claude répond à partir de vos fichiers, pas de sa propre mémoire, et vous dit quel fichier il a utilisé.
1. Ajoutez la fonction de réponse. En dessous du code de l'étape 5, dans rag.py :
1import anthropic23claude = anthropic.Anthropic(api_key=api_key)45def answer(question):6 results = search(question)7 chunks = results["documents"][0]8 sources = [m["source"] for m in results["metadatas"][0]]910 context = ""11 for i, chunk in enumerate(chunks):12 context += f"[From {sources[i]}]\n{chunk}\n\n"1314 message = claude.messages.create(15 model="claude-opus-4-8",16 max_tokens=1024,17 system=(18 "You answer questions using only the context provided. "19 "If the answer is not in the context, say you don't know. "20 "Always mention which file your answer came from."21 ),22 messages=[23 {24 "role": "user",25 "content": f"Context:\n{context}\nQuestion: {question}",26 }27 ],28 )29 return message.content[0].text
Ce qui se passe ici, en termes simples : nous recherchons les chunks pertinents, les assemblons en un seul bloc de contexte (chacun étiqueté avec son nom de fichier), puis envoyons ce bloc plus la question à Claude. L'instruction system est la partie clé. Elle dit trois choses à Claude : répondre uniquement à partir du contexte, admettre quand la réponse n'est pas là, et nommer le fichier source. Ces trois règles sont ce qui rend les réponses fiables plutôt qu'inventées.
model="claude-opus-4-8" est le nom exact du modèle (tirets, pas de points). max_tokens=1024 limite la longueur de la réponse.
2. Posez une question. Ajoutez ceci en dessous :
1question = "Who runs Northstar and when is feedback reviewed?"2print(answer(question))
3. Exécutez-le. Sauvegardez rag.py, puis dans votre terminal :
1python rag.py
Vous devriez obtenir une vraie réponse construite à partir de votre fichier, quelque chose comme :
Dana Reyes est l'ingénieur principal qui dirige le projet Northstar, et les retours sont examinés tous les vendredis. (Source : notes.txt)
C'est un système RAG complet qui fonctionne. Claude n'a jamais vu ce fichier pendant son entraînement, il ne peut pas savoir qui est Dana Reyes, et pourtant il a répondu correctement et vous a dit exactement d'où venait la réponse. Demandez-lui quelque chose qui n'est pas dans vos fichiers et il dira qu'il ne sait pas, au lieu d'inventer une réponse. Ce "je ne sais pas" est une fonctionnalité, pas un échec : c'est la différence entre un outil en qui vous pouvez avoir confiance et un qui devine.
Étape 7 : Transformez-le en quelque chose de réellement utilisable
Actuellement, vous devez modifier le code et réexécuter tout le script à chaque fois que vous voulez demander quelque chose. Pire encore, chaque exécution relit vos fichiers et les réajoute à la base de données, donc les chunks s'accumulent. Corrigeons les deux : construisez la base de données une seule fois, puis laissez-vous poser des questions en boucle, en les tapant directement dans le terminal.
1. Corrigez le double-ajout. Trouvez le bloc de l'étape 4 qui ajoute les chunks (la partie collection.add(...)) et remplacez-le par cette version, qui ne construit la base de données que si elle est vide :
1if collection.count() == 0:2 collection.add(3 ids=[str(i) for i in range(len(all_chunks))],4 embeddings=[emb.tolist() for emb in embeddings],5 documents=[chunk["text"] for chunk in all_chunks],6 metadatas=[{"source": chunk["source"]} for chunk in all_chunks],7 )8 print(f"Stored {collection.count()} chunk(s) in the database.")9else:10 print(f"Database already has {collection.count()} chunk(s), skipping rebuild.")
Maintenant, le travail lourd (lire les fichiers, créer les embeddings, remplir la base de données) n'a lieu que la première fois. Les exécutions ultérieures passent directement à la réponse.
2. Ajoutez la boucle de questions. Tout en bas de rag.py, remplacez la question de test unique de l'étape 6 par ceci :
1print("\nAsk a question about your documents (or type 'quit' to exit).\n")23while True:4 question = input("You: ")5 if question.lower() in ["quit", "exit"]:6 break7 print("\nClaude: " + answer(question) + "\n")
input("You: ") attend que vous tapiez une question et appuyiez sur Entrée. while True la maintient en boucle pour que vous puissiez en poser autant que vous le souhaitez. Taper quit l'arrête.
3. Exécutez-le. Sauvegardez rag.py, puis dans votre terminal :
1python rag.py
Maintenant, vous pouvez simplement parler à vos fichiers :
Posez une question sur vos documents (ou tapez 'quit' pour quitter).
You: who is the lead engineer on Northstar?
Claude: The lead engineer on Project Northstar is Dana Reyes. (Source: notes.txt)
You: what did it replace?
Claude: Northstar replaced the old spreadsheet system used through 2025. (Source: notes.txt)
You: quit
C'est votre système RAG terminé. Il lit vos fichiers une fois, les mémorise et répond aux questions les concernant à la demande, avec la source à chaque fois.
Une chose à savoir lorsque vous ajoutez de nouveaux fichiers. Comme la base de données ne se construit maintenant qu'une seule fois, le fait de déposer de nouveaux fichiers dans documents ne les rendra pas automatiquement visibles. Pour charger de nouveaux fichiers, supprimez le dossier chroma_db et exécutez le script une fois. Il reconstruit tout à partir de zéro avec tout ce qui se trouve dans le dossier.
Optionnel : donnez-lui une fenêtre de chat dans votre navigateur
Le terminal fonctionne, mais si vous voulez une vraie fenêtre de chat, Streamlit en ajoute une en environ 20 lignes.
1. Installez-le. Dans votre terminal :
1pip install streamlit
2. Créez app.py dans le même dossier et collez-y ceci. Il réutilise la fonction answer de votre rag.py :
1import streamlit as st2from rag import answer34st.title("Chat with your documents")56if "history" not in st.session_state:7 st.session_state.history = []89question = st.chat_input("Ask about your files...")1011if question:12 reply = answer(question)13 st.session_state.history.append((question, reply))1415for q, a in st.session_state.history:16 st.chat_message("user").write(q)17 st.chat_message("assistant").write(a)
3. Exécutez-le. Dans votre terminal (note : streamlit run, pas python) :
1streamlit run app.py
Cela ouvre automatiquement une fenêtre de chat dans votre navigateur. Tapez une question, obtenez une réponse avec sa source, comme dans le terminal mais plus agréable à regarder.
Une remarque : pour que cela fonctionne, la boucle de questions de l'étape 7 ne doit pas s'exécuter lors de l'importation. Encadrez cette boucle en bas de rag.py avec if __name__ == "__main__": afin qu'elle ne se déclenche que lorsque vous exécutez rag.py directement, et non lorsque app.py l'importe.
Laissez-le répondre aussi aux questions générales
Si vous voulez qu'il réponde aussi aux questions générales. Actuellement, le système ne répond qu'à partir de vos fichiers, donc une question comme "quelle est la capitale du Venezuela ?" obtient "ce n'est pas dans les documents", même si Claude connaît la réponse. Si vous voulez qu'il se rabatte sur ses propres connaissances, ouvrez rag.py, trouvez le bloc system=(...) à l'étape 6, et remplacez cette ligne :
1"Si la réponse ne se trouve pas dans le contexte, dites que vous ne savez pas. "
pour cela :
1"Si la réponse ne se trouve pas dans le contexte, répondez à partir de vos connaissances générales, mais dites que vous le faites. "
Enregistrez et relancez. Maintenant, il répond d'abord à partir de vos fichiers, puis se rabat sur les connaissances générales lorsque les fichiers ne couvrent pas la question, en vous indiquant lequel il a utilisé.
Pour conclure
Vous venez de construire un système RAG fonctionnel. Il lit vos propres fichiers, trouve les parties qui comptent et fait répondre Claude à partir d'eux avec la source exacte à chaque fois. La même configuration s'adapte de quelques notes à l'ensemble de votre base de connaissances.
À partir de là, vous pouvez le diriger où vous voulez : votre coffre Obsidian, vos documents de travail, vos recherches sauvegardées. Déposez les fichiers, reconstruisez une fois, et commencez à poser des questions. Tout ce que vous avez appris ici – les morceaux, les embeddings, la recherche, la réponse – est le même socle derrière chaque outil de « chat avec vos documents » que vous avez vu.
Si cela vous a été utile, allez sur mon profil et suivez-moi. J'écris sur la tech, l'IA et les systèmes qui fonctionnent vraiment.
Ciao,
[@undefinedKi**](https://x.com/@undefinedKi
