← Back to directory
L

Lm

Community
Offload routine tasks from Claude Code to local or cloud LLMs to save token spend.
Category
Dev Tools #227 of 438
Stars
★ 121 Very popular
Transport
stdio (local process)
Runtime
Node.js 22.5+
Credentials
Optional API key
License
Apache-2.0
Last commit
Tools
8
52FMRS · D

Houtini LM offers a practical token-saving solution for Claude Code users by offloading bounded tasks to local or cloud LLMs. It provides automatic model routing, performance tracking, and structured output support, significantly reducing Claude token consumption. It is a valuable tool for developers looking to control costs, but careful attention is needed regarding security risks and proper configuration.

Strongest · Documentation 15/20 Weakest · Reliability 6/20

Reliability
6/20
Security and permissions
9/20
Maintenance
9/20
Documentation
15/20
Setup experience
13/20
Why each score
Reliability 6/20
Only the README and server.json are supplied; no source, CI, or committed tests can verify behavior. The happy path described (npx start, OpenAI-compatible endpoint, eight tools) is plausible, but the init/tool-list handshake, streaming, and error handling cannot be confirmed from source. The README license badge (Apache-2.0) contradicts the repository's MIT license, and the manifest repository URL differs from the repository name, so no score above 10 is warranted.
Security and permissions 9/20
Credentials are passed via environment variables and marked secret in the manifest; examples use placeholders and no hardcoded tokens are present. The main risk is that code_task_files can read arbitrary absolute paths by default, with only an optional HOUTINI_LM_FILE_ROOTS allowlist and no explicit confirmation mechanism; data is sent to a user-configured local or cloud endpoint, which the docs disclose. No malware, credential theft, or dangerous default operations are evident, so no red line applies, but least-privilege and confirmation/scoping are incomplete.
Maintenance 9/20
Version evolution is visible (v2.8.0/v2.9.0/v3.2.3), the npm package is at 3.2.3, and the repository is not archived with 10 open issues. However, there is no evidence of commit cadence, dependency updates, issue responsiveness, or a security-response channel. The license is inconsistent (Apache-2.0 in README vs MIT in the repository). Stars are discovery signals only and add no points.
Documentation 15/20
The README is broad and well-structured: quick start, Claude Code/Claude Desktop configs, full tool parameter tables, environment variable table, compatible endpoints, streaming/timeout behavior, performance tracking, troubleshooting links, and a self-test section. Deductions: license label conflict, manifest repository URL mismatch with the repository name, and the referenced deep-dive docs (docs/manual) are not present in the supplied source material, so their content cannot be verified.
Setup experience 13/20
Install is clearly a few steps: a single npx command with complete Claude Code and Claude Desktop configuration examples, local/cloud endpoints via environment variables, and an explicit Node >=22.5 requirement. Static calibration caps setup at 15 without real CI and committed tests; additionally, the manifest does not expose a bin entry, so npx executability is inferred only from the README. Score 13.

Static review · not runListed 2026-08-07

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesUses the network

Best for

  • Developers using Claude Code for large refactors who want to reduce token bills.
  • Users with a local GPU server who want to leverage local models for repetitive tasks.
  • Those needing to offload bounded, well-defined tasks from Claude to a cheaper model.
  • Developers familiar with MCP and OpenAI-compatible APIs.

Not for

  • Tasks requiring strong reasoning or tool access should stay on Claude.
  • Latency-sensitive interactive scenarios, as local inference can be 3-30x slower than frontier models.
  • Users who do not need an MCP server but want to call LLM APIs directly.
  • Users not using Claude Code or Claude Desktop as an MCP client.

Required permissions

  • Read local files on the system (when using the code_task_files tool).
  • Create and read a local SQLite database file (~/.houtini-lm/model-cache.db).
  • Make network requests to the LLM endpoint (local or cloud).
  • Run Node.js processes.

Risks and side effects

  • Sending code or data to a local or cloud LLM may lead to information leakage, especially with cloud APIs.
  • Running untrusted code on local models may introduce security vulnerabilities.
  • Over-reliance on local models may degrade output quality because local models can be less capable.
  • The MCP server may inadvertently expose local file system paths, so use code_task_files with caution.
  • Token savings may be overestimated, as local inference can take more time or resources.

Setup

Before you start

Runtime:Node.js 22.5+

