Set Up MCP Clients

Connect Citlyze to Claude Desktop, Cursor, Codex, OpenCode, VS Code, Windsurf, Gemini CLI, JetBrains, Cline, Continue, and custom MCP clients.

Use this page for MCP clients that can connect to a remote Streamable HTTP server and send custom request headers.

Connection details

Setting	Value
Server name	`citlyze`
Transport	Streamable HTTP, usually named `http` or `streamable-http`
URL	`https://app.citlyze.com/api/mcp`
Header	`Authorization: Bearer aeo_live_...`

The public API index also reports:

{
  "mcp_endpoint": "/api/mcp"
}

Common clients

Client	Recommended setup
Claude Code	Use the CLI flow in Set Up Claude Code.
Cursor	Use the dedicated guide: Set Up Cursor.
OpenAI Codex	Use the dedicated guide: Set Up Codex.
OpenCode	Use the dedicated guide: Set Up OpenCode.
Claude Desktop	Use the generic JSON shape below if your installed version supports remote HTTP MCP servers.
VS Code / GitHub Copilot	Use the VS Code `servers` shape below in `.vscode/mcp.json` or user MCP config.
Windsurf / Cascade	Use the Windsurf `serverUrl` shape below.
Gemini CLI	Install the Citlyze extension; see the Gemini CLI section below.
JetBrains AI Assistant	Add the remote server in IDE settings; see the JetBrains section below.
Cline / Roo Code	Use the generic JSON shape below if the extension supports remote Streamable HTTP.
Continue	Use the generic JSON shape below if the installed version supports remote MCP.
OpenAI Agents SDK and custom agents	Configure a Streamable HTTP MCP client with the URL and authorization header above.

If a client only supports local stdio MCP servers, use the mcp-remote bridge section below.

If a client cannot send custom HTTP headers, it cannot connect directly to Citlyze, because Citlyze requires the Authorization header.

Clients that use an mcpServers JSON object can start from this shape. Try type: "http" first. If the client expects the protocol name instead, use type: "streamable-http". Codex and OpenCode use their own config formats; see their dedicated guides linked above.

{
  "mcpServers": {
    "citlyze": {
      "type": "http",
      "url": "https://app.citlyze.com/api/mcp",
      "headers": {
        "Authorization": "Bearer aeo_live_..."
      }
    }
  }
}

Do not put the API key in the URL.

Claude Desktop

For Claude Desktop versions that support remote HTTP MCP servers, add the generic JSON shape to the Claude Desktop MCP configuration file and restart the app.

If your Claude Desktop build only supports local stdio servers, use mcp-remote or another local bridge that can forward headers:

{
  "mcpServers": {
    "citlyze": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://app.citlyze.com/api/mcp",
        "--header",
        "Authorization: Bearer aeo_live_..."
      ]
    }
  }
}

VS Code / GitHub Copilot

VS Code uses a servers object in .vscode/mcp.json or the user MCP configuration.

{
  "servers": {
    "citlyze": {
      "type": "http",
      "url": "https://app.citlyze.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${input:citlyzeApiKey}"
      }
    }
  },
  "inputs": [
    {
      "id": "citlyzeApiKey",
      "type": "promptString",
      "description": "Citlyze API key",
      "password": true
    }
  ]
}

Prefer input variables or environment-backed secrets over committing API keys to a workspace file.

Windsurf / Cascade

Windsurf stores MCP configuration in ~/.codeium/windsurf/mcp_config.json. Remote HTTP servers use serverUrl or url.

{
  "mcpServers": {
    "citlyze": {
      "serverUrl": "https://app.citlyze.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:CITLYZE_API_KEY}"
      }
    }
  }
}

Gemini CLI

Install the Citlyze extension, which configures the server for you:

gemini extensions install https://github.com/citlyze/citlyze-mcp

Then export your API key in the shell you start Gemini CLI from:

export CITLYZE_API_KEY="aeo_live_..."

If your Gemini CLI version does not expand environment variables in extension headers, run gemini extensions edit citlyze and replace ${CITLYZE_API_KEY} with the key itself. Without the extension, you can also add the generic httpUrl shape to ~/.gemini/settings.json:

{
  "mcpServers": {
    "citlyze": {
      "httpUrl": "https://app.citlyze.com/api/mcp",
      "headers": {
        "Authorization": "Bearer aeo_live_..."
      }
    }
  }
}

JetBrains AI Assistant

JetBrains IDEs (IntelliJ IDEA, WebStorm, PyCharm, GoLand, and others) support remote MCP servers through the AI Assistant plugin.

Open Settings, then Tools, then AI Assistant, then Model Context Protocol (MCP).
Choose Add, switch to As JSON, and paste the generic JSON shape from above.
Apply the settings and start a new AI Assistant chat. The citlyze tools appear once the connection succeeds.

Older AI Assistant builds without a JSON option accept the same values in the form fields: transport Streamable HTTP (or SSE/HTTP), the server URL, and an Authorization header with the bearer key.

Custom HTTP clients

Custom agents should initialize MCP over Streamable HTTP at:

https://app.citlyze.com/api/mcp

Send the API key on every request:

Authorization: Bearer aeo_live_...

Clients must support HTTP MCP responses that return either JSON or text/event-stream.