RAG local Python : Guide complet 2026 pour automatiser vos tâches

En 2026, des milliers d'employés de bureau passent leurs journées à copier-coller des extraits de PDF dans des tableurs, à lire en diagonale des rapports de 80 pages pour en extraire trois chiffres, et à perdre 30 minutes à retrouver une clause dans un contrat.

Ce n'est pas un problème de compétences : c'est un problème d'outillage.

Ce tutoriel vous montre comment construire un système RAG local Python (Retrieval-Augmented Generation) qui tourne entièrement sur votre ordinateur, sans abonnement, sans connexion internet, et sans envoyer vos données sensibles sur un serveur externe.

Le système lit vos PDF, comprend vos questions en langage naturel, et rédige les réponses en citant les sources exactes (nom du fichier et numéro de page).

Nous allons construire trois scripts distincts, une interface web, et un outil de diagnostic, et chaque étape est autonome et testable.

Pourquoi le RAG local Python est votre seule option crédible en 2026

Si vous traitez des contrats, des données RH ou de la propriété intellectuelle, envoyer ces fichiers vers ChatGPT ou Claude représente un risque légal et sécuritaire inacceptable dans la plupart des entreprises.

Le RAG local Python résout ce problème par l'architecture même : le câble réseau peut être débranché, le système continue de fonctionner.

Le modèle d'IA s'exécute sur votre processeur, et vos documents sont stockés dans une base de données sur votre disque dur., donc rien ne sort.

L'autre argument décisif, c'est la stabilité.

OpenAI ou Anthropic changent leurs prix, modifient leurs conditions d'utilisation ou subissent des pannes. Votre script Python local ne change pas. Une fois configuré, il fonctionne tant que votre ordinateur s'allume, il s'agit d'un actif que vous possédez et contrôlez entièrement.

Enfin, la qualité des modèles ouverts a atteint un niveau très élevé.

Ollama fait tourner des modèles comme Llama 3 ou Mistral avec une fluidité qu'on n'imaginait pas il y a deux ans. En effet, ces modèles sont capables de raisonnement complexe, de synthèse et d'extraction de données structurées.

Vous n'avez plus besoin d'un datacenter ; vous avez juste besoin d'un peu de méthode.

Le matériel : Pas besoin d'un serveur

Le nerf de la guerre, c'est la RAM (mémoire vive).

Le processeur fait les calculs, mais la RAM doit contenir le modèle en entier. Si le modèle ne rentre pas dans la RAM, votre ordinateur va utiliser le disque dur en renfort (le swap), et les réponses seront extrêmement lentes.

• Minimum vital (Mode survie) : 16 Go de RAM. Ça passe, mais fermez Chrome et vos gros fichiers Excel avant de lancer le script. Le modèle sera fonctionnel mais lent.
• Confortable (Mode pro) : 32 Go de RAM. C'est le standard pour ce type de tâche. Vous pouvez laisser tourner le RAG en fond et continuer à travailler avec des réponses fluides.
• Optimal (Mode expert) : Un Mac avec puce M1/M2/M3 ou un PC avec une carte graphique NVIDIA (RTX 3060 ou mieux). Avec un GPU dédié, les réponses sont quasi instantanées et la vectorisation des documents se fait en quelques secondes.

Côté stockage, c'est négligeable.

Les modèles compressés (quantifiés) pèsent entre 4 et 8 Go, vos documents vectorisés prennent moins de place que les PDF originaux.

L'architecture simplifiée

Le système RAG local Python fonctionne en quatre étapes distinctes, les comprendre permettra de déboguer les problèmes quand ils surviennent.

1. Ingestion (Découpage) : Le script lit chaque page PDF et découpe les paragraphes en petits morceaux appelés chunks.
2. Indexation (Classement vectoriel) : Chaque morceau est transformé en une liste de nombres (un vecteur) qui représente le sens du texte. Les informations sur le "chiffre d'affaires" seront placées près des informations sur les "revenus", même si les mots sont différents.
3. Récupération (Le RAG) : Quand vous posez une question, le système cherche dans la base vectorielle les 3 ou 4 morceaux les plus pertinents.
4. Génération (La réponse) : Le modèle de langage (le LLM) lit ces morceaux et rédige la réponse à votre question en se basant uniquement sur le contenu trouvé.

