LatentGate

---

Véalo funcionar

Pruébelo en su navegador → El optimizador real se ejecuta en su máquina vía WebAssembly; nada de lo que pegue se sube.

Un log de errores de 400 líneas, leído a través de LatentGate (balanced, medido con 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

Instálelo en Claude Code en una línea, luego pregunte "lee app.log y dime por qué fallan los pedidos":

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

En lo que puede confiar: la misma entrada siempre produce la misma salida (para que el caché de prompts del proveedor siga funcionando); la salida nunca es más grande que la entrada; los bloques de código, URLs y cadenas entre comillas vuelven byte por byte; level="lossless" no cambia nada más que espacios en blanco, formato JSON y duplicados exactos. Lo que se sacrifica en el nivel predeterminado: las secuencias de líneas casi idénticas se pliegan a primera, última y rangos de valores, por lo que los IDs individuales dentro de una secuencia plegada no se conservan. El corpus completo, incluido dónde pierde datos, está en Cost Benchmarks y es reproducible con latent-gate --optimizer-benchmark.

Funciona en Claude Code, Claude Desktop, Cursor, Cline, Continue y Zed, gratis y offline.

¿No quiere instalar nada? El LatentGate alojado oficial en mcprush también funciona donde los servidores locales no pueden, como claude.ai en la web y móvil. Tiene un nivel gratuito (300 llamadas al mes) y planes de pago desde $9/mes.

---

El Problema

Cada vez que envía una imagen o un prompt largo a GPT-4o / Claude / Gemini, quema 1,000+ tokens en procesamiento que podría hacerse localmente y gratis.

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

---

Características

Característica	Descripción
Local-Primero	La compresión de visión y texto se ejecuta en Ollama (gratis, sin clave API)
Optimizador de Tokens	Compresión determinista y que preserva hechos: 66% menos tokens en un corpus de desarrollo realista en ~1ms (benchmark)
Servidor MCP	Funciona con Claude Desktop, Cursor, Cline, Continue, Zed
Decodificación Selectiva	Para video, solo llama a la API cuando cambia la escena (~2.85x menos llamadas) con similitud de coseno
Compresión de Texto	Prompts largos, conversaciones, documentos RAG comprimidos localmente
Optimizado para Velocidad	Pooling de conexiones, precarga de modelos, procesamiento paralelo
Multi-Proveedor	OpenAI, Anthropic, Google, Groq, DeepSeek, Together, Azure, AWS Bedrock, Ollama, o cualquier endpoint compatible con OpenAI
API REST	Servidor FastAPI para integración con aplicaciones web
Procesamiento de Video	Entrada directa de archivos de video con extracción automática de fotogramas
Seguimiento de Costos	Seguimiento persistente de costos con análisis SQLite y reportes exportables
Soporte Async	Métodos asíncronos no bloqueantes para FastAPI, aiohttp, etc.
Respuestas en Streaming	Transmite respuestas de LLMs remotos
Persistencia de Configuración	Archivos de configuración YAML/TOML con anulaciones de variables de entorno
Registro Estructurado	Registro en formato JSON con rotación e IDs de correlación
Soporte Docker	Dockerfile y docker-compose para despliegue fácil
Sistema de Plugins	Procesadores personalizados para compresión específica de dominio
Multilingüe	Soporte para 30+ idiomas con detección automática

---

Úselo en Claude

LatentGate se conecta a Claude como un servidor MCP. Sus herramientas de optimización funcionan offline, sin Ollama y sin clave API — Claude lee logs grandes, volcados JSON y documentos a través de él y gasta una fracción del contexto. Un log de errores de 400 líneas pasa de 14,400 a ~100 tokens.

Requiere uv (uvx descarga LatentGate desde PyPI en la primera ejecución). La primera ejecución descarga dependencias, lo que puede exceder el límite de inicio MCP de 30 segundos de Claude en una conexión lenta; ejecute esto una vez de antemano (los inicios posteriores toman ~2s):

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

Claude Code — plugin (servidor MCP + una skill que le dice a Claude cuándo usarlo):

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

Claude Code — solo servidor MCP:

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

Cualquier agente — desde el marketplace de Agensi: LatentGate Context Saver es la skill oficial para Claude Code, Cursor, Codex CLI y más de 20 otros agentes. Configura LatentGate si falta, funciona con las ediciones local y alojada, y le dice a su agente cuándo usarlo.

Claude Desktop — agregue a claude_desktop_config.json y reinicie:

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

Luego solo pregunte: "Lee logs/app.log con latent-gate y dime por qué fallan los pedidos."

Herramienta	Necesita Ollama	Qué hace
read_file_optimized	no	Lee un archivo de texto y devuelve su forma optimizada (úselo para archivos que lee, no para archivos que edita)
optimize_text	no	Optimiza texto que ya tiene, opcionalmente hacia un presupuesto de question / max_tokens
count_tokens	no	Cuenta tokens (tiktoken o200k_base)
compress_image	sí	Describe una imagen localmente como un payload de escena de ~150 tokens
compress_text / compress_conversation / compress_documents	sí	Optimizador + compresión LLM local verificada por hechos
get_stats	sí	Estadísticas de sesión

---

Inicio Rápido

Instalación

# 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]

Descargar Modelos Ollama

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

Inicio Rápido con Un Comando

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

Esto inicia todo: Ollama → descarga modelos → servidor API → sitio web. Vea scripts/quickstart.sh para opciones como --no-pull, --no-website, --port 9000.

Uso 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

Endurecimiento de Producción

Para despliegues de API, restrinja las lecturas directas de rutas de imagen a directorios de confianza:

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

Haga benchmarks antes de los lanzamientos para que la velocidad y los ahorros se midan, no se adivinen:

latent-gate --benchmark --json

---

API de Python

Consulta de Imagen

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']}")

Compresión 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")

Procesamiento por Lotes

# 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	Descripción
GET	/health	Verificación de salud (estado de conexión a Ollama)
GET	/stats	Estadísticas de uso de sesión
POST	/query/image	Consulta de imagen
POST	/query/text	Compresión de texto
POST	/query/conversation	Compresión de conversación
POST	/query/documents	Compresión de documentos RAG
POST	/query/universal	Auto-detección de tipo de entrada
POST	/query/image/upload	Subir imagen para consulta

Ejemplos de Solicitudes

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, ...}

