╭──────────────────────────────────────────╮ ╭──────────────────────────────────────────╮ │ >>>>>>>>>>>>>>> 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

Jak To Działa

Jak LeanCTX kontroluje to, co
widzi twój AI.

LeanCTX to warstwa context engineering dla agentów AI: mały binarny plik Rust wykonujący ten sam cykl przy każdym odczycie, poleceniu i wyszukiwaniu. decyduje, co czytają Twoi agenci, pamięta to, czego się uczą w różnych sesjach, chroni to, czego dotykają, udowadnia to, co zapisują w podpisowanym rejestrze, i odtwarza to, co widzieli. Odczyty są parsowane pod kątem struktury w 26 językach i oczyszczane z szumu, dzięki czemu to, co dociera do modelu, jest celowe, skompresowane i udowodnialne. Instalujesz raz. Wszystko inne działa automatycznie.

Przepływ danych

Gdzie znajduje się LeanCTX ?

LeanCTX znajduje się na dwóch ścieżkach. Na ścieżce odczytu kształtuje to, co do niej trafia — odczyty plików, wyszukiwanie kodu i wyjście z powłoki, skompresowane zanim agent je zobaczy. Na ścieżce przesyłu opcjonalny lokalny proxy znajduje się między agentem a modelem i kompresuje każdy wychodzący żądanie — prompt systemowy, pełną historię i wyniki narzędzi — z bezpieczeństwem prompt-cache. Jedno optymalizuje to, co trafia do kontekstu; drugie optymalizuje każde żądanie, za które płacisz. Model widzi ten sam sygnał w ułamku tokenów.

przepływ danych: przed vs. po

Bez lean-ctx:

Ty  →  Narzędzie AI  →  czyta plik  (pełna zawartość)  →  LLM przetwarza wszystko

Z lean-ctx:

Ty  →  Narzędzie AI  →  lean-ctx kompresuje  →  tylko sygnał  →  LLM: 60–90% mniej szumu
                           ├─ Sandbox PathJail + limity rozmiaru
                           ├─ Kompresja świadoma AST
                           ├─ Pamięć wykonawcza (wiedza + zapominanie)
                           ├─ Bufor sesji (ponowne odczytanie ≈ 13 tok)
                           └─ 10 tryby odczytu na typ pliku

Dogłębna analiza: Wzorce Shell (95+ wzorców) · Tryby Odczytu (10 tryby kompresji) · Caching

Ty

Koduj normalnie. Nie zmieniaj swojego workflow.

Narzędzie AI

Cursor, Claude Code, Copilot, Windsurf, …

LeanCTX

Decyduje, kompresuje i pamięta za pomocą serwera MCP i hooka powłoki automatycznie wykrywanego przez Twoje narzędzia AI.

LLM

Widzi tylko sygnał. O 60–90% mniej tokenów, ta sama informacja.

Architektura

Jeden binarny plik. Pięć możliwości.

Każda możliwość działa wewnątrz pojedynczego binarnego pliku Rust. Oto jak żądanie przepływa przez LeanCTX: od Twojego narzędzia AI, przez potok poznawczy, do modelu.

Twoje Narzędzie AI Cursor · Claude Code · Copilot · Windsurf

MCP · CLI · HTTP

lean-ctx Warstwa Kontekstu Poznawczego · Pojedynczy binarny plik · 81 narzędzi

Zrozumieć

10 trybów czytania
Widoczność kontekstu
Liczenie tokenów
Wykrywanie zamiaru

Kompresować

Tree-sitter AST (26 języków)
95+ wzorców powłoki
CDC reorder (Rabin-Karp)
Budżet 64 KB, termin 500 ms

Zapamiętać

Pamięć sesji (zstd, w pamięci)
Ponowne odczytywanie 13 tokenów
Graf wiedzy (SQLite)
Pamięć między sesjami

Weryfikacja

Sandbox PathJail
Izolacja na poziomie systemu operacyjnego
Lista dozwolonych poleceń shell (domyślnie zakazane)
Pełny ślad audytu

Połączenie