Installation des outils

Étape 1 : Préparer le terrain

1. Installer Python

Si vous êtes sur Windows :

• Allez sur python.org et téléchargez la dernière version stable (3.10 minimum, 3.12 recommandé).
• TRÈS IMPORTANT : Au moment de lancer l'installateur, cochez la case "Add Python to PATH" en bas de la fenêtre. Si vous ratez ça, rien ne marchera.
• Cliquez sur "Install Now".

Si vous êtes sur Mac :

• Téléchargez l'installateur universel sur python.org et suivez les instructions.
• Ouvrez votre dossier Applications, trouvez le dossier Python, et double-cliquez sur "Install Certificates.command". Ça règle 90% des problèmes de connexion SSL futurs.

Vous trouverez plus de détails à ce sujet dans mon Guide comment installer Python

2. Créer un environnement virtuel (étape obligatoire)

Un environnement virtuel isole les bibliothèques de votre projet de celles du reste de votre système. C'est une bonne pratique qui évite des conflits de versions entre projets.

Ouvrez votre terminal, naviguez dans votre dossier de projet, et tapez :

# Créer le dossier de projet et l'environnement virtuel
mkdir MonRAGLocal
cd MonRAGLocal
python -m venv venv

Ensuite, activez l'environnement. Cette commande est différente selon votre OS :

# Sur Windows (PowerShell ou CMD)
venv\Scripts\activate

# Sur Mac / Linux
source venv/bin/activate

Vous verrez (venv) apparaître au début de votre ligne de terminal.

Tant que vous voyez ce préfixe, toutes les installations pip n'affecteront que ce projet.

D'ailleurs, pensez à activer cet environnement à chaque fois que vous reprenez le travail.

3. Installer Ollama

Ollama est le gestionnaire de modèles d'IA local, il télécharge, stocke et sert les modèles à votre script Python.

• Allez sur ollama.com, téléchargez et installez la version pour votre OS.
• Une fois installé, ouvrez votre terminal et téléchargez les deux modèles nécessaires :

# Le modèle de langage principal (~4.7 Go)
ollama pull llama3

# Le modèle d'embeddings (~270 Mo)
ollama pull nomic-embed-text

Ces deux modèles ont des rôles distincts. llama3 génère du texte (les réponses)., quant à nomic-embed-text, il transforme les phrases en vecteurs numériques pour le classement.

Vous avez besoin des deux, et l'absence de l'un ou l'autre est la cause numéro un d'erreur au premier lancement.

4. Installer VS Code

N'écrivez pas de code dans le Bloc-notes. Installez Visual Studio Code sur code.visualstudio.com.

C'est gratuit, il colore le code pour repérer les erreurs visuellement, et il intègre un terminal directement dans l'interface.

Étape 1.5 : Installer les bibliothèques Python

Avec votre environnement virtuel activé ((venv) visible dans le terminal), tapez cette commande complète. Elle utilise langchain-chroma (le paquet officiel dédié depuis 2024) et langchain-ollama, et non plus les anciens imports de langchain_community qui sont dépréciés :

pip install langchain langchain-core langchain-chroma langchain-ollama langchain-community pypdf streamlit

Si vous voyez des messages en rouge, vérifiez s'ils indiquent "error" ou simplement "warning". Les warnings de version sont normaux. L'installation est réussie si la dernière ligne contient "Successfully installed".

Script de diagnostic (check_setup.py)

Avant d'écrire une seule ligne de code métier, vérifiez que votre environnement est correctement configuré. C'est la cause de 80% des questions sur les forums : les gens lancent le script principal sans vérifier que les prérequis sont bien en place.

Ce script de diagnostic fait ce travail pour vous en quelques secondes.

Créez un fichier check_setup.py dans votre dossier MonRAGLocal et copiez ce code :

import sys
import os
import subprocess

def check_python_version():
    version = sys.version_info
    if version.major == 3 and version.minor >= 10:
        print(f"✅ Python {version.major}.{version.minor}.{version.micro} détecté.")
    else:
        print(f"❌ Python {version.major}.{version.minor} trop ancien. Installez Python 3.10+.")

