Other Agents

Roo Code

Roo Code reads a JSON settings file similar to Cline.Config file: mcp_settings.json (Roo) or cline_mcp_settings.jsonRemote HTTP:

{
  "mcpServers": {
    "codealive": {
      "type": "streamable-http",
      "url": "https://mcp.codealive.ai/api",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY_HERE"
      }
    }
  }
}

Docker (STDIO):

{
  "mcpServers": {
    "codealive": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "CODEALIVE_API_KEY=YOUR_API_KEY_HERE",
        "ghcr.io/codealive-ai/codealive-mcp:main"
      ]
    }
  }
}

If your Roo build doesn’t honor HTTP headers, use the Docker STDIO option.

Antigravity

Antigravity uses a Gemini-style config format.Config file: ~/.gemini/antigravity/mcp_config.json

{
  "mcpServers": {
    "codealive": {
      "type": "streamable-http",
      "url": "https://mcp.codealive.ai/api",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY_HERE"
      }
    }
  }
}

KodaCode

KodaCode provides both IDE plugins and Koda CLI. They use different configuration files and MCP formats.

Koda IDE plugin
Koda CLI

Config file: ~/.koda/config.yamlThe IDE plugin documents command-based MCP servers. Run CodeAlive through Docker using STDIO:

mcpServers:
  - name: "codealive"
    command: "docker"
    args:
      - "run"
      - "--rm"
      - "-i"
      - "-e"
      - "CODEALIVE_API_KEY"
      - "ghcr.io/codealive-ai/codealive-mcp:main"
    env:
      CODEALIVE_API_KEY: ${CODEALIVE_API_KEY}

Set CODEALIVE_API_KEY in the environment before starting the IDE, then open Koda Settings → MCP. A Connected status confirms the server is available. In Agent mode, open Tools to review the discovered CodeAlive tools and their approval policies.

User config: ~/.kodacli/settings.json
Workspace config: <workspace>/.kodacli/settings.json

Koda CLI supports Streamable HTTP with httpUrl:

{
  "mcpServers": {
    "codealive": {
      "httpUrl": "https://mcp.codealive.ai/api",
      "headers": {
        "Authorization": "Bearer ${CODEALIVE_API_KEY}"
      }
    }
  }
}

Set CODEALIVE_API_KEY in the terminal environment, restart Koda CLI, and run /mcp to inspect the connection and available tools.

See the Koda IDE MCP guide and Koda CLI configuration reference.

GigaCode (Sber)

GigaCode uses the standard mcpServers object in its user configuration.Config file: ~/.gigacode/settings.jsonGigaCode’s public documentation does not currently specify a remote HTTP configuration format. Use CodeAlive’s Docker STDIO transport:

{
  "mcpServers": {
    "codealive": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "CODEALIVE_API_KEY=YOUR_API_KEY_HERE",
        "ghcr.io/codealive-ai/codealive-mcp:main"
      ]
    }
  }
}

Replace YOUR_API_KEY_HERE, save the file, and fully restart the IDE. Open GigaCode’s agent mode and confirm that CodeAlive MCP tools are available before using them.

External MCP configuration is not covered by the current public GigaCode documentation. The config path and mcpServers format are corroborated by Promptery’s GigaCode installer. If a newer GigaCode build exposes an MCP settings UI, prefer the UI-generated configuration.

See the official GigaCode installation guide.

Goose

Goose uses a UI-based setup flow.Setup path: Settings → MCP Servers → Add → choose Streamable HTTPStreamable HTTP configuration:

Name: codealive
Endpoint URL: https://mcp.codealive.ai/api
Headers: Authorization: Bearer YOUR_API_KEY_HERE

Docker (STDIO) alternative: Add a STDIO extension with:

Command: docker
Args: run --rm -i -e CODEALIVE_API_KEY=YOUR_API_KEY_HERE ghcr.io/codealive-ai/codealive-mcp:main

Kilo Code

Kilo Code uses a UI-based setup.Setup path: Manage → Integrations → Model Context Protocol (MCP) → Add ServerHTTP:

{
  "mcpServers": {
    "codealive": {
      "type": "streamable-http",
      "url": "https://mcp.codealive.ai/api",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY_HERE"
      }
    }
  }
}

STDIO (Docker):

{
  "mcpServers": {
    "codealive": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "CODEALIVE_API_KEY=YOUR_API_KEY_HERE",
        "ghcr.io/codealive-ai/codealive-mcp:main"
      ]
    }
  }
}