---

Soporte Async

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())

---

Procesamiento de Video

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']}")

---

Configuración

Archivo de Configuración

# 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")

Variables de Entorno

Variable	Descripción	Predeterminado
OPENAI_API_KEY	Clave API de OpenAI	-
ANTHROPIC_API_KEY	Clave API de Anthropic	-
GOOGLE_API_KEY	Clave API de Google	-
LATENTGATE_REMOTE_PROVIDER	Anular proveedor remoto	openai
LATENTGATE_REMOTE_MODEL	Anular modelo remoto	predeterminado del proveedor (p. ej. gpt-4o-mini, claude-sonnet-5)
LATENTGATE_VISION_MODEL	Anular modelo de visión	llava:7b
LATENTGATE_LOG_LEVEL	Nivel de registro	INFO
LATENTGATE_LOG_FILE	Ruta del archivo de registro	-
LATENTGATE_LOG_JSON	Formato de registro JSON	false
LATENTGATE_TRACK_COSTS	Habilitar análisis de costos	false
LATENTGATE_COST_DB_PATH	Ruta a la base de datos SQLite	.latentgate_costs.db
LATENTGATE_API_KEY	Requerir Authorization: Bearer <key> en la API (incl. /compress; los clientes WebSocket pueden pasar ?api_key=)	sin configurar (abierto)
LATENTGATE_COMPRESSION_LEVEL	Nivel del optimizador de tokens: lossless, balanced, aggressive	balanced
LATENTGATE_COMPRESSION_STRATEGY	auto (optimizador + LLM local verificado por hechos) o deterministic	auto
LATENTGATE_TARGET_TOKEN_BUDGET	Máximo de tokens para un prompt comprimido (0 = sin presupuesto)	0
LATENTGATE_MAX_OUTPUT_TOKENS	Máximo de tokens que el modelo en la nube puede generar por respuesta	4096
LATENTGATE_PRELOAD	Calentar modelos Ollama en segundo plano al iniciar la API	true
LATENTGATE_MAX_CONCURRENT_REQUESTS	Máximo de llamadas de pipeline concurrentes en el servidor API	3
LATENTGATE_CORS_ORIGINS	Orígenes CORS permitidos separados por comas	http://localhost:5173

Guardar Configuración

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

La configuración de docker-compose incluye:

• latent-gate servidor API (puerto 8000)
• Ollama servidor LLM local (puerto 11434)
• ollama-init contenedor que descarga automáticamente los modelos requeridos (perfil: setup)
• Prometheus recolector de métricas en el puerto 9090 (perfil: monitoring)
• Grafana panel en el puerto 3000 (perfil: monitoring, credenciales: admin/latentgate)

Stack de Monitoreo

Inicie con monitoreo:

docker compose --profile monitoring up -d

Acceso:

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

