Second Cerveau IA Vectorielle : mon REX Ollama + Claude

Aujourd’hui, je vais vous raconter comment j’ai transformé mon second cerveau IA vectorielle en passant d’un système de compilation manuelle à une solution utilisant des embeddings locaux qui indexent et recherchent mes notes en temps réel. Cette approche révolutionnaire que j’ai mise en place combine Ollama, bases vectorielles locales (Milvus) et intégration Claude Desktop pour créer un système ultra-performant et 100% local.

Vous connaissez cette sensation ? Vous avez un système qui marche nickel sur le papier, mais au quotidien, ça devient lourd. C’est exactement ce qui m’arrivait avec mon ancien second cerveau. Malgré tout mon arsenal – Superwhisper, scripts automatiques, Dust (LLM) – je me retrouvais comme ce bibliothécaire qui doit tout vérifier à chaque nouveau bouquin.

Table des matières

• Mon problème avec la compilation manuelle
• Mon setup initial et ses limites
• Ma révolution vectorielle locale
• Ma migration vers Claude Desktop
• Mes résultats et performances
• Questions fréquentes

Le déclic : quand ma compilation manuelle me freinait

J’ai réalisé que je devais passer de mon système de compilation manuelle vers un second cerveau IA vectorielle quand ma productivité a commencé à stagner. Selon la documentation Ollama sur les modèles d’embedding, les systèmes vectoriels offrent une recherche sémantique 10x plus rapide que ma compilation de fichiers traditionnelle.

Mon setup de départ : compilation manuelle mais limitée

Voici comment fonctionnait mon ancien second cerveau :

1. Captage vocal avec Superwhisper (que j’utilise pour brainstormer)
2. Notes en markdown avec une structure stricte que je devais respecter
3. Script d’extraction de l’intégralité de mon Google Agenda (format txt)
4. Compilation automatique en un seul gros fichier
5. Envoi manuel du fichier compilé vers mon agent Dust

Mes galères du quotidien

Chaque petite mise à jour dans mon système de compilation nécessitait que je :

• Attende la recompilation complète (encore…)
• Force mon agent Dust à analyser tout le nouveau fichier
• Risque de ne pas discuter sur ma dernière base connue
• Subisse les temps d’analyse longs à chaque envoi sur Dust

Étant quelqu’un de naturellement bordélique, maintenir cette structure de notes stricte et gérer ces scripts de compilation devenait un vrai frein à ma créativité.

Bon même si une fois en place je n’ai plus à y penser. Juste devoir recompiler, récupérer le fichier (même avec un raccourcie clavier) et ensuite l’envoyer à mon agent Dust pour qu’il analyse le nouveau fichier … m’oblige à devoir vérifier fréquemment que je discute sur la dernière base de connaissances.

Et autre frein que j’ai rencontré c’est la correction des notes, dans ma situation tout est manuelle …

Ma révolution : l’index vectoriel en local

Le concept de mon nouveau second cerveau IA vectorielle

La nouvelle approche que j’ai mise en place remplace ma compilation par :

1. Ollama avec un modèle d’embedding performant (nomic-embed-text)
2. Base vectorielle locale Milvus dans Docker
3. Indexation live qui détecte tout en temps réel
4. Architecture Merkle trees pour des performances optimales

Pourquoi c’est game-changing pour moi

Mon nouveau second cerveau IA vectorielle versus mon ancien système de compilation m’offre :

• local : La base vectorielle reste en local
• Ultra-rapide : Fini les recompilations complètes à chaque modif
• MCP natif : S’intègre parfaitement avec Claude Desktop (et on pourrait rester avec ollama si votre config le permet et ainsi être 100% local)
• Temps réel : Détecte mes changements à la milliseconde
• Intelligence AST : Comprend le contexte sans structure imposée

Mon passage à Claude Desktop

Migration forcée mais bénéfique

Dust ne gérant pas les MCP locaux, j’ai dû migrer vers Claude Desktop (et comme j’avais déjà un compte Pro pour tester Claude Code, autant faire d’une pierre deux coups) et cela va révèler tout le potentiel de mon second cerveau IA vectorielle moderne :

• Intégration native : MCP supporté out-of-the-box
• Édition directe : Claude modifie ma base de connaissances en direct (avec les extensions disponibles)
• Mise à jour auto : L’indexation vectorielle se fait en arrière-plan
• Zéro friction : Plus de compilation ni d’envoi de fichiers de ma part

L’écosystème se développe avec l’intégration Google Agenda native qui remplace mes scripts d’extraction : Claude accède directement à mon planning et anticipe mes besoins.

Mes résultats concrets

Mes performances techniques