def check_libraries():
    required = [
        "langchain",
        "langchain_chroma",
        "langchain_ollama",
        "langchain_community",
        "pypdf",
        "streamlit",
        "chromadb",
    ]
    all_ok = True
    for lib in required:
        try:
            __import__(lib)
            print(f"✅ Bibliothèque '{lib}' trouvée.")
        except ImportError:
            print(f"❌ Bibliothèque '{lib}' manquante. Lancez : pip install {lib}")
            all_ok = False
    return all_ok

def check_ollama_running():
    try:
        import httpx
        response = httpx.get("http://localhost:11434", timeout=3)
        if response.status_code == 200:
            print("✅ Ollama est actif et répond sur le port 11434.")
            return True
    except Exception:
        pass
    print("❌ Ollama ne répond pas. Lancez 'ollama serve' dans un terminal séparé.")
    return False

def check_ollama_models():
    try:
        result = subprocess.run(
            ["ollama", "list"],
            capture_output=True,
            text=True,
            timeout=5
        )
        output = result.stdout
        for model in ["llama3", "nomic-embed-text"]:
            if model in output:
                print(f"✅ Modèle '{model}' disponible.")
            else:
                print(f"❌ Modèle '{model}' manquant. Lancez : ollama pull {model}")
    except FileNotFoundError:
        print("❌ Commande 'ollama' introuvable. Ollama est-il installé ?")
    except subprocess.TimeoutExpired:
        print("⚠️  Timeout lors de la vérification des modèles Ollama.")

def check_chroma_db():
    db_path = "./chroma_db"
    if os.path.exists(db_path) and os.listdir(db_path):
        print(f"✅ Base ChromaDB trouvée dans '{db_path}'.")
    else:
        print(f"⚠️  Aucune base ChromaDB trouvée. Lancez 'python ingest.py' après avoir ajouté des PDF.")

def check_documents_folder():
    docs_path = "./mes_documents"
    if not os.path.exists(docs_path):
        print(f"⚠️  Dossier '{docs_path}' inexistant. Il sera créé par ingest.py.")
    else:
        pdfs = [f for f in os.listdir(docs_path) if f.endswith(".pdf")]
        if pdfs:
            print(f"✅ {len(pdfs)} fichier(s) PDF trouvé(s) dans '{docs_path}'.")
        else:
            print(f"⚠️  Dossier '{docs_path}' vide. Ajoutez des PDF avant de lancer ingest.py.")

if __name__ == "__main__":
    print("=" * 50)
    print("  Diagnostic RAG Local Python")
    print("=" * 50)
    check_python_version()
    print()
    check_libraries()
    print()
    check_ollama_running()
    check_ollama_models()
    print()
    check_documents_folder()
    check_chroma_db()
    print()
    print("=" * 50)
    print("  Diagnostic terminé. Corrigez les ❌ avant de continuer.")
    print("=" * 50)

Lancez-le avec python check_setup.py avant chaque session de travail, ou dès qu'une erreur incompréhensible apparaît.

Il vérifie six points critiques : la version de Python, la présence de chaque bibliothèque, si Ollama tourne en arrière-plan, si les deux modèles requis sont téléchargés, si votre dossier de documents contient des PDF, et si la base ChromaDB a déjà été créée.

Chaque problème détecté affiche la commande exacte pour le corriger.

Étape 2 : Ingestion des données (ingest.py)

Créez un sous-dossier nommé mes_documents dans MonRAGLocal. C'est là que vous glissez vos PDF. Créez ensuite un fichier ingest.py et copiez ce code :

import os
from langchain_community.document_loaders import PyPDFLoader, DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_ollama import OllamaEmbeddings
from langchain_chroma import Chroma

# --- Configuration ---
DOSSIER_DOCS = "./mes_documents"
DB_PATH = "./chroma_db"
EMBEDDING_MODEL = "nomic-embed-text"

