llmtrim

llmtrim

Proxy local que compacta o tráfego de API de LLMs para você pagar menos. Mesmas respostas, conta menor.

_{−31% entrada · −74% saída · −66% custo de ida e volta · 112 casos A/B ao vivo · ~5 ms/chamada · sem modelo para carregar}

_{Usando Claude Code? Uma instalação também te dá /sub para servir através do CLIProxyAPI.}

_{Proxy · CLI · MCP · biblioteca (Python · Ruby · Swift · Kotlin · JS/WASM)}

O que faz • Instalação • Dia a dia • Em ação • Funciona com • Claude Code • Números • Config • CLI & biblioteca

O que faz

Você usa Claude Code, Codex, Cursor ou seu próprio aplicativo. A cada turno, a ferramenta envia uma solicitação grande: prompt do sistema, ferramentas, histórico, saída bruta de comandos. Você paga por cada token disso, incluindo as partes que não ajudam o modelo.

Um log de build de 200 linhas com dois erros. Esquemas de ferramentas reenviados a cada chamada. JSON com centenas de linhas quase idênticas. Esse volume ainda é cobrado.

llmtrim fica na sua máquina como um proxy local, remove o desperdício e encaminha uma solicitação menor. A resposta não muda. Você mantém as mesmas ferramentas e respostas; gasta menos.

  before:  your tool ───── full request ─────▶  OpenAI / Anthropic / …
                    ◀──────── reply ──────────

  after:   your tool ──▶ llmtrim ──smaller──▶  OpenAI / Anthropic / …
                            (on your machine)
                    ◀──────── reply ──────────  (same answer)

A compactação não pode aumentar sua conta nem quebrar uma solicitação; o pior caso é zero de economia. Tudo roda localmente, nada é enviado para nós. Em ação →

Para Claude Code, a mesma instalação também conecta /sub para rotear sessões por outra assinatura. Detalhes →

Comece agora

npm install -g @llmtrim/cli@latest && llmtrim setup
# open a new terminal, then keep working
llmtrim status

É isso. setup inicia um proxy local e configura seu shell. Quando Claude Code está presente, também ativa /sub. Você não precisa de uma instalação separada para isso.

Qualquer ferramenta que respeite HTTPS_PROXY funciona (Claude Code, Codex, Cursor, Aider, seu SDK). GitHub Copilot não funciona (fixação de certificado). Lista completa →

# Linux / macOS
curl -fsSL https://raw.githubusercontent.com/fkiene/llmtrim/main/install.sh | sh

# Windows (PowerShell)
irm https://raw.githubusercontent.com/fkiene/llmtrim/main/install.ps1 | iex

# Package managers
brew install fkiene/tap/llmtrim
cargo binstall llmtrim
scoop install llmtrim
docker run -d -p 43117:43117 -v llmtrim-state:/data ghcr.io/fkiene/llmtrim

llmtrim ca
openssl x509 -in ~/.llmtrim/ca.pem -noout -text | grep -A3 "Name Constraints"

Dia a dia

llmtrim status     # savings + health  (aliases: monitor, gain)
llmtrim update     # new release, restart daemon, refresh integrations
llmtrim ensure     # match the recommended install state on this machine

Após setup, update ou ensure, o /sub do Claude Code permanece sincronizado com o binário.

Séries temporais: llmtrim status --daily · --weekly · --monthly · --json · --csv.

Em ação

Um agente executou um build. A ferramenta retornou 58 linhas; duas eram erros. Todas as 58 teriam sido cobradas.

4.662 caracteres → 978 (−79%). Erros permanecem verbatim. Linhas INFO repetidas se dobram em um template mais os valores (sem perda quando o intervalo é regular).

# before (noise + signal)
[2026-06-13T10:02:00Z] INFO  compiling module core::worker::task_0 (incremental)
… 28 more near-identical INFO lines …
[2026-06-13T10:02:31Z] ERROR src/worker/pool.rs:214: mismatched types: expected `usize`, found `i64`
… 25 more INFO lines …
[2026-06-13T10:03:01Z] ERROR src/net/conn.rs:88: cannot borrow `buf` as mutable more than once
[2026-06-13T10:03:02Z] INFO  build failed, 2 errors

# after (errors verbatim; INFO folded losslessly)
[{}] INFO compiling module core::worker::task_{} (incremental) [×30: (10:02:00Z..10:02:29Z step 1s; 0..29)]
[2026-06-13T10:02:31Z] ERROR src/worker/pool.rs:214: mismatched types: expected `usize`, found `i64`
[{}] INFO compiling module core::net::conn_{} (incremental) [×25: 10:02:32Z..10:02:56Z; 0..24]
[2026-06-13T10:03:01Z] ERROR src/net/conn.rs:88: cannot borrow `buf` as mutable more than once
[2026-06-13T10:03:02Z] INFO  build failed, 2 errors

Experimente com um corpo de solicitação seu:

echo '{"model":"gpt-4o","messages":[...]}' | llmtrim compress --provider openai