HOUTINI_LM_API_KEY optionalsecret Bearer token for authenticated endpoints; leave blank for local, obtain from the provider console for DeepSeek/Groq/Cerebras/OpenRouter.
Other optional settings (10)
HOUTINI_LM_ENDPOINT_URL optional Base URL of the OpenAI-compatible API (e.g. http://localhost:1234 for LM Studio default); defaults to that if unset.
HOUTINI_LM_MODEL optional Pin a specific model ID; leave blank to auto-detect the loaded model.
HOUTINI_LM_PROVIDER optional Force provider-specific handling (e.g. openrouter); normally auto-detected from the endpoint URL.
HOUTINI_LM_CONTEXT_WINDOW optional Fallback context window if the API doesn't report one; default 100000.
HOUTINI_LM_FILE_ROOTS optional Colon/comma-separated allowlist of directory roots code_task_files may read from; unset allows any absolute path.
HOUTINI_LM_MAX_FILE_MB optional Per-file size cap for code_task_files; default 10 MB.
HOUTINI_LM_CROSS_PROCESS_LOCK optional Set to 0 to disable only the cross-process inference lock.
HOUTINI_LM_SERIALISE optional Set to 0 to disable inference serialisation entirely; useful for backends that batch natively (vLLM, TGI, SGLang).
HOUTINI_LM_MIN_TOKENS optional Floor for caller-supplied max_tokens, default 4096; set to 0 to honour any value.
HOUTINI_LM_THINKING optional Thinking control: auto detects support, off forces no-think, on forces thinking.
  1. Ensure Node.js >= 22.5 (>= 22.13 recommended).
  2. For Claude Code, run: claude mcp add houtini-lm -- npx -y @houtini/lm
  3. For other clients, add a configuration similar to the example in your MCP client config (e.g., claude_desktop_config.json).
  4. Optionally, if the LLM is on a different machine, set the environment variable HOUTINI_LM_ENDPOINT_URL to your LLM server URL (e.g., http://192.168.1.50:1234).
  5. If the endpoint requires auth, set HOUTINI_LM_API_KEY.
  6. For OpenRouter, optionally set HOUTINI_LM_MODEL to pin a specific model.
claude_desktop_config.json
{
  "mcpServers": {
    "houtini-lm": {
      "command": "npx",
      "args": [
        "-y",
        "@houtini/lm"
      ],
      "env": {
        "HOUTINI_LM_ENDPOINT_URL": "http://localhost:1234"
      }
    }
  }
}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "houtini-lm": {
      "command": "npx",
      "args": [
        "-y",
        "@houtini/lm"
      ],
      "env": {
        "HOUTINI_LM_ENDPOINT_URL": "http://localhost:1234"
      }
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add houtini-lm -e HOUTINI_LM_ENDPOINT_URL=http://localhost:1234 -- npx -y @houtini/lm

Run it in a terminal; replace any <…> placeholders with your own values first.

Check that it works

After install, the client's tool list should show all eight tools: chat, custom_prompt, code_task, code_task_files, embed, discover, list_models, stats. Call discover first — if it returns the model name, context window, and measured tok/s, the connection to your local or cloud LLM endpoint is working.

Troubleshooting

  1. If you cannot connect to the LLM endpoint at startup, check HOUTINI_LM_ENDPOINT_URL and ensure the LLM server is running.
  2. If you get empty responses or timeouts, check whether the model is loaded and the context window is sufficient.
  3. If using reasoning models, ensure HOUTINI_LM_THINKING is set appropriately, or check if the backend supports separate reasoning.
  4. If code_task_files rejects files, check if the file size exceeds HOUTINI_LM_MAX_FILE_MB or if the path is within allowed roots.
  5. Run 'npm run shakedown' for an end-to-end self-test to verify the installation and model capabilities.

Things to try

Once connected, you can ask your AI assistant things like:

  • Run discover to check whether my local LLM is reachable and how fast it is
  • Use code_task to have the local model write tests for this TypeScript function
  • Use list_models to show all loaded and downloaded models and what each is best at
  • Review these files in src/utils with code_task_files, reading them directly from disk

Tools 8

chat read-only
Send a task to the local/cloud LLM and get an answer; the primary offload tool.
custom_prompt read-only
Use a three-part prompt (system, context, instruction) to reduce context bleed.
code_task read-only
For code analysis with a pre-configured system prompt and output constraints.
code_task_files read-only
Have the local LLM read files directly from disk for analysis; source never passes through the MCP client's context.
embed read-only
Generate text embeddings via an OpenAI-compatible embedding endpoint.
discover read-only
Health check and speed readout: model name, context window, connection latency, measured tok/s.
list_models read-only
List all loaded and downloaded models on the LLM server with metadata including HuggingFace enrichment.
stats read-only
Compact markdown dump of offload statistics, session and lifetime totals.

Use cases

Generate test stubs, code review, commit messages, format conversions, mock data, type definitions, and other bounded tasks.
Save token costs by using local inference, especially when running local models with LM Studio or Ollama.
Use cloud APIs (DeepSeek, Groq, Cerebras) and OpenRouter's 300+ models through one endpoint.
Generate embeddings for semantic search or RAG pipelines.

Supported clients

Claude Desktop
Claude Code

Listed from the project's documentation, not tested by this site.

Overview

Houtini LM is an MCP server that connects Claude Code to any OpenAI-compatible LLM endpoint (such as LM Studio, Ollama, vLLM, DeepSeek, Groq, Cerebras) and saves Claude tokens by delegating bounded tasks—like generating boilerplate, code review, commit messages, format conversion—to a cheaper local or cloud model. Claude keeps doing the hard reasoning (architecture, planning, multi-file changes), while the local model handles the grunt work. It provides automatic model routing, performance tracking, structured JSON output, and model discovery.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 62.9k · Tools 2 Compare with this →

Source revision 68717f3dbe63 Data synced 2026-10-12 Read the FMRS scoring method