def charger_et_indexer():
    """Charge les PDF, les découpe et les indexe dans ChromaDB."""
    print(f"🔍 Chargement des fichiers depuis '{DOSSIER_DOCS}'...")

    if not os.path.exists(DOSSIER_DOCS) or not os.listdir(DOSSIER_DOCS):
        print("❌ Le dossier est vide ou inexistant. Ajoutez des PDF et relancez.")
        return

    loader = DirectoryLoader(DOSSIER_DOCS, glob="*.pdf", loader_cls=PyPDFLoader)
    documents = loader.load()

    if not documents:
        print("❌ Aucun document PDF trouvé. Vérifiez le dossier.")
        return

    print(f"✅ {len(documents)} pages chargées depuis les PDF.")

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200
    )
    chunks = text_splitter.split_documents(documents)
    print(f"✂️  {len(chunks)} morceaux créés.")

    print("💾 Indexation dans ChromaDB (peut prendre quelques minutes)...")
    embeddings = OllamaEmbeddings(model=EMBEDDING_MODEL)

    vector_db = Chroma.from_documents(
        documents=chunks,
        embedding=embeddings,
        persist_directory=DB_PATH,
        collection_name="mes_documents"
    )

    print(f"✅ Base de données créée dans '{DB_PATH}'. Prêt à interroger !")


if __name__ == "__main__":
    if not os.path.exists(DOSSIER_DOCS):
        os.makedirs(DOSSIER_DOCS)
        print(f"📁 Dossier '{DOSSIER_DOCS}' créé. Ajoutez vos PDF dedans et relancez.")
    else:
        charger_et_indexer()

Explication du code : PyPDFLoader extrait le texte brut de chaque page. RecursiveCharacterTextSplitter découpe ce texte en blocs de 1000 caractères avec un chevauchement de 200 caractères pour éviter de couper une phrase importante à la frontière de deux blocs.

OllamaEmbeddings transforme chaque morceau en vecteur numérique via le modèle nomic-embed-text. Enfin, Chroma.from_documents() stocke tout dans le dossier chroma_db de façon persistante.

Vous n'avez à relancer ce script que si vous ajoutez de nouveaux fichiers.

Pour lancer ce script, ouvrez le terminal VS Code (Menu Terminal > New Terminal), assurez-vous que votre environnement virtuel est activé (venv\Scripts\activate sur Windows ou source venv/bin/activate sur Mac), puis tapez :

python ingest.py

Étape 3 : Interroger les documents (query.py)

Ce script utilise la chaîne LCEL (LangChain Expression Language) moderne, qui remplace l'ancienne classe RetrievalQA officiellement dépréciée depuis LangChain v0.2.

Il charge la base ChromaDB existante (sans la recréer), cherche les passages pertinents, et envoie le tout à Ollama avec gestion des erreurs de connexion.

import os
from langchain_chroma import Chroma
from langchain_ollama import OllamaEmbeddings, ChatOllama
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate

# --- Configuration ---
DB_PATH = "./chroma_db"
LLM_MODEL = "llama3"
EMBEDDING_MODEL = "nomic-embed-text"

PROMPT_SYSTEM = """Tu es un assistant documentaire. Utilise uniquement le contexte fourni pour répondre.
Si la réponse n'est pas dans le contexte, dis clairement que tu ne trouves pas cette information dans les documents.
Ne fabrique pas de données chiffrées ou de faits absents du contexte.

Contexte :
{context}"""

def creer_chaine_rag():
    """Charge la base vectorielle existante et construit la chaîne RAG."""
    if not os.path.exists(DB_PATH):
        print(f"❌ Base de données introuvable dans '{DB_PATH}'.")
        print("Lancez d'abord 'python ingest.py' pour indexer vos documents.")
        return None

    embeddings = OllamaEmbeddings(model=EMBEDDING_MODEL)
    vector_db = Chroma(
        persist_directory=DB_PATH,
        embedding_function=embeddings,
        collection_name="mes_documents"
    )

    retriever = vector_db.as_retriever(search_kwargs={"k": 4})
    llm = ChatOllama(model=LLM_MODEL, temperature=0)

    prompt = ChatPromptTemplate.from_messages([
        ("system", PROMPT_SYSTEM),
        ("human", "{input}"),
    ])

    question_answer_chain = create_stuff_documents_chain(llm, prompt)
    rag_chain = create_retrieval_chain(retriever, question_answer_chain)
    return rag_chain


