jcode MCP Servers: Setup and Configuration

MCP (Model Context Protocol) lets an agent reach outside its own built in tools and call a separate server for things like file access, a database, or another integration. jcode can read MCP servers you’ve already set up for Claude Code or Codex, or you can configure them for jcode directly.

This page covers where jcode looks for MCP servers, how to write an entry, and what to expect once one is running.

If you haven’t installed jcode yet, start with the installation guide first, then come back here once you’ve logged into a provider.

Where jcode looks for MCP servers

MCP servers are configured separately from jcode’s main settings file (config.toml, which lives at ~/.jcode/config.toml). MCP servers get their own files instead, and which file you use depends on how widely you want that server available.

File	Scope
~/.jcode/mcp.json	Every project on this machine
.jcode/mcp.json	Only the project it lives in

Use the global file for servers you want on hand no matter what you’re working on, things like a search server or a database you reach for across projects.

Use the project local file for anything specific to that one repo, such as a server pointed at that project’s own files or a project specific API.

Reusing a Claude Code or Codex setup

If you’ve already configured MCP servers for Claude Code, you don’t need to write them twice. jcode reads Claude Code’s own configuration directly: the user level ~/.claude.json (including servers defined for a specific project, stored under that project’s own entry inside the file), the repo level .mcp.json at a project’s root, and, for older Claude Code installs, the legacy ~/.claude/mcp.json fallback.

On the very first run, if jcode’s own ~/.jcode/mcp.json doesn’t exist yet, jcode imports whatever servers it can find in Claude Code’s configuration and in Codex’s configuration (~/.codex/config.toml) automatically.

After that first import, jcode reads its own file going forward, so you’re free to edit it independently of whatever Claude Code or Codex still have configured.

For compatibility with configs written for early jcode releases, both the standard mcpServers key and jcode’s older servers key are still recognized.

New entries should use mcpServers, since that’s what Claude Code and Codex configs also use.

Writing a server entry

Every entry needs a name, the command that starts the server, and its arguments.

Here’s the shape jcode expects, in either mcp.json file:

{
  "mcpServers": {
    "filesystem": {
      "command": "/path/to/mcp-server",
      "args": ["--root", "/workspace"],
      "env": {}
    }
  }
}

• The key (filesystem here) is just a label. Both jcode and the model use it to refer to the server, so pick something you’ll recognize later.
• command is the executable jcode runs to start the server. It needs to be a full path, or a command already on your PATH.
• args is the list of command line arguments passed to that command, in order.
• env sets environment variables for the server process. Leave it as an empty object if the server doesn’t need any.

What kind of servers jcode supports?

jcode currently runs stdio servers only, meaning ones that start as a local command and communicate over standard input and output. If an entry points at an HTTP or SSE (server sent events) server instead, jcode recognizes the entry, logs that it’s skipping it, and carries on rather than failing to start.

In practice, that means a server only reachable over HTTP or SSE won’t do anything inside jcode yet, even if the entry itself is written correctly.

Startup stays fast, even with a slow server

One detail worth knowing: jcode doesn’t wait on a live handshake with every configured server before your session starts.

It advertises each server’s tools right away, using a schema it already has cached on disk from a previous run.

A server that’s slow to respond, or briefly unreachable, doesn’t hold up jcode’s startup and doesn’t force it to throw away the prompt cache the way waiting on a live connection would.

Adding a server, step by step

1. Decide whether the server belongs in the global file or a single project’s file, based on where you want it available.
2. Open, or create, that file: ~/.jcode/mcp.json for global, .jcode/mcp.json inside the project for project local.
3. Add an entry under mcpServers with a name, command, args, and env, following the shape above.
4. Save the file, then start a new jcode session so it picks up the change.
5. Ask the agent to use the new server, or check the tool list inside the session to confirm it showed up.

For the current, version matched reference, see jcode’s official MCP documentation.