╭──────────────────────────────────────────╮ ╭──────────────────────────────────────────╮ │ >>>>>>>>>>>>>>> ctx_read >>>>>>>>>>>> │ │ >>>>>>>>>>>>>>> ctx_read >>>>>>>>>>>> │ ┌─────────────┐ │ >>>>>>>>>>>>>>> compress >>>>>>>>>>>> │ ┌──────────┐ ┌─────────────┐ │ >>>>>>>>>>>>>>> compress >>>>>>>>>>>> │ ┌──────────┐ │ 100K tokens │ =========>│ >>> AST >>> cache >>> signal >>> │ =========> │ ~5K tok │ │ 100K tokens │ =========>│ >>> AST >>> cache >>> signal >>> │ =========> │ ~5K tok │ └─────────────┘ │ >>>>>>>>>>>>>>> filter >>>>>>>>>>>> │ └──────────┘ └─────────────┘ │ >>>>>>>>>>>>>>> filter >>>>>>>>>>>> │ └──────────┘ │ >>>>>>>>>>>>>>> dedupe >>>>>>>>>>>> │ │ >>>>>>>>>>>>>>> dedupe >>>>>>>>>>>> │ ╔══════════════╗ ╰──────────────────────────────────────────╯ ╔══════════╗ ╔══════════════╗ ╰──────────────────────────────────────────╯ ╔══════════╗ ║ raw input ║ ─ ─ ─ ─ ─ ─ ─ ─ LeanCTX ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ║ output ║ ║ raw input ║ ─ ─ ─ ─ ─ ─ ─ ─ LeanCTX ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ║ output ║ ╚══════════════╝ ╚══════════╝ ╚══════════════╝ ╚══════════╝ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ │░░│ │░░│ │░░│ │░░│ │▓▓│ │▓▓│ │▓▓│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │▓▓│ │▓▓│ │▓▓│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ ───> │▓▓│ │▓▓│ │▓▓│ ───> │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ ───> │▓▓│ │▓▓│ │▓▓│ ───> │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ file file file file read cache send tok tok tok tok tok tok file file file file read cache send tok tok tok tok tok tok ╭──────────────────────────────────────────╮ ╭──────────────────────────────────────────╮ │ >>>>>>>>>>>>>>> ctx_read >>>>>>>>>>>> │ │ >>>>>>>>>>>>>>> ctx_read >>>>>>>>>>>> │ ┌─────────────┐ │ >>>>>>>>>>>>>>> compress >>>>>>>>>>>> │ ┌──────────┐ ┌─────────────┐ │ >>>>>>>>>>>>>>> compress >>>>>>>>>>>> │ ┌──────────┐ │ 100K tokens │ =========>│ >>> AST >>> cache >>> signal >>> │ =========> │ ~5K tok │ │ 100K tokens │ =========>│ >>> AST >>> cache >>> signal >>> │ =========> │ ~5K tok │ └─────────────┘ │ >>>>>>>>>>>>>>> filter >>>>>>>>>>>> │ └──────────┘ └─────────────┘ │ >>>>>>>>>>>>>>> filter >>>>>>>>>>>> │ └──────────┘ │ >>>>>>>>>>>>>>> dedupe >>>>>>>>>>>> │ │ >>>>>>>>>>>>>>> dedupe >>>>>>>>>>>> │ ╔══════════════╗ ╰──────────────────────────────────────────╯ ╔══════════╗ ╔══════════════╗ ╰──────────────────────────────────────────╯ ╔══════════╗ ║ raw input ║ ─ ─ ─ ─ ─ ─ ─ ─ LeanCTX ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ║ output ║ ║ raw input ║ ─ ─ ─ ─ ─ ─ ─ ─ LeanCTX ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ║ output ║ ╚══════════════╝ ╚══════════╝ ╚══════════════╝ ╚══════════╝ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ │░░│ │░░│ │░░│ │░░│ │▓▓│ │▓▓│ │▓▓│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │▓▓│ │▓▓│ │▓▓│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ ───> │▓▓│ │▓▓│ │▓▓│ ───> │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ ───> │▓▓│ │▓▓│ │▓▓│ ───> │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ file file file file read cache send tok tok tok tok tok tok file file file file read cache send tok tok tok tok tok tok

