Guide — Les 3 Outils pour Maximiser Votre Stack IA

avril 2026 · 18 min de lecture

Ce guide couvre l'installation, la configuration, les cas d'usage concrets et les bonnes pratiques pour Mulch, Graphify et Everything Claude Code — trois outils open source qui transforment la manière dont vous travaillez avec les agents IA.

Table des matières

  1. Vue d'ensemble
  2. Mulch — Mémoire persistante pour agents IA
  3. Graphify — Graphe de connaissances multimodal
  4. Everything Claude Code — Système d'optimisation complet
  5. Combinaison des 3 outils
  6. Récapitulatif et recommandations

1. Vue d'ensemble

Outil Problème résolu Impact principal Stars GitHub
Mulch L'agent oublie tout entre les sessions Expertise composée, mémoire persistante Nouveau
Graphify L'agent lit trop de fichiers, coûte cher 71x moins de tokens par requête 25K ⭐
Everything Claude Code Pas de système structuré pour les agents 48 agents + 183 skills prêts en prod 159K ⭐

Ces trois outils sont complémentaires et non concurrents. Mulch gère la mémoire longitudinale, Graphify gère la compréhension structurelle, Everything Claude Code fournit le cadre d'exécution.

2. Mulch — Mémoire persistante pour agents IA

Le problème qu'il résout

Par défaut, chaque session avec un agent IA commence de zéro. Le contexte découvert hier, les conventions établies, les erreurs déjà rencontrées — tout est perdu. Mulch est une couche passive qui permet à l'agent d'enregistrer et de relire ses apprentissages entre les sessions.

Principe fondamental : Mulch ne contient pas de LLM. C'est l'agent qui utilise Mulch — pas l'inverse.

Installation

npx mulch-cli init                # Initialise .mulch/ dans votre projet
mulch add database                # Ajoute un domaine d'expertise
mulch add api
mulch add testing

Structure des fichiers

.mulch/
├── expertise/
│   ├── database.jsonl     # Tout ce que l'agent a appris sur la base de données
│   ├── api.jsonl          # Conventions API accumulées
│   └── testing.jsonl      # Patterns de test découverts
└── mulch.config.yaml      # Configuration des domaines

Types d'enregistrements

Type Champs requis Exemple d'usage
convention content "Utiliser le mode WAL pour SQLite"
pattern name, description Pattern de pagination nommé
failure description, resolution Bug récurrent + sa solution
decision title, rationale Décision architecturale documentée

Commandes essentielles

# Enregistrer un apprentissage
mulch record database --type convention "Toujours utiliser des transactions pour les insertions en lot"

# Enregistrer un échec avec sa résolution
mulch record database --type failure \
  --description "VACUUM dans une transaction corrompt silencieusement les données" \
  --resolution "Toujours exécuter VACUUM hors des limites de transaction"

# Consulter l'expertise accumulée
mulch query database

# Générer un contexte complet pour injection dans l'agent
mulch prime
mulch prime database              # Scoped à un seul domaine

# Rechercher dans tous les domaines
mulch search "pagination"

# Vérifier la fraîcheur des connaissances
mulch status

Cas d'usage concrets

Cas 1 — Projet solo sur plusieurs semaines

Vous travaillez sur une API REST. La semaine 1, votre agent découvre que l'ORM utilisé a un bug sur les jointures imbriquées avec plus de 3 niveaux. Avec Mulch :

mulch record api --type failure \
  --description "Jointures imbriquées > 3 niveaux causent N+1 queries avec Prisma" \
  --resolution "Utiliser des requêtes raw SQL ou restructurer le schéma"

La semaine 2, un nouvel agent repart immédiatement avec cette information. Zéro redécouverte.

Cas 2 — Équipe de développement

Chaque développeur travaille avec son propre agent. Mulch est dans git. Quand un développeur enregistre une convention critique :

mulch record api --type convention \
  "Tous les endpoints publics doivent retourner des erreurs au format RFC 7807"

Le lendemain, l'agent d'un autre développeur commence sa session avec cette convention déjà intégrée via mulch prime.

Cas 3 — Refactoring d'une codebase legacy

# Phase 1 : L'agent explore et documente
mulch record legacy --type decision \
  --title "AuthService : ne pas toucher avant migration complète" \
  --rationale "17 dépendances circulaires, migration planifiée Q3"

