One MCP Configuration for Codex, Claude, Cursor, and Copilot with chezmoi

Source: Dev.to

When you use multiple coding agents on several machines, MCP configuration drift is inevitable—unless you make one file the source of truth.
The following guide shows a practical, reproducible setup for:

• Codex
• Claude Code
• Cursor
• GitHub Copilot (including VS Code and Copilot‑coding‑agent scenarios)

Core Idea

1. Keep one canonical MCP manifest in your chezmoi source state.
2. Generate each tool’s native config format from that manifest.
3. Let chezmoi manage symlinks / templates and machine‑specific values.

All four tools model MCP servers with the same conceptual fields:

What differs is file location and schema shape.
Instead of editing four formats manually, you maintain one normalized model and project it into each target file.

Tool‑Specific Storage Details

Canonical MCP Manifest

Create a single YAML file that describes all servers. Example:

# dot_config/mcp/servers.yaml
servers:
  github:
    transport: http
    url: "https://api.githubcopilot.com/mcp/"
    headers:
      Authorization: "Bearer ${GITHUB_TOKEN}"

  filesystem:
    transport: stdio
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/Users/lukas"]
    env:
      NODE_NO_WARNINGS: "1"

Tip: Store secrets (${GITHUB_TOKEN}) in encrypted/ private files (see Security below).

Directory Layout (chezmoi source state)

~/.local/share/chezmoi/
├─ .chezmoitemplates/
│   └─ mcp/
│       ├─ codex-config.toml.tmpl
│       ├─ claude-mcp.json.tmpl
│       ├─ cursor-mcp.json.tmpl
│       ├─ vscode-mcp.json.tmpl
│       └─ copilot-mcp-config.json.tmpl
├─ dot_config/
│   └─ mcp/
│       └─ servers.yaml          ← canonical model (committed)
├─ dot_codex/
│   └─ config.toml.tmpl
├─ dot_claude/
│   └─ mcp_servers.json.tmpl
├─ dot_cursor/
│   └─ mcp.json.tmpl
├─ dot_vscode/
│   └─ mcp.json.tmpl
└─ dot_copilot/
    └─ mcp-config.json.tmpl

• Files under .chezmoitemplates are reusable snippets.
• Templates are recognized by the .tmpl suffix (or by living inside .chezmoitemplates).
• Machine facts such as .chezmoi.os and .chezmoi.hostname are available inside templates.

Example Template Logic

{{- /* Render internal server only on work laptop */ -}}
{{- if eq .chezmoi.hostname "work-laptop" -}}
{
  "name": "internal",
  "type": "http",
  "url": "https://internal.example.com/mcp/",
  "headers": {
    "Authorization": "Bearer ${INTERNAL_TOKEN}"
  }
}
{{- end -}}

You can also vary filesystem roots, company‑only servers, etc., based on .chezmoi.os, .chezmoi.hostname, or any custom fact.

Source‑State Attributes (chezmoi)

Recommended split

• Committed – servers.yaml (topology, non‑secret data)
• Encrypted / private – per‑machine secrets (tokens, passwords)

Render env‑var references (${GITHUB_TOKEN}) into the final tool configs.

Transformation Rules (once, in templates)

Applying the Configuration

# From your chezmoi repo root
chezmoi apply

chezmoi will:

• Render each template using the canonical servers.yaml (and any encrypted/private files).
• Place the resulting files in the appropriate locations:

~/.codex/config.toml               ← MCP block
~/.claude.json   or   .mcp.json    ← projection
~/.cursor/mcp.json
.vscode/mcp.json
~/.copilot/mcp-config.json

Never edit the generated targets directly – always modify the source model or templates and re‑run chezmoi apply.

Security & Reproducibility

• Strict reproducibility – generate all config files from templates; source‑only edits.
• Secret handling – keep tokens in encrypted_ files or external secret managers; reference them via environment variables in the templates.
• Version control – only the canonical model (servers.yaml) and template files are committed.

Quick Reference Links

• chezmoi – templating guide, machine facts, source‑state attributes
• OpenAI Codex MCP – advanced config docs
• Anthropic Claude Code MCP – settings overview
• Cursor MCP – official docs page confirming first‑class MCP support
• VS Code MCP – workspace (.vscode/mcp.json) and user config
• GitHub Copilot MCP – coding‑agent configuration

TL;DR

1. One canonical YAML model (servers.yaml).
2. Templates for each tool’s native format.
3. chezmoi manages rendering, symlinks, and machine‑specific overrides (private/encrypted).

Result: Consistent, drift‑free MCP configuration across Codex, Claude, Cursor, and Copilot without locking yourself into any single vendor schema.

# Copilot coding agent MCP

## skills-sync agent storage map