Skip to main content
Glama

mcp-servers — a personal MCP server collection

A repo of MCP servers for Devin and other MCP clients (Claude Code, Cursor, Windsurf, VS Code, Zed, Junie, Copilot for IntelliJ). One entry point — node src/index.ts <server> — serves any of them; npm run configure registers them into your clients. Per-server tool reference lives in docs/ and is generated from the live tool registrations (npm run docs).

Servers

  • local_llm — Offloads low-complexity, repetitive work — summarize, extract, classify, bulk file transforms, embeddings, staged edits — to a cheap local model (Ollama or OpenAI-compatible) so the client doesn't spend frontier-model context and tokens on it. Includes a local tool-calling agent, reviewable staged writes, whitelisted command exec, and Ollama model management. 42 tools, 12 ask-tier.

  • task_runner — Detached long-running processes that survive MCP server restarts — dev servers, watchers, downloads — with per-task logs, process-group kill, stdin, respawn, and regex-aware waiting. 8 tools, 2 ask-tier.

Related MCP server: Houtini LM

local_llm

The headline server: offload low-complexity, monotonous work to a cheap local model (Ollama by default, or any OpenAI-compatible endpoint) instead of burning frontier tokens on it.

Its headline feature is run_local_agent: the small model runs its own tool loop server-side (read/search files, run whitelisted commands, stage writes). File contents and intermediate steps never enter the client's context — only a compact final answer comes back. Think of it as a local, free-tier version of cloud subagents.

Why it actually saves tokens

  • Server-side file I/O. summarize, extract, map_files, and run_local_agent take paths/globs and read files inside the server process. A 200KB file summarized this way costs Devin ~500 tokens instead of ~60k.

  • Compact results. Tool results, diffs, and agent steps are truncated/capped before returning.

  • Visible savings. Every response reports usage and delegated_bytes — bytes processed that never entered Devin's context. get_usage_stats totals it for the session.

Requirements

  • Node >= 22.18 (runs TypeScript natively — no build step). Verified on Node 26.

  • Ollama (ollama serve) for the default provider, or any OpenAI-compatible /v1 endpoint.

  • rg (ripgrep) is optional — search_files uses it when installed and falls back to a built-in walker (gitignore-aware, hidden/binary skipped) when it isn't.

  • nvtop (optional) for the best GPU detection — all vendors + per-process usage; falls back to nvidia-smi/rocm-smi.

Setup

Automatic — npm run configure (recommended)

npm run configure

One wizard does everything: installs deps if missing, probes your ollama, writes ~/.config/openai-mcp/config.json (prefills from an existing config — rerun it to update settings), picks which servers to install (all by default), detects installed clients (Devin, Claude Code, Cursor, Windsurf, VS Code, Zed, Junie, Copilot-for-IntelliJ), writes each client's MCP config and merges recommended allow/ask permissions where the client supports them — backing up every file it touches.

npm run configure -- --yes                    # accept all defaults non-interactively
npm run configure -- --clients devin,cursor   # subset of clients ('all' = every known client)
npm run configure -- --servers local_llm      # subset of servers
npm run configure -- --no-install --print-devin   # just print the mcpServers block to paste

