OLLAMAt son RAG et Chunking

Installation du RAG et plus...

Transformer l’AI Act en réflexes opérationnels pour tes équipes, pas en PDF poussiéreux. On va le prendre comme un projet produit avec ses solutions et outils.

Mon classement de mes données sur ce sujet :

CO-WORK2026\

├── 01_DCP\              ← Contrats-NDA, Juridique, COMEX  🔴

├── 02_CONFIDENTIEL\     ← Commercial, Tarifs, Partenaires  🟠

├── 03_CONFORMITE\       ← RGPD, Gouvernance, Cybersécurité  🟡

├── 04_TECHNIQUE\        ← Ollama, Docker, PHI4, Scripts  🟢

├── 05_PUBLICATIONS\     ← Formations, Audit, Livre  🔵

└── 06_ARCHIVES\         ← Historique, purge annuelle

En isolant les DCP en Zone 1, vos agents Ollama/PHI4 peuvent travailler librement sur les zones 3, 4 et 5 — ce qui est exactement l'architecture Privacy by Design que la CNIL recommande pour les SLM on-premise. Il faut se tenir prêt et prendre les bonnes habitudes, se tenir en conformité avec le RGPD.

Cette approche est d'ores et déjà une étape qu'il faut mettre en place et expliquer, puis former les responsables dans l'entreprise.

Le pourquoi toutes ces démarches ?

La conformité est-elle réellement prête pour un contrôle ?

L’accountability désigne l’obligation pour les entreprises de mettre en œuvre des mécanismes et des procédures internes permettant de démontrer le respect des règles relatives à la protection des données. Accountability | CNIL

https://www.cnil.fr/fr/definition/accountability

Il en découle une première obligation Les durées de conservation des données | CNIL

https://www.cnil.fr/fr/passer-laction/les-durees-de-conservation-des-donnees

Les questions :

1. Sommes-nous capables de le démontrer, concrètement, à tout moment ?
2. Savons-nous réellement ce que nous serions capables de montrer demain ?
3. Comment ?
4. Avec quels supports ?
5. Quelles solutions techniques ?
6. Durée de la productions des preuves ?

 

1. Cadrer le chatbot AI Act avant la technique:

• Objectif:
• Q/R métier sur l’AI Act (par rôle : DPO, RSSI, Produit, COMEX).
• Guidage procédural : “Que dois‑je faire si… ?”
• Traçabilité : garder un log des questions pour améliorer la conformité et la doc.
• Périmètre initial:
• AI Act (texte officiel + FAQ Commission + guides nationaux).
• Tes propres politiques internes (charte IA, procédures DPIA, registres, etc.).
• Personas cibles:
• COMEX / Direction : synthèse, risques, décisions.
• Produit / Data / IT : obligations par cas d’usage, classification des systèmes.
• Juridique / DPO / RSSI : articles, références, checklists.

Installation des outils (phase 1 POC - phase 2 prduction) :

Ollama est nativement compatible avec Linux :

C'est d'ailleurs l'une des plateformes où il est le plus performant, notamment pour exploiter la puissance des GPU. Voici ce qu'il faut savoir pour l'installer et l'utiliser :

Installation standard (Recommandé)

---

1. Installation rapide

La méthode la plus simple consiste à utiliser la commande "one-liner" officielle dans votre terminal : Ollama est nativement compatible avec Linux et c'est d'ailleurs l'une des plateformes où il est le plus performant, notamment pour exploiter la puissance des GPU.

Bash

curl -fsSL https://ollama.com/install.sh | sh

2. Pourquoi Linux est un excellent choix pour Ollama ?

Gestion des GPU : Ollama supporte parfaitement les cartes NVIDIA (via les pilotes NVIDIA et les outils CUDA) et les cartes AMD (via ROCm).

Serveur en arrière-plan : Sous Linux, Ollama s'installe généralement comme un service systemd. Cela signifie qu'il démarre automatiquement avec votre machine et tourne discrètement en arrière-plan.

Performance : L'overhead (la consommation de ressources système) est souvent plus faible que sur Windows ou macOS, laissant plus de RAM disponible pour vos modèles (LLM).

3. Quelques commandes de base

