LatentGate

---

Veja funcionando

Experimente no seu navegador → O otimizador real roda na sua máquina via WebAssembly; nada que você colar é enviado.

Um log de erro de 400 linhas, lido através do LatentGate (balanced, medido com tiktoken):

BEFORE  13,641 tokens
2026-10-08 09:00:00 ERROR order 10000 failed: payment gateway timeout after 2982ms (retry 1/3)
... 398 more lines in the same shape ...

AFTER   145 tokens  (98.9% saved)
2026-10-08 09:00:00 INFO app started, 3 workers
2026-10-08 09:00:00 ERROR order 10000 failed: payment gateway timeout after 2982ms (retry 1/3)
[… 398 similar lines: order 10001…10398, 2900…3100 ms …]
2026-10-08 09:06:39 ERROR order 10399 failed: payment gateway timeout after 3030ms (retry 1/3)
2026-10-08 09:07:00 FATAL circuit breaker open for payments-api

Instale no Claude Code em uma linha, depois pergunte "leia app.log e me diga por que os pedidos falham":

claude mcp add --scope user latent-gate -- uvx --from "latent-gate[mcp,tokens]" latent-gate-mcp

No que você pode confiar: a mesma entrada sempre produz a mesma saída (então o cache de prompt do provedor continua funcionando); a saída nunca é maior que a entrada; blocos de código, URLs e strings entre aspas voltam byte por byte; level="lossless" não muda nada além de espaços em branco, formatação JSON e duplicatas exatas. O que você troca no nível padrão: sequências de linhas quase idênticas são reduzidas para primeiro, último e faixas de valores, então IDs individuais dentro de uma sequência reduzida não são mantidos. O corpus completo, incluindo onde ele perde fatos, está em Benchmarks de Custo e é reproduzível com latent-gate --optimizer-benchmark.

Funciona no Claude Code, Claude Desktop, Cursor, Cline, Continue e Zed, gratuito e offline.

Não quer instalar nada? O LatentGate hospedado oficial no mcprush também roda onde servidores locais não podem, como claude.ai na web e no celular. Ele tem um nível gratuito (300 chamadas por mês) e planos pagos a partir de $9/mês.

---

O Problema

Toda vez que você envia uma imagem ou prompt longo para GPT-4o / Claude / Gemini, você gasta 1.000+ tokens em processamento que poderia acontecer localmente de graça.

Traditional:  Image -> Cloud LLM (1,200 tokens) -> Answer
LatentGate:   Image -> Local Ollama (FREE) -> Cloud LLM (200 tokens) -> Answer

---

Recursos

Recurso	Descrição
Local-Primeiro	Compressão de visão e texto roda no Ollama (gratuito, sem necessidade de chave de API)
Otimizador de Tokens	Compressão determinística que preserva fatos: 66% menos tokens em um corpus de desenvolvimento realista em ~1ms (benchmark)
Servidor MCP	Funciona com Claude Desktop, Cursor, Cline, Continue, Zed
Decodificação Seletiva	Para vídeo, só chama a API quando a cena muda (~2,85x menos chamadas) com similaridade de cosseno
Compressão de Texto	Prompts longos, conversas, documentos RAG comprimidos localmente
Otimizado para Velocidade	Pool de conexões, pré-carregamento de modelos, processamento paralelo
Multi-Provedor	OpenAI, Anthropic, Google, Groq, DeepSeek, Together, Azure, AWS Bedrock, Ollama, ou qualquer endpoint compatível com OpenAI
API REST	Servidor FastAPI para integração com aplicações web
Processamento de Vídeo	Entrada direta de arquivo de vídeo com extração automática de quadros
Rastreamento de Custos	Rastreamento persistente de custos com análise SQLite e relatórios exportáveis
Suporte Assíncrono	Métodos assíncronos sem bloqueio para FastAPI, aiohttp, etc.
Respostas em Streaming	Transmita respostas de LLMs remotos
Persistência de Configuração	Arquivos de configuração YAML/TOML com substituições por variáveis de ambiente
Logging Estruturado	Logging formatado em JSON com rotação e IDs de correlação
Suporte a Docker	Dockerfile e docker-compose para implantação fácil
Sistema de Plugins	Processadores personalizados para compressão específica de domínio
Multi-idioma	Suporte para 30+ idiomas com detecção automática