File roots are auto-detected. Effective roots = allowed_roots (config) ∪ workspace roots the MCP client advertises (the spec's roots capability) ∪ the directory the client spawned the server from (= your project dir, controlled by trust_cwd: true). So file tools work out of the box inside the project, and allowed_roots is for extra directories outside it. deny_globs blocks secrets everywhere. get_server_info shows each root with its source.

Manual

1. Server config

npm install && cp config.example.json ~/.config/openai-mcp/config.json   # then edit

2. Register with your MCP client

The mcpServers envelope works verbatim in Devin (~/.config/devin/mcp_config.json), Claude Code (~/.claude.json), Cursor (~/.cursor/mcp.json), Windsurf, and Junie:

{
  "mcpServers": {
    "local_llm": {
      "command": "node",
      "args": ["/path/to/mcp-servers/src/index.ts"],
      "env": {
        "LOCAL_LLM_CONFIG": "~/.config/openai-mcp/config.json",
        "LOCAL_LLM_RUN_COMMAND": "1",
        "LOCAL_LLM_DYNAMIC_TOOLS": "1"
      }
    },
    "task_runner": {
      "command": "node",
      "args": ["/path/to/mcp-servers/src/index.ts", "task_runner"]
    }
  }
}

Other envelopes: VS Code and Copilot-for-IntelliJ use a servers key with "type": "stdio" on each entry (mcp.servers in VS Code user settings; ~/.local/share/github-copilot/intellij/mcp.json for Copilot); Zed uses context_servers with {"command": {"path", "args"}, "settings": {}}. IntelliJ's built-in AI Assistant stores MCP config in IDE options XML — configure it via Settings → Tools → AI Assistant → Model Context Protocol.

Omit the two LOCAL_LLM_* env flags to disable shell access and dynamic tools entirely. Devin CLI equivalent: devin mcp add -s user local_llm -- node /path/to/mcp-servers/src/index.ts

3. Permissions (Devin / Claude Code)

In ~/.config/devin/config.json (or ~/.claude/settings.json — same syntax):

{
  "permissions": {
    "allow": ["mcp__local_llm__chat", "mcp__local_llm__summarize", "…", "mcp__task_runner__task_kill"],
    "ask":   ["mcp__local_llm__commit_write", "…", "mcp__task_runner__task_start"]
  }
}

The lists aren't hardcoded: each tool declares its tier at registration (reg.allow / reg.ask in src/*/tools/), and node src/cli.ts manifest emits the full {tools, ask} map the configure script merges. ask = approve button before writes hit disk, models download, or processes spawn. Everything else is allow-tier; task_start is task_runner's only ask tool — kill/stdin/wait are scoped to registry-managed tasks.

Provider config notes

Provider entries in config.json accept think (bool or "low"/"medium"/"high"), options (provider-native request overrides), temperature, num_ctx, and keep_alive — defaults applied to every call; per-request args override them. The configure wizard asks about think since thinking-capable models can eat the whole max_tokens budget.

Tools

Full per-tool reference — descriptions, parameters, types, defaults — is generated from the live registrations: docs/local_llm.md and docs/task_runner.md (npm run docs regenerates; npm run docs:check verifies freshness).

Tools group by job:

  • Delegate — run_local_agent (local model runs its own tool loop on the task), chat, summarize, extract, classify, decide (calibrated decision models, no generation), map_files (one instruction across a glob), embed, count_tokens.

  • Staged writes — propose_write/propose_edit/stage_delete produce reviewable diffs; commit_write (incl. batch ops:[...]) / discard_write settle them; set_write_mode gates whether commits reach disk; verify_staged lints a draft in a temp file; undo via list_commits, revert_write, uncommit_write. Nothing reaches disk without commit_write.

  • Models — list_models, search_models, list_model_tags, recommend_model (VRAM/RAM-aware, apply:true sets default), pull_model, download_model, unload_model, delete_model, prune_models, get_system_resources.

  • Jobs — get_job, list_jobs, wait_job, control_job (pause/inject/cancel long pulls and agent runs).

  • Agent tools & exec policy — register_agent_tool/unregister_agent_tool/ list_agent_tools (runtime tools for the local agent only), get_command_whitelist/update_command_whitelist.

  • Meta — get_server_info (providers/roots/flags — call first), get_usage_stats (session savings).

Slash commands (MCP prompts): /mcp__local_llm__delegate <task> [files] and /mcp__local_llm__cheap_summary <path> [focus].

task_runner — a second server

This repo also ships task_runner (registered by npm run configure alongside local_llm) — a process manager for long-running background tasks: dev servers, build watchers, downloads, test loops.

  • task_start spawns a detached process (argv — no shell; optional name/cwd/env/stdin/log). task_list/task_status/task_log inspect it, task_stdin feeds it, task_kill signals the whole process group, task_restart respawns the recorded spec, and task_wait returns early on exit or a log-regex match (seconds:-1 waits uncapped). task_start/task_restart are ask-tier; the rest are allow-tier. Full reference: docs/task_runner.md.

For a human view: npm run task_runner_top opens a top-style TUI over tasks.json — live status, CPU%, RSS, age, log tail; x/X SIGTERM/SIGKILL the selected group, l pages the log, q quits. Works without the server running (reads the registry + /proc directly), and flags !pid-reused when a dead pid got recycled by an unrelated process.

Log files are append-only but bounded — past 64MB the log is pruned to its last 8MB with a marker line (safe against concurrent writers; children append at EOF). Logs at a caller-chosen log path are never pruned. The registry itself is bounded too: stopped tasks are dropped when older than TASKD_KEEP_DAYS (default 14) or beyond TASKD_KEEP entries (default 100) — custom logs are kept, state-dir logs go with the entry.

Both servers launch through one entry: node src/index.ts (defaults to local_llm) or node src/index.ts task_runner. Server code lives in src/local-llm/ and src/task-runner/; src/shared/ (preflight.ts dep-check + mcp.ts bootstrap) is the common kit — add another server by writing src/<name>/server.ts and one line in index.ts's SERVERS map.

Generation params

Every generation tool accepts these on top of model/provider/temperature/num_ctx/max_tokens:

Param

Effect

think

Chain-of-thought control: true/false, or "low"/"medium"/"high" on models with effort levels. Maps to ollama's think; on openai-compatible servers false → chat_template_kwargs.enable_thinking (vLLM/llama.cpp convention), a level → reasoning_effort.

top_p, seed, stop

Standard sampling controls.

options

Provider-native override bag — merged into ollama options (top_k, repeat_penalty, …) or the openai-compat request body. Wins over the named params.

Set defaults per provider in config: "think": false, "options": {"top_k": 20}. Request args override them.

Thinking models eat max_tokens. On thinking-capable models (gemma4, qwen3, gpt-oss) a tight max_tokens can be consumed entirely by reasoning, returning empty text. Fix per call with think:false, or globally per provider with "think": false. chat returns the model's thinking trace when the provider reports it, so the budget usage is observable. (run_local_agent accepts think/options too — disabling think leaves more context and steps for tool calls.)

Progress

Two free/cheap progress channels:

  • MCP notifications/progress: run_local_agent reports each agent step and map_files reports per-file completion — if the client attaches a progressToken. These go to client UI plumbing, not into the model context — zero token cost.

  • Job polling: every run_local_agent call runs under a job. run_async:true returns the job_id immediately; sync calls return the inline result if they finish within agent_sync_grace_ms, otherwise the job_id. get_job shows live progress + the final result. Polling costs a few tokens per call, but only when Devin chooses to check. (pull_model/download_model are always jobs.)

Safety model

  • Staged writes + write modes: local-model output lands in a review queue, never directly on disk. Default write_mode: "propose" means the server never writes — Devin reviews get_diff and applies through its own edit tools, so changes go through Devin's native file-review flow (at the cost of the diff/content tokens). set_write_mode("write") (or write_mode: "write" in config) lets commit_write apply server-side — those bypass Devin's edit-review UI but stay git-visible. The required path/summary args keep the ask-permission prompt meaningful, and commit_write/set_write_mode belong in ask permissions either way.

  • run_command: whitelist-only, executed via execFile argv — no shell, so ;, &&, |, > are literal arguments and can't inject. allow_args constrains subcommands (e.g. git → read-only verbs).

  • File scope: union of configured allowed_roots + MCP-advertised workspace roots + cwd (disable with trust_cwd: false), minus deny_globs for secrets.

  • VRAM: ollama calls set num_ctx explicitly (default 16384) — an unbounded context blew up the KV-cache allocation on a 16GB GPU. get_system_resources + unload_model help manage memory.

  • Honesty: the instructions tell Devin not to delegate anything where a plausible-but-wrong answer is worse than no answer. 8B models produce garbage sometimes — verify:"self" and staged diffs are the mitigations, not a guarantee.

Provider config

Two types:

  • ollama → native /api (chat with num_ctx/keep_alive/tools, pull, ps, unload, delete). Local or remote.

  • openai → generic /v1 (chat completions, list models). Works with LM Studio, vLLM, llama.cpp, OpenAI proper (api_key_env references an env var — never store keys in the file).

Multi-GPU hosts

GPU detection prefers nvtop -s (all vendors + per-process usage), falling back to nvidia-smi/rocm-smi. GPUs are identified by PCI bus id — tool enumeration order is not trusted (nvtop order ≠ DRM cardN ≠ lspci order on multi-vendor hosts). Each GPU is bound to its /sys/class/drm/cardN entry via PCI match or device-name matching, so pciSlot/driver are always correct; missing VRAM is filled from sysfs mem_info_vram_* (i915/xe/amdgpu) or ollama's own discovery log.

get_system_resources returns an ollama_gpu block describing where the server runs:

  • env + env_source — GPU pinning vars discovered from the ollama serve process env (env_source: "proc"), falling back to the systemd unit (Environment=/EnvironmentFile, "systemd") or the journal's server config env=map[...] line ("journal"). Cross-user /proc denial is reported in env_note rather than silently yielding an empty env.

  • pinned_indices/pinned_slots — numeric selectors resolved to PCI slots through the journal's inference compute device table (e.g. GGML_VK_VISIBLE_DEVICES=2 → the Vulkan device whose pci_id matches index 2).

  • runners/gpus_in_use — loaded runner processes attributed to GPUs via /proc/<pid>/fd device nodes, keyed on PCI slot.

  • inference_devices — devices ollama discovered (name, pci_id, total/available VRAM) — authoritative for backends nvtop can't measure (e.g. Intel Arc via Vulkan).

To pin ollama to a specific card — e.g. an A380 while a P100 stays reserved for a vLLM server — set the backend-appropriate selector on ollama serve (GGML_VK_VISIBLE_DEVICES=N for llama.cpp Vulkan/Intel Arc, CUDA_VISIBLE_DEVICES=N NVIDIA, HIP_VISIBLE_DEVICES/ROCR_VISIBLE_DEVICES AMD, ONEAPI_DEVICE_SELECTOR=level_zero:N Intel SYCL) in its unit's EnvironmentFile, restart ollama, then get_system_resources shows the pin and recommend_model sizes its budget against that GPU — never a roomier GPU ollama can't use.

Quick single-provider env mode (no config file): LOCAL_LLM_BASE_URL, LOCAL_LLM_API_KEY_ENV, LOCAL_LLM_MODEL, LOCAL_LLM_PROVIDER_TYPE.

llama.cpp / exllamav3 / vLLM

These already work — their servers (llama-server, TabbyAPI, vLLM) all expose an OpenAI-compatible /v1, so just add type: "openai" provider entries:

"llamacpp": { "type": "openai", "base_url": "http://localhost:8080/v1", "default_model": "local-model" },
"tabby":    { "type": "openai", "base_url": "http://localhost:5000/v1", "api_key_env": "TABBY_API_KEY" }

What you lose vs. ollama-type providers: no num_ctx control (llama.cpp uses -c at launch), no pull/ps/unload management, and no system-resources introspection for remote hosts. download_model fills the acquisition gap — it runs hf download as a job (requires the hf CLI from huggingface_hub). Note llama-server can't hot-load a downloaded GGUF without a restart; TabbyAPI can load via its own admin endpoints.

Dev

npm install
npm test            # unit tests (node:test)
npm run smoke       # end-to-end: spawns server, hits real ollama
npm run build       # optional: emit dist/ for node<22.18 or distribution
npm run docs        # regenerate docs/<server>.md from live tool registrations
npm run docs:check  # fail if docs/ is stale (CI)
npm run task_runner_top  # TUI: top for task_runner tasks (no server needed)
node src/index.ts   # run the server standalone (stdin MCP)

Available Tools

42 tools
chatA

Chat-completion passthrough to the cheap/local model — cheapest way to offload a small mechanical task. Pass prompt (+ optional system) for one-shot completions, or messages for a full OpenAI-style conversation (few-shot examples, multi-turn).

Inputs: seed, stop, model, think, +10 more.

classifyC

Classify text/file content into one or more labels with the local model.

Inputs: labels (required), glob, path, seed, +11 more.

commit_writeA

Apply a staged write to disk (atomic: tmp+rename). Call only AFTER reviewing the diff with get_diff. Refuses if the file changed since it was staged — pass force=true to overwrite anyway. Only works when write_mode is 'write' — do NOT call it in 'propose' mode (it refuses and the permission prompt would just show an opaque op_id). path and summary are REQUIRED because the user's approval prompt only shows tool args — make them say exactly what is being written. Pass ops: [{op_id, path, summary}] instead to commit a batch in ONE approval — use it for map_files stage_writes output so the user sees the whole set at once.

Inputs: ops, path, force, op_id, +1 more.

control_jobA

Steer a running background job: pause (halt between agent steps), resume, cancel (aborts in-flight work too), or inject (append an operator instruction the local agent sees on its next step — for course-correcting a run_local_agent mid-flight).

Inputs: action (required), job_id (required), message.

count_tokensA

Estimate token counts for text/files (chars/4 heuristic — ±20% vs a real tokenizer; for input sizing, not billing). Use before run_local_agent/summarize to check fit vs num_ctx.

Inputs: glob, path, text, paths.

decideA

Decision-model scoring (ollama /v1/systemone — clef / clef-flash / nimble / tev). Scores 1–64 TYPED questions about a state in ONE forward pass and returns calibrated probabilities per option — no text generation, no output parsing, no retries. Prefer over classify when a decision model is available: you get real probabilities instead of parsed JSON. Question types: 'choice' (criteria maps option keys→descriptions, null uses the key), 'score' (numeric scale), 'noul' (true/false). Requires an ollama provider running a decision model; a normal chat model returns an error. State is read server-side — files never enter your context.

Inputs: questions (required), glob, path, model, +3 more.

delete_modelA

Permanently delete a model from an ollama provider (DELETE /api/delete). Irreversible — the model must be re-pulled to restore. Refuses to delete the provider's default_model or a currently-loaded model unless force=true.

Inputs: model (required), force, provider.

discard_writeC

Drop a staged write op without applying it.

Inputs: op_id (required).

download_modelA

Download a model from Hugging Face via the hf CLI (for llama.cpp/TabbyAPI/vLLM-style servers where pull_model doesn't apply). Runs as a background job — poll with get_job. e.g. repo 'bartowski/Qwen2.5-Coder-7B-Instruct-GGUF' with include 'Q4_K_M'.

Inputs: repo (required), include, revision, local_dir.

embedA

Embed text/files with an embedding model on the local provider — for semantic dedup, clustering, or find-similar work that generation can't do. Needs an embedding model (e.g. nomic-embed-text, embeddinggemma) — check list_models capabilities. Returns raw vectors; cosine-similarity them yourself.

Inputs: glob, path, text, model, +2 more.

extractB

Extract structured data from text/files with the local model. Optionally validate output against a JSON schema (one automatic retry on invalid output).

Inputs: instruction (required), glob, path, seed, +11 more.

get_command_whitelistA

Show which commands the local agent's run_command tool may execute (argv-level whitelist, no shell).

Inputs: no named parameters.

get_diffC

Show the unified diff for a staged write op.

Inputs: op_id (required), include_content.

get_jobB

Get status/progress of a background job (e.g. a model pull).

Inputs: job_id (required).

get_server_infoA

Show this server's config: providers (sanitized), allowed_roots, feature flags, limits. Call this first if unsure what's configured.

Inputs: no named parameters.

get_system_resourcesA

Report host RAM + GPU VRAM and currently-loaded models. Only works for LOCAL ollama providers — returns {unavailable: true} for remote/openai-type providers. Use before picking a model or num_ctx for heavy jobs. Includes ollama_gpu: which GPU(s) the ollama server is pinned to (env) or observed using (runner process device fds).

Inputs: provider.

get_usage_statsA

Session totals: local LLM calls, tokens consumed on the cheap model, and delegated_bytes (bytes of file content processed server-side that never entered your context — i.e. the savings).

Inputs: no named parameters.

list_agent_toolsB

List runtime-registered tools available to the local agent.

Inputs: no named parameters.

list_commitsA

List recently committed writes (last 20) — for revert_write.

Inputs: no named parameters.

list_jobsB

List background jobs (most recent first).

Inputs: no named parameters.

list_modelsA

List models available on a provider. For ollama providers includes size, parameter count, quantization and capabilities — use this plus get_system_resources to pick the biggest model that fits VRAM.

Inputs: provider.

list_model_tagsA

List pullable tags for a model in the ollama registry (e.g. model 'gemma4' -> e4b, 12b, 26b, ...). With include_sizes=true, fetches each tag's download size from the registry manifest API (one request per tag). Requires internet access.

Inputs: model (required), limit, provider, include_sizes.

list_stagedA

List pending staged writes (proposed changes not yet on disk).

Inputs: no named parameters.

map_filesA

Run one instruction over many files with the local model (batch job). output='report': get per-file results. output='stage_writes': the model rewrites each file and every change is staged as a diff for your review — NOTHING hits disk until you commit_write.

Inputs: glob (required), instruction (required), seed, stop, +10 more.

propose_editA

Like propose_write, but the local model emits SEARCH/REPLACE hunks instead of the whole file — much more reliable on large files and small models. Server applies the hunks and stages the result as a normal op (same diff/commit flow).

Inputs: path (required), instruction (required), seed, stop, +6 more.

propose_writeA

Have the local model rewrite/create ONE file per your instruction, staged for review. Returns an op id + diff. Nothing is written until commit_write. Use for mechanical rewrites where the file content shouldn't flow through your own context.

Inputs: path (required), instruction (required), seed, stop, +6 more.

prune_modelsA

Bulk-delete old models from an ollama provider. dry_run=true (default) only reports candidates. Always keeps: keep[] ids, the provider default_model, currently-loaded models, and the keep_recent most recently modified others. With dry_run=false, deletes the rest.

Inputs: keep, dry_run, provider, keep_recent, +2 more.

pull_modelA

Download a model on an ollama provider (e.g. 'qwen2.5-coder:7b'). Runs as a background job — returns a job_id; poll progress with get_job. Only for ollama providers.

Inputs: model (required), provider.

recommend_modelA

Analyze installed models against detected hardware and recommend a default_model for a provider. Prefers tool-calling models that fit the target GPU's free VRAM (or free RAM for CPU-only). With apply=true, writes the pick to the provider's default_model in the config file AND applies it live to this server.

Inputs: apply, model, provider, budget_mb.

register_agent_toolA

Register a NEW tool that the local model can call during run_local_agent (persists for this server session; persist=true saves it across restarts). kind='shell': an executable + argv template with ${param} placeholders (execFile, no shell). kind='js': a JS function body run in node:vm as (body)(args). Requires LOCAL_LLM_DYNAMIC_TOOLS=1 on the server.

Inputs: kind (required), name (required), description (required), input_schema (required), +4 more.

revert_writeA

Undo a committed write: stages a NEW op restoring the pre-commit content (goes through normal review — commit_write applies it).

Inputs: commit_id (required).

run_local_agentA

Delegate a low-complexity task to the LOCAL SUBAGENT: the cheap model runs its own tool loop (read_file, list_dir, search_files, stage_write, whitelisted run_command, plus any registered dynamic tools) entirely server-side. File contents and intermediate steps never enter your context — you get back a compact final answer + staged-write op ids to review. Use for mechanical, monotonous, or bulk work: finding things, transforming files, answering questions over many files. Do NOT delegate work needing real reasoning, security judgment, or architecture decisions.

Inputs: task (required), files, model, paths, +11 more.

search_modelsA

Search the public ollama registry (ollama.com) for models to pull_model. Returns name, description, capability chips (tools/thinking/vision), available parameter sizes, and whether the family is already installed. Requires internet access.

Inputs: query (required), limit, category, provider.

set_write_modeA

Switch the server's write posture. 'propose' (default): staged writes only — commit_write is refused; you apply diffs with your own tools. 'write': commit_write applies staged ops to disk. persist=true also writes the choice to the server config file.

Inputs: mode (required), persist.

stage_deleteA

Stage a file DELETION for review — nothing touches disk until commit_write. The diff shows all lines removed; uncommit_write restores the file afterwards. Use for dead-code cleanup instead of emptying a file with propose_write.

Inputs: path (required), reason.

summarizeA

Summarize files or text with the local model. File contents are read server-side and NEVER enter your context — only the summaries come back. Prefer this over reading large files yourself.

Inputs: glob, path, seed, stop, +12 more.

uncommit_writeA

One-call undo of a committed write — restores the pre-commit content atomically (deletes files the commit created), no re-staging/re-commit needed. Refuses if the file changed since the commit unless force:true. Requires write_mode 'write' — in 'propose' mode use revert_write + commit_write for the reviewed path.

Inputs: commit_id (required), force.

unload_modelC

Unload a model from VRAM on an ollama provider (frees memory immediately).

Inputs: model (required), provider.

unregister_agent_toolC

Remove a runtime-registered dynamic tool.

Inputs: name (required).

update_command_whitelistB

Add/remove commands the local agent may run. Writes the server config file — prefer tight allow_args over broad access. This tool should stay in Devin's 'ask' permissions.

Inputs: add, remove.

verify_stagedA

Run a whitelisted command against a staged write WITHOUT touching the target file: the op's content is materialized to a temp file in the same directory (import/path resolution matches the real file), '{file}' in argv is replaced by the temp path (appended if absent), and the command runs under the command_whitelist. Use it to typecheck/lint a staged op before commit_write — running a checker on the original path sees the OLD on-disk content, not the stage. restore_paths lists files the command may rewrite (e.g. an auto-updated lint baseline) — snapshotted before, restored after. The temp file is always removed.

Inputs: argv (required), op_id (required), cwd, timeout_s, +1 more.

wait_jobA

Sleep for a number of seconds (max 600), then return. With job_id, returns early as soon as that job reaches done/error — use to poll pull_model/run_local_agent without busy-looping get_job.

Inputs: seconds (required), job_id.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 42 tools

    Disambiguation4/5

    The 42 tools cover distinct sub-domains, and detailed descriptions differentiate overlapping pairs like propose_write/propose_edit and revert_write/uncommit_write. However, a few pairs (e.g., decide vs classify, revert_write vs uncommit_write) could still cause misselection without careful reading.

    Naming Consistency4/5

    Nearly all tools use snake_case verb_noun (list_staged, commit_write, pull_model), with a few single-verb actions (chat, summarize, extract) that remain stylistically consistent. No mixed camelCase or chaotic patterns.

    Tool Count3/5

    42 tools is heavy for a single MCP server, exceeding the typical 3-15 range, though the server's broad scope (staged writes, model management, jobs, local LLM tasks, config) justifies many of them. It risks overwhelming an agent's tool selection.

    Completeness5/5

    The surface covers full lifecycle for staged writes (stage, review, commit, revert, uncommit, verify, discard), model management (search, pull, download, delete, prune, unload, recommend), jobs, local inference tasks, and config. No obvious gaps in the stated domain.

    Maintenance

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      F
      maintenance
      Enables a primary coding agent to delegate bounded implementation and repair tasks to a local OpenAI-compatible model that edits a copy of the project, runs configured checks, and returns artifacts for review. Exposes stdio tools for capability discovery, task submission, progress polling, artifact reading, and cancellation.
      MIT
    • F
      license
      Not graded
      quality
      A
      maintenance
      Lets an MCP client hand bounded work such as code review, boilerplate, commit messages, format conversion or embeddings to a local or cloud OpenAI-compatible LLM, so file contents never enter the orchestrating model's context and token costs drop. It also provides a second model to sanity-check code and drafts while the main assistant keeps planning and tool use.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables an MCP client such as Claude Code to hand bounded work — code review, test stubs, commit messages, format conversion, embeddings — to a local or cloud OpenAI-compatible model, so the files being processed never enter the orchestrator's context window and token costs drop. It also provides a cheap second model for reviewing code and checking work without consuming the primary assistant's quota.
      -
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables Claude Code and other MCP clients to offload bounded tasks to a local or cloud LLM (LM Studio, Ollama, vLLM, LiteLLM, OpenRouter, DeepSeek, Groq, Cerebras, OpenAI) so files are read and drafted outside the orchestrator's context window, cutting token costs. It also provides a cheap second model for code review, test stubs, commit messages, format conversion, and embeddings.
      MIT