Mon second cerveau IA vectorielle versus mon ancienne compilation me délivre :

• Indexation instantanée : Fini les temps de recompilation que je subissais
• Recherche éclair : Réponses sémantiques vs ma recherche textuelle d’avant
• Stabilité béton : Architecture locale sans mes scripts fragiles

Mon impact productivité

• Fini mes scripts de récupération Google Agenda
• Plus de structure de notes à respecter impérativement (focus sur le contenu et plus la forme)
• Requêtes ciblées au lieu de tout recompiler
• Proactivité intelligente sans risque de base obsolète

Ma conclusion : mon second cerveau IA vectorielle qui évolue

Cette transformation illustre parfaitement comment mes outils de productivité ont dû évoluer. Je suis passé d’un système de compilation manuelle avec des scripts fragiles à une vraie intelligence vectorielle qui comprend, anticipe et agit de manière autonome.

Mon secret ? Remettre constamment en question mes méthodes et rester ouvert aux nouveautés technologiques. Parce que le meilleur second cerveau IA vectorielle, ce n’est pas celui qui compile aujourd’hui – c’est celui qui s’adapte intelligemment à mes besoins de demain.

L’installation

• curl -fsSL https://ollama.com/install.sh | sh
• ollama pull nomic-embed-text
• le docker compose https://milvus.io/docs/fr/install_standalone-docker-compose.md ou faire le votre 🙂

Ou le mien :

services:
  etcd:
    container_name: milvus-etcd
    image: rancher/mirrored-coreos-etcd:v3.5.15
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
      - ETCD_SNAPSHOT_COUNT=50000
    command: >
      etcd
      -advertise-client-urls=http://127.0.0.1:2379
      -listen-client-urls=http://0.0.0.0:2379
      --data-dir=/etcd
    volumes:
      - ./volumes/etcd:/etcd
    healthcheck:
      test: ["CMD", "etcdctl", "endpoint", "health", "--endpoints=http://127.0.0.1:2379"]
      interval: 30s
      timeout: 20s
      retries: 3
    restart: unless-stopped

  minio:
    container_name: milvus-minio
    image: minio/minio:RELEASE.2024-12-18T13-15-44Z
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: minioadmin
    command: minio server /minio_data --console-address ":9001"
    ports:
      - "9000:9000"
      - "9001:9001"
    volumes:
      - ./volumes/minio:/minio_data
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3
    restart: unless-stopped

  milvus:
    container_name: milvus-standalone
    image: milvusdb/milvus:v2.5.16
    command: ["milvus", "run", "standalone"]
    security_opt:
      - seccomp:unconfined
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
      MINIO_BUCKET_NAME: milvus-bucket
    volumes:
      - ./volumes/milvus:/var/lib/milvus
    ports:
      - "19530:19530"   # gRPC
      - "9091:9091"     # WebUI
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9091/healthz"]
      interval: 30s
      start_period: 90s
      timeout: 20s
      retries: 3
    depends_on:
      - etcd
      - minio
    restart: unless-stopped

networks:
  default:
    name: milvus

• ma config claude/mcp

"claude-context": {
  "command": "npx",
  "args": ["@zilliz/claude-context-mcp@latest"],
  "env": {
    "AUTO_REINDEX_ON_CHANGE": "true",
    "WATCH_FILE_CHANGES": "true",
    "INCREMENTAL_UPDATE": "true",
    "EMBEDDING_PROVIDER": "OpenAI",
    "EMBEDDING_MODEL": "nomic-embed-text",
    "OPENAI_API_KEY": "not-needed",
    "OPENAI_BASE_URL": "http://localhost:11434/v1",
    "MILVUS_ADDRESS": "localhost:19530",
    "MILVUS_TOKEN": "local",
    "CHUNK_SIZE": "256",
    "CHUNK_OVERLAP": "64",
    "SEARCH_LIMIT": "20",
    "SIMILARITY_THRESHOLD": "0.3",
    "DEBOUNCE_MS": "5000"
    }
}

Les plus observateurs auront vu @zilliz/claude-context-mcp@latest -> claude-context-mcp utilisé pour rechercher dans notre base vectorielle.

Comment ça marche ? :

1. Claude Desktop lance le MCP via npx
2. npx télécharge automatiquement @zilliz/claude-context-mcp@latest
3. Cache dans ~/.npm/_npx/3aea99e9ad4d1a82/
4. Lance plusieurs instances pour gérer les requêtes

Pourquoi plusieurs processus ? :

PID 83193: Instance principale MCP
PID 83177: Worker pour indexation
PID 83126: Worker pour recherche  
PID 83118: Worker pour embeddings

→ Architecture multi-processus pour la performance ! 🦍