---

Use no Claude

O LatentGate se conecta ao Claude como um servidor MCP. Suas ferramentas de otimização funcionam offline, sem Ollama e sem chave de API — o Claude lê logs grandes, dumps JSON e documentos através dele e gasta uma fração do contexto. Um log de erro de 400 linhas vai de 14.400 para ~100 tokens.

Requer uv (uvx busca o LatentGate do PyPI na primeira execução). A primeira execução baixa dependências, o que pode exceder o limite de inicialização MCP de 30 segundos do Claude em uma conexão lenta; execute isto uma vez antes (inicializações posteriores levam ~2s):

uvx --from "latent-gate[mcp,tokens]" latent-gate --optimizer-benchmark

Claude Code — plugin (servidor MCP + uma skill que diz ao Claude quando usá-lo):

/plugin marketplace add KathanModh259/latent-gate
/plugin install latent-gate@latent-gate

Claude Code — apenas servidor MCP:

claude mcp add latent-gate -- uvx --from "latent-gate[mcp,tokens]" latent-gate-mcp

Qualquer agente — do marketplace Agensi: LatentGate Context Saver é a skill oficial para Claude Code, Cursor, Codex CLI e 20+ outros agentes. Ela configura o LatentGate se estiver faltando, funciona com as edições local e hospedada, e diz ao seu agente quando usá-lo.

Claude Desktop — adicione a claude_desktop_config.json e reinicie:

{
  "mcpServers": {
    "latent-gate": {
      "command": "uvx",
      "args": ["--from", "latent-gate[mcp,tokens]", "latent-gate-mcp"]
    }
  }
}

Depois é só perguntar: "Leia logs/app.log com latent-gate e me diga por que os pedidos falham."

Ferramenta	Precisa de Ollama	O que faz
read_file_optimized	não	Lê um arquivo de texto e retorna sua forma otimizada (use para arquivos que você lê, não para arquivos que você edita)
optimize_text	não	Otimiza texto que você já tem, opcionalmente em direção a um orçamento de question / max_tokens
count_tokens	não	Conta tokens (tiktoken o200k_base)
compress_image	sim	Descreve uma imagem localmente como um payload de cena de ~150 tokens
compress_text / compress_conversation / compress_documents	sim	Otimizador + compressão LLM local com verificação de fatos
get_stats	sim	Estatísticas da sessão

---

Início Rápido

Instalação

# Core install
pip install latent-gate

# With MCP server (for Claude Desktop, Cursor, Cline, etc.)
pip install latent-gate[mcp]

# With API server (for web applications)
pip install latent-gate[api]

# With video processing
pip install latent-gate[video]

# With embedding-based similarity (more accurate selective decoding)
pip install latent-gate[embeddings]

# With LangChain integration
pip install latent-gate[langchain]

# With AWS Bedrock support
pip install latent-gate[bedrock]

# Exact token counts via tiktoken (otherwise a calibrated ~6%-error estimate)
pip install latent-gate[tokens]

# With all features
pip install latent-gate[all]

Baixar Modelos Ollama

ollama pull llava:7b      # Vision model (required for image queries)
ollama pull llama3:8b     # Text model (required for text compression & prediction)

Início Rápido com Um Comando

chmod +x scripts/quickstart.sh
./scripts/quickstart.sh

Isso inicia tudo: Ollama → baixa modelos → servidor API → site. Veja scripts/quickstart.sh para opções como --no-pull, --no-website, --port 9000.

Uso via CLI

# Image query
latent-gate photo.jpg "What is in this image?" --provider ollama -v

