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.

Installation d'Ollama et de PHI sur UBUNTU

 Installation d'Ollama et de PHI ou mieux de Mistral sur un PC avec 8 Go ou 16 Go de RAM.

Voici mes commentaires et suggestions d'amélioration pour ce script et ma documentation :

Les points forts de cette approche

1. Détection automatique du GPU - excellent pour adapter l'installation
2. Structure claire du script avec émojis pour faciliter la lecture
3. Documentation complète sur les méthodes de démarrage/arrêt
4. Puis, suggestions d'amélioration des scripts.
5. Modèles recommandés selon la RAM

Ollama sur UBUNTU avec PHI.

La méthode pour relancer Ollama dépend de la façon dont vous l'avez arrêté, mais en général, la façon la plus simple sur Ubuntu est de le démarrer comme un service système.

Je dispose de deux ordinateurs l'un pour Ubuntu et l'autre pour Windows 11.

Voici les deux principales méthodes pour relancer Ollama. Bien entendu cela demande des améliorations, mais ceci fonctionne.

 

1. Démarrage via systemd (Méthode Recommandée).

Si vous avez précédemment arrêté Ollama avec sudo systemctl stop ollama, ou si vous voulez qu'il fonctionne en arrière-plan comme un service, utilisez la commande suivante :

.

• Démarrez le service Ollama :

  Bash

  sudo systemctl start ollama
  

• Vérifiez le statut (Optionnel) :

  Pour vous assurer qu'il est bien en cours d'exécution :

  Bash

  systemctl status ollama
  

  Vous devriez voir Active: active (running).

• Redémarrez le service (Si vous étiez en train de le modifier) :

  Si Ollama était déjà en cours d'exécution, mais que vous voulez appliquer des changements de configuration (comme des variables d'environnement), utilisez restart :

  Bash

  sudo systemctl restart ollama
  

2. Démarrage en mode manuel

Si vous préférez exécuter Ollama dans votre terminal pour voir directement les logs, ou si vous ne l'avez pas installé en tant que service systemd :

• Exécutez la commande serve :

  Bash

  ollama serve
  

  Cette commande va lancer le serveur Ollama. Il restera actif tant que vous ne fermerez pas la fenêtre du terminal ou que vous n'appuyerez pas sur Ctrl+C.

• Lancer en arrière-plan (Démon) :

  Si vous voulez le lancer manuellement sans bloquer votre terminal, vous pouvez ajouter & à la fin de la commande :

  Bash

  ollama serve &
  

  Vous pourrez ensuite utiliser votre terminal pour d'autres commandes. Vous devrez le tuer manuellement plus tard (par exemple avec pkill ollama) si vous voulez l'arrêter.

---

Astuce : Une fois qu'Ollama est démarré, vous pouvez tester sa disponibilité en exécutant un modèle :

Bash

ollama run llama3

Voici les lignes de commandes SUDO pour Ollama sur Ubuntu.

C'est MISTRAL.

Mes trois models sur Ollama.

Ollama.

Commandes pour Ollama.

Suggestions d'amélioration du script :

1. Gestion du redémarrage NVIDIA

bash

# Au lieu de forcer un reboot immédiat :
if [ "$GPU_TYPE" = "NVIDIA" ]; then
  echo "🚀 Installation driver NVIDIA + CUDA"
  sudo add-apt-repository ppa:graphics-drivers/ppa -y
  sudo apt update
  sudo apt install -y nvidia-driver-550 nvidia-cuda-toolkit
  
  echo "⚠️  Un redémarrage est nécessaire pour activer les drivers NVIDIA"
  echo "Appuyez sur [Entrée] pour redémarrer maintenant, ou Ctrl+C pour le faire plus tard"
  read
  sudo reboot
fi

2. Vérification préalable d'Ollama

bash

