LatentGate

---

看看它如何工作

在浏览器中试用 → 实际的优化器通过 WebAssembly 在你的 机器上运行；你粘贴的内容不会上传。

一份 400 行的错误日志，通过 LatentGate（balanced，使用 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

一行命令即可将它安装到 Claude Code，然后询问 "读取 app.log 并告诉我订单失败的原因"：

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

你可以放心依赖的特性： 相同输入始终得到相同输出（因此服务提供商的提示词缓存能正常工作）；输出永远不会比输入更大；代码块、URL 和带引号的字符串会逐字节原样返回；level="lossless" 除空白、JSON 格式和完全重复内容外，不会更改任何内容。默认级别需要权衡的地方： 相似度极高的连续行会被折叠为首行、末行和数值范围，因此折叠区段内的各个 ID 不会保留。完整语料及事实丢失的具体情况见成本基准测试，也可通过 latent-gate --optimizer-benchmark 重现。

可在 Claude Code、Claude Desktop、Cursor、Cline、Continue 和 Zed 中免费离线使用。

不想安装任何东西？ 官方的 mcprush 托管版 LatentGate 也能用于无法运行本地服务的场景，例如网页版和移动版 claude.ai。它提供免费套餐 （每月 300 次调用）和每月 $9 起的付费套餐。

---

问题

每次向 GPT-4o / Claude / Gemini 发送图像或长提示词时，你都会耗费 1,000 多个 Token 来处理本可在本地免费完成的任务。

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

---

功能

功能	描述
本地优先	视觉和文本压缩在 Ollama 上运行（免费，无需 API 密钥）
Token 优化器	确定性、保留事实的压缩：在真实开发语料上减少 66% 的 token，耗时约 1 毫秒（基准测试）
MCP 服务	适用于 Claude Desktop、Cursor、Cline、Continue、Zed
选择性解码	对于视频，仅在场景发生变化时调用 API（调用次数减少约 2.85 倍），使用余弦相似度
文本压缩	在本地压缩长提示词、对话和 RAG 文档
速度优化	连接池、模型预加载、并行处理
多提供商	OpenAI、Anthropic、Google、Groq、DeepSeek、Together、Azure、AWS Bedrock、Ollama，或任何兼容 OpenAI 的端点
REST API	用于 Web 应用集成的 FastAPI 服务
视频处理	直接输入视频文件并自动提取帧
成本跟踪	使用 SQLite 分析并支持导出报告的持久化成本跟踪
异步支持	适用于 FastAPI、aiohttp 等的非阻塞异步方法
流式响应	从远程大模型流式传输响应
配置持久化	支持环境变量覆盖的 YAML/TOML 配置文件
结构化日志记录	支持轮转和关联 ID 的 JSON 格式日志记录
Docker 支持	提供 Dockerfile 和 docker-compose，便于部署
插件系统	用于特定领域压缩的自定义处理器
多语言	支持 30 多种语言并自动检测

---

在 Claude 中使用

LatentGate 作为 MCP 服务接入 Claude。它的优化器工具可离线工作，无需 Ollama，也无需 API 密钥——Claude 可通过它读取大型日志、JSON 转储和文档，只消耗一小部分上下文。400 行的错误日志可从 14,400 个 token 压缩到约 100 个。

需要 uv（首次运行时，uvx 会从 PyPI 获取 LatentGate）。 首次运行会下载依赖项；在网络较慢时，这可能超过 Claude 的 30 秒 MCP 启动时限。请预先运行一次（之后启动约需 2 秒）：

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

Claude Code — 插件（MCP 服务 + 告诉 Claude 何时使用它的技能）：

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

Claude Code — 仅 MCP 服务：

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

任意 Agent — 从 Agensi 市场获取： LatentGate Context Saver 是适用于 Claude Code、Cursor、Codex CLI 和其他 20 多种 Agent 的官方技能。如果缺少 LatentGate，它会进行设置；它适用于本地版和托管版，并会告诉你的 Agent 何时使用它。

Claude Desktop — 将其添加到 claude_desktop_config.json 并重启：

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