# Phase 2 : Semaines plus tard, nouvel agent, même contexte
mulch prime legacy
# → L'agent sait immédiatement quelles zones sont hors limites

Bonnes pratiques

  • Enregistrer après chaque découverte importante, pas seulement en fin de session
  • Utiliser mulch prime en début de session pour charger le contexte
  • Versionner .mulch/ dans git pour partager l'expertise avec l'équipe
  • Utiliser mulch prune régulièrement pour supprimer les entrées tactiques obsolètes
  • Scoper par domaine : database, api, auth, infra — un fichier par responsabilité

3. Graphify — Graphe de connaissances multimodal

Le problème qu'il résout

Un agent IA qui doit comprendre un projet de 50+ fichiers va lire chaque fichier séquentiellement. C'est lent, coûteux et souvent incomplet. Graphify transforme n'importe quel dossier (code, docs, PDFs, images, vidéos) en un graphe de connaissances structuré et interrogeable.

Benchmark mesuré : 71,5x moins de tokens par requête sur un corpus mixte (repos Karpathy + papers + images).

Installation

pip install graphifyy && graphify install

Note importante : Le package PyPI s'appelle graphifyy (double y). Le CLI reste graphify.

Utilisation de base

/graphify .                        # Sur le dossier courant
/graphify ./src                    # Sur un sous-dossier spécifique
/graphify ./docs --mode deep       # Extraction agressive d'inférences
/graphify ./raw --update           # Mise à jour incrémentale (seuls les fichiers modifiés)

Ce que Graphify génère

graphify-out/
├── graph.html        # Graphe interactif — cliquer, filtrer, explorer
├── GRAPH_REPORT.md   # Rapport : god nodes, connexions surprenantes, questions suggérées
├── graph.json        # Graphe persistant — interrogeable des semaines plus tard
└── cache/            # Cache SHA256 — re-runs ultra-rapides

Types de fichiers supportés

Type Extensions Méthode d'extraction
Code .py .ts .js .go .rs .java .c .cpp .rb .cs + 12 autres AST via tree-sitter, sans LLM
Docs .md .txt .rst Extraction sémantique via Claude
Office .docx .xlsx Conversion markdown + extraction
Papers .pdf Citation mining + extraction de concepts
Images .png .jpg .webp .gif Vision Claude — screenshots, diagrammes
Vidéo/Audio .mp4 .mp3 .wav .m4a + autres Transcription locale via Whisper
YouTube Toute URL vidéo yt-dlp + pipeline Whisper

Commandes avancées

# Ajouter du contenu externe au graphe
/graphify add https://arxiv.org/abs/1706.03762        # Paper arxiv
/graphify add https://x.com/karpathy/status/...       # Tweet
/graphify add <video-url>                             # Vidéo YouTube

# Interroger le graphe directement
/graphify query "qu'est-ce qui connecte l'authentification au cache ?"
/graphify path "AuthService" "CacheManager"           # Chemin le plus court
/graphify explain "UserRepository"                    # Explication plain-text

# Synchronisation automatique
/graphify ./src --watch                               # Auto-sync sur changements

Intégration toujours active (Claude Code)

graphify claude install

Cette commande fait deux choses :

  1. Écrit une section dans CLAUDE.md indiquant à Claude de lire GRAPH_REPORT.md avant de répondre aux questions d'architecture
  2. Installe un hook PreToolUse qui se déclenche avant chaque Glob et Grep — si un graphe existe, Claude navigue par structure plutôt que par recherche brute

Cas d'usage concrets

Cas 1 — Onboarding sur un projet inconnu

Vous rejoignez une codebase de 80 000 lignes en monorepo. Sans Graphify : 3-4 jours pour comprendre l'architecture. Avec Graphify :

/graphify .
# → graph.html : visualisation interactive de toutes les dépendances
# → GRAPH_REPORT.md : les 10 "god nodes" (modules dont tout dépend)
# → Questions suggérées : "Pourquoi PaymentService dépend-il de NotificationService ?"

En 30 minutes, vous comprenez les décisions architecturales critiques.

Cas 2 — Recherche technique (papers + code)

Vous implémentez un algorithme basé sur des papers. Vous avez 5 PDFs, 3 repos GitHub et des notes :

