> ## Documentation Index
> Fetch the complete documentation index at: https://docs.codealive.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Other Agents

> Connect CodeAlive with Roo Code, KodaCode, GigaCode, Goose, and more

## Overview

CodeAlive works with any MCP-compatible AI agent. This page covers setup for agents that use standard JSON configuration. For agents with unique setup requirements, see their dedicated pages.

## General Setup

All agents below follow the same pattern:

1. Get your API key from [app.codealive.ai](https://app.codealive.ai/settings/api-keys)
2. Find the agent's MCP config file
3. Add the CodeAlive server configuration
4. Restart the agent

<Tip>
  **Quick install:** Run `npx @codealive/installer` to automatically detect and configure CodeAlive for supported agents.
  See the [Installation Guide](/installation) for details.
</Tip>

## Agent Configurations

<AccordionGroup>
  <Accordion title="Roo Code">
    Roo Code reads a JSON settings file similar to Cline.

    **Config file:** `mcp_settings.json` (Roo) or `cline_mcp_settings.json`

    **Remote HTTP:**

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

    **Docker (STDIO):**

    ```json theme={null}
    {
      "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"
          ]
        }
      }
    }
    ```

    <Info>If your Roo build doesn't honor HTTP headers, use the Docker STDIO option.</Info>
  </Accordion>

  <Accordion title="Antigravity">
    Antigravity uses a Gemini-style config format.

    **Config file:** `~/.gemini/antigravity/mcp_config.json`

    ```json theme={null}
    {
      "mcpServers": {
        "codealive": {
          "type": "streamable-http",
          "url": "https://mcp.codealive.ai/api",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY_HERE"
          }
        }
      }
    }
    ```
  </Accordion>

  <Accordion title="KodaCode">
    KodaCode provides both IDE plugins and Koda CLI. They use different configuration files and MCP formats.

    <Tabs>
      <Tab title="Koda IDE plugin">
        **Config file:** `~/.koda/config.yaml`

        The IDE plugin documents command-based MCP servers. Run CodeAlive through Docker using STDIO:

        ```yaml theme={null}
        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.
      </Tab>

      <Tab title="Koda CLI">
        * **User config:** `~/.kodacli/settings.json`
        * **Workspace config:** `<workspace>/.kodacli/settings.json`

        Koda CLI supports Streamable HTTP with `httpUrl`:

        ```json theme={null}
        {
          "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.
      </Tab>
    </Tabs>

    See the [Koda IDE MCP guide](https://docs.kodacode.ru/plugin/advanced/mcp/index.html) and [Koda CLI configuration reference](https://docs.kodacode.ru/koda-cli/cli/configuration.html).
  </Accordion>

  <Accordion title="GigaCode (Sber)">
    GigaCode uses the standard `mcpServers` object in its user configuration.

    **Config file:** `~/.gigacode/settings.json`

    GigaCode's public documentation does not currently specify a remote HTTP configuration format. Use CodeAlive's Docker STDIO transport:

    ```json theme={null}
    {
      "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.

    <Warning>
      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](https://github.com/dzenlotus/promptery). If a newer GigaCode build exposes an MCP settings UI, prefer the UI-generated configuration.
    </Warning>

    See the [official GigaCode installation guide](https://gitverse.ru/features/gigacode/install/).
  </Accordion>

  <Accordion title="Goose">
    Goose uses a UI-based setup flow.

    **Setup path:** Settings → MCP Servers → Add → choose Streamable HTTP

    **Streamable 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`
  </Accordion>

  <Accordion title="Kilo Code">
    Kilo Code uses a UI-based setup.

    **Setup path:** Manage → Integrations → Model Context Protocol (MCP) → Add Server

    **HTTP:**

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

    **STDIO (Docker):**

    ```json theme={null}
    {
      "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"
          ]
        }
      }
    }
    ```
  </Accordion>

  <Accordion title="Qwen Code">
    Qwen Code supports multiple transports (stdio/SSE/streamable-http).

    **Config file:** `~/.qwen/settings.json`

    **Streamable HTTP:**

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

    **Docker (STDIO):**

    ```json theme={null}
    {
      "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"
          ]
        }
      }
    }
    ```

    <Info>Qwen Code wraps headers in `requestOptions` — different from most other clients.</Info>
  </Accordion>

  <Accordion title="Kiro">
    Kiro does not yet support remote MCP servers natively. Use the `mcp-remote` workaround.

    **Prerequisites:**

    ```bash theme={null}
    npm install -g mcp-remote
    ```

    **Config file:** `~/.kiro/settings/mcp.json` or `.kiro/settings/mcp.json` (workspace)

    **Remote HTTP (via mcp-remote):**

    ```json theme={null}
    {
      "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):**

    ```json theme={null}
    {
      "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"
          ]
        }
      }
    }
    ```
  </Accordion>

  <Accordion title="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):**

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

    **STDIO (Docker):**

    ```json theme={null}
    {
      "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"
          ]
        }
      }
    }
    ```
  </Accordion>

  <Accordion title="JetBrains AI Assistant">
    JetBrains AI Assistant requires the `mcp-remote` workaround for remote HTTP MCP servers.

    **Prerequisites:**

    ```bash theme={null}
    npm install -g mcp-remote
    ```

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

    ```json theme={null}
    {
      "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](https://www.jetbrains.com/help/ai-assistant/mcp.html) for more details.
  </Accordion>

  <Accordion title="n8n">
    n8n connects via the AI Agent node with MCP tools.

    **Setup:**

    1. Add an **AI Agent** node to your workflow

    2. Configure the agent with MCP tools:
       * **Server URL:** `https://mcp.codealive.ai/api`
       * **Authorization Header:** `Bearer YOUR_API_KEY_HERE`

    3. The server automatically handles n8n's extra parameters (`sessionId`, `action`, `chatInput`, `toolCallId`)

    **Example Workflow:**

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

    <Info>n8n middleware is built-in — the server automatically strips n8n's extra parameters before processing tool calls.</Info>
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="MCP server not connecting">
    1. Verify your API key is correct
    2. Check the config file location and JSON syntax
    3. Ensure the `Authorization` header includes `Bearer ` prefix
    4. Restart the agent completely
  </Accordion>

  <Accordion title="Agent doesn't support HTTP transport">
    Use Docker STDIO instead — it works with every agent that supports MCP:

    ```json theme={null}
    {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "CODEALIVE_API_KEY=YOUR_API_KEY_HERE",
        "ghcr.io/codealive-ai/codealive-mcp:main"
      ]
    }
    ```
  </Accordion>

  <Accordion title="Agent requires mcp-remote">
    Some agents (Kiro, JetBrains AI) don't support remote HTTP natively. Install `mcp-remote`:

    ```bash theme={null}
    npm install -g mcp-remote
    ```

    Then use the STDIO config with `npx mcp-remote` as the command.
  </Accordion>
</AccordionGroup>

<Tip>
  For more solutions, see the [Troubleshooting Guide](/troubleshooting).
</Tip>

## Related Resources

* [MCP Overview](/integrations/mcp)
* [Installation Guide](/installation)
* [Self-Hosting Guide](/integrations/mcp/self-hosting)
* [GitHub Repository](https://github.com/CodeAlive-AI/codealive-mcp)

## Instruct Your Agent

Connecting CodeAlive makes its tools available, but the agent may still default to its built-in search. For reliable results, add a short instruction in the agent's native format telling it to prefer `semantic_search` and `grep_search` when exploring indexed code. See [Instructing Coding Agents](https://docs.codealive.ai/guides/instructing-agents).