Comment ça marche

Comment LeanCTX contrôle ce que
votre IA voit.

LeanCTX est la couche d'ingénierie de contexte pour les agents IA : un petit binaire Rust qui exécute la même boucle sur chaque lecture, commande et recherche. Il décide ce que vos agents lisent, se souvient de ce qu'ils apprennent au fil des sessions, protège ce qu'ils touchent, prouve ce qu'ils sauvegardent dans un registre signé, et rejoue ce qu'ils ont vu. Les lectures sont analysées pour leur structure sur 26 langues et débarrassées de tout bruit, afin que ce qui atteint le modèle soit intentionnel, compressé et prouvable. Vous l'installez une seule fois. Tout le reste est automatique.

Le flux de données

Où se situe LeanCTX ?

LeanCTX se situe sur deux chemins. Sur le chemin de lecture, il façonne ce qui entre — lectures de fichiers, recherche de code et sortie shell, compressés avant que l'agent ne les voie. Sur le chemin de transmission, un proxy local optionnel se situe entre l'agent et le modèle et compresse chaque requête sortante — invite système, historique complet et résultats d'outils — avec la sécurité du cache d'invite. L'un réduit ce qui entre dans le contexte ; l'autre réduit chaque requête pour laquelle vous payez. Le modèle voit le même signal dans une fraction des tokens.

flux de données : avant vs après

Sans lean-ctx :

Vous  →  Outil IA  →  lit le fichier  (contenu complet)  →  le LLM traite tout

Avec lean-ctx :

Vous  →  Outil IA  →  lean-ctx compresse  →  signal uniquement  →  LLM : 60 à 90 % de bruit en moins
                           ├─ Sandbox PathJail + limites de taille
                           ├─ Compression consciente de l'AST
                           ├─ Runtime Mémoire (connaissances + oubli)
                           ├─ Cache de session (relecture ≈ 13 tok)
                           └─ 10 modes de lecture par type de fichier

Plongée : Patterns Shell (95+ modèles) · Modes de Lecture (10 modes de compression) · Caching

Vous

Codez normalement. Ne changez rien à votre flux de travail.

Outil IA

Cursor, Claude Code, Copilot, Windsurf, …

LeanCTX

Décide, compresse et mémorise via un serveur MCP et un hook shell que vos outils IA détectent automatiquement.

LLM

Ne voit que le signal. 60 à 90 % de tokens en moins, mêmes informations.

Architecture

Un binaire. Cinq capacités.

Chaque capacité s'exécute à l'intérieur d'un seul binaire Rust. Voici comment une requête circule dans LeanCTX : de votre outil d'IA, à travers le pipeline cognitif, jusqu'au modèle.

Votre outil IA Cursor · Claude Code · Copilot · Windsurf

MCP · CLI · HTTP

lean-ctx Couche de contexte cognitif · Binaire unique · 81 outils

Comprendre

10 modes de lecture
Visibilité du contexte
Comptage de tokens
Détection d'intention

Compresser

AST Tree-sitter (26 langues)
Plus de 95 patterns shell
Réordonnancement CDC (Rabin-Karp)
Budget de 64 Ko, délai de 500 ms

Mémoriser

Cache de session (zstd, en mémoire)
13 relectures de tokens
Graphe de connaissances (SQLite)
Mémoire inter-sessions

Vérifier

Sandbox PathJail
Isolation au niveau de l'OS
Liste blanche shell (refus par défaut)
Piste d'audit complète

Connecter

GitHub · GitLab · Jira · Linear
Postgres · REST · MCP Bridge
Recherche hybride (BM25 + sémantique)
Fournisseurs basés sur la configuration (TOML)

10modes de lecture