A dobra de logs é um estágio. Outros entram em ação com diferentes desperdícios:

[!IMPORTANT] A compactação não pode aumentar sua conta nem quebrar uma solicitação. Cada estágio é re-medido com o tokenizador real do provedor e desfeito se não economizar tokens. Se o provedor rejeitar o corpo compactado, o original é reenviado. O pior caso é zero de economia.

Prefixos existentes de prompt-cache (cache_control) são deixados intactos. A modelagem recuperável de primeira chegada (llmtrim recall r_…) está desativada por padrão; a janela de saída de ferramentas na zona ativa ainda roda, e uma re-execução da mesma ferramenta é enviada por completo. Para pular a modelagem de um comando (stdout verbatim, incluindo um trailer de terminal), defina toolout_passthrough = ["*gpt.sh*"] ou prefixe o comando com LLMTRIM_TOOL_OUTPUT=passthrough. Linhas começando com LLMTRIM_KEEP: sobrevivem à janela mesmo quando o resto é cortado.

Claude Code

Quando ~/.claude existe, setup, update e ensure conectam /sub (e subagentes roteados). Nenhum comando de instalação separado para isso.

llmtrim sub on                  # install + start CLIProxyAPI, enable redirect
llmtrim sub on grok             # write opus/sonnet/haiku/fable → that CLI's models
llmtrim sub auth                # CLIProxyAPI TUI — sign in
llmtrim sub models              # official + live sidecar models
llmtrim sub map on opus grok-4.6
llmtrim sub chain anthropic,codex
llmtrim sub mode fallback       # try hops in order when the current one fails
llmtrim sub status
llmtrim sub off

llmtrim agents install          # also installed/refreshed by setup, update, and ensure

/sub on [optional:cli-or-model]  # gemini, codex, claude, grok, kimi, vertex, qwen, copilot, or a model id
/sub off
/sub status

llmtrim sub anthropic-login keep   # connectors OK; Anthropic login required
llmtrim sub anthropic-login skip   # default: no Anthropic /login; connectors off

Use como CLI, MCP ou biblioteca

Mesmo mecanismo, sem necessidade de proxy. Sem chamadas extras de modelo; a compressão roda no processo.

echo '{"model":"gpt-4o","messages":[...]}' | llmtrim compress --provider openai > out.json
echo '{"model":"gpt-4o","messages":[...]}' | llmtrim send --provider openai

use llmtrim_core::{compress, ir::ProviderKind};
let out = compress(request_json, Some(ProviderKind::OpenAi))?;

import llmtrim
out = llmtrim.compress(request_json, llmtrim.Provider.OPEN_AI, "aggressive")

import { compress } from "@llmtrim/js";
const out = compress(requestJson, "openai", "aggressive");

llmtrim mcp install          # Claude Code
llmtrim mcp install --print  # paste into any client

{
  "mcpServers": {
    "llmtrim": { "command": "llmtrim", "args": ["mcp"] }
  }
}

Funciona com

Qualquer ferramenta que respeite HTTPS_PROXY e uma CA fornecida por env:

Sem proxy: qualquer cliente MCP pode chamar llmtrim como ferramentas (llmtrim mcp install), ou usar o CLI / biblioteca.

Os provedores vêm do registro llm_providers (OpenAI, Anthropic, Google, DeepSeek, Mistral, xAI, Moonshot, Zhipu, Qwen, OpenRouter, …) e são atualizados junto com ele. Conexões que não são de LLM passam intocadas.

Configuração

O padrão é suficiente para a maior parte do tráfego. auto inspeciona cada requisição e escolhe compressores pela forma (ferramentas → agent, código → code, Q&A longo → rag, senão aggressive).

Substitua com LLMTRIM_PRESET=<name> ou preset = "<name>" em $XDG_CONFIG_HOME/llmtrim/config.toml:

Opções do Claude Code (redirecionamento de assinatura) estão em Claude Code.

export LLMTRIM_UPSTREAM_PROXY=http://host:port
# or with auth: http://user:pass@host:port  (redacted in logs)

Os números

Cada caso é enviado duas vezes, uma original e uma comprimida, e então ambas as respostas são pontuadas e cobradas a taxas reais. Custo e qualidade são medidos juntos, não estimados, em 112 casos:

Os cortes de tokens são independentes do modelo (−31% entrada, −74% saída). A economia em dólares acompanha a razão de preço saída-para-entrada do modelo: −66% aqui, projetando −57% nas taxas do GPT-4o e −59% nas taxas do Claude Sonnet. O proxy comprime apenas a superfície de conteúdo novo e nunca reescreve o prefixo controlado por cache, então seu desconto de prompt-cache sobrevive.

make -C crates/llmtrim-cli/bench data
(cd crates/llmtrim-cli && cargo run -q --features live -- bench quality \
   --corpus bench/data/squad2.jsonl --preset rag \
   --model qwen/qwen3-next-80b-a3b-instruct --route "" --n 20)