# Text compression
latent-gate --text "Your long prompt here..." --provider ollama -v

# Text from file
latent-gate --text-file prompt.txt --provider openai -v

# Image + Text combined
latent-gate photo.jpg "Analyze" --text "Extra context..." -v

# Full JSON output
latent-gate photo.jpg "Describe" --json -v

# Compress only, deterministically (no LLM call, ~1ms, reproducible)
cat prompt.txt | latent-gate --text-file - --compress-only --deterministic --level balanced

# Reproduce the token-savings benchmark (no Ollama needed)
latent-gate --optimizer-benchmark

# Production benchmark
latent-gate --benchmark --benchmark-output reports/benchmark.json

# Start API server (requires: pip install latent-gate[api])
latent-gate-api

Endurecimento para Produção

Para implantações de API, restrinja leituras diretas de caminhos de imagem a diretórios confiáveis:

set LATENTGATE_ALLOWED_IMAGE_ROOTS=C:\safe-images;D:\datasets
latent-gate-api

Execute benchmarks antes de lançamentos para que velocidade e economia sejam medidas, não adivinhadas:

latent-gate --benchmark --json

---

API Python

Consulta de Imagem

from latent_gate import LatentGatePipeline, PipelineConfig

config = PipelineConfig(
    vision_model="llava:7b",
    predictor_model="llama3:8b",
    remote_provider="openai",
    remote_model="gpt-4o-mini",
)

with LatentGatePipeline(config) as pipeline:
    result = pipeline.query("photo.jpg", "What is in this image?")

    print(result["answer"])
    print(f"Tokens sent: ~{result['tokens_estimated']}")
    print(f"Timing: {result['timing']}")

Compressão de Texto

# Long prompt compression
result = pipeline.query_text("Your 500-word prompt here...", mode="auto")

# Conversation history compression
messages = [
    {"role": "user", "content": "Help me with Kubernetes setup"},
    {"role": "assistant", "content": "Sure! What's your target configuration?"},
    {"role": "user", "content": "3 nodes, t3.large, us-east-1 with autoscaling"},
]
result = pipeline.query_conversation(messages, "Now give me the setup commands")

# RAG document compression
documents = ["doc1 text...", "doc2 text...", "doc3 text..."]
result = pipeline.query_documents(documents, "How do I implement JWT refresh?")

# Universal (auto-detect input type)
result = pipeline.query_universal(text="Explain this code...", image="screenshot.png")

Processamento em Lote

# Sequential with selective decoding (skips redundant API calls)
results = pipeline.query_batch(image_paths, "Describe each scene")

# Parallel processing
results = pipeline.query_batch(image_paths, "Describe each scene", parallel=True, max_workers=4)

# Text batch
results = pipeline.query_batch_texts(text_list, question="Summarize each")

Streaming

# Stream image query
for token in pipeline.query_stream("photo.jpg", "Describe this"):
    print(token, end="", flush=True)

# Stream text query
for token in pipeline.query_text_stream("Long prompt...", mode="compress"):
    print(token, end="", flush=True)

---

API REST

Iniciar Servidor

# Default (0.0.0.0:8000)
latent-gate-api

# Custom host/port
# Linux/macOS:
LATENTGATE_HOST=127.0.0.1 LATENTGATE_PORT=9000 latent-gate-api

# Windows PowerShell:
$env:LATENTGATE_HOST="127.0.0.1"; $env:LATENTGATE_PORT="9000"; latent-gate-api

# Windows CMD:
set LATENTGATE_HOST=127.0.0.1 && set LATENTGATE_PORT=9000 && latent-gate-api

Endpoints

Método	Endpoint	Descrição
GET	/health	Verificação de saúde (status da conexão Ollama)
GET	/stats	Estatísticas de uso da sessão
POST	/query/image	Consulta de imagem
POST	/query/text	Compressão de texto
POST	/query/conversation	Compressão de conversa
POST	/query/documents	Compressão de documento RAG
POST	/query/universal	Detecção automática de tipo de entrada
POST	/query/image/upload	Enviar imagem para consulta

