# just for you
claude mcp add congressmcp --env CONGRESS_API_KEY=your-api-key-here -- uvx congressmcp

# shared with your team via .mcp.json in the repo root
claude mcp add --scope project congressmcp --env CONGRESS_API_KEY='${CONGRESS_API_KEY}' -- uvx congressmcp

Put the server name before --env as shown — if --env comes first, the CLI tries to parse the name as another KEY=value pair. Equivalent .mcp.json:

{
  "mcpServers": {
    "congressmcp": {
      "type": "stdio",
      "command": "uvx",
      "args": ["congressmcp"],
      "env": { "CONGRESS_API_KEY": "${CONGRESS_API_KEY}" }
    }
  }
}

${VAR} / ${VAR:-default} are expanded from your environment, so the key never has to be committed.

Workspace: .vscode/mcp.json (or Command Palette → MCP: Add Server / MCP: Open User Configuration for user-level). VS Code uses servers rather than mcpServers, and inputs lets it prompt for the key and store it securely instead of writing it to disk:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "congress-api-key",
      "description": "Congress.gov API key",
      "password": true
    }
  ],
  "servers": {
    "congressmcp": {
      "type": "stdio",
      "command": "uvx",
      "args": ["congressmcp"],
      "env": { "CONGRESS_API_KEY": "${input:congress-api-key}" }
    }
  }
}

VS Code shows a trust prompt the first time the server starts.

codex mcp add congressmcp --env CONGRESS_API_KEY=your-api-key-here -- uvx congressmcp

Or in ~/.codex/config.toml (also read by the Codex IDE extension and the ChatGPT desktop app; project-level .codex/config.toml works in trusted projects):

[mcp_servers.congressmcp]
command = "uvx"
args = ["congressmcp"]
env_vars = ["CONGRESS_API_KEY"]   # forward from your shell — nothing secret in the file

To inline the key instead, replace the env_vars line with a [mcp_servers.congressmcp.env] table containing CONGRESS_API_KEY = "…". Check with codex mcp list or /mcp inside a session.

Global: ~/.cursor/mcp.json. Per-project: .cursor/mcp.json.

{
  "mcpServers": {
    "congressmcp": {
      "command": "uvx",
      "args": ["congressmcp"],
      "env": { "CONGRESS_API_KEY": "${env:CONGRESS_API_KEY}" }
    }
  }
}

${env:NAME} reads from your shell environment; a literal key string works too.

AI Assistant: Settings → Tools → AI Assistant → Model Context Protocol (MCP) → Add → As JSON and paste the Claude Desktop block (there's also an Import from Claude button that reads claude_desktop_config.json).

Junie: Settings → Tools → Junie → MCP Settings, which edits ~/.junie/mcp/mcp.json (global) or .junie/mcp/mcp.json (project) — same mcpServers shape.

Global ~/.config/opencode/opencode.json or project-root opencode.json / opencode.jsonc (project overrides global). OpenCode puts the command and its args in one array and calls the env map environment:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "congressmcp": {
      "type": "local",
      "command": ["uvx", "congressmcp"],
      "environment": { "CONGRESS_API_KEY": "your-api-key-here" },
      "enabled": true
    }
  }
}

There's no opencode mcp add; edit the file, then check with opencode mcp list / opencode mcp debug congressmcp. Remote servers use "type": "remote", "url": "https://<host>/mcp".

gemini mcp add -s user -e CONGRESS_API_KEY=your-api-key-here congressmcp uvx congressmcp

(-s user makes it global; the default scope is the current project.) Or in ~/.gemini/settings.json / .gemini/settings.json:

{
  "mcpServers": {
    "congressmcp": {
      "command": "uvx",
      "args": ["congressmcp"],
      "env": { "CONGRESS_API_KEY": "$CONGRESS_API_KEY" }
    }
  }
}

Claude menu → Settings… → Developer → Edit Config, or edit the file directly:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "congressmcp": {
      "command": "uvx",
      "args": ["congressmcp"],
      "env": { "CONGRESS_API_KEY": "your-api-key-here" }
    }
  }
}

Restart Claude Desktop. If the server doesn't appear, use the absolute path to uvx (which uvx / where uvx) — GUI apps don't always inherit your shell PATH. Logs: ~/Library/Logs/Claude/mcp*.log or %APPDATA%\Claude\logs.

Cascade panel → MCPs icon → raw config, or edit ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "congressmcp": {
      "command": "uvx",
      "args": ["congressmcp"],
      "env": { "CONGRESS_API_KEY": "${env:CONGRESS_API_KEY}" }
    }
  }
}

Windsurf caps total tools across all servers at 100; CongressMCP registers 24 (each bundling related operations), so it fits comfortably.

Settings → AI → MCP Servers → Add Local Server, or edit settings.json (macOS ~/Library/Application Support/Zed/settings.json, Linux ~/.config/zed/settings.json, Windows %APPDATA%\Zed\settings.json; project-level .zed/settings.json):