然后只需提问：“使用 latent-gate 读取 logs/app.log，并告诉我订单失败的原因。”

工具	是否需要 Ollama	功能
read_file_optimized	否	读取文本文件并返回优化后的内容（用于读取文件，不用于编辑文件）
optimize_text	否	优化已有文本，可选择针对 question / max_tokens 预算进行优化
count_tokens	否	统计 token 数量（tiktoken o200k_base）
compress_image	是	在本地描述图像，生成约 150 个 token 的场景内容
compress_text / compress_conversation / compress_documents	是	优化器 + 经过事实核查的本地大模型压缩
get_stats	是	会话统计信息

---

快速开始

安装

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

拉取 Ollama 模型

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

一键快速启动

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

这会启动所有组件：Ollama → 拉取模型 → API 服务 → 网站。有关 --no-pull、--no-website、--port 9000 等选项，请参阅 scripts/quickstart.sh。

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

生产环境加固

对于 API 部署，请将直接读取图像路径的范围限制在可信目录内：

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

发布前进行基准测试，确保速度和节省量是经过测量的，而非凭空猜测：

latent-gate --benchmark --json

---

Python API

图像查询

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

文本压缩

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

批处理

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

流式处理

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

---

REST API

启动服务

# 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

端点

方法	端点	说明
GET	/health	健康检查（Ollama 连接状态）
GET	/stats	会话使用统计
POST	/query/image	图像查询
POST	/query/text	文本压缩
POST	/query/conversation	对话压缩
POST	/query/documents	RAG 文档压缩
POST	/query/universal	自动检测输入类型
POST	/query/image/upload	上传图像以进行查询

请求示例

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

---

异步支持

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

---

视频处理

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

---

配置

配置文件

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

环境变量

变量	说明	默认值
OPENAI_API_KEY	OpenAI API 密钥	-
ANTHROPIC_API_KEY	Anthropic API 密钥	-
GOOGLE_API_KEY	Google API 密钥	-
LATENTGATE_REMOTE_PROVIDER	覆盖远程提供方	openai
LATENTGATE_REMOTE_MODEL	覆盖远程模型	提供方默认值（例如 gpt-4o-mini、claude-sonnet-5）
LATENTGATE_VISION_MODEL	覆盖视觉模型	llava:7b
LATENTGATE_LOG_LEVEL	日志级别	INFO
LATENTGATE_LOG_FILE	日志文件路径	-
LATENTGATE_LOG_JSON	JSON 日志格式	false
LATENTGATE_TRACK_COSTS	启用成本分析	false
LATENTGATE_COST_DB_PATH	SQLite 数据库路径	.latentgate_costs.db
LATENTGATE_API_KEY	要求在 API（包括 /compress）中使用 Authorization: Bearer <key>；WebSocket 客户端可传递 ?api_key=	未设置（开放）
LATENTGATE_COMPRESSION_LEVEL	令牌优化级别：lossless、balanced、aggressive	balanced
LATENTGATE_COMPRESSION_STRATEGY	auto（优化器 + 经事实核查的本地 LLM）或 deterministic	auto
LATENTGATE_TARGET_TOKEN_BUDGET	压缩后提示词的最大令牌数（0 = 无预算限制）	0
LATENTGATE_MAX_OUTPUT_TOKENS	云端模型每次回答可生成的最大令牌数	4096
LATENTGATE_PRELOAD	API 启动时在后台预热 Ollama 模型	true
LATENTGATE_MAX_CONCURRENT_REQUESTS	API 服务中的最大并发管道调用数	3
LATENTGATE_CORS_ORIGINS	以逗号分隔的允许跨域来源	http://localhost:5173

保存配置

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

docker-compose 配置包含：

• latent-gate API 服务（端口 8000）
• Ollama 本地 LLM 服务（端口 11434）
• ollama-init 容器，会自动拉取所需模型（配置文件：setup）
• Prometheus 指标收集器，运行于端口 9090（配置文件：monitoring）
• Grafana 仪表板，运行于端口 3000（配置文件：monitoring，凭据：admin/latentgate）

监控栈