Exemplos de Requisições

import requests

# Image query
response = requests.post("http://localhost:8000/query/image", json={
    "image_path": "photo.jpg",
    "question": "What is in this image?"
})

# Text query
response = requests.post("http://localhost:8000/query/text", json={
    "text": "Your long prompt here...",
    "question": "Summarize this",
    "mode": "auto"  # auto | compress | summarize | condense | code
})

# Health check
response = requests.get("http://localhost:8000/health")
print(response.json())  # {"status": "healthy", "ollama_connected": true, ...}

---

Suporte Assíncrono

import asyncio
from latent_gate import AsyncLatentGatePipeline, PipelineConfig

async def main():
    async with AsyncLatentGatePipeline() as pipeline:
        # Single queries
        result = await pipeline.query("photo.jpg", "What is this?")
        result = await pipeline.query_text("Long prompt...")

        # Concurrent batch processing
        results = await pipeline.query_many_images(
            ["img1.jpg", "img2.jpg", "img3.jpg"],
            "Describe each image",
            max_concurrent=3,
        )

asyncio.run(main())

---

Processamento de Vídeo

from latent_gate import LatentGatePipeline, PipelineConfig, VideoProcessor, VideoConfig

config = PipelineConfig(
    vision_model="llava:7b",
    remote_provider="ollama",
    remote_model="llama3:8b",
)

video_config = VideoConfig(
    fps=1.0,            # Extract 1 frame per second
    max_frames=100,     # Max frames to process
    quality=95,         # JPEG quality
    resize_width=640,   # Resize frames (saves processing time)
)

with VideoProcessor(config, video_config) as processor:
    result = processor.process_video("video.mp4", "Describe the action")

    print(f"Frames processed: {result['total_frames']}")
    print(f"Unique scenes: {result['statistics']['unique_scenes']}")
    print(f"Skip rate: {result['statistics']['skip_rate']}")

---

Configuração

Arquivo de Configuração

# latentgate.yaml
ollama_base_url: http://localhost:11434
vision_model: llava:7b
predictor_model: llama3:8b
remote_provider: openai
remote_model: gpt-4o-mini
selective_decoding: true
similarity_threshold: 0.85
use_embeddings: true
enable_caching: true
temperature: 0.1
request_timeout: 120
track_costs: true
cost_db_path: "latentgate_costs.db"

from latent_gate import get_config, LatentGatePipeline

config = get_config("latentgate.yaml")
with LatentGatePipeline(config) as pipeline:
    result = pipeline.query("photo.jpg", "Describe this")

Variáveis de Ambiente

Variável	Descrição	Padrão
OPENAI_API_KEY	Chave de API OpenAI	-
ANTHROPIC_API_KEY	Chave de API Anthropic	-
GOOGLE_API_KEY	Chave de API Google	-
LATENTGATE_REMOTE_PROVIDER	Substituir provedor remoto	openai
LATENTGATE_REMOTE_MODEL	Substituir modelo remoto	padrão do provedor (ex.: gpt-4o-mini, claude-sonnet-5)
LATENTGATE_VISION_MODEL	Substituir modelo de visão	llava:7b
LATENTGATE_LOG_LEVEL	Nível de log	INFO
LATENTGATE_LOG_FILE	Caminho do arquivo de log	-
LATENTGATE_LOG_JSON	Formato de log JSON	false
LATENTGATE_TRACK_COSTS	Habilitar análise de custos	false
LATENTGATE_COST_DB_PATH	Caminho para o banco SQLite	.latentgate_costs.db
LATENTGATE_API_KEY	Exigir Authorization: Bearer <key> na API (incl. /compress; clientes WebSocket podem passar ?api_key=)	não definido (aberto)
LATENTGATE_COMPRESSION_LEVEL	Nível do otimizador de tokens: lossless, balanced, aggressive	balanced
LATENTGATE_COMPRESSION_STRATEGY	auto (otimizador + LLM local com verificação de fatos) ou deterministic	auto
LATENTGATE_TARGET_TOKEN_BUDGET	Máximo de tokens para um prompt comprimido (0 = sem orçamento)	0
LATENTGATE_MAX_OUTPUT_TOKENS	Máximo de tokens que o modelo em nuvem pode gerar por resposta	4096
LATENTGATE_PRELOAD	Pré-aquecer modelos Ollama em segundo plano na inicialização da API	true
LATENTGATE_MAX_CONCURRENT_REQUESTS	Máximo de chamadas de pipeline concorrentes no servidor de API	3
LATENTGATE_CORS_ORIGINS	Origens CORS permitidas separadas por vírgula	http://localhost:5173