Une fois installé, vous pouvez tester si cela fonctionne immédiatement :

Lancer un modèle (ex: Llama 3) : ollama run llama3

Lister vos modèles téléchargés : ollama list

Supprimer un modèle : ollama rm [nom_du_modele]

4. Docker (Alternative)

Si vous préférez ne pas installer de fichiers directement sur votre système, vous pouvez aussi faire tourner Ollama dans un conteneur Docker. C'est très pratique pour isoler l'application :

Bash

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Note : Si vous avez une carte graphique NVIDIA, n'oubliez pas d'installer le nvidia-container-toolkit pour que Docker puisse y accéder.

Voici le Chunking de mes PDF dans le cadre du POC.

Chunking :

Dans le contexte des bases de données et du RAG (Retrieval-Augmented Generation), le chunking est l'art de découper un document volumineux en petits morceaux (les "chunks") pour qu'ils puissent être transformés en vecteurs et stockés efficacement. Voici une explication technique de leur fonctionnement et de leur importance. Le chunking, ou segmentation, est utilisé en psychologie cognitive pour améliorer la mémorisation à court terme, mais joue aussi un rôle clé en informatique, notamment dans le traitement automatique du langage (NLP) et les systèmes RAG. Il permet de mieux retenir et retrouver des informations en organisant le contenu de manière structurée.

1. Pourquoi découper en chunks ? (morceaux).

Les modèles d'IA et les bases de données vectorielles ont des limites physiques :

• Fenêtre de contexte : Un modèle ne peut lire qu'un nombre limité de tokens à la fois.

• Précision de la recherche : Si vous cherchez une réponse spécifique dans un livre de 500 pages, une base de données vectorielle sera bien plus précise si elle pointe vers le paragraphe exact plutôt que vers le fichier entier.

• Rapport signal/bruit : Plus le texte est long, plus le "sens" moyen du vecteur est dilué. Un chunk court permet de conserver une sémantique forte.

2. Les stratégies de découpage

Il existe plusieurs méthodes pour définir la taille et la séparation des chunks :

Le découpage fixe (Fixed-size chunking)

On définit un nombre strict de caractères ou de tokens (ex: 500 tokens).

• Pro : Très simple à implémenter.

• Contra : Risque de couper une phrase en plein milieu, perdant ainsi le sens.

Le découpage récursif / structurel

On utilise des séparateurs naturels dans l'ordre de priorité : paragraphes (\n\n), puis phrases (.), puis mots.

• Pro : Respecte la structure logique du texte.

• Outil type : RecursiveCharacterTextSplitter dans LangChain.

Le découpage sémantique

On utilise l'IA pour détecter quand le sujet change. Si la phrase suivante est trop différente de la précédente (distance vectorielle élevée), on crée un nouveau chunk.

3. Le concept critique : L'Overlap (Recouvrement)

Pour éviter de perdre le contexte à la jointure de deux chunks, on utilise souvent un Overlap.

Exemple :

○ Chunk 1 : "L'intelligence artificielle est un domaine vaste. Elle comprend le machine learning..."

○ Chunk 2 : "...le machine learning et le deep learning qui simule les neurones."

Ici, "le machine learning" est présent dans les deux. Cela permet à la base de données de garder le lien logique entre les segments lors d'une recherche.

4. Organisation dans la base de données (DB)

Une fois découpés, les chunks sont stockés avec des métadonnées essentielles :

Champ Description

ID Identifiant unique du chunk.

Vector (Embedding) La représentation mathématique du texte.

Content Le texte brut du chunk.

Source_ID Référence au fichier d'origine (ex: manuel_IA_2026.pdf).

Page_Number Pour permettre à l'utilisateur de retrouver la source exacte.

5. Comment choisir la taille idéale ?

La taille d'un chunk (le "Chunk Size") dépend de votre cas d'usage :

• Petits chunks (100-300 tokens) : Idéal pour des recherches granulaires (ex: chercher une définition précise).

• Gros chunks (500-1000 tokens) : Meilleur pour comprendre le contexte global ou résumer une idée complexe.

Dans une architecture optimisée, on teste souvent plusieurs tailles pour trouver le meilleur compromis entre vitesse de recherche et pertinence des réponses.

