# io.github.houtini-ai/lm (npm · @houtini/lm)

Connect Claude to any OpenAI-compatible LLM endpoint and offload routine work to a local model.

- Trust score: 59/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-07

## Components

- npm · `@houtini/lm`: 59/100 (this document), [markdown](https://verifymcp.io/servers/houtini-ai-lm/houtini-lm.md), [page](https://verifymcp.io/servers/houtini-ai-lm/houtini-lm)

## Channel facts

- Registry: `npm`
- Package: `@houtini/lm`
- Version: `3.2.3`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-07.

- **Supply Chain Security**: 86/100
  - No malware found by supply-chain analysis.
  - Known CVEs were checked across the 94 of 98 dependencies we could resolve, so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Dependency health was assessed across the 94 of 98 dependencies we could resolve, so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 19/100
  - Repository check failed: the declared repository URL redirects; it must resolve directly.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 73/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3291 tokens (~365/item across 9 items; 8 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add houtini-ai-lm -- npx -y @houtini/lm
```

### Codex

```bash
codex mcp add houtini-ai-lm -- npx -y @houtini/lm
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "houtini-ai-lm": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@houtini/lm"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add houtini-ai-lm --command npx --arg -y --arg @houtini/lm
```

### Hermes

```yaml
mcp_servers:
  houtini-ai-lm:
    command: "npx"
    args: ["-y", "@houtini/lm"]
```

### Other

```json
{
  "mcpServers": {
    "houtini-ai-lm": {
      "command": "npx",
      "args": [
        "-y",
        "@houtini/lm"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-05 (score 59, +29)

- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: excellent
- [functional] First check of Schema quality: fail
- [functional] First check of Tool coverage: 100

### 2026-08-04 (score 30)

First indexed and scored.

## MCP tools (8)

### `chat` (~876 tokens)

Send a task to a local LLM — a sidekick running on the user's hardware or a configured OpenAI-compatible endpoint. It does not consume the user's Claude quota. Trades latency for tokens: local inference is typically 3-30× slower than frontier models, so delegation wins when the task is bounded and self-contained.

Good fit:
• Explain or summarise code/docs you already have in context
• Generate boilerplate, test stubs, type definitions, mock data
• Answer factual questions about languages, frameworks, APIs
• Draft commit messages, PR descriptions, comments
• Translate or reformat content (JSON↔YAML, snake_case↔camelCase)
• Brainstorm approaches before committing to one

Less good when: the task needs tool access, depends on multi-file context you have not captured, or is quick enough for you to answer directly before the round-trip completes.

Prompt tips (local models take instructions literally):
(1) Send COMPLETE context — the local LLM cannot read files.
(2) Be explicit about output format ("respond as a JSON array", "return only the function").
(3) Specific system persona beats generic — "Senior TypeScript dev" not "helpful assistant".
(4) State constraints — "no preamble", "reference line numbers", "max 5 bullets".
(5) Leave max_tokens UNSET — the server sizes the budget from the model's real context window. Tiny caps like 256 waste the model: reasoning burns the budget before any visible output.

Routing picks the best loaded model automatically. Call `discover` to see what is loaded and, after the first real call, its measured speed. The footer shows cumulative tokens kept in the user's quota.

Input parameters:

- `frequency_penalty` (number): OpenAI-style frequency penalty, -2 to 2.
- `json_schema` (object): Force structured JSON output. Provide a JSON Schema object and the response will be guaranteed valid JSON conforming to it. Example: {"name":"result","schema":{"type":"object","properties":{"answer":…
- `max_tokens` (number): Response token budget. OMIT THIS — when omitted the server checks the live model's context window and allocates 25% of it (e.g. ~32,000 tokens on a 128k-context model), which is right for almost ever…
- `message` (string, required): The task. Be specific about expected output format. Include COMPLETE code/context — never truncate.
- `model` (string): Optional: pin to a specific model id (e.g. "nvidia/nemotron-3-nano-30b-a3b:free" on OpenRouter, "qwen.qwen3-coder-30b-a3b-instruct" on LM Studio). When set, overrides automatic routing. Useful on pro…
- `presence_penalty` (number): OpenAI-style presence penalty, -2 to 2.
- `repeat_penalty` (number): Penalise repetition, 0–2 (1 = off, ~1.1 typical).
- `seed` (integer): Deterministic sampling seed — same seed + same prompt → reproducible output. Useful for testing.
- `stop` (string|array): Stop sequence(s) — generation halts when one is produced (up to 4).
- `system` (string): Persona for the local LLM. Be specific: "Senior TypeScript dev" not "helpful assistant".
- `temperature` (number): 0.1 for factual/code, 0.3 for analysis (default), 0.7 for creative. Stay under 0.5 for code.
- `top_k` (integer): Sample only from the top-K tokens (e.g. 40). 0/omitted = disabled.
- `top_p` (number): Nucleus sampling 0–1 (e.g. 0.9). Lower = more focused. Alternative to temperature.

### `custom_prompt` (~644 tokens)

Structured analysis via the local LLM with explicit system/context/instruction separation. The 3-part format prevents context bleed in smaller models — the local LLM acknowledges the context in a fake assistant turn before receiving the instruction.

Good fit when prompt structure matters:
• Code review — paste full source, ask for bugs/improvements
• Comparison — paste two implementations, ask which is better and why
• Refactoring suggestions — paste code, ask for a cleaner version
• Content analysis — paste text, ask for structure/tone/issues
• Any task where separating context from instruction improves clarity

Field guidance (each has a job — keep them focused):
• system: persona + constraints, under 30 words. "Expert Python developer focused on performance and correctness."
• context: COMPLETE data — full source, full logs, full text. Never truncate.
• instruction: exactly what to produce, under 50 words. Specify format: "Return a JSON array of {line, issue, fix}."

Review the output before acting on it — local model capability varies.

Input parameters:

- `context` (string): The COMPLETE data to analyse. Full source code, full logs, full text. NEVER truncate.
- `frequency_penalty` (number): OpenAI-style frequency penalty, -2 to 2.
- `instruction` (string, required): What to produce. Specify format: "List 3 bugs as bullet points" or "Return a JSON array of {line, issue, fix}".
- `json_schema` (object): Force structured JSON output. Provide a JSON Schema object and the response will be guaranteed valid JSON conforming to it.
- `max_tokens` (number): Response token budget. OMIT THIS — the server sizes it from the live model's context window (25%, e.g. ~32,000 on a 128k-context model). Values below 4,096 are IGNORED (tiny caps strangle reasoning m…
- `model` (string): Optional: pin to a specific model id. When set, overrides automatic routing.
- `presence_penalty` (number): OpenAI-style presence penalty, -2 to 2.
- `repeat_penalty` (number): Penalise repetition, 0–2 (1 = off, ~1.1 typical).
- `seed` (integer): Deterministic sampling seed — same seed + same prompt → reproducible output. Useful for testing.
- `stop` (string|array): Stop sequence(s) — generation halts when one is produced (up to 4).
- `system` (string): Persona. Be specific: "Expert Node.js developer focused on error handling and edge cases."
- `temperature` (number): 0.1 for bugs/review, 0.3 for analysis (default), 0.5 for suggestions.
- `top_k` (integer): Sample only from the top-K tokens (e.g. 40). 0/omitted = disabled.
- `top_p` (number): Nucleus sampling 0–1 (e.g. 0.9). Lower = more focused. Alternative to temperature.

### `code_task` (~525 tokens)

Send a code-specific task to the local LLM, wrapped with an optimised code-review system prompt. Temperature is locked low (0.2 or the routed model's hint) for deterministic output.

Good fit:
• Explain what a function/class does
• Find bugs or suggest improvements
• Generate unit tests or type definitions for existing code
• Add error handling, logging, or validation
• Convert between languages or patterns

For best results:
• Provide COMPLETE source — the local LLM cannot read files.
• Include imports and type definitions so the model has full context.
• Be specific: "Write 3 Jest tests for the error paths in fetchUser" beats "Write tests".
• Set the language field — it shapes the system prompt and improves accuracy.

Verify generated code compiles, handles edge cases, and follows project conventions before committing.

Input parameters:

- `code` (string, required): COMPLETE source code. Never truncate. Include imports and full function bodies.
- `frequency_penalty` (number): OpenAI-style frequency penalty, -2 to 2.
- `language` (string): Programming language: "typescript", "python", "rust", etc.
- `max_tokens` (number): Response token budget. OMIT THIS — the server sizes it from the live model's context window (25%, e.g. ~32,000 on a 128k-context model). Values below 4,096 are IGNORED (tiny caps strangle reasoning m…
- `model` (string): Optional: pin to a specific model id. When set, overrides automatic routing.
- `presence_penalty` (number): OpenAI-style presence penalty, -2 to 2.
- `repeat_penalty` (number): Penalise repetition, 0–2 (1 = off, ~1.1 typical).
- `seed` (integer): Deterministic sampling seed — same seed + same prompt → reproducible output. Useful for testing.
- `stop` (string|array): Stop sequence(s) — generation halts when one is produced (up to 4).
- `task` (string, required): What to do: "Find bugs", "Explain this", "Add error handling to fetchData", "Write tests".
- `top_k` (integer): Sample only from the top-K tokens (e.g. 40). 0/omitted = disabled.
- `top_p` (number): Nucleus sampling 0–1 (e.g. 0.9). Lower = more focused. Alternative to temperature.

### `code_task_files` (~625 tokens)

Like code_task, but the local LLM reads files directly from disk — source never passes through the MCP client's context window. Use when reviewing multiple files or a single large file.

How it works:
• Provide absolute paths. Relative paths are rejected.
• Files are read in parallel (Promise.allSettled) — one unreadable file does not sink the call.
• Files are concatenated with `=== filename ===` headers and sent to the same code-review pipeline as code_task.
• Read failures are surfaced inline with the reason so the LLM can still reason about the rest.
• Pre-flight prefill estimate: if measured per-model data shows the input would exceed the MCP client's ~60s request timeout during prompt processing, the call is refused early with a diagnostic instead of hanging. Split or trim when this fires.

Good fit:
• Reviewing related files together (module + its tests, client + server pair)
• Auditing a single large file too big to paste comfortably
• Any code_task where keeping source out of the Claude context window matters

Size guidance: on slow hardware (< 25 tok/s generation), keep total input under ~8,000 tokens (~32,000 chars) to stay safely under the client timeout. Faster hardware handles much more — the pre-flight estimator adapts once you've done a few calls and real per-model timings are in the SQLite cache.

Same review discipline as code_task — verify the output before acting on it.

Input parameters:

- `frequency_penalty` (number): OpenAI-style frequency penalty, -2 to 2.
- `language` (string): Optional language hint: "typescript", "python", etc. Shapes the system prompt.
- `max_tokens` (number): Response token budget. OMIT THIS — the server sizes it from the live model's context window (25%). Values below 4,096 are IGNORED and the dynamic budget applies. Only set to raise the ceiling.
- `model` (string): Optional: pin to a specific model id. When set, overrides automatic routing.
- `paths` (array, required): Absolute file paths to analyse. Relative paths are rejected — always pass absolute.
- `presence_penalty` (number): OpenAI-style presence penalty, -2 to 2.
- `repeat_penalty` (number): Penalise repetition, 0–2 (1 = off, ~1.1 typical).
- `seed` (integer): Deterministic sampling seed — same seed + same prompt → reproducible output. Useful for testing.
- `stop` (string|array): Stop sequence(s) — generation halts when one is produced (up to 4).
- `task` (string, required): What to do: "Find bugs", "Explain this module", "Suggest a cleaner API", etc.
- `top_k` (integer): Sample only from the top-K tokens (e.g. 40). 0/omitted = disabled.
- `top_p` (number): Nucleus sampling 0–1 (e.g. 0.9). Lower = more focused. Alternative to temperature.

### `discover` (~86 tokens)

Check whether the local LLM is online and what model is loaded. Returns model name, context window size, response latency, and cumulative session stats (tokens offloaded so far). Call this if you are unsure whether the local LLM is available before delegating work. Fast — typically responds in under 1 second, or returns an offline status within 5 seconds if the host is unreachable.

### `list_models` (~90 tokens)

List all models on the local LLM server — both loaded (ready) and available (downloaded but not active). Shows rich metadata for each model: type (llm/vlm/embeddings), architecture, quantization, context window, and a capability profile describing what the model is best at. Use this to understand which models are available and suggest switching when a different model would suit the task better.

### `embed` (~103 tokens)

Generate text embeddings via the local LLM server. Requires an embedding model to be loaded (e.g. Nomic Embed). Returns a vector representation of the input text for semantic search, similarity comparison, or RAG pipelines. Uses the OpenAI-compatible /v1/embeddings endpoint.

Input parameters:

- `input` (string, required): The text to embed. Can be a single string.
- `model` (string): Embedding model ID. If omitted, uses whatever embedding model is loaded.

### `stats` (~136 tokens)

Show user stats: tokens offloaded, calls made, per-model performance — for the current session AND lifetime (persisted in SQLite at ~/.houtini-lm/model-cache.db). Unlike `discover` which includes the model catalog, `stats` returns just the numbers in a compact markdown table — cheap to call repeatedly to see the 💰 Claude-quota savings counter climb. Useful for quantifying how much work the local model is genuinely doing, and for noticing when a model's reasoning-token ratio is drifting.

Input parameters:

- `model` (string): Optional: filter output to a single model ID. Omit to see all models this workstation has used.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/houtini-ai-lm/houtini-lm#diagnostics

## Score history

- 2026-08-07: 59
- 2026-08-06: 59
- 2026-08-05: 59
- 2026-08-04: 30

## Links

- npm package: https://www.npmjs.com/package/@houtini/lm
- Socket report: https://socket.dev/npm/package/@houtini/lm
- Changelog RSS feed: https://verifymcp.io/servers/houtini-ai-lm/houtini-lm.xml
- Changelog JSON feed: https://verifymcp.io/servers/houtini-ai-lm/houtini-lm.json
- HTML version of this page: https://verifymcp.io/servers/houtini-ai-lm/houtini-lm