if __name__ == "__main__":
    chain = creer_chaine_rag()
    if chain:
        print("\n🤖 Assistant prêt. Posez vos questions (tapez 'exit' pour quitter).")
        while True:
            query = input("\n❓ Question : ").strip()
            if query.lower() in ["exit", "quit", "quitter"]:
                break
            if not query:
                continue

            try:
                response = chain.invoke({"input": query})
                print(f"\n💡 Réponse :\n{response['answer']}")
                print("\n📄 Sources utilisées :")
                seen = set()
                for doc in response.get("context", []):
                    src = doc.metadata.get("source", "?")
                    page = doc.metadata.get("page", "?")
                    key = f"{src}:{page}"
                    if key not in seen:
                        seen.add(key)
                        print(f"  - Page {page} du fichier {os.path.basename(src)}")
            except Exception as e:
                print(f"\n❌ Erreur lors de la requête : {e}")
                print("Vérifiez qu'Ollama est actif (lancez 'ollama serve' si nécessaire).")

Point clé : Notez le bloc try/except autour de chain.invoke(). Sans cette protection, si Ollama n'est pas démarré ou plante en cours de route, votre script s'arrête avec un message d'erreur incompréhensible. Avec ce bloc, vous obtenez un message clair et le programme continue d'accepter des questions.

Étape 4 : Interface utilisateur avec Streamlit (app.py)

Un terminal avec du texte blanc sur fond noir n'est pas acceptable pour présenter un outil à des collègues. Streamlit est une bibliothèque Python qui génère une interface web complète sans écrire une seule ligne de HTML ou CSS.

Votre navigateur s'ouvre sur une page de chat proche de ChatGPT, mais qui tourne intégralement en local.

Créez un fichier app.py dans votre dossier MonRAGLocal :

import os
import streamlit as st
from langchain_chroma import Chroma
from langchain_ollama import OllamaEmbeddings, ChatOllama
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate

# --- Configuration ---
DB_PATH = "./chroma_db"
LLM_MODEL = "llama3"
EMBEDDING_MODEL = "nomic-embed-text"

PROMPT_SYSTEM = """Tu es un assistant documentaire. Utilise uniquement le contexte fourni pour répondre.
Si la réponse n'est pas dans le contexte, dis clairement que tu ne trouves pas cette information dans les documents.

Contexte :
{context}"""

# --- Configuration de la page ---
st.set_page_config(page_title="Assistant Documentaire Local", layout="wide")
st.title("🤖 Assistant Documentaire Local")
st.caption("Powered by Ollama + ChromaDB — 100% local, 0% cloud")

@st.cache_resource
def charger_chaine():
    """Charge la chaîne RAG une seule fois, mise en cache par Streamlit."""
    if not os.path.exists(DB_PATH):
        return None

    embeddings = OllamaEmbeddings(model=EMBEDDING_MODEL)
    vector_db = Chroma(
        persist_directory=DB_PATH,
        embedding_function=embeddings,
        collection_name="mes_documents"
    )

    retriever = vector_db.as_retriever(search_kwargs={"k": 3})
    llm = ChatOllama(model=LLM_MODEL, temperature=0)

    prompt = ChatPromptTemplate.from_messages([
        ("system", PROMPT_SYSTEM),
        ("human", "{input}"),
    ])

    question_answer_chain = create_stuff_documents_chain(llm, prompt)
    return create_retrieval_chain(retriever, question_answer_chain)


# --- Interface latérale ---
with st.sidebar:
    st.header("⚙️ Configuration")
    st.info("Assurez-vous qu'Ollama est lancé en arrière-plan.")
    st.markdown("**Étapes préalables :**")
    st.markdown("1. `ollama pull llama3`")
    st.markdown("2. `ollama pull nomic-embed-text`")
    st.markdown("3. `python ingest.py`")
    if st.button("🔄 Recharger la base"):
        st.cache_resource.clear()
        st.success("Cache effacé ! La base sera rechargée à la prochaine question.")

# --- Zone de chat ---
chain = charger_chaine()

if chain is None:
    st.error(
        "❌ Base de données introuvable. "
        "Lancez d'abord `python ingest.py` pour indexer vos documents."
    )
    st.stop()

if "messages" not in st.session_state:
    st.session_state.messages = []

for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