Résultat je fais fonctionner Ollama avec Mistral et une DB Chunkée 

Si vous avez un outil d'anonymisation il faut le faire en premier.

Pipeline RAG souverain.

SCRIPT D’INDEXATION COMPLET (PDF → Chunks → Embeddings → ChromaDB - POC)

 

⚠️ Ce script utilise PyPDF2. Si tu ne l’as pas encore installé :

Code

py -3.13 -m pip install PyPDF2

 

 

import os

import PyPDF2

from chromadb import Client

from chromadb.config import Settings

 

 

# ============================================================

# 1. EXTRACTION TEXTE PDF

# ============================================================

 

def extract_text_from_pdf(pdf_path):

    """Extrait le texte d’un PDF."""

    text = ""

    with open(pdf_path, "rb") as f:

        reader = PyPDF2.PdfReader(f)

        for page in reader.pages:

            text += page.extract_text() + "\n"

    return text

 

 

# ============================================================

# 2. CHUNKING SIMPLE (optimisé pour RAG)

# ============================================================

 

def chunk_text(text, max_chars=1200):

    """Découpe le texte en chunks de taille raisonnable."""

    chunks = []

    current = ""

 

    for paragraph in text.split("\n"):

        if len(current) + len(paragraph) < max_chars:

            current += paragraph + "\n"

        else:

            chunks.append(current.strip())

            current = paragraph + "\n"

 

    if current.strip():

        chunks.append(current.strip())

 

    return chunks

 

 

# ============================================================

# 3. INITIALISATION CHROMADB

# ============================================================

 

def get_collection():

    chroma = Client(Settings(persist_directory="./ai_act_db"))

    return chroma.get_or_create_collection("ai_act")

 

 

# ============================================================

# 4. INDEXATION D’UN DOSSIER COMPLET

# ============================================================

 

def index_directory(pdf_dir):

    collection = get_collection()

 

    for filename in os.listdir(pdf_dir):

        if not filename.lower().endswith(".pdf"):

            continue

 

        pdf_path = os.path.join(pdf_dir, filename)

        print(f"\n📄 Traitement : {pdf_path}")

 

        text = extract_text_from_pdf(pdf_path)

        chunks = chunk_text(text)

 

        print(f" → {len(chunks)} chunks générés")

 

        for i, chunk in enumerate(chunks):

            chunk_id = f"{filename}_chunk_{i}"

 

            collection.add(

                documents=[chunk],

                metadatas=[{"source": filename}],

                ids=[chunk_id]

            )

 

        print(f" ✔ Indexation terminée pour {filename}")

 

    print("\n🎉 Indexation complète !")

    print("Nombre total de documents :", collection.count())

 

 

# ============================================================

# 5. POINT D’ENTRÉE

# ============================================================

 

if __name__ == "__main__":

    pdf_directory = r"C:\Users\xxxx\OneDrive\Bureau\CO-WORK2026\RGPD"

    index_directory(pdf_directory)

Ce que fait ce script :

(bien entendu pour la phase 2 le script est différent)

✔ Parcourt mon dossier RGPD

→ tous les PDF sont détectés automatiquement.

✔ Extrait le texte de chaque PDF

→ via PyPDF2.

✔ Découpe en chunks intelligents

→ environ 1200 caractères, parfait pour Mistral.

✔ Ajoute dans ChromaDB

→ collection ai_act → avec métadonnées source = nom_du_pdf.

✔ Vérifie l’indexation

→ affiche le nombre total de documents.

Comment l’exécuter :

Dans PowerShell :

Code

 

py -3.13 index_rgpd_pdfs.py

Vérifiez l'installation :

import chromadb

print(f"ChromaDB version: {chromadb.__version__}")

Désinstaller 

py -3.13 -m pip uninstall chromadb

Successfully uninstalled chromadb-1.5.8

Vérification

py -3.13 -m pip show chromadb

Ici la version 1.5.8 de la ChromaDB pour mon POC.

ChromaDB est une base de données vectorielle open source conçue pour stocker, gérer et rechercher des embeddings pour des applications d’IA.