/graphify ./research --mode deep
/graphify add https://arxiv.org/abs/1706.03762

# L'agent peut maintenant répondre :
/graphify query "quelle implémentation correspond au Theorem 2 du paper ?"

Le graphe connecte le code aux concepts théoriques. 71x moins de tokens que de passer tous les fichiers au contexte.

Cas 3 — Audit d'une décision architecturale

/graphify path "UserModel" "BillingService"
# → Chemin exact avec tous les intermédiaires
# → Type de chaque relation (EXTRACTED vs INFERRED)
# → Score de confiance sur les inférences

/graphify explain "AuthMiddleware"
# → Explication plain-text de ce que fait ce module
# → Pourquoi il existe (rationale extraite des commentaires)
# → Ce qui en dépend et ce dont il dépend

Cas 4 — Corpus de connaissances personnelles

# Dossier avec papers, tweets sauvegardés, screenshots, notes
/graphify ./raw
/graphify add https://www.youtube.com/watch?v=...   # Conférence technique

# 3 semaines plus tard, sans relire :
/graphify query "qu'est-ce que j'ai appris sur les transformers ?"

Fonctionnalités avancées

# Export pour outils externes
/graphify ./src --graphml               # Pour Gephi, yEd
/graphify ./src --neo4j-push bolt://localhost:7687  # Push direct Neo4j

# Serveur MCP (accès structuré depuis l'agent)
python -m graphify.serve graphify-out/graph.json
# → Outils : query_graph, get_node, get_neighbors, shortest_path

# Wiki navigable par agent
/graphify ./src --wiki
# → index.md + un article par communauté de concepts

# Git hooks (rebuild automatique à chaque commit)
graphify hook install

Bonnes pratiques

  • Commencer par GRAPH_REPORT.md — pas par graph.json directement
  • Utiliser --update pour les re-runs (seuls les fichiers modifiés sont retraités)
  • Ajouter .graphifyignore pour exclure node_modules, dist, fichiers générés
  • Installer le hook PreToolUse (graphify claude install) pour une intégration transparente
  • Cache SHA256 : les re-runs sur un grand corpus sont quasi-instantanés

4. Everything Claude Code — Système d'optimisation complet

Le problème qu'il résout

Claude Code sans configuration, c'est un moteur sans transmission. Everything Claude Code est le système d'optimisation complet : agents spécialisés, skills réutilisables, hooks automatiques, mémoire persistante, sécurité intégrée. Construit sur 10+ mois d'usage intensif en production. Gagnant d'un hackathon Anthropic.

Chiffres clés : 159K stars | 24K forks | 170+ contributeurs | 12 écosystèmes de langages

Installation rapide

# Option 1 : Plugin (recommandé)
/plugin marketplace add https://github.com/affaan-m/everything-claude-code
/plugin install everything-claude-code@everything-claude-code

# Option 2 : Manuel
git clone https://github.com/affaan-m/everything-claude-code.git
cd everything-claude-code
./install.sh --profile full         # macOS/Linux
.\install.ps1 --profile full        # Windows

Ce que vous obtenez

Composant Quantité Description
Agents 48 Sous-agents spécialisés pour délégation
Skills 183 Workflows réutilisables par domaine
Commands 79 Commandes slash (compatibilité legacy)
Hooks 20+ scripts Automatisations sur événements outils
Rules 34 Guidelines toujours appliquées (common + langages)

Les agents principaux

planner.md           → Planification d'implémentation de features
architect.md         → Décisions de design système
tdd-guide.md         → Développement test-first
code-reviewer.md     → Review qualité et sécurité
security-reviewer.md → Analyse de vulnérabilités
build-error-resolver → Résolution d'erreurs de build
e2e-runner.md        → Tests E2E Playwright
typescript-reviewer  → Review TypeScript/JavaScript
python-reviewer      → Review Python
java-reviewer        → Review Java/Spring Boot

Workflows courants

# Nouvelle feature
/ecc:plan "Ajouter l'authentification OAuth"
# → planner crée un blueprint d'implémentation complet

/tdd
# → tdd-guide enforce write-tests-first

/code-review
# → code-reviewer vérifie qualité + sécurité

# Debugging
/tdd                    # Écrire un test qui reproduit le bug
/code-review            # Vérifier les régressions

