Installer un RAG avec raisonnement IA depuis le terminal

# Créer le dossier du projet
mkdir rag-reason && cd rag-reason

# Créer et activer l'environnement virtuel
python3 -m venv .venv

# Linux / macOS
source .venv/bin/activate

# Windows (PowerShell)
.venv\Scripts\Activate.ps1

# Linux / macOS — script d'installation officiel
curl -fsSL https://ollama.com/install.sh | sh

# Vérifier que le service répond
ollama --version

# Modèle de RAISONNEMENT (≈ 4,7 Go)
ollama pull deepseek-r1:7b

# Modèle d'EMBEDDINGS pour la recherche (≈ 270 Mo)
ollama pull nomic-embed-text

# Lister ce qui est installé
ollama list

ollama==0.4.7
chromadb==0.5.23
pypdf==5.1.0
rich==13.9.4

pip install -r requirements.txt

mkdir documents
# Déposez au moins un fichier de test, par ex. documents/notes.txt

# Réglages centraux du projet
LLM_MODEL = "deepseek-r1:7b"      # modèle de raisonnement
EMBED_MODEL = "nomic-embed-text"  # modèle d'embeddings

DOCS_DIR = "documents"           # dossier des sources
DB_DIR = "chroma_db"             # base vectorielle persistée
COLLECTION = "connaissances"

CHUNK_SIZE = 800                 # caractères par fragment
CHUNK_OVERLAP = 120              # chevauchement entre fragments
TOP_K = 4                        # passages récupérés par question

import os, glob, uuid
import ollama, chromadb
from pypdf import PdfReader
import config as cfg


def lire_fichier(chemin):
    """Extrait le texte brut d'un PDF, TXT ou MD."""
    if chemin.endswith(".pdf"):
        lecteur = PdfReader(chemin)
        return "\n".join(page.extract_text() or "" for page in lecteur.pages)
    with open(chemin, encoding="utf-8") as f:
        return f.read()


def decouper(texte, taille, chevauchement):
    """Découpe le texte en fragments qui se chevauchent."""
    morceaux, i = [], 0
    while i < len(texte):
        morceaux.append(texte[i:i + taille])
        i += taille - chevauchement
    return [m.strip() for m in morceaux if m.strip()]


def embed(texte):
    """Transforme un texte en vecteur via Ollama."""
    r = ollama.embeddings(model=cfg.EMBED_MODEL, prompt=texte)
    return r["embedding"]


def main():
    client = chromadb.PersistentClient(path=cfg.DB_DIR)
    # On repart d'une base propre à chaque ingestion complète
    try:
        client.delete_collection(cfg.COLLECTION)
    except Exception:
        pass
    col = client.create_collection(cfg.COLLECTION)

    fichiers = glob.glob(os.path.join(cfg.DOCS_DIR, "**/*"), recursive=True)
    fichiers = [f for f in fichiers if f.endswith((".pdf", ".txt", ".md"))]
    if not fichiers:
        print("Aucun document dans", cfg.DOCS_DIR); return

    total = 0
    for chemin in fichiers:
        texte = lire_fichier(chemin)
        morceaux = decouper(texte, cfg.CHUNK_SIZE, cfg.CHUNK_OVERLAP)
        for m in morceaux:
            col.add(
                ids=[str(uuid.uuid4())],
                embeddings=[embed(m)],
                documents=[m],
                metadatas=[{"source": os.path.basename(chemin)}],
            )
        total += len(morceaux)
        print(f"  {chemin} → {len(morceaux)} fragments")

    print(f"\nTerminé : {total} fragments indexés.")


if __name__ == "__main__":
    main()

python ingest.py
# → documents/notes.txt → 12 fragments
# → Terminé : 12 fragments indexés.

import re
import ollama, chromadb
import config as cfg

_client = chromadb.PersistentClient(path=cfg.DB_DIR)


def _embed(texte):
    return ollama.embeddings(model=cfg.EMBED_MODEL, prompt=texte)["embedding"]


def rechercher(question, k=cfg.TOP_K):
    """Retrouve les k passages les plus proches de la question."""
    col = _client.get_collection(cfg.COLLECTION)
    res = col.query(query_embeddings=[_embed(question)], n_results=k)
    passages = res["documents"][0]
    sources = [m["source"] for m in res["metadatas"][0]]
    return passages, sources


def construire_prompt(question, passages):
    contexte = "\n\n---\n\n".join(passages)
    return f"""Tu es un assistant rigoureux. Réponds à la QUESTION
en t'appuyant UNIQUEMENT sur le CONTEXTE ci-dessous.
Si le contexte ne suffit pas, dis-le clairement.

CONTEXTE :
{contexte}

QUESTION : {question}"""


def repondre(question):
    """Renvoie (raisonnement, reponse, sources)."""
    passages, sources = rechercher(question)
    prompt = construire_prompt(question, passages)

    sortie = ollama.chat(
        model=cfg.LLM_MODEL,
        messages=[{"role": "user", "content": prompt}],
    )["message"]["content"]

    # DeepSeek-R1 place sa réflexion entre <think>...</think>
    m = re.search(r"<think>(.*?)</think>", sortie, re.DOTALL)
    raisonnement = m.group(1).strip() if m else ""
    reponse = re.sub(r"<think>.*?</think>", "", sortie, flags=re.DOTALL).strip()

    return raisonnement, reponse, sorted(set(sources))

from rich.console import Console
from rich.panel import Panel
from rich.markdown import Markdown
import engine

console = Console()


def main():
    console.print(Panel.fit(
        "[bold cyan]RAG + Raisonnement[/]\n"
        "[dim]Tapez votre question — 'exit' pour quitter.[/]",
        border_style="cyan"))

    while True:
        question = console.input("\n[bold green]?[/] ").strip()
        if question.lower() in {"exit", "quit", "q"}:
            break
        if not question:
            continue

        with console.status("[cyan]Recherche et raisonnement…[/]"):
            raisonnement, reponse, sources = engine.repondre(question)

        if raisonnement:
            console.print(Panel(raisonnement, title="🧠 Raisonnement",
                                border_style="yellow", expand=False))
        console.print(Panel(Markdown(reponse), title="✅ Réponse",
                            border_style="green"))
        console.print(f"[dim]Sources : {', '.join(sources)}[/]")


if __name__ == "__main__":
    main()

# 1) Vérifier qu'Ollama tourne (sinon : ollama serve)
ollama list

# 2) Indexer vos documents
python ingest.py

# 3) Démarrer l'assistant
python cli.py

╭─ RAG + Raisonnement ─────────────────────────╮
│ Tapez votre question — 'exit' pour quitter.  │
╰──────────────────────────────────────────────╯

? Quelle est la politique de remboursement ?

╭─ 🧠 Raisonnement ────────────────────────────╮
│ Le contexte mentionne un délai de 30 jours    │
│ et exige un justificatif d'achat. Je combine  │
│ ces deux éléments pour la réponse.            │
╰──────────────────────────────────────────────╯
╭─ ✅ Réponse ─────────────────────────────────╮
│ Le remboursement est possible sous 30 jours,  │
│ sur présentation d'un justificatif d'achat.   │
╰──────────────────────────────────────────────╯
Sources : notes.txt