Baton

dev.dudkoPublished by dudko.devv0.2.0Updated Oct 25, 2026

Local MCP server for Baton: edit git-native API requests, collections, environments and scripts.

The publisher's own server: PDF to Markdown

VerifiedSTDIODesktop onlyFiles & StorageDeveloper Tools

Overview

AI-generated overview

Local MCP server for Baton, a git-native API client, letting an assistant read and edit requests, collections, environments and scripts in a YAML workspace.

What you can do
  • Inspect the workspace: collections, environments, schedules, requests with method, URL and tags, and app connection state.
  • Read and write requests: fetch parsed or raw YAML, create or update, move or rename, and delete requests.
  • Manage collections and environments: create or replace collections and folders, list and write environment variables and secret names.
  • Edit scripts: read and write pre-request, test and shared library scripts.
  • Run requests and collections, and manage saved examples and local mock servers.
  • App mode only: see what is open in the desktop app and open a request there.
When to use it
Useful when your API requests, collections and environments live in a Baton workspace of YAML files and you want an assistant to draft, reorganize or document them under git review. App mode suits teams that want edits to arrive as drafts and sends to run through the desktop app with its secrets.
Requirements
Runs locally over stdio via the npm package @dudko.dev/baton-mcp, requiring Node.js 24 or newer. The workspace folder must contain baton.yaml; the default is the current directory, otherwise pass --workspace. No authentication or environment variables are declared. Optional flags: --allow-run to permit request execution in file mode and --agent to name the agent in the app.
Before you install
In file mode the assistant writes directly to workspace YAML files, so changes should go through git review; request execution is off unless --allow-run is added. In app mode, sends into a production environment and deletes wait for your confirmation. Secret values stay in the OS secure store or Vault and only names and references are handled, but responses are still sent to the model, with bodies truncated and auth headers masked. The server does not commit to git.

Installation

In SourceWeft

  1. Open Baton in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

Baton — MCP setup

Let your AI assistant work in a Baton workspace. Baton is a git-native API client (a Postman alternative): requests, collections and environments are plain YAML files in a repository you own. The MCP server runs locally with one configuration and two modes, picked at start:

  • File mode — the Baton app is not open on the workspace: an edit is a write to the YAML file, the same bytes the app would write, and goes through git review like any other change.

  • App mode — the desktop app is open on the workspace: an edit lands as a draft on the request's tab for you to accept or discard, a send runs through the app with the app's secrets, a send into a production environment or a delete waits for your confirmation, and the assistant sees which request and environment you have open.

  • Server: baton

  • Transport: stdio (local process)

  • Package: @dudko.dev/baton-mcp — Node.js 24+

  • Auth: none — it runs locally with your user's permissions; secrets never pass through it.

What you can do

In file mode the assistant can read and write the workspace but not send requests unless you add --allow-run. In app mode every send goes through the app, on your screen.

ToolWhat it does
workspace_infoCollections, environments, schedules, load issues, and whether the app is connected.
list_requestsRequests with method, URL and tags — optionally under one collection.
get_requestA parsed request, its raw YAML, and where its auth comes from — secrets appear as references only.
upsert_requestWrite a request as deterministic YAML (file mode) or propose it as a draft in the app.
move_requestMove or rename a request, keeping its id and its scripts.
delete_requestDelete a request; in app mode, after you confirm.
upsert_collectionCreate or replace a collection or folder: variables, auth, order.
list_environmentsVariables and secret names, with each secret's source.
upsert_environmentWrite an environment (secret names only; a secret may map to Vault).
get_script / upsert_scriptRead and write pre-request, test and shared library scripts.
run_request / run_collectionExecute a request or every request under a collection — file mode needs --allow-run; app mode sends through the app.
list_examples / save_exampleA request's saved responses, and save the last response as one.
list_mocks / start_mock / stop_mockStand a mock up from mocks/<name>.yaml on 127.0.0.1, answering from the examples.
app_state / select_requestApp mode only: what is open in the app, and open a request there.

In app mode the resources baton://app/state and baton://app/selection are subscribable, so the assistant learns of a click, an accepted draft or a finished send as it happens.