13tokens par relecture

18langues (AST)

contexte optimisé

LLM Moins de bruit · Signal plus élevé · Meilleurs résultats

Les cinq sous-systèmes

Cinq choses que LeanCTX fait pour chaque token.

Entre votre IA et votre code, un binaire local exécute la même boucle en cinq étapes sur chaque lecture, commande et recherche — percevoir, compresser, se souvenir, acheminer, gouverner. Ensemble, ils réalisent les cinq fonctions : il décide ce que vos agents lisent, se souvient de ce qu'ils apprennent, protège ce qu'ils touchent, prouve ce qu'ils sauvegardent et rejoue ce qu'ils ont vu.

Percevoir

Voir ce qui compte avant d'agir.

Mappe un dépôt inconnu, met en évidence les fichiers et symboles importants, et lit la structure au lieu de fichiers entiers, dans 26 langues avec tree-sitter.

ctx_overview → repo mapped in one call

Compresser

Chaque jeton porte un signal.

Dix modes de lecture, plus de 95 modèles de sortie shell et un cache adressé par contenu réduisent les lectures de 60 à 90 % et les relectures à environ 13 tokens. Le bruit n'atteint jamais le modèle.

ctx_read → 4,200 → 920 tokens (78% saved)

Se souvenir

Continuité entre les sessions.

Les découvertes, les décisions et les fichiers touchés persistent et se restaurent automatiquement dans chaque nouvelle session, de sorte que votre agent n'explique jamais le contexte à nouveau ou ne relit pas ce qu'il sait déjà.

ctx_session → restored · 0 re-reads

Router

Le bon contexte au bon modèle.

Détecte l'intention, choisit le mode de lecture et le budget de tokens, et charge uniquement les outils dont une tâche a besoin, de sorte que chaque modèle voie exactement le contexte qu'il devrait, et rien de plus.

ctx_intent → right mode + budget per task

Gouverner

Sûr, mesuré, appliqué.

PathJail, une liste d'autorisation shell, la détection de secrets, les politiques de rôle et les budgets de tokens maintiennent chaque appel d'outil dans les limites, et les analyses prouvent exactement ce qui a été sauvegardé.

ctx_verify → paths ok · secrets blocked

Deux commandes. C'est tout.

Que faites VOUS faites réellement ?

Presque rien. LeanCTX fonctionne de manière invisible après une configuration unique. Vous continuez à coder exactement comme avant.

Installer

Binaire Rust unique. Aucune dépendance, aucun cloud, aucun compte.

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

Setup

Détecte automatiquement votre shell et vos outils d'IA. Configure tout en quelques secondes.

lean-ctx setup

Terminé. C'est automatique

Codez normalement. Votre IA utilise des outils compressés automatiquement.

Tokens économisés : automatiquement

Vous vs. La Machine

Ce que VOUS faites (une fois)	Ce qui se passe AUTOMATIQUEMENT
lean-ctx setup	L'IA utilise `ctx_read` au lieu de Read - jusqu'à 99% de tokens en moins (relectures mises en cache)
	L'IA utilise `ctx_shell` au lieu de Shell - 60–90% de tokens en moins
	L'IA utilise `ctx_search` au lieu de Grep - 50–80% de tokens en moins
	Le hook de shell compresse la sortie CLI de manière transparente
	Le cache de session se souvient des fichiers entre les lectures (~13 tokens pour les relectures)
lean-ctx gain (optional)	Voir votre tableau de bord d'économies à vie

Guide d'installation complet → Commencer · Toutes les commandes CLI → Référence CLI

Même l'oubli est une décision.

Lorsque le cache de session est plein, LeanCTX décide automatiquement quoi conserver et quoi évincer. Il classe les entrées par récence, fréquence et taille, puis fusionne ces signaux en un score unique. Aucun réglage requis.

Comment fonctionne le cache

Sécurité

Garde ce qu'ils touchent.