启动监控：

docker compose --profile monitoring up -d

访问：

• Grafana： http://localhost:3000（登录：`admin` / latentgate）
• Prometheus： http://localhost:9090
• 指标端点： http://localhost:8000/metrics

LatentGate 仪表板会自动加载到 Grafana 中，包含 9 个面板，涵盖请求速率、延迟百分位数（p50/p95/p99）、令牌节省量、错误率、管道健康状况和端点细分。

通过环境变量自定义：

• GRAFANA_ADMIN — Grafana 管理员用户名（默认值：admin）
• GRAFANA_PASSWORD — Grafana 密码（默认值：latentgate）
• GRAFANA_ANONYMOUS — 启用匿名访问（默认值：true）
• LATENTGATE_ENABLE_METRICS — 启用 Prometheus 指标（默认值：true）

---

AI 编码工具集成（MCP）

LatentGate 可作为模型上下文协议（MCP）服务与所有主流 AI 编码工具配合使用。你的 AI 助手会在图像、长提示词和文档发送到云端模型之前自动压缩它们。

支持的工具

工具	状态	配置方式
VS Code / Copilot	支持	扩展
Claude Desktop	支持	MCP 配置
Claude Code (CLI)	支持	Skill
Cursor	支持	MCP 配置
Cline (VS Code)	支持	MCP 配置
Continue.dev	支持	MCP 配置
Zed Editor	支持	MCP 配置

VS Code 扩展

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

功能：

• 右键点击任意图片即可用 LatentGate 压缩
• 选中文本并按 Ctrl+Shift+Alt+C 进行压缩
• 活动栏中的成本仪表盘
• 自动为 Copilot Chat 配置 MCP
• 状态栏显示节省的 token

MCP 配置

Claude 请参见在 Claude 中使用。Cursor、Cline、Continue、Zed 及其他 MCP 客户端，请使用相同的服务命令：

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

或将其安装到你的环境中（pip install "latent-gate[mcp,tokens]"），然后使用 "command": "latent-gate-mcp"。注意命令是 latent-gate-mcp——单纯的 latent-gate 是命令行工具，不会说 MCP。图像工具和 compress_* 工具还需要 ollama pull llava:7b 和 ollama pull phi3:mini。

各工具的详细配置指南请参见 integrations/ 文件夹。

托管 MCP（远程，适用于 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

在 /mcp 提供可流式 HTTP（无状态，因此任何实例都能应答任何请求），并在 /health 提供健康检查。由于它是远程的，它也能在本地 MCP 服务无法运行的地方工作：网页版和 移动端的 claude.ai，以及任何只接受连接器 URL 的客户端。那里的主要工具是 fetch_url_optimized。它通过 URL 抓取页面、JSON API 或原始日志，并返回可见文本， 经过压缩和去重，无需摘要模型。非公网地址 （localhost、10.x、云元数据）会被拒绝，而且这是在实时连接上检查的，因此 DNS 技巧无法绕过。在此模式下：

• read_file_optimized、compress_image 和 get_stats 被隐藏。前两个会 读取服务端的磁盘，而统计信息会混入所有调用者的用量。
• compress_* 工具仅在 LATENTGATE_HOSTED_OLLAMA=1（主机运行 Ollama）时列出。
• 每次调用的输入上限为 2MB。
• 设置了 LATENTGATE_API_KEY 后，请求需要 Authorization: Bearer <key>。只把密钥 给你的网关，不要给别人，这样调用者就无法绕过付费方案。

环境变量	默认值	用途
LATENTGATE_API_KEY	未设置（开放，会警告）	网关必须发送的 Bearer 密钥
LATENTGATE_HOSTED_OLLAMA	关闭	暴露由 Ollama 支持的 compress_* 工具
PORT	8000	监听端口（大多数主机会设置此项）

---

速度优化