GitHub · GitLab · Jira · Linear
Postgres · REST · MCP Bridge
Wyszukiwanie hybrydowe (BM25 + semantyczne)
Powiadomienia o dostawcach na podstawie konfiguracji (TOML)

10tryby czytania

13tokeny na ponowne przeczytanie

18języki (AST)

zoptymalizowany kontekst

LLM Mniej szumu · Wyższy sygnał · Lepsze wyniki

Pięć podsystemów

Pięć rzeczy, które LeanCTX robi dla każdego tokenu.

Pomiędzy Twoim AI a Twoim kodem, jeden lokalny binarny plik wykonuje ten sam pięcioetapowy cykl przy każdym odczycie, poleceniu i wyszukiwaniu — percepcja, kompresja, pamięć, routowanie, zarządzanie. Razem realizują pięć zadań: decyduje, co czytają Twoi agenci, pamięta to, czego się uczą, chroni to, czego dotykają, udowadnia to, co zapisują, i odtwarza to, co widzieli.

Percepcja

Zobacz, co ma znaczenie, zanim coś zrobisz.

Mapuje nieznany repozytorium, ujawnia istotne pliki i symbole oraz czyta strukturę zamiast całych plików, w ponad 26 językach za pomocą tree-sitter.

ctx_overview → repo mapped in one call

Kompresja

Każdy token niesie sygnał.

Dziesięć trybów odczytu, ponad 95 wzorców wyjścia z shella i cache adresowany treścią skracają odczyty o 60–90%, a ponowne odczyty do około 13 tokenów. Szum nigdy nie dociera do modelu.

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

Zapamiętywanie

Ciągłość między sesjami.

Wyniki, decyzje i dotknięte pliki są trwałe i automatycznie przywracane w każdej nowej sesji, dzięki czemu Twój agent nigdy nie musi ponownie wyjaśniać kontekstu ani ponownego czytać tego, co już wie.

ctx_session → restored · 0 re-reads

Routing

Prawidłowy kontekst do właściwego modelu.

Wykrywa zamiar, wybiera tryb czytania i budżet tokenów, ładując tylko narzędzia potrzebne do zadania, dzięki czemu każdy model widzi dokładnie kontekst, którego powinien, i nic więcej.

ctx_intent → right mode + budget per task

Sterowanie

Bezpieczne, mierzalne, egzekwowane.

PathJail, biała lista powłoki, wykrywanie sekretów, polityki ról i budżety tokenów utrzymują każde wywołanie narzędzia w granicach, a analityka udowadnia dokładnie, co zostało zaoszczędzone.

ctx_verify → paths ok · secrets blocked

Dwa polecenia. Tyle.

Co TY faktycznie robisz?

Prawie nic. LeanCTX działa niewidocznie po jednorazowej konfiguracji. Nadal kodujesz dokładnie tak, jak wcześniej.

Instalacja

Jeden binarny plik Rust. Bez zależności, bez chmury, bez konta.

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

Setup

Automatycznie wykrywa Twoją powłokę i narzędzia AI. Konfiguruje wszystko w kilka sekund.

lean-ctx setup

Gotowe. To jest automatyczne

Koduj normalnie. Twoje AI automatycznie używa skompresowanych narzędzi.

Oszczędzone tokeny: automatycznie

Ty vs. Maszyna

Co TY robisz (raz)	Co dzieje się AUTOMATYCZNIE
lean-ctx setup	AI używa `ctx_read` zamiast Read - do 99% mniej tokenów (buforowane ponowne odczyty)
	AI używa `ctx_shell` zamiast Shell - 60–90% mniej tokenów
	AI używa `ctx_search` zamiast Grep - 50–80% mniej tokenów
	Hak powłoki kompresuje wyjście CLI przezroczystym sposobem
	Bufor sesji pamięta pliki między odczytami (~13 tokenów na ponowne odczyty)
lean-ctx gain (optional)	Zobacz swój pulpit oszczędności życiowej

Pełny przewodnik instalacji → Rozpoczęcie pracy · Wszystkie polecenia CLI → Referencja CLI

Nawet zapominanie to decyzja.

