CodeAlive MCP: Deep Context for your project (especially for large codebases)

Connect your AI assistant to CodeAlive's powerful code understanding platform in seconds!

This MCP (Model Context Protocol) server enables AI clients like Claude Code, Cursor, Claude Desktop, Continue, VS Code (GitHub Copilot), and Cline to access CodeAlive's advanced semantic code search and codebase interaction features.

What is CodeAlive?

CodeAlive analyzes your entire codebase to understand its structure, patterns, and logic. It creates a detailed internal map of your repositories, enabling AI assistants to:

Find relevant code faster with semantic search
Understand the bigger picture beyond isolated files
Provide better answers with full project context
Reduce costs and time by eliminating guesswork

🛠 Available Tools

Once connected, you'll have access to these powerful tools:

get_data_sources - List your indexed repositories and workspaces
search_code - Semantic code search across your codebase
chat_completions - AI chat with full project context

🎯 Usage Examples

After setup, try these commands with your AI assistant:

"Show me all available repositories" → Uses get_data_sources
"Find authentication code in the user service" → Uses search_code
"Explain how the payment flow works in this codebase" → Uses chat_completions

🚀 Quick Start (Remote)

The fastest way to get started - no installation required! Our remote MCP server at https://mcp.codealive.ai/api/ provides instant access to CodeAlive's capabilities.

Step 1: Get Your API Key

Sign up at https://app.codealive.ai/
Navigate to API Keys (under Organization)
Click "+ Create API Key"
Copy your API key immediately - you won't see it again!

Step 2: Choose Your AI Client

Select your preferred AI client below for instant setup:

🤖 AI Client Integrations

Claude Code

One command setup:

claude mcp add --transport http codealive https://mcp.codealive.ai/api/ --header "Authorization: Bearer YOUR_API_KEY_HERE"

Replace YOUR_API_KEY_HERE with your actual API key. That's it! 🎉

Cursor

Open Cursor → Settings (Cmd+, or Ctrl+,)
Navigate to "MCP" in the left panel
Click "Add new MCP server"
Paste this configuration:

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

Save and restart Cursor

Continue

Create/edit .continue/config.yaml in your project or ~/.continue/config.yaml
Add this configuration:

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

Restart VS Code

Visual Studio Code with GitHub Copilot

Open Command Palette (Ctrl+Shift+P or Cmd+Shift+P)
Run "MCP: Add Server"
Choose "HTTP" server type
Enter this configuration:

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

Restart VS Code

Claude Desktop

Note: Claude Desktop remote MCP requires OAuth authentication. Use Docker option below for Bearer token support.

Cline

Open Cline extension in VS Code
Click the MCP Servers icon to configure
Add this configuration to your MCP settings:

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

Save and restart VS Code

🐳 Alternative: Docker Setup

If you prefer Docker over the remote service, use our Docker image:

Claude Desktop with Docker

For local development or if you prefer Docker over the remote service:

Edit your config file:
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json
Add this configuration:

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

Restart Claude Desktop

Cursor with Docker

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

Continue with Docker

mcpServers:
  - name: CodeAlive
    type: stdio
    command: docker
    args:
      - run
      - --rm
      - -i
      - -e
      - CODEALIVE_API_KEY=YOUR_API_KEY_HERE
      - ghcr.io/codealive-ai/codealive-mcp:main

VS Code with Docker

Create .vscode/mcp.json in your workspace:

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

Cline with Docker

Open Cline extension in VS Code
Click the MCP Servers icon to configure
Add this Docker configuration:

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

🔧 Advanced: Local Development

For developers who want to customize or contribute to the MCP server.

Prerequisites

Python 3.11+
uv (recommended) or pip

Installation

# Clone the repository
git clone https://github.com/CodeAlive-AI/codealive-mcp.git
cd codealive-mcp

# Setup with uv (recommended)
uv venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
uv pip install -e .

# Or setup with pip
python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate  
pip install -e .

Local Server Configuration

Once installed locally, configure your AI client to use the local server:

Claude Code (Local)

claude mcp add codealive-local /path/to/codealive-mcp/.venv/bin/python /path/to/codealive-mcp/src/codealive_mcp_server.py --env CODEALIVE_API_KEY=YOUR_API_KEY_HERE

Other Clients (Local)

Replace the Docker command and args with:

{
  "command": "/path/to/codealive-mcp/.venv/bin/python",
  "args": ["/path/to/codealive-mcp/src/codealive_mcp_server.py"],
  "env": {
    "CODEALIVE_API_KEY": "YOUR_API_KEY_HERE"
  }
}

Running HTTP Server Locally

# Start local HTTP server
export CODEALIVE_API_KEY="your_api_key_here"
python src/codealive_mcp_server.py --transport http --host localhost --port 8000

# Test health endpoint
curl http://localhost:8000/health

Smithery Installation

Auto-install for Claude Desktop via Smithery:

npx -y @smithery/cli install @CodeAlive-AI/codealive-mcp --client claude

🐞 Troubleshooting

Quick Diagnostics

Test the hosted service:
```
curl https://mcp.codealive.ai/health
```

Check your API key:

curl -H "Authorization: Bearer YOUR_API_KEY" https://app.codealive.ai/api/v1/data_sources

Enable debug logging: Add --debug to local server args

Common Issues

"Connection refused" → Check internet connection
"401 Unauthorized" → Verify your API key
"No repositories found" → Check API key permissions in CodeAlive dashboard
Client-specific logs → See your AI client's documentation for MCP logs

Getting Help

📧 Email: support@codealive.ai
🐛 Issues: GitHub Issues

📄 License

MIT License - see LICENSE file for details.

Ready to supercharge your AI assistant with deep code understanding?
Get started now →

Name		Name	Last commit message	Last commit date
Latest commit History 27 Commits
.github/workflows		.github/workflows
src		src
.gitignore		.gitignore
CLAUDE.md		CLAUDE.md
Dockerfile		Dockerfile
LICENSE		LICENSE
README.md		README.md
pyproject.toml		pyproject.toml
smithery.yaml		smithery.yaml
uv.lock		uv.lock

License

CodeAlive-AI/codealive-mcp

Folders and files

Latest commit

History

Repository files navigation