Qwen Code

Qwen Code supports multiple transports (stdio/SSE/streamable-http).Config file: ~/.qwen/settings.jsonStreamable HTTP:

{
  "mcpServers": {
    "codealive": {
      "type": "streamable-http",
      "url": "https://mcp.codealive.ai/api",
      "requestOptions": {
        "headers": {
          "Authorization": "Bearer YOUR_API_KEY_HERE"
        }
      }
    }
  }
}

Docker (STDIO):

{
  "mcpServers": {
    "codealive": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "CODEALIVE_API_KEY=YOUR_API_KEY_HERE",
        "ghcr.io/codealive-ai/codealive-mcp:main"
      ]
    }
  }
}

Qwen Code wraps headers in requestOptions — different from most other clients.

Kiro

Kiro does not yet support remote MCP servers natively. Use the mcp-remote workaround.Prerequisites:

npm install -g mcp-remote

Config file: ~/.kiro/settings/mcp.json or .kiro/settings/mcp.json (workspace)Remote HTTP (via mcp-remote):

{
  "mcpServers": {
    "codealive": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.codealive.ai/api",
        "--header",
        "Authorization: Bearer ${CODEALIVE_API_KEY}"
      ],
      "env": {
        "CODEALIVE_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}

Docker (STDIO):

{
  "mcpServers": {
    "codealive": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "CODEALIVE_API_KEY=YOUR_API_KEY_HERE",
        "ghcr.io/codealive-ai/codealive-mcp:main"
      ]
    }
  }
}

Qoder

Qoder uses a UI-based setup with SSE transport.Setup path: User icon → Qoder Settings → MCP → My Servers → + Add (Agent mode)SSE (remote HTTP):

{
  "mcpServers": {
    "codealive": {
      "type": "sse",
      "url": "https://mcp.codealive.ai/api",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY_HERE"
      }
    }
  }
}

STDIO (Docker):

{
  "mcpServers": {
    "codealive": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "CODEALIVE_API_KEY=YOUR_API_KEY_HERE",
        "ghcr.io/codealive-ai/codealive-mcp:main"
      ]
    }
  }
}

JetBrains AI Assistant

JetBrains AI Assistant requires the mcp-remote workaround for remote HTTP MCP servers.Prerequisites:

npm install -g mcp-remote

Setup path: Settings/Preferences → AI Assistant → Model Context Protocol → Configure

{
  "mcpServers": {
    "codealive": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.codealive.ai/api",
        "--header",
        "Authorization: Bearer ${CODEALIVE_API_KEY}"
      ],
      "env": {
        "CODEALIVE_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}

See JetBrains MCP Documentation for more details.

n8n

n8n connects via the AI Agent node with MCP tools.Setup:

Add an AI Agent node to your workflow
Configure the agent with MCP tools:
- Server URL: https://mcp.codealive.ai/api
- Authorization Header: Bearer YOUR_API_KEY_HERE
The server automatically handles n8n’s extra parameters (sessionId, action, chatInput, toolCallId)

Example Workflow:

Trigger → AI Agent (with CodeAlive MCP tools) → Process Response

n8n middleware is built-in — the server automatically strips n8n’s extra parameters before processing tool calls.

MCP server not connecting

Verify your API key is correct
Check the config file location and JSON syntax
Ensure the Authorization header includes Bearer prefix
Restart the agent completely

Agent doesn't support HTTP transport

Use Docker STDIO instead — it works with every agent that supports MCP:

{
  "command": "docker",
  "args": [
    "run", "--rm", "-i",
    "-e", "CODEALIVE_API_KEY=YOUR_API_KEY_HERE",
    "ghcr.io/codealive-ai/codealive-mcp:main"
  ]
}

Agent requires mcp-remote

Some agents (Kiro, JetBrains AI) don’t support remote HTTP natively. Install mcp-remote:

npm install -g mcp-remote

Then use the STDIO config with npx mcp-remote as the command.

Getting Started

Features

Model Context Protocol

Agent Skills & Plugins

Instructing Agents

Overview

General Setup

Agent Configurations

Troubleshooting

Instruct Your Agent

​Overview

​General Setup

​Agent Configurations

​Troubleshooting

​Related Resources

​Instruct Your Agent

Overview

General Setup

Agent Configurations

Troubleshooting

Related Resources

Instruct Your Agent