El panel de LatentGate se carga automáticamente en Grafana con 9 paneles que cubren tasa de solicitudes, percentiles de latencia (p50/p95/p99), ahorro de tokens, tasas de error, salud del pipeline y desglose por endpoint.

Personalice mediante variables de entorno:

• GRAFANA_ADMIN — nombre de usuario admin de Grafana (predeterminado: admin)
• GRAFANA_PASSWORD — contraseña de Grafana (predeterminado: latentgate)
• GRAFANA_ANONYMOUS — Habilitar acceso anónimo (predeterminado: true)
• LATENTGATE_ENABLE_METRICS — Habilitar métricas de Prometheus (predeterminado: true)

---

Integración con Herramientas de Codificación IA (MCP)

LatentGate funciona como un servidor de Protocolo de Contexto de Modelo (MCP) con cada herramienta importante de codificación IA. Su asistente IA comprime automáticamente imágenes, prompts largos y documentos antes de que lleguen al modelo en la nube.

Herramientas Soportadas

Herramienta	Estado	Configuración
VS Code / Copilot	Soportado	Extensión
Claude Desktop	Soportado	Config MCP
Claude Code (CLI)	Soportado	Skill
Cursor	Soportado	Config MCP
Cline (VS Code)	Soportado	Config MCP
Continue.dev	Soportado	Config MCP
Zed Editor	Soportado	Config MCP

Extensión de VS Code

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

Características:

• Haga clic derecho en cualquier imagen para comprimirla con LatentGate
• Seleccione texto y presione Ctrl+Shift+Alt+C para comprimir
• Panel de costos en la barra de actividades
• Auto-configura MCP para Copilot Chat
• Barra de estado que muestra el ahorro de tokens

Configuración MCP

Para Claude, vea Úselo en Claude. Para Cursor, Cline, Continue, Zed y otros clientes MCP, use el mismo comando de servidor:

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

O instálelo en su entorno (pip install "latent-gate[mcp,tokens]") y use "command": "latent-gate-mcp". Nota: el comando es latent-gate-mcp — el simple latent-gate es el CLI y no hablará MCP. Las herramientas de imagen y compress_* adicionalmente necesitan ollama pull llava:7b y ollama pull phi3:mini.

Vea la carpeta integrations/ para guías de configuración detalladas por herramienta.