ChromaDB permet aux développeurs de stocker et de récupérer des embeddings numériques représentant du texte, des images, de l’audio ou d’autres données modalités, ce qui le rend idéal pour la recherche sémantique, les systèmes de recommandation et les applications pilotées par l’IA (GeeksforGeeks). Il supporte la recherche dense, clairsemée et hybride, permettant des requêtes par similarité, mot-clé ou régex, et permet de filtrer les résultats en utilisant des conditions de métadonnées (Chroma Docs). 

Introduction to ChromaDB - GeeksforGeeks

https://www.geeksforgeeks.org/nlp/introduction-to-chromadb/ 

Cas d’usage typiques :

Recherche sémantique : Récupérer des documents ou des médias en fonction du sens plutôt que des mots-clés exacts.

Agents IA et intégration des LLM : Créez des agents qui recherchent et affinent de manière itérative les résultats pour des requêtes complexes.

Indexation de base de code : Utilisez un segment compatible AST pour indexer le code des assistants de codage.

Rapid Prototypage and POC : Prend en charge à la fois l’expérimentation en mémoire et le stockage persistant pour des applications prêtes à la production (Blog de Stephane Robert). 

ChromaDB met l’accent sur la simplicité, la rapidité et la flexibilité, en faisant un outil puissant pour les développeurs travaillant avec des embeddings et des applications de recherche pilotées par l’IA. 

Il peut être facilement installé via pip install chromadb et intégré sans interruption dans des projets Python ou d’autres environnements de programmation (DataCamp ; Blog de Stephane Robert). 

ChromaDB : base de données vectorielle pour Python :

https://blog.stephane-robert.info/docs/developper/programmation/python/chroma/

L’outil le plus simple, stable et optimal pour faire du chunking aujourd’hui est :

LlamaIndex – SentenceWindowNodeParser ou SemanticChunker

C’est l’outil :

• le plus simple à utiliser

• le plus robuste pour les PDF complexes

• le plus intelligent (chunking sémantique)

• le plus compatible avec ChromaDB, Ollama, Mistral, RAG souverain

• le plus fiable pour les documents réglementaires (RGPD, AI Act, CNIL)

LlamaIndex OSS (développé par LlamaIndex) est un cadre open source destiné à la création d’applications agentiques.

https://github.com/run-llama/llama_index

LlamaIndex Multimodal with Ollama [Local LLM]

https://youtu.be/5M5qiDJvuv0?si=eX7KD49nGgJqqIJ_

Production :

Pour garantir l'auditabilité du système UGAIA-ready, la base SQLite ne doit pas être un simple index, mais un véritable registre de preuves. Elle fait le pont entre la question de l'utilisateur, les documents sources et la réponse du LLM.

Voici une proposition de structure relationnelle optimisée pour la traçabilité DPO/RSSI :

1. Architecture des Tables (Schéma SQL)

Une structure robuste repose sur trois piliers : les Sources, les Vecteurs et les Interactions.

A. Table document_catalog (Référentiel)

Stocke l'identité de chaque document ingéré.

B. Table chunk_metadata (Granularité) 

C. Table audit_logs (Traçabilité des échanges)

2. Flux de Données & Relations

Le flux opérationnel suit cette logique :

1. L'ingestion : Quand un nouveau PDF arrive, le script remplit document_catalog.

2. Le Chunking : Chaque segment crée une entrée dans chunk_metadata avec son ID FAISS.

3. La Requête : Lorsqu'une question est posée :

   • Le moteur retrouve les vector_id les plus proches.

   • Le script SQL récupère les métadonnées liées (chemins, pages).

   • L'API enregistre l'interaction complète dans audit_logs.

3. Exemples de requêtes d'audit (Cas d'usage)

Grâce à cette structure SQLite, vous pouvez générer des rapports automatiques pour le COMEX ou les autorités :

• Preuve de source : "Sur quels documents s'est basée l'IA pour répondre à la question X ?"

• Analyse de confiance : "Quelles sont les thématiques où le score de similarité est inférieur à 0.6 ?" (Indique un manque de documentation).

• Purger les données : "Supprimer tous les index liés à la version V1 du document Y suite à sa mise à jour."