# Avant l'installation, vérifier si déjà installé
if command -v ollama &> /dev/null; then
  echo "⚠️  Ollama est déjà installé (version $(ollama --version))"
  echo "Voulez-vous réinstaller ? [o/N]"
  read -r response
  if [[ ! "$response" =~ ^[Oo]$ ]]; then
    exit 0
  fi
fi

3. Test plus robuste après installation

bash

# Au lieu de juste tester Mistral, proposer un choix
echo "📥 Modèles suggérés selon votre RAM :"
total_ram=$(free -g | awk '/^Mem:/{print $2}')

if [ "$total_ram" -ge 16 ]; then
  echo "  - mistral (7B) - Recommandé"
  echo "  - llama3.2 (3B) - Plus rapide"
else
  echo "  - phi (2.7B) - Recommandé pour 8GB RAM"
  echo "  - llama3.2 (3B)"
fi

echo "Entrez le nom du modèle à télécharger [mistral] :"
read -r model_choice
model_choice=${model_choice:-mistral}

ollama pull "$model_choice"
ollama run "$model_choice" "Bonjour, peux-tu te présenter en français ?"

4. Gestion des logs

bash

# Ajouter une fonction pour vérifier les logs en cas de problème
echo "📝 Pour consulter les logs d'Ollama :"
echo "   sudo journalctl -u ollama -f"
echo ""
echo "📊 Pour vérifier l'utilisation GPU :"
if [ "$GPU_TYPE" = "NVIDIA" ]; then
  echo "   watch -n 1 nvidia-smi"
fi

5. Configuration de la mémoire

bash