MCP Alojado (remoto, para pasarelas 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

Sirve HTTP transmisible en /mcp (sin estado, por lo que cualquier instancia puede responder cualquier solicitud) y /health. Como es remoto, también funciona donde los servidores MCP locales no pueden ejecutarse: claude.ai en la web y móvil, y cualquier cliente que solo acepte una URL de conector. La herramienta principal allí es fetch_url_optimized. Obtiene una página, API JSON o registro sin procesar por URL y devuelve el texto visible, compactado y deduplicado sin un modelo de resumen. Las direcciones que no son públicas (localhost, 10.x, metadatos de nube) se rechazan, y eso se verifica en la conexión en vivo, por lo que los trucos de DNS no lo evitan. En este modo:

• read_file_optimized, compress_image y get_stats están ocultos. Los dos primeros leerían el disco del servidor, y las estadísticas mezclarían el uso de todos los llamadores.
• Las herramientas compress_* se listan solo cuando LATENTGATE_HOSTED_OLLAMA=1 (el host ejecuta Ollama).
• La entrada de cada llamada está limitada a 2MB.
• Con LATENTGATE_API_KEY configurado, las solicitudes necesitan Authorization: Bearer <key>. Dale la clave a tu puerta de enlace y a nadie más, para que los llamadores no puedan evitar el plan de pago.

Variable de entorno	Predeterminado	Propósito
LATENTGATE_API_KEY	sin configurar (abierto, advierte)	Clave Bearer que la puerta de enlace debe enviar
LATENTGATE_HOSTED_OLLAMA	desactivado	Expone las herramientas compress_* respaldadas por Ollama
PORT	8000	Puerto de escucha (la mayoría de los hosts lo configuran)

---

Optimizaciones de Velocidad

Optimización	Qué Hace	Impacto
Agrupación de Conexiones	Reutiliza conexiones HTTP mediante requests.Session	~30-50% más rápido por llamada
Precarga de Modelos	Calienta modelos de Ollama al iniciar (keep_alive)	Elimina el arranque en frío de 5-15s
Prompts Más Cortos	Los prompts de extracción optimizados producen menos tokens de salida	~20% más rápido en generación
Análisis JSON de 3 Niveles	Análisis rápido, extracción de texto, respaldo LLM	Evita llamadas LLM lentas el 90% del tiempo
Procesamiento Paralelo	Imagen y texto procesados simultáneamente mediante ThreadPool	~40% más rápido en consultas combinadas
Caché por Hash de Contenido	Caché en disco para imágenes repetidas	Instantáneo en acierto de caché
Decodificación Selectiva	Similitud de coseno omite llamadas API redundantes	~2.85x menos llamadas

---

Benchmarks de Costos

Consultas de Imagen (por proveedor, estimado)

Estimaciones de las fórmulas de tokens de imagen publicadas por cada proveedor frente a una descripción local de ~150 tokens.

Proveedor	Tokens de Imagen Crudos	Tokens LatentGate	Ahorro
OpenAI GPT-4o (alto detalle)	~1,105	~150	~86%
Claude 3.5 Sonnet (imagen 1MP)	~1,334	~150	~89%
Gemini 2.0 Flash	~258	~150	~42%

Texto: medido, reproducible

Optimizador determinista en entradas realistas integradas, contado con tiktoken (o200k_base). Hechos conservados = proporción de números, identificadores, URLs, nombres de archivo y código preservados textualmente. Reproducir con latent-gate --optimizer-benchmark (no se necesita Ollama ni clave API).

Entrada	Tokens	lossless	balanced (predeterminado)	aggressive
API JSON con formato bonito	1,407	−33%, hechos 100%	−33%, hechos 100%	−33%, hechos 100%
60 líneas de registro repetidas + traza	2,235	0%	−92% (rangos conservados)	−92%
Prompt pegado 3×	121	−61%, hechos 100%	−61%, hechos 100%	−61%, hechos 100%
Especificación verbosa con 6 requisitos	127	0%	−20%, hechos 100%	−51%, hechos 90%
Solicitud de revisión de código	57	−5%	−16%, hechos 100%	−28%, hechos 100%
5 fragmentos RAG + pregunta	190	0%	−58% (2 documentos relevantes conservados)	−58%
Total	4,137	−13%, hechos 100%	−66%	−67%

Los registros pierden ids/marcas de tiempo individuales al plegarse (el plegado conserva el primero, el último y los rangos de valores), y RAG descarta hechos de documentos irrelevantes para la pregunta — ambos por diseño.

Cómo funciona (la etapa más segura primero; ver latent_gate/optimizer.py):

1. Proteger bloques de código, código en línea, URLs y cadenas entre comillas — restaurados byte por byte
2. Sin pérdida: limpieza de espacios en blanco/Unicode, minificación JSON (valores intactos), plegado de duplicados
3. Plegado de registros: secuencias de líneas de registro que difieren solo en números/ids → primero, último y rangos
4. Relleno: cortesías puras ("¡Hola!", "¡Gracias de antemano!") y frases de evasión eliminadas
5. Selección (solo sobre un presupuesto, o aggressive): relevancia de pregunta BM25 + señales de requisitos, orden original conservado, la solicitud real del usuario nunca se descarta

Garantías: la salida nunca tiene más tokens que la entrada; misma entrada → misma salida (para que el caché de prompts del proveedor siga funcionando); cuando se usa una reescritura LLM local, debe ser más pequeña y conservar cada hecho, de lo contrario se envía el resultado determinista.

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)

Video

La decodificación selectiva omite llamadas remotas para fotogramas similares al anterior (~2.85x menos llamadas en metraje típico).

A Escala (10,000 consultas de imagen con gpt-4o-mini, estimado)

Métrica	Tradicional	LatentGate	Ahorro
Tokens de entrada	12,000,000	2,000,000	10M tokens
Costo	$1.80	$0.30	$1.50 (83%)

---

Seguimiento de Costos

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")

---

Soporte Multi-Idioma

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]}...")

---

Estructura del Proyecto

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

---

Comunidad

• Discusiones de GitHub — Solicitudes de funciones, preguntas y respuestas, demostraciones

---

Contribuciones

¡Las contribuciones son bienvenidas! Ver CONTRIBUTING.md.

Configuración de Desarrollo

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]"

Ejecutar Pruebas

pytest tests/ -v

Áreas Prioritarias

• Soporte adicional de modelos de visión (Florence-2, InternVL, Qwen-VL)
• Plugins de similitud personalizados para casos de uso específicos de dominio
• Soporte WebSocket para transmisión en tiempo real
• Análisis avanzado de costos y sugerencias de optimización
• Desarrollo de plugins para industrias especializadas
• Mejoras en la cobertura de pruebas
• Documentación y ejemplos

---

Cita

@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).

---

Licencia

Licencia Propietaria Personalizada — ver LICENSE.

---