Salvar Configuração

from latent_gate import PipelineConfig, save_config

config = PipelineConfig(remote_provider="anthropic", remote_model="claude-sonnet-5")
save_config(config, "my_config.yaml")

---

Docker

# Start full stack (API + Ollama)
docker compose up -d

# Pull models first (one-time setup)
docker compose --profile setup up ollama-init

# Start with monitoring (Prometheus + Grafana)
docker compose --profile monitoring up -d

# Build and run manually
docker build -t latent-gate .
docker run -p 8000:8000 latent-gate

A configuração docker-compose inclui:

• latent-gate servidor de API (porta 8000)
• Ollama servidor LLM local (porta 11434)
• ollama-init contêiner que baixa automaticamente os modelos necessários (perfil: setup)
• Prometheus coletor de métricas na porta 9090 (perfil: monitoring)
• Grafana painel na porta 3000 (perfil: monitoring, credenciais: admin/latentgate)

Stack de Monitoramento

Inicie com monitoramento:

docker compose --profile monitoring up -d

Acesse:

• Grafana: http://localhost:3000 (login: admin / latentgate)
• Prometheus: http://localhost:9090
• Endpoint de métricas: http://localhost:8000/metrics

O painel do LatentGate carrega automaticamente no Grafana com 9 painéis cobrindo taxa de requisições, percentis de latência (p50/p95/p99), economia de tokens, taxas de erro, saúde do pipeline e detalhamento por endpoint.

Personalize via variáveis de ambiente:

• GRAFANA_ADMIN — nome de usuário admin do Grafana (padrão: admin)
• GRAFANA_PASSWORD — senha do Grafana (padrão: latentgate)
• GRAFANA_ANONYMOUS — Habilitar acesso anônimo (padrão: true)
• LATENTGATE_ENABLE_METRICS — Habilitar métricas Prometheus (padrão: true)

---

Integração com Ferramentas de Codificação por IA (MCP)

O LatentGate funciona como um servidor Model Context Protocol (MCP) com todas as principais ferramentas de codificação por IA. Seu assistente de IA comprime automaticamente imagens, prompts longos e documentos antes que eles cheguem ao modelo em nuvem.

Ferramentas Suportadas

Ferramenta	Status	Configuração
VS Code / Copilot	Suportado	Extensão
Claude Desktop	Suportado	Config MCP
Claude Code (CLI)	Suportado	Skill
Cursor	Suportado	Config MCP
Cline (VS Code)	Suportado	Config MCP
Continue.dev	Suportado	Config MCP
Zed Editor	Suportado	Config MCP

Extensão VS Code

code --install-extension KathanModh259.latent-gate-vscode

Recursos:

• Clique com o botão direito em qualquer imagem para comprimir com LatentGate
• Selecione texto e pressione Ctrl+Shift+Alt+C para comprimir
• Painel de custos na barra de atividades
• Configura automaticamente MCP para Copilot Chat
• Barra de status mostrando economia de tokens

Configuração MCP

Para Claude, veja Use no Claude. Para Cursor, Cline, Continue, Zed e outros clientes MCP, use o mesmo comando de servidor:

{
  "mcpServers": {
    "latent-gate": {
      "command": "uvx",
      "args": ["--from", "latent-gate[mcp,tokens]", "latent-gate-mcp"]
    }
  }
}

Ou instale no seu ambiente (pip install "latent-gate[mcp,tokens]") e use "command": "latent-gate-mcp". Note que o comando é latent-gate-mcp — latent-gate simples é o CLI e não falará MCP. As ferramentas de imagem e compress_* adicionalmente precisam de ollama pull llava:7b e ollama pull phi3:mini.

Veja a pasta integrations/ para guias de configuração detalhados por ferramenta.

MCP Hospedado (remoto, para gateways como mcprush)

docker build -f Dockerfile.mcp -t latent-gate-mcp .
docker run -p 8000:8000 -e LATENTGATE_API_KEY=change-me latent-gate-mcp
# or without Docker:  latent-gate mcp --http --port 8000

Serve HTTP transmissível em /mcp (sem estado, então qualquer instância pode responder a qualquer solicitação) e /health. Como é remoto, também funciona onde servidores MCP locais não podem rodar: claude.ai na web e em dispositivos móveis, e qualquer cliente que aceite apenas uma URL de conector. A principal ferramenta lá é fetch_url_optimized. Ela busca uma página, API JSON ou log bruto por URL e retorna o texto visível, compactado e deduplicado sem um modelo de sumarização. Endereços que não são públicos (localhost, 10.x, metadados de nuvem) são recusados, e isso é verificado na conexão ativa, então truques de DNS não contornam isso. Neste modo:

• read_file_optimized, compress_image e get_stats ficam ocultos. Os dois primeiros leriam o disco do servidor, e estatísticas misturariam o uso de todos os chamadores.
• As ferramentas compress_* são listadas apenas quando LATENTGATE_HOSTED_OLLAMA=1 (o host executa Ollama).
• A entrada de cada chamada é limitada a 2MB.
• Com LATENTGATE_API_KEY definido, as solicitações precisam de Authorization: Bearer <key>. Dê a chave ao seu gateway e a mais ninguém, para que chamadores não possam contornar o plano pago.

Variável de ambiente	Padrão	Finalidade
LATENTGATE_API_KEY	não definido (aberto, avisa)	Chave Bearer que o gateway deve enviar
LATENTGATE_HOSTED_OLLAMA	desligado	Expõe as ferramentas compress_* baseadas em Ollama
PORT	8000	Porta de escuta (a maioria dos hosts define isso)

---

Otimizações de Velocidade

Otimização	O Que Faz	Impacto
Pooling de Conexões	Reutiliza conexões HTTP via requests.Session	~30-50% mais rápido por chamada
Pré-carregamento de Modelos	Aquece modelos Ollama na inicialização (keep_alive)	Elimina inicialização a frio de 5-15s
Prompts Mais Curtos	Prompts de extração otimizados produzem menos tokens de saída	~20% de geração mais rápida
Parsing JSON em 3 Camadas	Parse rápido, extração de texto, fallback com LLM	Evita chamada LLM lenta 90% das vezes
Processamento Paralelo	Imagem e texto processados simultaneamente via ThreadPool	~40% mais rápido em consultas combinadas
Cache por Hash de Conteúdo	Cache em disco para imagens repetidas	Instantâneo em cache hit
Decodificação Seletiva	Similaridade de cosseno pula chamadas de API redundantes	~2,85x menos chamadas

---

Benchmarks de Custo

Consultas de Imagem (por provedor, estimado)

Estimativas das fórmulas de tokens de imagem publicadas por cada provedor versus uma descrição local de ~150 tokens.

Provedor	Tokens de Imagem Brutos	Tokens LatentGate	Economia
OpenAI GPT-4o (alta qualidade)	~1.105	~150	~86%
Claude 3.5 Sonnet (imagem 1MP)	~1.334	~150	~89%
Gemini 2.0 Flash	~258	~150	~42%