Install in Claude Code (plugin)

/plugin marketplace add dudko-dev/baton-mcp-setup/plugin install baton@baton/reload-plugins

The plugin starts the server in the current project directory, so open Claude Code in your Baton workspace (the folder with baton.yaml). Open the Baton app on the same workspace to get app mode. To point the server elsewhere, or to let the assistant execute requests in file mode, add it by hand instead (below) with --workspace <dir> and/or --allow-run. In the app, Settings → Agents writes a .mcp.json into the workspace for you.

Prefer not to use the marketplace? Add the server directly:

claude mcp add baton -- npx -y @dudko.dev/baton-mcp --workspace /path/to/workspace

Connect from other clients

Claude Desktop

claude_desktop_config.json (Settings → Developer → Edit Config):

json
{  "mcpServers": {    "baton": {      "command": "npx",      "args": [        "-y",        "@dudko.dev/baton-mcp"      ]    }  }}

Cursor

~/.cursor/mcp.json or .cursor/mcp.json:

json
{  "mcpServers": {    "baton": {      "command": "npx",      "args": [        "-y",        "@dudko.dev/baton-mcp"      ]    }  }}

VS Code (GitHub Copilot / MCP) and other clients

json
{  "servers": {    "baton": {      "type": "stdio",      "command": "npx",      "args": [        "-y",        "@dudko.dev/baton-mcp"      ]    }  }}

Safety

  • In file mode, running requests is off by default. Add --allow-run to the args only when you want the assistant to fire requests — editing files should never silently send traffic.
  • In app mode, you stay in the loop. Edits arrive as drafts you accept or discard; a send into a production environment and every delete wait for your confirmation in the app.
  • Secrets stay out of the workspace. The server reads and writes secret names and {{secret:name}} references only; the values live in the OS secure store or in Vault, and a plaintext value where a reference belongs is refused. Responses are masked by value, bodies truncated, and Authorization, Cookie, Set-Cookie and X-API-Key replaced by name.
  • The server never touches git. Commits stay yours.
FlagMeaning
--workspace <dir>The workspace root — the folder holding baton.yaml (default: current directory).
--allow-runLet the agent execute requests in file mode. Off by default; app-mode sends go through the app.
--agent <name>What the app calls this agent on its banners and confirmations.

Troubleshooting

  • "not a Baton workspace" / the client says "Connection closed" — the server exits at start when the folder has no baton.yaml. Open Claude Code in your workspace, or add the server by hand with --workspace /path/to/workspace.
  • run_request refuses — the server is in file mode: add --allow-run, or open the Baton app on the workspace and restart the server for app mode.
  • Edits are written straight to files although the app is open — the mode is decided when the server starts. Restart the MCP server in your client after opening the app on that workspace.
  • npm warn EBADENGINE … required: { node: '>=24' }, then nothing — the server needs Node.js 24+; node --version in the shell your client starts.

Support

Source: README.md at commit 58e37b6

Tools

0
SourceWeft started this package once in an isolated sandbox, without credentials, to list its tools. That failed: the server did not start.

Version history

2
  1. v0.2.0LatestOct 25, 2026
  2. v0.1.3Sep 26, 2026

Score

40% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.

Other Dudko integrations

PDF to Markdown

dev.dudkoOfficial publisher

Hosted MCP front door to the pdf2md API that lets an assistant look up conversion options and get a ready-to-run request with a short-lived credential.

Streamable HTTPWeb executableAuth
Files & StorageCredential requiredOct 24, 2026

Vectorize

dev.dudkoOfficial publisher

Hosted MCP front door to the Vectorize API that lets an assistant prepare raster-to-vector tracing requests producing SVG, PDF, EPS or DXF output.

Streamable HTTPWeb executableAuth
Developer ToolsCredential requiredOct 24, 2026

Tabellum

dev.dudko

Bridges an AI assistant to the Tabellum desktop database client so it can inspect schemas, run reads and draft SQL, with writes approved in the app.

STDIODesktop only
DatabasesNot validated · the server did not complete the MCP handshakeOct 25, 2026