openai-mcp
Downloads models from Hugging Face via the hf CLI as a background job, so they can be served by local OpenAI-compatible inference servers such as llama.cpp, TabbyAPI, or vLLM.
Default local model provider integration. Lists installed and registry models (with sizes, capabilities, and tags), pulls, deletes, and prunes models, unloads models to free VRAM, and detects which GPU(s) loaded models are using. All generation tools (chat, complete, summarize, extract, classify, map_files, propose_write, run_local_agent) can be routed to an Ollama model with provider-specific controls like think, num_ctx, keep_alive, and native options.
Provider integration for any OpenAI-compatible /v1 endpoint (e.g. vLLM, llama.cpp, TabbyAPI) alongside Ollama. Supports the same generation and agent tooling, mapping thinking controls to reasoning_effort or chat_template_kwargs, and allows provider-native request overrides through an options bag for per-call or per-provider defaults.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@openai-mcp summarize src/index.ts with the local model"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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, andrun_local_agenttake 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
usageanddelegated_bytes— bytes processed that never entered Devin's context.get_usage_statstotals 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/v1endpoint.rg(ripgrep) is optional —search_filesuses 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 tonvidia-smi/rocm-smi.
Setup
Automatic — npm run configure (recommended)
npm run configureOne 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 pasteFile 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 edit2. 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 docsregenerates;npm run docs:checkverifies 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_deleteproduce reviewable diffs;commit_write(incl. batchops:[...]) /discard_writesettle them;set_write_modegates whether commits reach disk;verify_stagedlints a draft in a temp file; undo vialist_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:truesets 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_startspawns a detached process (argv— no shell; optionalname/cwd/env/stdin/log).task_list/task_status/task_loginspect it,task_stdinfeeds it,task_killsignals the whole process group,task_restartrespawns the recorded spec, andtask_waitreturns early on exit or a log-regexmatch(seconds:-1waits uncapped).task_start/task_restartare 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 |
| Chain-of-thought control: |
| Standard sampling controls. |
| Provider-native override bag — merged into ollama |
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_agentreports each agent step andmap_filesreports per-file completion — if the client attaches aprogressToken. These go to client UI plumbing, not into the model context — zero token cost.Job polling: every
run_local_agentcall runs under a job.run_async:truereturns thejob_idimmediately; sync calls return the inline result if they finish withinagent_sync_grace_ms, otherwise thejob_id.get_jobshows live progress + the finalresult. Polling costs a few tokens per call, but only when Devin chooses to check. (pull_model/download_modelare 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 reviewsget_diffand 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")(orwrite_mode: "write"in config) letscommit_writeapply server-side — those bypass Devin's edit-review UI but stay git-visible. The requiredpath/summaryargs keep theask-permission prompt meaningful, andcommit_write/set_write_modebelong inaskpermissions either way.run_command: whitelist-only, executed viaexecFileargv — no shell, so;,&&,|,>are literal arguments and can't inject.allow_argsconstrains subcommands (e.g. git → read-only verbs).File scope: union of configured
allowed_roots+ MCP-advertised workspace roots + cwd (disable withtrust_cwd: false), minusdeny_globsfor secrets.VRAM: ollama calls set
num_ctxexplicitly (default 16384) — an unbounded context blew up the KV-cache allocation on a 16GB GPU.get_system_resources+unload_modelhelp 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 withnum_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_envreferences 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 theollama serveprocess env (env_source: "proc"), falling back to the systemd unit (Environment=/EnvironmentFile,"systemd") or the journal'sserver config env=map[...]line ("journal"). Cross-user/procdenial is reported inenv_noterather than silently yielding an empty env.pinned_indices/pinned_slots— numeric selectors resolved to PCI slots through the journal'sinference computedevice table (e.g.GGML_VK_VISIBLE_DEVICES=2→ the Vulkan device whosepci_idmatches index 2).runners/gpus_in_use— loaded runner processes attributed to GPUs via/proc/<pid>/fddevice nodes, keyed on PCI slot.inference_devices— devices ollama discovered (name,pci_id,total/availableVRAM) — 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 toolschatA
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
Scored across 42 tools
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.
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.
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.
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
Related MCP Connectors
LLM cost optimization gateway, repo token-waste auditor & model arbitrage MCP server.
Hand tasks, bugs and finished work to AI coding agents, and get back a write-up with evidence.
Deterministic AI agent microtools, no accounts/API keys. fetch_extract: 98% token cut. 47 tools.
x402 pay-per-call tools for AI agents: code review, data clean, briefs, regex, diff, URL meta.
Related MCP Servers
- AlicenseNot gradedqualityFmaintenanceEnables 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
- FlicenseNot gradedqualityAmaintenanceLets 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.-
- FlicenseNot gradedqualityAmaintenanceEnables 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.-
- AlicenseNot gradedqualityAmaintenanceEnables 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