if prompt := st.chat_input("Posez votre question sur les documents..."):
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)

    with st.chat_message("assistant"):
        with st.spinner("Analyse en cours..."):
            try:
                response = chain.invoke({"input": prompt})
                answer = response["answer"]

                sources_lines = []
                seen = set()
                for doc in response.get("context", []):
                    src = os.path.basename(doc.metadata.get("source", "Inconnu"))
                    page = doc.metadata.get("page", "?")
                    key = f"{src}:{page}"
                    if key not in seen:
                        seen.add(key)
                        sources_lines.append(f"- {src} (p. {page})")

                sources_text = ""
                if sources_lines:
                    sources_text = "\n\n**📄 Sources :**\n" + "\n".join(sources_lines)

                full_response = answer + sources_text
                st.markdown(full_response)
                st.session_state.messages.append(
                    {"role": "assistant", "content": full_response}
                )
            except Exception as e:
                error_msg = f"❌ Erreur de connexion à Ollama : {e}\n\nVérifiez qu'Ollama est actif."
                st.error(error_msg)

Pour lancer l'interface, tapez dans le terminal :

streamlit run app.py

Votre navigateur s'ouvre automatiquement sur http://localhost:8501.

Le bouton "Recharger la base" dans le panneau latéral efface le cache de Streamlit, utile quand vous avez ajouté de nouveaux PDF et relancé ingest.py.

Toutes les erreurs de connexion Ollama s'affichent maintenant proprement dans l'interface au lieu de faire planter le serveur.

Structure finale du projet

À la fin de ce tutoriel, votre dossier MonRAGLocal doit ressembler à ceci :

MonRAGLocal/
├── venv/                ← Environnement virtuel Python (ne pas modifier)
├── mes_documents/       ← Vos fichiers PDF à analyser
│   ├── rapport_q3.pdf
│   └── contrat_fournisseur.pdf
├── chroma_db/           ← Généré automatiquement par ingest.py
├── check_setup.py       ← Diagnostic : à lancer en premier si quelque chose ne marche pas
├── ingest.py            ← Script d'indexation (à relancer si vous ajoutez des PDF)
├── query.py             ← Interface terminal
├── app.py               ← Interface web Streamlit
└── .gitignore           ← Si vous utilisez Git : ajoutez venv/ et chroma_db/

Si vous utilisez Git pour versionner votre projet, créez un fichier .gitignore et ajoutez-y ces deux lignes : venv/ et chroma_db/. L'environnement virtuel et la base vectorielle se régénèrent facilement ; inutile de les versionner.

L'ordre d'utilisation est toujours le même : d'abord check_setup.py pour vérifier l'environnement, ensuite ingest.py pour créer ou mettre à jour la base, enfin query.py ou app.py pour poser des questions.

Maintenance et pièges à éviter

La qualité des données source (Garbage In, Garbage Out)
Le RAG est aussi bon que les documents qu'il ingère. Si vous mettez des brouillons, des fichiers corrompus ou des notes contradictoires dans mes_documents, le système produira des réponses confuses.

Ne mettez que les versions finales et vérifiées de vos documents.

Les hallucinations sur les tableaux PDF
Les modèles locaux peuvent interpréter incorrectement des chiffres issus de tableaux complexes (colonnes multiples, cellules fusionnées).

Le PDF est un format conçu pour l'impression, pas pour l'extraction de données structurées.

Avant de copier-coller un chiffre dans un rapport officiel, vérifiez toujours la source citée en bas de la réponse.

Ne mettez pas à jour les bibliothèques sans raison
L'écosystème LangChain évolue rapidement.

Si votre script fonctionne aujourd'hui, ne lancez pas pip install --upgrade sans raison.

Si une mise à jour future casse quelque chose, l'erreur la plus courante sera une modification du nom d'un paramètre ou d'un import.

Cherchez le message d'erreur exact dans les notes de version LangChain avant toute autre chose.

Ollama doit tourner en arrière-plan
Avant de lancer query.py ou app.py, assurez-vous qu'Ollama est actif.

Sur Windows, il tourne en tant que service après installation, et sur Mac, vérifiez la barre des menus.

Si vous obtenez une erreur de connexion refusée, tapez ollama serve dans un terminal séparé pour le démarrer manuellement. Le script check_setup.py vous le signalera automatiquement.

Réindexer après ajout de documents
ChromaDB ne surveille pas votre dossier en temps réel. Si vous ajoutez un nouveau PDF dans mes_documents, relancez python ingest.py. Le script recréera une base complète.

Pour des bases de plusieurs centaines de documents, ce processus peut prendre quelques minutes.

Dans Streamlit, cliquez ensuite sur "Recharger la base" pour vider le cache.