Texto: medido, reproduzível

Otimizador determinístico em entradas realistas integradas, contado com tiktoken (o200k_base). Fatos mantidos = parcela de números, identificadores, URLs, nomes de arquivos e código preservados literalmente. Reproduza com latent-gate --optimizer-benchmark (sem necessidade de Ollama ou chave de API).

Entrada	Tokens	lossless	balanced (padrão)	aggressive
API JSON formatada	1.407	−33%, fatos 100%	−33%, fatos 100%	−33%, fatos 100%
60 linhas de log repetidas + rastreamento	2.235	0%	−92% (intervalos mantidos)	−92%
Prompt colado 3×	121	−61%, fatos 100%	−61%, fatos 100%	−61%, fatos 100%
Especificação detalhada com 6 requisitos	127	0%	−20%, fatos 100%	−51%, fatos 90%
Solicitação de revisão de código	57	−5%	−16%, fatos 100%	−28%, fatos 100%
5 chunks RAG + pergunta	190	0%	−58% (2 documentos relevantes mantidos)	−58%
Total	4.137	−13%, fatos 100%	−66%	−67%

Logs perdem ids/timestamps individuais quando dobrados (a dobra mantém primeiro, último e intervalos de valores), e RAG descarta fatos de documentos irrelevantes para a pergunta — ambos por design.

Como funciona (estágio mais seguro primeiro; veja latent_gate/optimizer.py):

1. Proteger blocos de código, código inline, URLs e strings entre aspas — restaurados byte a byte
2. Sem perdas: limpeza de espaços em branco/Unicode, minificação JSON (valores intocados), dobra de duplicatas
3. Dobra de logs: sequências de linhas de log que diferem apenas em números/ids → primeiro, último e intervalos
4. Enchimento: meras cortesias ("Oi!", "Obrigado desde já!") e frases de evasão removidas
5. Seleção (apenas acima de um orçamento, ou aggressive): relevância BM25 à pergunta + pistas de requisitos, ordem original preservada, a solicitação real do usuário nunca é descartada

Garantias: a saída nunca tem mais tokens que a entrada; mesma entrada → mesma saída (então o cache de prompts do provedor continua funcionando); quando uma reescrita com LLM local é usada, ela deve ser menor e manter cada fato, caso contrário o resultado determinístico é enviado.

from latent_gate import optimize

r = optimize(long_prompt, question="What failed?", level="balanced", max_tokens=2000)
print(r.optimized_tokens, r.savings_pct, r.stages)

Vídeo

A decodificação seletiva pula chamadas remotas para quadros semelhantes ao anterior (~2,85x menos chamadas em filmagens típicas).

Em Escala (10.000 consultas de imagem com gpt-4o-mini, estimado)

Métrica	Tradicional	LatentGate	Economia
Tokens de entrada	12.000.000	2.000.000	10M tokens
Custo	$1,80	$0,30	$1,50 (83%)

---

Rastreamento de Custos

from latent_gate import CostTracker

tracker = CostTracker()
tracker.record_usage(
    query_type="image",
    provider="openai",
    model="gpt-4o-mini",
    input_tokens=150,
    output_tokens=200,
    tokens_saved=1000,
    compression_ratio=6.7,
    latency_ms=1500,
)

# Session statistics
stats = tracker.get_session_statistics()
print(f"Total cost: ${stats['total_cost']:.4f}")
print(f"Tokens saved: {stats['total_tokens_saved']}")

# Cost projection
projection = tracker.get_cost_projection(
    daily_queries=1000,
    provider="openai",
    model="gpt-4o-mini"
)
print(f"Monthly savings: ${projection['savings']['monthly']:.2f}")

# Export report
tracker.export_report("usage_report.json", fmt="json")
tracker.export_report("usage_report.csv", fmt="csv")

---

Suporte a Múltiplos Idiomas