Gdy pamięć podręczna sesji się zapełnia, LeanCTX automatycznie decyduje, co zachować, a co usunąć. Sortuje wpisy według recencyjności, częstotliwości i rozmiaru: następnie łączy te sygnały w jeden wynik. Nie wymaga dostrajania.

Jak działa cache

Bezpieczeństwo

Strzeże tego, co dotyka.

LeanCTX egzekwuje model bezpieczeństwa typu defense-in-depth, aby zapobiec wyciekowi promptów LLM do plików poza projektem:

[//]

PathJail - Wszystkie operacje na plikach są sandboksowane do głównego katalogu projektu. Przechodzenie przez symlinki, ucieczki typu ../ i ścieżki absolutne poza więzieniem są blokowane w punkcie kontrolnym resolve_path.

[##]

Lista dozwolonych poleceń + Parsowanie AST - Po skonfigurowaniu każdy segment złożonych poleceń (potoki, łańcuchy) jest walidowany względem listy dozwolonych. Niebezpieczne wzorce (eval, backticks, $()) są blokowane bezwarunkowo. Wyjście ograniczone do 200KB.

[]

Bezpieczny dostęp do plików - Odczyty plików nie mogą zostać oszukane tak, aby śledziły symlinki poza projektem, a lokalny proxy komunikuje się tylko z własną maszyną.

[ok]

Integralność budowy - Integralność ziarna czasu kompilacji i weryfikacja hasha wykrywają zmodyfikowane binarki. Sprawdzane automatycznie przez lean-ctx doctor.

Szczegóły bezpieczeństwa i zaufania →

Chcesz zrozumieć architekturę?

Zapoznaj się z Cognitive Context Layer: sześciostopniowym potokiem, trybami integracji, macierzą agentów, Teorią Pola Kontekstu i dziewięcioma filarami architektonicznymi, które sprawiają, że LeanCTX działa.

Dogłębne zanurzenie w architekturę

FAQ

Jak to działa? Odpowiedzi.

Czym jest LeanCTX?

LeanCTX (skrót od Lean Context) to open-source warstwa context engineering dla agentów AI. Jeden lokalny binarny plik Rust decyduje, co agenci czytają, kompresuje to, co wysyłają, pamięta to, czego się uczą, chroni to, czego dotykają, udowadnia to, co zapisują, i odtwarza to, co widzieli — z oszczędnością 60–90% na każde przeczytanie.

Czy kompresja szkodzi jakości kodu?

Nie. LeanCTX używa parsowania AST tree-sitter, aby zrozumieć strukturę kodu, a następnie usuwa tylko to, czego LLM nie potrzebuje: nadmiarowe białe znaki, boilerplate importy i dekoracyjne komentarze. Średnio zachowane jest 98% struktury AST, 97% identyfikatorów i 96% znaczących linii kodu. Możesz zweryfikować to za pomocą uruchomienia benchmarku lean-ctx.

Jak zainstalować LeanCTX?

Zainstaluj za pomocą cargo install lean-ctx lub curl -fsSL https://leanctx.com/install.sh | sh. Następnie uruchom lean-ctx init dla hooka powłoki i lean-ctx setup, aby połączyć się z Twoimi narzędziami AI. Nie wymaga konfiguracji.

Jakie narzędzia AI obsługuje LeanCTX?

LeanCTX działa z każdym głównym narzędziem do kodowania AI: Cursor, GitHub Copilot, Claude Code, Windsurf, Cline, OpenAI Codex, Gemini CLI, Antigravity, Pi, Crush, Zed, Continue i OpenCode. Wszystkie narzędzia korzystają zarówno z serwera kontekstu, jak i kompresji hooka powłoki.

Rozpocznij

Sześćdziesiąt sekund do inteligentniejszych agentów.

Jeden binarny plik. Zero zależności chmurowych. Apache-2.0. Twoja następna sesja jest lżejsza, a księga przechowuje potwierdzenie.

Rozpocznij pracę Sprawdź kompatybilność

Jak LeanCTX kontroluje to, cowidzi twój AI.