优化	作用	效果
连接池	通过 requests.Session 复用 HTTP 连接	每次调用约快 30-50%
模型预加载	初始化时预热 Ollama 模型（keep_alive）	消除 5-15 秒冷启动
更短的提示词	优化的提取提示词产生更少的输出 token	生成速度约快 20%
三级 JSON 解析	快速解析、从文本提取、大模型兜底	90% 的情况下避免缓慢的大模型调用
并行处理	通过 ThreadPool 同时处理图像和文本	组合查询约快 40%
内容哈希缓存	对重复图片进行磁盘缓存	缓存命中时即时返回
选择性解码	余弦相似度跳过冗余 API 调用	调用次数约减少 2.85 倍

---

成本基准

图像查询（按提供商估算）

根据各提供商公布的图像 token 公式与约 150 token 的本地描述进行估算。

提供商	原始图像 Token	LatentGate Token	节省
OpenAI GPT-4o（高细节）	~1,105	~150	~86%
Claude 3.5 Sonnet（1MP 图像）	~1,334	~150	~89%
Gemini 2.0 Flash	~258	~150	~42%

文本：可测量、可复现

在内置的真实输入上运行确定性优化器，使用 tiktoken（o200k_base）计数。 保留的事实 = 逐字保留的数字、标识符、URL、文件名和代码所占比例。 可通过 latent-gate --optimizer-benchmark 复现（无需 Ollama 或 API key）。

输入	Token 数	lossless	balanced（默认）	aggressive
格式化输出的 API JSON	1,407	−33%，事实 100%	−33%，事实 100%	−33%，事实 100%
60 行重复日志 + trace	2,235	0%	−92%（保留区间）	−92%
重复粘贴 3 次的提示词	121	−61%，事实 100%	−61%，事实 100%	−61%，事实 100%
含 6 条需求的冗长规格	127	0%	−20%，事实 100%	−51%，事实 90%
代码审查请求	57	−5%	−16%，事实 100%	−28%，事实 100%
5 个 RAG 分块 + 问题	190	0%	−58%（保留 2 篇相关文档）	−58%
总计	4,137	−13%，事实 100%	−66%	−67%

日志在折叠时会丢失单独的 id/时间戳（折叠保留首条、末条和数值区间）， RAG 会丢弃与问题无关文档中的事实——两者均为有意设计。

工作原理（从最安全的阶段开始；参见 latent_gate/optimizer.py）：

1. 保护代码块、行内代码、URL 和引用字符串——逐字节还原
2. 无损：空白/Unicode 清理、JSON 压缩（值不变）、重复折叠
3. 日志折叠：仅在数字/id 上不同的连续日志行 → 首条、末条和区间
4. 填充内容：纯客套话（“Hi!”、“Thanks in advance!”）和模糊措辞被移除
5. 筛选（仅在超出预算时，或 aggressive 模式）：BM25 问题相关度 + 需求线索， 保留原始顺序，用户的真正诉求绝不会被丢弃

保证：输出 token 数绝不会多于输入；相同输入 → 相同输出（因此提供商的提示词 缓存能持续生效）；当使用本地大模型改写时，改写结果必须更小 且 保留每一条事实， 否则就发送确定性结果。

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)

视频

选择性解码会跳过与上一帧相似的帧的远程调用（在典型素材上调用次数约减少 2.85×）。

规模化（10,000 次图像查询，使用 gpt-4o-mini，估算值）

指标	传统方式	LatentGate	节省
输入 token	12,000,000	2,000,000	10M token
成本	$1.80	$0.30	$1.50（83%）

---

成本跟踪

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

---

多语言支持

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

---

项目结构

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

---

社区

• GitHub Discussions — 功能请求、问答、展示

---

贡献

欢迎贡献！请参阅 CONTRIBUTING.md。

开发环境设置

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

运行测试

pytest tests/ -v

优先领域

• 支持更多视觉模型（Florence-2、InternVL、Qwen-VL）
• 面向特定领域用例的自定义相似度插件
• 用于实时流式传输的 WebSocket 支持
• 高级成本分析和优化建议
• 面向专业行业的插件开发
• 提升测试覆盖率
• 文档和示例

---

引用

@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}
}

灵感来自 VL-JEPA（Meta FAIR，2025）。

---

许可证

自定义专有许可证——请参阅 LICENSE。

---