# Mise en production
/security-scan          # Audit OWASP Top 10
/e2e                    # Tests des flows critiques
/test-coverage          # Vérifier 80%+ de couverture

Hooks — Automatisations événementielles

Les hooks se déclenchent automatiquement sur les événements outils.

# Contrôle du profil de strictness
export ECC_HOOK_PROFILE=standard      # minimal | standard | strict

# Désactiver des hooks spécifiques
export ECC_DISABLED_HOOKS="pre:bash:tmux-reminder,post:edit:typecheck"

Continuous Learning v2 — Apprentissage automatique

/instinct-status        # Voir les patterns appris avec scores de confiance
/instinct-import <file> # Importer les instincts d'un autre développeur
/instinct-export        # Exporter vos instincts pour partage
/evolve                 # Regrouper les instincts en skills réutilisables
/learn                  # Extraire des patterns mid-session

AgentShield — Sécurité intégrée

# Scan rapide (sans installation)
npx ecc-agentshield scan

# Auto-fix des problèmes sûrs
npx ecc-agentshield scan --fix

# Analyse approfondie (3 agents Opus en red-team/blue-team/auditor)
npx ecc-agentshield scan --opus --stream

Ce qu'AgentShield scanne : CLAUDE.md, settings.json, configs MCP, hooks, définitions d'agents — 102 règles d'analyse statique, 1282 tests.

Optimisation des tokens

// ~/.claude/settings.json
{
  "model": "sonnet",
  "env": {
    "MAX_THINKING_TOKENS": "10000",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50",
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku"
  }
}
Paramètre Impact
model: sonnet ~60% de réduction de coût vs Opus
MAX_THINKING_TOKENS: 10000 ~70% de réduction du coût de thinking
AUTOCOMPACT_PCT: 50 Compaction plus tôt = meilleure qualité en longues sessions
SUBAGENT_MODEL: haiku Sous-agents sur tâches simples = économies massives

Cas d'usage concrets

Cas 1 — Développeur solo en production

# Matin : nouvelle feature
/ecc:plan "Système de notifications push"
# → Blueprint complet : schema DB, API endpoints, tests, plan de migration

# Pendant le dev
/tdd                    # Tests en premier, toujours
/code-review            # Review automatique avant chaque commit

# Avant le merge
/security-scan          # Aucune vulnérabilité passée
/e2e                    # Flows critiques couverts

Cas 2 — Équipe avec continuité de contexte

# Setup une fois par projet
./install.sh --profile full
graphify claude install
mulch init && mulch add api database auth

# Chaque développeur démarre sa session
mulch prime                          # Contexte équipe chargé
# graphify hook → contexte architectural actif en arrière-plan

# En cours de session
/learn                               # Extraire les patterns découverts
mulch record api --type failure ...  # Documenter les bugs résolus

Cas 3 — Refactoring massif

# Phase audit
/graphify . --mode deep
# → Identifier les god nodes (modules à fort risque)
# → Visualiser les dépendances circulaires

mulch record legacy --type decision \
  --title "Ne pas toucher PaymentService avant Q3" \
  --rationale "17 dépendances circulaires identifiées par Graphify"

# Phase exécution
/refactor-clean         # Suppression code mort
/ecc:plan "Décomposer UserService en 3 sous-services"
/tdd                    # Tests de non-régression en premier

Cas 4 — Onboarding d'un nouveau développeur

# Le repo contient déjà .mulch/ et graphify-out/
mulch prime             # Historique d'expertise de l'équipe
/graphify .             # Architecture complète du projet
# ECC installé → agents + hooks + rules disponibles immédiatement

# Le nouveau dev est opérationnel en < 1 heure
# au lieu de 3-4 jours habituels

Bonnes pratiques

  • Ne pas activer tous les MCPs — chaque serveur consomme des tokens (200k réduit à ~70k avec trop de MCPs actifs)
  • /clear entre tâches non liées — reset gratuit et instantané
  • /compact aux points de rupture logiques — après la recherche, avant l'implémentation
  • /cost régulièrement — surveiller la consommation en session
  • Passer à Opus uniquement pour l'architecture profonde ou le debugging complexe

5. Combinaison des 3 outils

Architecture recommandée