{
  "context_servers": {
    "congressmcp": {
      "command": "uvx",
      "args": ["congressmcp"],
      "env": { "CONGRESS_API_KEY": "your-api-key-here" }
    }
  }
}

Cline: MCP Servers icon → Configure → Configure MCP Servers (opens cline_mcp_settings.json; the Cline CLI uses ~/.cline/mcp.json). Roo Code: MCP Servers → Edit Global MCP, or per-project .roo/mcp.json.

Both use the Claude Desktop shape plus a couple of client-specific fields:

{
  "mcpServers": {
    "congressmcp": {
      "command": "uvx",
      "args": ["congressmcp"],
      "env": { "CONGRESS_API_KEY": "your-api-key-here" },
      "disabled": false,
      "autoApprove": []
    }
  }
}

On Windows, Roo's docs recommend wrapping the command: "command": "cmd", "args": ["/c", "uvx", "congressmcp"].

Interactive: goose configure → Add Extension → Command-line Extension (command uvx congressmcp, then add CONGRESS_API_KEY when prompted for env vars). One-off: goose session --with-extension "CONGRESS_API_KEY=your-api-key-here uvx congressmcp". Or in ~/.config/goose/config.yaml:

extensions:
  congressmcp:
    name: congressmcp
    type: stdio
    cmd: uvx
    args: [congressmcp]
    envs: { "CONGRESS_API_KEY": "your-api-key-here" }
    enabled: true
    timeout: 300

xAI's terminal coding agent. If you already configured CongressMCP for Claude Code (~/.claude.json / .mcp.json) or Cursor (.cursor/mcp.json), Grok Build picks it up automatically — nothing more to do. Otherwise:

grok mcp add congressmcp -- uvx congressmcp      # add --scope project for .grok/config.toml

then set the key in ~/.grok/config.toml (or project .grok/config.toml):

[mcp_servers.congressmcp]
command = "uvx"
args = ["congressmcp"]
env = { CONGRESS_API_KEY = "${CONGRESS_API_KEY}" }

grok mcp list / grok mcp doctor congressmcp to verify; /mcps in a session toggles servers. Tools appear as congressmcp__<tool>.

Nous Research's Hermes Agent. ~/.hermes/config.yaml:

mcp_servers:
  congressmcp:
    command: "uvx"
    args: ["congressmcp"]
    env:
      CONGRESS_API_KEY: "${CONGRESS_API_KEY}"   # or a literal key
    enabled: true

Or hermes mcp add congressmcp --command uvx --args congressmcp and then add the env: block by hand. hermes mcp test congressmcp checks the connection; /reload-mcp in a session reloads without restarting. Tools appear as mcp__congressmcp__<tool>.

openclaw mcp add congressmcp --command uvx --arg congressmcp --env CONGRESS_API_KEY=your-api-key-here

Or under mcp.servers in ~/.openclaw/openclaw.json (JSON5, so comments and trailing commas are fine):

{
  mcp: {
    servers: {
      congressmcp: {
        command: "uvx",
        args: ["congressmcp"],
        env: { CONGRESS_API_KEY: "your-api-key-here" },
      },
    },
  },
}

openclaw mcp status / openclaw mcp probe congressmcp to verify. OpenClaw does not read mcporter's registry — use mcp.servers. For a remote server, use url with an explicit transport: "streamable-http".

~/.continue/config.yaml, or one file per server under .continue/mcpServers/ in your workspace (Continue also accepts Claude/Cursor-style JSON files dropped in that folder). MCP tools are available in agent mode.

mcpServers:
  - name: congressmcp
    type: stdio
    command: uvx
    args:
      - congressmcp
    env:
      CONGRESS_API_KEY: ${{ secrets.CONGRESS_API_KEY }}

Program tab → Install → Edit mcp.json. LM Studio follows Cursor's mcp.json format, so the Cursor block works as-is — use a literal key string rather than ${env:…}. This gives any local model that supports tool calling access to congressional data.

These clients can't launch a local process; they connect to an MCP server at a URL. Run CongressMCP in HTTP mode and give them the URL:

• ChatGPT (Plus/Pro/Business/Enterprise/Edu, web): Settings → Security and login → Developer mode, then add a connector with your server URL. Requires a public HTTPS endpoint (or a Secure MCP Tunnel).
• Claude.ai (web; synced to mobile): Customize → Connectors → Add custom connector (Team/Enterprise: Organization settings → Connectors). Must be reachable over the public internet.
• Open WebUI: Admin Settings → Integrations → + Add Server → MCP (Streamable HTTP). Streamable HTTP only; it can be on your LAN.

The endpoint in every case is https://<your-host>/mcp. Most of the local clients above (OpenCode, Grok Build, Hermes, OpenClaw, Codex, Claude Code, Cursor, VS Code) can also connect to that URL instead of launching uvx — useful for sharing one install across a team.