Infra16 min de lecture
Économiser des tokens dans Claude Code avec rtk et graphify
Comment je dépense moins de tokens dans Claude Code avec rtk, qui résume la sortie du terminal, et graphify, qui répond depuis le graphe du code. Chiffres réels.

Tout agent d'IA qui travaille dans le terminal a le même problème : tout ce que le terminal renvoie finit dans le contexte du modèle. Des tests qui tournent, des logs qu'on lit, des fichiers qu'on cherche : chaque sortie prend de la place et coûte des tokens.
Une suite de tests renvoie une ligne PASS par fichier, des avertissements du framework et des logs que personne ne lira. Un git log ramène le hash complet, l'e-mail et la date de chaque commit. Une question comme « où est-ce que c'est utilisé ? » devient dix fichiers ouverts, l'un après l'autre.
Il y a quelques mois, j'ai installé deux outils pour couper ce gaspillage : rtk, qui résume la sortie des commandes avant qu'elle n'arrive au modèle, et graphify, qui transforme le code en graphe pour que je puisse interroger le graphe avant d'ouvrir un fichier. Les deux ont le vent en poupe : le 16/11/2026, rtk dépassait les 86 000 étoiles sur GitHub et graphify approchait les 149 000, pour un dépôt créé en avril.
Ce billet explique comment j'utilise les deux, avec les vrais chiffres de ma machine, et là où ils n'aident pas.
TL;DR#
- rtk est un binaire en Rust qui se branche comme hook dans Claude Code : avant chaque commande dans le terminal, il remplace
git logparrtk git loget ne transmet au modèle que ce qui compte. - Sur ma machine, depuis août : 148 000 commandes et 228,1 millions de tokens économisés, d'après
rtk gain. Mais en mesurant à la main, j'ai découvert que le chiffre des tests est gonflé. - graphify lit le code avec tree-sitter, sans LLM et sans rien envoyer à l'extérieur, et construit un graphe de fonctions, d'imports et d'appels. Ensuite,
graphify explain "articlesPath()"répond en 15 lignes à ce qui demanderait dix fichiers ouverts. - Les deux ont des limites : le hook de rtk n'attrape que les commandes du terminal (les outils natifs Read et Grep passent tels quels), un filtre peut échouer, et le graphe laisse passer des références.
- Mesurez avant d'y croire. Sur une vraie suite de tests,
rtk gaina enregistré 99,6 % d'économie. Comparé à jest tout seul, c'était 73 %.
Où partent les tokens#
Tout ce qu'un outil renvoie entre dans le contexte de la conversation : la sortie d'une commande, le contenu d'un fichier, le résultat d'une recherche. Et ça y reste, renvoyé à chaque tour, jusqu'à la fin de la conversation ou jusqu'à ce qu'elle soit résumée.
En pratique, je vois deux types de gaspillage :
- Une sortie de commande pleine de bruit. Des tests qui passent, des barres de progression, des hashs de 40 caractères, des avertissements répétés. Le modèle a besoin de l'échec, pas de cent lignes de
PASS. - Ouvrir des fichiers pour trouver où se trouve quelque chose. Pour répondre à « qui appelle cette fonction ? », l'agent lance un
greppuis ouvre les fichiers un par un pour comprendre chaque usage.
rtk s'attaque au premier. graphify s'attaque au second.
rtk : le terminal résumé#
rtk (Rust Token Killer) est un binaire unique en Rust, sous licence Apache-2.0. Il a des filtres pour plus de 100 commandes : git, gh, npm, jest, vitest, tsc, eslint, pytest, cargo, docker, ls, grep et bien d'autres. Chaque filtre sait ce qui compte dans cette sortie. Pour les tests, uniquement les échecs avec leur assertion. Pour git log, une ligne par commit. Pour grep, les résultats regroupés par fichier.
Comment il se branche sur Claude Code#
On l'installe avec brew install rtk, puis rtk init -g, qui enregistre un hook dans ~/.claude/settings.json. Le mien ressemble à ça :
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [{ "type": "command", "command": "rtk hook claude" }]
}
]
}
}Un hook PreToolUse s'exécute avant chaque outil. Celui-ci ne regarde que Bash : Claude Code annonce qu'il va lancer une commande, rtk renvoie la commande réécrite, et c'est cette version qui s'exécute. Vous pouvez voir le remplacement avec rtk rewrite. Ce sont des sorties réelles :
| L'agent demande | Ce qui s'exécute |
|---|---|
git log -10 | rtk git log -10 |
npx jest | rtk jest |
cat src/root.tsx | rtk read src/root.tsx |
cd src && git status | cd src && rtk git status |
git log | head -5 | rtk git log | head -5 |
python3 build.py | (rien : pas de filtre, ça tourne tel quel) |
Les commandes composées marchent aussi : il réécrit chaque morceau qu'il connaît. Et ce qu'il ne connaît pas passe tel quel.
Avant et après : un vrai git log#
J'ai lancé git log -10 sur le dépôt de ce blog, sans et avec rtk. Sans, chaque commit arrive comme ça :
commit 0785527405c98135c27f735d944f7a560279cb31
Author: Yasmin Lopes <...>
Date: Mon Nov 16 19:12:27 2026 -0300
feat(artigos): publica o post do rscoveryAvec rtk, chaque commit tient sur une ligne, avec un hash court, une date relative et l'auteur. Un long message de commit est coupé, avec une note indiquant combien de lignes ont disparu :
0785527 feat(artigos): publica o post do rscovery (4 minutes ago) <Yasmin Lopes>
87c3543 feat(artigos): botao de copiar nos blocos de codigo (5 minutes ago) <Yasmin Lopes>
5abcd1b feat(artigos): rascunho do post arquivo apagado nao some (rscovery) (10 minutes ago) <Yasmin Lopes>
Post sobre por que da pra recuperar arquivo apagado de HD, SSD e pendrive,
como o rscovery acha esses dados por assinatura e como apagar de verdade
antes de vender. Quatro ilustracoes, animacao da varredura, capa #20 e
[+1 lines omitted]Ça fait 2 244 caractères sans et 1 243 avec : 45 % de moins. Pour un git log, c'est peu. La grosse différence apparaît dans les tests.
Avant et après : la suite de tests de l'app#
C'est là que j'attendais le beau chiffre. J'ai lancé les 103 fichiers de test du plus gros module du backend d'un de mes projets, sans et avec rtk :
| Caractères | Tokens (estimés) | |
|---|---|---|
npx jest src/modules/game, sans rtk | 8 603 | 2 100 |
| la même commande, avec rtk | 2 288 | 570 |
Environ 73 % de moins. Bien, mais loin des 94,5 % que rtk gain affiche pour jest. Et quand je suis allée voir l'historique de rtk (il garde tout dans un SQLite sur votre machine), cette même exécution était enregistrée ainsi :
original_cmd rtk_cmd input_tokens output_tokens savings_pct
jest run rtk jest run 142508 539 99.6142 000 tokens en entrée, contre les 2 100 que jest renvoyait tout seul. La différence, c'est que rtk ne lance pas jest normalement : il demande le rapport en JSON, beaucoup plus gros (ici, 558 065 caractères), filtre ce JSON et mesure l'économie par rapport à lui. Autrement dit, la base du calcul est une sortie que vous ne verriez jamais sans rtk.
Et cette fois, le filtre n'a même pas marché. Voici ce qui est arrivé au modèle, suivi du début du JSON coupé à 2 000 caractères :
[RTK:PASSTHROUGH] jest parser: All parsing tiers failed
[RTK:PASSTHROUGH] Output truncated (558065 chars → 2000 chars)
[full output: ~/Library/Application Support/rtk/tee/1794868468_jest_run.log]Le résumé arrive au début du JSON (tout est passé, 1 419 tests), donc le modèle a eu le résultat. Mais si un test avait échoué au milieu des 103 fichiers, la raison aurait pu se retrouver après la coupure, et l'agent aurait dû ouvrir le log complet.
Encore un chiffre : la suite entière de l'app, avec 3 088 tests qui passent, ne renvoie que 1 926 caractères avec jest tout seul. Quand tout passe, jest est déjà court. rtk fait vraiment la différence quand la sortie a du bruit : un console.log au milieu d'un test, des avertissements du framework, un échec avec une stack trace.
Mes chiffres#
Avec ça en tête, voici mon rtk gain du 16/11/2026 :
RTK Token Savings (Global Scope)
════════════════════════════════════════════════════════════
Total commands: 148053
Input tokens: 405.1M
Output tokens: 177.1M
Tokens saved: 228.1M (56.3%)
Total exec time: 4661m25s (avg 1.9s)
Efficiency meter: ██████████████░░░░░░░░░░ 56.3%« Input », c'est la taille de la sortie d'origine des commandes. « Output », c'est ce que le modèle a lu après le filtre. En trois mois et demi, mes agents ont lancé 148 000 commandes dans le terminal et, selon son propre calcul, rtk a évité d'envoyer 228,1 millions de tokens dans le contexte.
Maintenant, ce qu'il dit par commande :
- jest représente 61 % du total, mais c'est la barre la moins fiable. Ce sont 139,9 millions de tokens sur 2 422 exécutions, comptés par rapport au JSON, comme je l'ai montré plus haut. L'économie réelle est plus faible, et je n'ai aucun moyen de recalculer l'historique.
- La recherche économise peu à chaque fois, mais tourne beaucoup.
grepa tourné 45 000 fois avec une moyenne de 24,9 %. - Lire un fichier ne change presque rien.
catest devenurtk read24 000 fois, avec une moyenne de 4,7 %. Logique : dans un fichier de code, presque chaque ligne compte. - Ça varie beaucoup selon le travail du mois. En septembre, un mois avec beaucoup de tests, l'économie enregistrée était de 83,7 %. En octobre, de 29,7 %.
Une réserve que le README lui-même fait : rtk estime les tokens comme le nombre d'octets divisé par 4, et il réduit la sortie des commandes, qui n'est qu'une partie de ce que vous envoyez au modèle. Couper 90 % de la sortie, ce n'est pas couper 90 % de la facture.
graphify : interroger le graphe avant d'ouvrir un fichier#
graphify lit un dossier et construit un graphe de connaissances : chaque fonction, type, fichier et import devient un nœud, et chaque appel ou import devient une arête. Une fois le graphe prêt, l'agent l'interroge au lieu d'ouvrir des fichiers.
Ce que j'aime chez lui :
- Le code est lu en local avec tree-sitter, sans LLM et sans rien envoyer à l'extérieur. Les documents, PDF et images ont besoin d'un modèle pour en extraire le sens, mais pas le code.
- Chaque arête dit d'où elle vient :
EXTRACTEDquand c'est écrit dans le code,INFERREDquand graphify l'a déduit,AMBIGUOUSquand il n'est pas sûr. - Ce n'est pas une recherche par embeddings. C'est un vrai graphe, qu'on peut parcourir : les voisins d'un nœud, le chemin entre deux nœuds, les communautés de fichiers qui se parlent.
Construire le graphe de ce blog#
Je l'ai installé avec pipx install graphifyy (oui, avec deux « y ») et je l'ai lancé sur le dépôt de ce blog :
$ graphify update .
Re-extracting code files in . (no LLM needed)...
AST extraction: 170/170 files (100%) [10 workers]
[graphify watch] Rebuilt: 1049 nodes, 1410 edges, 83 communities
[graphify watch] graph.json, graph.html and GRAPH_REPORT.md updated in graphify-outÇa a pris 1,5 seconde. Le dossier graphify-out/ contient graph.json (le graphe entier), un graph.html à explorer en cliquant, et GRAPH_REPORT.md, un résumé avec les nœuds les plus connectés :
## God Nodes (most connected - your core abstractions)
1. `cn()` - 31 edges
2. `useI18n()` - 23 edges
3. `compilerOptions` - 20 edges
4. `compilerOptions` - 18 edges
5. `articlesPath()` - 15 edges
6. `ArticleMeta` - 14 edges
7. `absoluteUrl()` - 12 edgesÇa correspond à ce que je sais du projet : cn() combine les classes Tailwind dans chaque composant, useI18n() traduit le site en quatre langues et articlesPath() construit l'adresse de la liste d'articles dans chaque langue.
Un exemple réel : qui utilise articlesPath() ?#
C'est la question typique avant de toucher à une fonction. Sans le graphe, le chemin de l'agent, c'est un grep (23 lignes dans 10 fichiers), puis l'ouverture de ces fichiers pour comprendre chaque usage : 30 622 caractères, environ 7 600 tokens.
Avec le graphe :
$ graphify explain "articlesPath()"
Node: articlesPath()
ID: articles_paths_articlespath
Source: src/features/articles/paths.ts L18
Type: code
Community: 0
Degree: 15
Connections (15):
<-- paths.ts [contains] [EXTRACTED]
<-- static-build.ts [imports] [EXTRACTED]
<-- article-page.tsx [imports] [EXTRACTED]
<-- site-pages.ts [imports] [EXTRACTED]
<-- article-seo.ts [imports] [EXTRACTED]
<-- articles-page.tsx [imports] [EXTRACTED]
<-- articlesListMeta() [calls] [EXTRACTED]
<-- articleMeta() [calls] [EXTRACTED]
<-- renderRss() [calls] [EXTRACTED]
<-- ArticlesPage() [calls] [EXTRACTED]
<-- trail-filter.tsx [imports] [EXTRACTED]
<-- ArticlePage() [calls] [EXTRACTED]
<-- TrailFilter() [calls] [EXTRACTED]
<-- routes.ts [imports] [EXTRACTED]
<-- navHref() [calls] [INFERRED]Ça fait 798 caractères, environ 200 tokens. Et ça en dit déjà plus que grep : quelles fonctions l'appellent (le flux RSS, le SEO, la page), pas seulement quels fichiers citent le nom. Ensuite, l'agent n'ouvre que le fichier qui l'intéresse.
La règle que j'ai laissée à Claude#
graphify propose un graphify claude install, qui installe un hook pour pousser l'assistant vers le graphe. J'ai préféré écrire la règle dans mon ~/.claude/CLAUDE.md, qui s'applique à tous les projets. L'original est en portugais ; la voici traduite en anglais :
# Token saving (default in EVERY session, EVERY project)
2. **graphify (graph-first)**: before opening a file to answer "where/how/what connects",
use the graph. At the start of every task on a codebase, silently:
- `which graphify`: if installed AND `graphify-out/graph.json` exists in the project,
navigate the graph (`GRAPH_REPORT.md`, `graphify query/path/explain`) BEFORE Read.
- Installed but no graph, in a code project I'll change: run
`graphify update .` once (AST-only, cheap) and then use the graph.
- Not installed: carry on with Grep/Read silently (don't warn, don't block).
- Never read more than 3 source files per question; if you need to, the question is
too broad, ask me to narrow it. Trust EXTRACTED/INFERRED edges; only verify AMBIGUOUS.Et une commande /econ qui réactive les deux dans une session qui a démarré sans.
Le graphe se trompe aussi#
En comparant la réponse ci-dessus avec grep, j'ai trouvé trois choses à savoir :
- Il a raté un fichier.
src/routes/articles.tsxappellearticlesPath()à l'intérieur d'un objet (handle.alternates), et cet appel n'est pas devenu une arête. Le graphe a trouvé 9 fichiers sur 10. Pour renommer une fonction, je vérifie encore avecgrep. INFERRED, c'est parfois juste un nom qui se ressemble. Dans la section « connexions surprenantes » du rapport, il a relié undescribe()du plugin d'images à unresolve()du serveur de prévisualisation. Ils n'ont rien à voir : c'est une déduction par le nom. Ma règle fait confiance àINFERRED, et ce cas m'a fait revoir ça.- Les questions en langage naturel marchent mal sur le code.
graphify queryfait une recherche par mots-clés et parcourt le graphe à partir de là. J'ai demandé comment la couverture de chaque langue est choisie, et il est parti des titres d'un article en anglais (le graphe indexe aussi les.mdx). Avec le nom du symbole, comme"ArticleMeta cover", il trouve.
Et le graphe vieillit : le rapport indique de quel commit il vient. Vous avez modifié le code ? Relancez graphify update ..
Limites et quand ne pas les utiliser#
Le hook de rtk n'attrape que le terminal. Les outils natifs de Claude Code, comme Read, Grep et Glob, ne passent pas par Bash et arrivent donc en entier. Le README de rtk indique qu'un pipeline peut aussi les compresser, ce que je n'utilise pas. C'est pour ça que ma règle demande : pour une grosse sortie (diff, logs de test, build), passez plutôt par le terminal.
Un filtre peut casser la commande. C'est arrivé pendant que j'écrivais ce billet. Dans une de mes apps, npx jest est devenu rtk jest, et rtk a décidé de lancer jest via pnpm, parce que le projet a un pnpm-lock.yaml oublié à côté du package-lock.json. Le pnpm de corepack était cassé sur ma machine. Résultat : les tests ne se sont même pas lancés, la commande est sortie en erreur et le modèle n'a reçu que ça :
[RTK:PASSTHROUGH] jest parser: All parsing tiers failed
[full output: ~/Library/Application Support/rtk/tee/1794867612_jest_run.log]Sans rtk, les mêmes tests passaient. Et rtk gain a quand même enregistré cette exécution comme 90 % d'économie. Un agent qui lit « échec » sans voir pourquoi peut se mettre à corriger ce qui n'est pas cassé. L'indice était dans le log complet, que rtk enregistre et indique.
Quand vous avez besoin de toute la sortie, demandez-la. Si le filtre a trop coupé une erreur, lancez la commande sans filtre : dans la version 0.43 que j'utilise, c'est rtk proxy git log, et dans le README actuel, ça s'appelle rtk bypass. Ça compte toujours dans rtk gain.
N'utilisez pas le graphe pour un petit projet ou une question sur un seul fichier. Si vous savez déjà quel fichier ouvrir, ouvrez-le. Le rapport lui-même mesure d'abord le projet et prévient quand le graphe n'en vaut pas la peine.
Faites attention à ce qui sort de votre machine.
- rtk a une télémétrie optionnelle. Vérifiez avec
rtk telemetry status(la mienne est désactivée). - graphify n'a pas de télémétrie, mais il enregistre chaque question dans
~/.cache/graphify-queries.log. Et si vous lui demandez de lire des documents, des PDF ou des images, ce contenu part vers le modèle que vous avez configuré. - Le dossier
graphify-out/contient la carte de votre code. Je le garde hors de git.
Vérifiez que c'est le bon rtk. Il existe un autre projet appelé rtk sur crates.io. Si rtk gain n'affiche pas le tableau des économies, vous avez installé l'autre.
Comment monter le vôtre#
brew install rtkrtk init -gpipx install graphifyygraphify update .Redémarrez Claude Code après rtk init -g. Au bout de quelques jours, lancez rtk gain pour voir ce qui a vraiment changé dans votre cas.
Ce que j'ai appris#
Le compteur mesure par rapport à sa propre base. rtk gain annonçait 99,6 % sur une suite où le gain réel, comparé à jest tout seul, était de 73 %. C'est toujours bien. Mais si je me fiais au tableau de bord, je croirais économiser bien plus que ce que j'économise. Pour savoir vraiment, lancez la même commande avec rtk proxy et comparez.
L'économie apparaît là où il y a du bruit. Des tests avec des logs, un lint avec des centaines d'avertissements, ps aux, git log. Des tests qui passent sans logs sont déjà courts, et lire un fichier ne change presque rien.
Chaque nouvelle couche est un nouvel endroit où ça peut casser. Le hook est invisible exprès, et c'est justement pour ça que, quand il se trompe, on met du temps à s'en rendre compte. Aujourd'hui, quand un test échoue de façon bizarre, la première chose que je vérifie, c'est si la commande a vraiment tourné.
Un graphe est une carte, pas la vérité. Il répond vite et pour pas cher à « qui utilise ça ? », et il a raison presque à chaque fois. Pour un changement qui ne peut rien laisser derrière lui, comme un renommage, je vérifie dans le texte du code.
Références#
À lire aussi

Infra13 min de lecture
Comment effacer un disque dur ou SSD avant de le vendre

Back-end19 min de lecture
Qu'est-ce que le RAG ? Indexation, recherche et cas réel

Front-end17 min de lecture
SEO multilingue avec React : hreflang, prérendu, sitemap