Session de travail
│
├── mulch prime              → Charge l'expertise accumulée de l'équipe
├── Graphify (hook actif)    → Contexte architectural disponible en arrière-plan
└── ECC                     → Agents + Skills + Hooks prêts à l'emploi
    │
    ├── /ecc:plan            → Agent planner informé par le graphe
    ├── /tdd                 → Agent tdd-guide respecte les conventions Mulch
    ├── /code-review         → Agent reviewer navigue via Graphify
    └── mulch record         → Enrichit la base de connaissance équipe

Exemple de session complète

# 1. Démarrage de session
mulch prime                     # Expertise équipe chargée
# → ECC hook PreToolUse active Graphify automatiquement

# 2. Compréhension du contexte
/graphify query "quel est l'impact d'ajouter un cache Redis sur l'auth ?"
# → Graphify trace le chemin AuthService → SessionStore → DB

# 3. Planification informée
/ecc:plan "Ajouter un cache Redis sur les sessions"
# → Planner connaît l'architecture (Graphify) + les conventions (Mulch)

# 4. Implémentation test-first
/tdd
# → TDD guide respecte les conventions enregistrées dans Mulch

# 5. Documentation des apprentissages
mulch record infra --type convention \
  "Redis TTL = 3600s pour les sessions, 300s pour les tokens CSRF"

mulch record infra --type failure \
  --description "Redis sans persistence = perte sessions au restart" \
  --resolution "Activer AOF persistence en production"

# 6. Fin de session
/learn                          # ECC extrait les patterns de la session

Tableau de décision — Quel outil pour quel besoin ?

Besoin Outil Commande
L'agent oublie vos conventions Mulch mulch prime + mulch record
Comprendre une nouvelle codebase Graphify /graphify . && /graphify explain
Trouver l'impact d'un changement Graphify /graphify path "A" "B"
Partager les apprentissages d'équipe Mulch git push .mulch/
Planifier une feature complexe ECC /ecc:plan
Review de code automatique ECC /code-review
Audit sécurité ECC /security-scan
Réduire les coûts de tokens Graphify + ECC hook + model: sonnet
Onboarding rapide Mulch + Graphify mulch prime + /graphify .

6. Récapitulatif et recommandations

Ordre d'adoption recommandé

Semaine 1 — Fondations

# Installer ECC (impact immédiat sur la qualité)
/plugin install everything-claude-code@everything-claude-code
# Configurer l'optimisation tokens : model: sonnet, MAX_THINKING_TOKENS: 10000

Semaine 2 — Mémoire

# Initialiser Mulch sur vos projets actifs
npx mulch-cli init
mulch add [vos domaines métier]
# Commencer à enregistrer après chaque découverte importante

Semaine 3 — Compréhension structurelle

pip install graphifyy && graphify install
/graphify .                        # Sur votre projet principal
graphify claude install            # Intégration transparente

Semaine 4+ — Synergie

Les 3 outils travaillent ensemble. Mulch pour la mémoire longitudinale, Graphify pour la compréhension structurelle, ECC pour le cadre d'exécution. La somme est supérieure aux parties.

Métriques d'impact attendues

Métrique Sans ces outils Avec ces outils
Tokens par requête complexe ~50 000 tokens ~700 tokens (Graphify)
Temps d'onboarding 3-4 jours < 1 heure
Redécouverte de bugs connus Fréquente Quasi-nulle (Mulch)
Couverture de tests Variable 80%+ (ECC TDD)
Coût mensuel Claude Code $100+ $20-30 (optimisation tokens)

Ressources

Outil Repository Documentation
Mulch github.com/jayminwest/mulch README.md
Graphify github.com/safishamsi/graphify README + ARCHITECTURE.md
Everything Claude Code github.com/affaan-m/everything-claude-code Longform Guide (X/Twitter)

Guide rédigé en avril 2026. Les trois outils sont open source sous licence MIT.

Ce guide vient de Build With Nath

La communauté est gratuite. J’y publie ces guides au fil de l’eau et on y répond aux questions.

Rejoindre gratuitement →Voir l’original

Autres guides · Guides

Vous dirigez une entreprise et vous voulez savoir lequel de vos process mérite ce genre de traitement ? Le diagnostic vous le dit en trois minutes, ou on en parle trente minutes.