LeanCTX applique un modèle de sécurité de défense en profondeur pour empêcher l'injection de prompt LLM d'accéder à des fichiers en dehors du projet :

[//]

PathJail - Toutes les opérations de fichiers sont isolées à la racine du projet. Les traversées de liens symboliques, les échappées ../ et les chemins absolus en dehors de la jail sont bloqués au point de contrôle resolve_path.

[##]

Liste d'autorisation Shell + Analyse AST - Lorsqu'il est configuré, chaque segment de commandes composites (pipes, chaînes) est validé par rapport à la liste d'autorisation. Les modèles dangereux (eval, backticks, $()) sont bloqués sans condition. Sortie limitée à 200 Ko.

[]

Accès sécurisé aux fichiers - Les lectures de fichiers ne peuvent pas être trompées pour suivre des liens symboliques hors de votre projet, et le proxy local ne communique qu'avec votre propre machine.

[ok]

Intégrité de la construction - La graine d'intégrité au moment de la compilation et la vérification du hachage détectent les binaires falsifiés. Vérifié automatiquement par lean-ctx doctor.

Détails sur la sécurité et la confiance →

Vous voulez comprendre l'architecture ?

Explorez la couche de contexte cognitif : le pipeline en six étapes, les modes d'intégration, la matrice d'agents, la théorie du champ de contexte et les neuf piliers architecturaux qui font fonctionner LeanCTX.

Plongée dans l'architecture

FAQ

Comment ça marche, en réponse.

Qu'est-ce que LeanCTX ?

LeanCTX (abréviation de Lean Context) est la couche d'ingénierie de contexte open-source pour les agents IA. Un binaire Rust local décide ce que les agents lisent, compresse ce qu'ils envoient, se souvient de ce qu'ils apprennent, protège ce qu'ils touchent, prouve ce qu'ils sauvegardent et rejoue ce qu'ils ont vu — avec des économies de 60 à 90 % par lecture enregistrée.

La compression nuit-elle à la qualité du code ?

Non. LeanCTX utilise l'analyse AST tree-sitter pour comprendre la structure du code, puis supprime uniquement ce dont le LLM n'a pas besoin : espaces blancs redondants, imports boilerplate, et commentaires décoratifs. En moyenne, 98 % de la structure AST, 97 % des identifiants, et 96 % des lignes de code significatives sont préservées. Vous pouvez le vérifier avec lean-ctx benchmark run.

Comment installer LeanCTX ?

Installez via cargo install lean-ctx ou curl -fsSL https://leanctx.com/install.sh | sh. Ensuite, exécutez lean-ctx init pour le hook shell et lean-ctx setup pour vous connecter à vos outils IA. Aucune configuration requise.

Quels outils IA LeanCTX prend-il en charge ?

LeanCTX fonctionne avec tous les principaux outils de codage IA : Cursor, GitHub Copilot, Claude Code, Windsurf, Cline, OpenAI Codex, Gemini CLI, Antigravity, Pi, Crush, Zed, Continue, et OpenCode. Tous les outils bénéficient à la fois du serveur de contexte et de la compression du hook shell.

Commencer

Soixante secondes pour des agents plus intelligents.

Un binaire. Zéro dépendance cloud. Apache-2.0. Votre prochaine session sera plus légère, et le registre conserve le reçu.

Commencer Vérifier la compatibilité

Comment LeanCTX contrôle ce quevotre IA voit.

Où se situe LeanCTX ?

Vous

Outil IA

LeanCTX

LLM

Un binaire. Cinq capacités.

Cinq choses que LeanCTX fait pour chaque token.

Percevoir

Compresser

Se souvenir

Router

Gouverner

Que faites VOUS faites réellement ?

Installer

Setup

Terminé. C'est automatique

Même l'oubli est une décision.

Garde ce qu'ils touchent.

Vous voulez comprendre l'architecture ?

Comment ça marche, en réponse.

Soixante secondes pour des agents plus intelligents.

Comment LeanCTX contrôle ce que
votre IA voit.