from latent_gate import detect_language, MultiLanguageProcessor

# Detect language
lang = detect_language("Esto es un texto en español")
print(f"Detected: {lang.name} ({lang.confidence:.0%})")

# Process with auto-translation to English
processor = MultiLanguageProcessor()
text, lang_info = processor.process("Texto en español para analizar")
print(f"Language: {lang_info.name}, Translated: {text[:100]}...")

---

Estrutura do Projeto

latent-gate/
├── latent_gate/
│   ├── __init__.py           # Package exports and version
│   ├── config.py             # PipelineConfig dataclass
│   ├── config_loader.py      # YAML/TOML/JSON config loading
│   ├── payload.py            # SemanticPayload (compact representation)
│   ├── text_processor.py     # TextPayload + TextProcessor (local compression)
│   ├── local_processor.py    # X-Encoder + Predictor (Ollama vision pipeline)
│   ├── remote_decoder.py     # Y-Decoder (OpenAI, Anthropic, Google, Ollama)
│   ├── selective_decoder.py  # Cosine/Jaccard similarity for skip decisions
│   ├── fast_client.py        # Connection pooling + model preloading
│   ├── cache.py              # Content-hash disk cache
│   ├── pipeline.py           # LatentGatePipeline (main orchestrator)
│   ├── async_pipeline.py     # AsyncLatentGatePipeline
│   ├── video_processor.py    # Video frame extraction + batch processing
│   ├── cost_tracker.py       # SQLite-based cost analytics
│   ├── mcp_server.py         # MCP server (Model Context Protocol)
│   ├── api_server.py         # FastAPI REST server
│   ├── cli.py                # Command-line interface
│   ├── logging_config.py     # Structured logging with rotation
│   ├── plugin_system.py      # Custom processor plugins
│   └── multilang.py          # Multi-language detection and translation
├── integrations/
│   ├── agent_skills/         # Prompt compression skill + scripts
│   ├── vscode-extension/     # VS Code extension source
│   ├── cursor/               # Cursor rules and MCP config
│   ├── continue_dev/         # Continue.dev config
│   ├── langchain/            # LangChain integration wrapper
│   ├── llamaindex/           # LlamaIndex retriever integration
│   └── openai_functions/     # OpenAI/Anthropic function schemas
├── tests/                    # 240+ tests (unit + integration)
├── website/                  # React-based analytics dashboard & landing page
├── deployments/              # Kubernetes Helm configs
├── .github/workflows/        # CI + publish workflows
├── Dockerfile
├── docker-compose.yml
├── pyproject.toml
└── requirements.txt

---

Comunidade

• Discussões no GitHub — Solicitações de recursos, perguntas e respostas, demonstrações

---

Contribuindo

Contribuições são bem-vindas! Veja CONTRIBUTING.md.

Configuração de Desenvolvimento

git clone https://github.com/KathanModh259/latent-gate.git
cd latent-gate
python -m venv .venv
source .venv/bin/activate       # Linux/macOS
.venv\Scripts\Activate.ps1      # Windows

pip install -e ".[dev]"

Executar Testes

pytest tests/ -v

Áreas Prioritárias

• Suporte adicional a modelos de visão (Florence-2, InternVL, Qwen-VL)
• Plugins de similaridade personalizados para casos de uso específicos de domínio
• Suporte a WebSocket para streaming em tempo real
• Análise avançada de custos e sugestões de otimização
• Desenvolvimento de plugins para indústrias especializadas
• Melhorias na cobertura de testes
• Documentação e exemplos

---

Citação

@software{latentgate2026,
  author  = {Kathan Modh},
  title   = {LatentGate: Local-First Semantic Compression Pipeline},
  year    = {2026},
  url     = {https://github.com/KathanModh259/latent-gate},
  version = {1.3.0}
}

Inspirado por VL-JEPA (Meta FAIR, 2025).

---

Licença

Licença Proprietária Personalizada — veja LICENSE.

---