Metodologia, fronteira por corpus e intervalos de confiança: crates/llmtrim-cli/bench/README.md. Reproduza:

make -C crates/llmtrim-cli/bench data   # pull real corpora (gsm8k, humaneval, dolly, hotpotqa, …)
(cd crates/llmtrim-cli && cargo run -q --features live -- bench suite)  # live A/B across all corpora (needs OPENROUTER_API_KEY)
(cd crates/llmtrim-cli/bench/scripts && PYTHONPATH=. python3 -m benchkit.tools.chart)  # regenerate the chart + table

Como se compara

Cada ferramenta comprime uma fatia da requisição. O llmtrim comprime entrada e saída, deixa o prefixo em cache intocado para manter o prompt-cache estável, e pontua se a resposta sobrevive ao corte, não pelos tokens removidos. Ambos os eixos abaixo usam o codificador o200k_base e reproduzem a partir deste repositório.

Entrada

Redução de entrada (determinística) ao lado da qualidade da resposta de um A/B ao vivo. Qualidade é a queda vs. llmtrim em cada configuração comparada da ferramenta (✅ mantida, empate estatístico; ❌ significativamente menor), então uma grande redução com ❌ significa que a ferramenta comprou tokens perdendo respostas:

Overhead é o tempo mediano de compressão por chamada (wall-clock em Python, não CPU comparável): Headroom e leanctx executam ML na CPU aqui (mais rápido em GPU) e pagam um carregamento único de modelo por cima (~3 s e ~4 s); llmtrim é Rust e entroly é lexical, então nenhum dos dois paga.

• auto é o padrão com gate de qualidade; aggressive aceita cortes com perda onde o gate se mantém.
• Headroom cai para 0% com seu ML desabilitado (seus roteadores não operam em prosa).
• leanctx e entroly são com perda e sem gate de qualidade; entroly não tem modo de baixa redução.

Headroom empata na redução correspondente (24-25%, n=30, não significativo), mas suas respostas mais longas atingem o limite de tokens de saída do modelo e são truncadas 12 vezes contra 2 do llmtrim, a inflação de saída por trás de seu custo maior. leanctx (medido em 26%) e entroly (em 69%, seu modo mais suave) pontuam significativamente abaixo do llmtrim (n=20), e caem ainda mais em suas reduções de destaque (vs-leanctx, vs-entroly).

Saída

Redução de saída ao pedir respostas mais concisas, em uma chamada paga ao vivo em 9 prompts de codificação:

O custo é o prompt de sistema de 949 tokens que caveman reenvia em toda requisição (coluna direita); o do llmtrim é 19 para quase o mesmo corte. Ambos ainda economizam líquido aqui, então o corte mais profundo do caveman só sai à frente quando a saída que ele remove vale mais do que os 949 tokens que ele adiciona de volta (artefato vs-caveman).

As ferramentas se empilham: RTK encolhe a saída da CLI, então llmtrim comprime os schemas das ferramentas por cima. Comparações completas: crates/llmtrim-cli/bench/README.md.

Limitações conhecidas

Estas são expostas pelo mesmo A/B que prova as economias:

• As contagens de tokens da Anthropic / Gemini são aproximadas. Não há tokenizador público exato, então um proxy BPE é usado e sinalizado em status. OpenAI é exato.
• As economias de saída não são medidas ao vivo. O proxy comprime entrada; uma economia de saída precisa do contrafactual A/B, que só o benchmark offline executa. status "economizado" é do lado da entrada.
• O padrão tem gate de qualidade, não é sem perda. Estágios com perda rodam apenas onde a avaliação mostra que a qualidade se mantém. Quer um round-trip byte a byte fiel? Use o preset safe.
• "Sem perda" é do lado da entrada, não restauração de resposta. Um estágio sem perda preserva a informação que o modelo lê (um log dobrado, um array codificado em TOON, uma legenda de abreviação que o modelo decodifica no prompt), e o gate de tokens reverte qualquer corte de entrada que não compensa. O motor não transforma a resposta do modelo de volta a uma forma original.

Agradecimentos

Cada compressor é uma implementação determinística de pesquisa publicada: as ideias são deles, a engenharia e o gate de tokens são nossos.

Encontrou um problema?

llmtrim doctor          # diagnose
llmtrim doctor --fix     # diagnose + apply repairs
llmtrim ensure          # same repair path

Cada verificação que falha nomeia sua correção. Se uma requisição foi corrompida, defina LLMTRIM_CAPTURE_DIR e abra uma issue com o par antes/depois.

Se llmtrim economizou seu dinheiro, uma ⭐ ajuda outros a encontrá-lo.

Histórico de estrelas

_{Licenciado sob MPL-2.0. Use llmtrim livremente em sua stack, inclusive comercialmente, sem obrigação de divulgação de fonte para seu próprio código; o copyleft em nível de arquivo se aplica apenas a modificações que você fizer nos próprios arquivos-fonte do llmtrim. Contribuições via assinatura DCO.}