# Créer un fichier de configuration pour optimiser selon la RAM
sudo mkdir -p /etc/systemd/system/ollama.service.d/
cat <<EOF | sudo tee /etc/systemd/system/ollama.service.d/override.conf
[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"
Environment="OLLAMA_KEEP_ALIVE=5m"
EOF

sudo systemctl daemon-reload

Suggestions pour la documentation

Ajouter une section dépannage

markdown

## Dépannage

### Ollama ne démarre pas
```bash
# Vérifier les logs
sudo journalctl -u ollama -n 50

# Vérifier le port
sudo netstat -tlnp | grep 11434
```

### Modèle trop lent
- Pour 8GB RAM : utilisez phi, gemma:2b, ou llama3.2:1b
- Pour 16GB RAM : mistral, llama3.2, phi3
- Arrêtez les autres applications gourmandes en RAM

### Erreur "out of memory"
```bash
# Limiter le nombre de couches GPU
OLLAMA_NUM_GPU_LAYERS=20 ollama run mistral
```

Script de test rapide

Créez un fichier test-ollama.sh :

bash

#!/bin/bash
echo "🧪 Test d'Ollama..."

# Vérifier le service
if systemctl is-active --quiet ollama; then
  echo "✅ Service actif"
else
  echo "❌ Service inactif - Démarrage..."
  sudo systemctl start ollama
  sleep 3
fi

# Lister les modèles
echo -e "\n📦 Modèles installés :"
ollama list

# Test de performance
echo -e "\n⚡ Test de vitesse :"
time ollama run phi "Compte de 1 à 10" --verbose

Modèles recommandés selon la RAM

Pour 8 GB RAM :

• phi (2.7B) - Équilibré
• gemma:2b - Très rapide
• qwen2.5:3b - Bon en code

Pour 16 GB RAM :

• mistral (7B) - Excellent polyvalent
• llama3.2 (3B) - Rapide et performant
• deepseek-coder:6.7b - Spécialisé code

                  OLLAMA - AIDE-MÉMOIRE RAPIDE                    

 🚀 INSTALLATION (PREMIÈRE FOIS)                                   

  1. Installation d'Ollama

     $ chmod +x ollama-install-optimized.sh

     $ ./ollama-install-optimized.sh

  2. Configuration optimale

     $ chmod +x configure-ollama.sh

     $ ./configure-ollama.sh

 💻 UTILISATION QUOTIDIENNE                                         

  Lancer une conversation

  $ ollama run mistral

  Question rapide

  $ ollama run qwen2.5:3b "Explique-moi les listes en Python"

  Utiliser un fichier

  $ cat script.py | ollama run qwen2.5:3b "Explique ce code"

  📦 GESTION DES MODÈLES                                             

  Lister les modèles installés

  $ ollama list

  Télécharger un modèle

  $ ollama pull llama3.2:3b

  Supprimer un modèle

  $ ollama rm nom-du-modele

  Voir les modèles actifs

  $ ollama ps

 🔧 SERVICE OLLAMA                                                   

  Démarrer

  $ sudo systemctl start ollama

  Arrêter

  $ sudo systemctl stop ollama

  Redémarrer

  $ sudo systemctl restart ollama

  Voir l'état

  $ systemctl status ollama

  Voir les logs

  $ sudo journalctl -u ollama -f

 🛠️ SCRIPTS UTILITAIRES                                             

  État complet du système

  $ ~/ollama-status.sh

  Test de performance

  $ ~/test-vitesse.sh mistral

  Nettoyer la RAM (8GB seulement)

  $ ~/prepare-ollama.sh

🎯 MODÈLES RECOMMANDÉS                                             

  8GB RAM - Code

  $ ollama pull qwen2.5:3b

  8GB RAM - Conversation

  $ ollama pull llama3.2:3b

  8GB RAM - Ultra-rapide

  $ ollama pull gemma:2b

  16GB RAM - Polyvalent

  $ ollama pull mistral:7b

  16GB RAM - Code spécialisé

  $ ollama pull deepseek-coder:6.7b

  16GB RAM - Multilingue

  $ ollama pull qwen2.5:7b

🐛 DÉPANNAGE RAPIDE                                             

  Modèle trop lent (8GB) ?

  → Utilisez qwen2.5:3b ou gemma:2b au lieu de mistral:7b

  Out of memory ?

  → sudo sync && echo 3 | sudo tee /proc/sys/vm/drop_caches

  → sudo systemctl restart ollama

  Service ne démarre pas ?

  → sudo journalctl -u ollama -n 50

  → sudo pkill ollama

  → sudo systemctl restart ollama

  Réponses en anglais ?

  → Utilisez qwen2.5:3b (meilleur en français)

  → Forcez : "Réponds en français : [question]"

 💡 ASTUCES                                                      

  Réduire l'utilisation RAM

  $ ollama run mistral --num-ctx 2048

  Mode verbeux (voir les stats)

  $ ollama run mistral --verbose "Test"

  Sauvegarder une réponse

  $ ollama run mistral "Question" > reponse.txt

  Utiliser le GPU (si NVIDIA)

  → Automatique, surveillez avec : watch -n 1 nvidia-smi

  Forcer CPU uniquement

  $ OLLAMA_NUM_GPU_LAYERS=0 ollama run mistral

  

📚 DOCUMENTATION                                                    │

  README.md                                      → Guide complet d'installation

  GUIDE-OLLAMA-COMPLET.md    → Dépannage et optimisations

  CHOIX-MODELE-RAPIDE.md         → Aide au choix du modèle

 🔗 LIENS UTILES                                                   

  Site officiel    : https://ollama.com

  Liste modèles    : https://ollama.com/library

  GitHub           : https://github.com/ollama/ollama

 💾 RAPPEL RAM                                                       

 8GB  → Modèles 3B uniquement (qwen2.5:3b, llama3.2:3b, gemma:2b)   

16GB → Modèles 7B-8B utilisables (mistral, deepseek-coder, etc.)   

  ⚠️ RÈGLE D'OR 8GB                                                  

 • UN SEUL modèle actif à la fois                                   

• NE PAS utiliser mistral:7b (trop lent)                           

 • Fermez les applications gourmandes avant utilisation