4. Avantages pour le cadre UGAIA

• Souveraineté : Le fichier .db est un fichier local unique, facile à sauvegarder ou à chiffrer.

• Performance : FAISS gère le calcul lourd (vecteurs), SQLite gère l'intelligence métier (contexte).

• Conformité IA Act : Vous disposez d'un journal immuable des décisions de l'IA, indispensable pour les systèmes classés "à haut risque".

• Cette structure me semble adaptée à nos contraintes de reporting, il faudra peut-être y ajouter des champs spécifiques liés à la gestion des risques.

graph TD

    subgraph COMEX ["🟦 COUCHE DIRECTION & MÉTIER (Consommation)"]

        A1["📊 Tableaux de bord (Power BI / Excel)"]

        A2["🌐 Interface Web Interne / Plugin Métier"]

        style COMEX fill:#e1f5fe,stroke:#01579b,stroke-width:2px

    end

    subgraph API ["🟪 COUCHE ASSISTANT RAG (Orchestration)"]

        B1["⚙️ API Python (FastAPI / CLI)"]

        B2["📝 Journalisation & Traçabilité (ID Corrélation)"]

        style API fill:#f3e5f5,stroke:#4a148c,stroke-width:2px

    end

    subgraph ENGINE ["🟩 MOTEURS DE TRAITEMENT (Local)"]

        C1["🧠 MOTEUR LLM (Ollama)<br/>Modèles locaux (Llama 3, Mistral)"]

        C2["🔍 MOTEUR DE RECHERCHE (FAISS)<br/>Recherche de similarité top-k"]

        C3["🗄️ METADATA (SQLite)<br/>Logs, Sources, Versions"]

        style ENGINE fill:#e8f5e9,stroke:#1b5e20,stroke-width:2px

    end

    subgraph DATA ["🟧 COUCHE DONNÉES & PIPELINE"]

        D1["📂 RÉFÉRENTIELS (Sources)<br/>PDF, DOCX, Registres, AIPD"]

        D2["🏗️ PIPELINE D'INDEXATION<br/>Chunking + Embeddings Locaux"]

        style DATA fill:#fff3e0,stroke:#e65100,stroke-width:2px

    end

    %% Flux de données

    A2 <==>|Questions / Réponses| B1

    B1 ==>|1. Requête Vectorisée| C2

    C2 -.->|2a. Recherche| C3

    C2 ==>|2b. Contexte métier (Top-k)| B1

    B1 ==>|3. Prompt enrichi| C1

    C1 ==>|4. Réponse générée| B1

    B1 -.->|Audit / KPI| A1

    

    D1 ==> D2

    D2 ==>|Indexation| C2

    D2 ==>|Métadonnées| C3

Détails des Composants & Responsabilités

Composant	Couleur	Rôle Stratégique	Technologie Clé
COMEX / Métier	Bleu	Pilotage des risques et conformité IA Act.	Power BI, Excel, Web
Assistant RAG	Violet	Garant de la logique métier et de l'auditabilité.	Python 3.11+, FastAPI
Moteurs (Local)	Vert	Cœur du système : pas de fuite de données (Air-gapped).	Ollama, FAISS, SQLite
Pipeline/Data	Orange	Préparation des connaissances brutes en vecteurs.	LangChain/Llam

Points de Robustesse "UGAIA/AFEES-ready"

• Souveraineté Totale : Le déploiement s'effectue sur environnement Windows interne. Aucun appel vers des API tierces (type OpenAI/Anthropic). Les données restent sous le contrôle de l'infrastructure NTFS/Nextcloud de l'organisation.

• Auditabilité (Mode Audit) : Chaque réponse générée est liée par un Correlation ID aux métadonnées stockées dans SQLite. On peut ainsi prouver quelle version de quelle politique (AIPD, RGPD) a servi à construire la réponse.

• Conformité IA Act : La journalisation systématique (inputs/outputs) permet de répondre aux exigences de documentation technique et de surveillance humaine des systèmes d'IA à haut risque.

• Agilité Windows : Utilisation de scripts PowerShell pour l'orchestration des services et le déploiement reproductible, évitant la complexité de Docker si le service IT préfère une installation native.