CodeAlive MCP: Tiefer Kontext für Ihr Projekt (insbesondere für große Codebasen)

Dieser MCP-Server (Model Context Protocol) für die CodeAlive-API ermöglicht KI-Clients wie Claude Desktop, Cursor, Windserf, VS Code (GitHub Copilot), Cline, Roo-Code und Refact den Zugriff auf die erweiterten Funktionen zur semantischen Codesuche und Codebase-Interaktion von CodeAlive.

CodeAlive MCP verbessert diese Agenten, indem es einen erweiterten Kontext aus der Codebasis Ihres Projekts bereitstellt und so intelligentere und effizientere Interaktionen ermöglicht.

Was ist CodeAlive?

CodeAlive ist eine Plattform, die Ihre gesamte Codebasis inklusive Dokumentation und Abhängigkeiten analysiert, um deren Struktur, Muster und Logik zu verstehen. Sie erstellt eine detaillierte interne Karte Ihrer Repositories oder Arbeitsbereiche und ermöglicht IT-Experten so schnelle, zuverlässige und qualitativ hochwertige Antworten auf Fragen zu Ihrer Lösung.

Durch die Verwendung dieses MCP-Servers können KI-Agenten (wie Claude, Copilot usw.) das umfassende Code-Verständnis von CodeAlive nutzen. Dies hilft Agenten:

• Finden Sie relevanten Code schneller: Erhalten Sie präzise Codeausschnitte zu Ihren Fragen.

• Verstehen Sie das Gesamtbild: Erhalten Sie Kontext zum gesamten Repository oder Arbeitsbereich, nicht nur zu einzelnen Dateien.

• Reduzieren Sie Kosten und Zeit: Verbessern Sie die Effizienz der Agenten, indem Sie direkt genaue Kontextinformationen bereitstellen und so die Notwendigkeit umfangreicher Dateisuchen oder Rätselraten reduzieren.

Related MCP server: code-index-mcp

Inhaltsverzeichnis

• Verfügbare Tools

• Erste Schritte

  • Voraussetzungen

  • Einen API-Schlüssel erhalten

  • Installation

• Konfiguration

  • Umgebungsvariablen

  • Befehlszeilenoptionen

• Integration mit KI-Clients

  • Weitermachen

  • Claude Desktop

  • Visual Studio Code mit GitHub Copilot

  • Cursor

• Python direkt verwenden

  • Claude Desktop mit Python

  • Cursor mit Python

• Fehlerbehebung

• Lizenz

Verfügbare Tools

Der MCP-Server bietet die folgenden Tools:

1. chat_completions : Greifen Sie mit Codebase-Kontext auf die CodeAlive Chat-API zu. Wenn Ihr API-Schlüssel genau einer Datenquelle zugewiesen ist, ist die Angabe der Datenquelle optional.

2. get_data_sources : Listet die verfügbaren, von CodeAlive indizierten Repositories und Arbeitsbereiche auf.

3. search_code : Suchen Sie mit der semantischen Suche von CodeAlive nach Codefragmenten in Ihren Datenquellen. Wenn Ihr API-Schlüssel genau einer Datenquelle zugewiesen ist, ist die Angabe der Datenquelle optional.

Erste Schritte

Voraussetzungen

• Python 3.11

• uv (empfohlen) oder pip

• Ein CodeAlive-Konto und ein API-Schlüssel

Einen API-Schlüssel erhalten

1. Melden Sie sich unter https://app.codealive.dev/ bei Ihrem CodeAlive-Konto an.

2. Navigieren Sie zum Abschnitt „API-Schlüssel“ (unter „Organisation“).

3. Klicken Sie auf „ + API-Schlüssel erstellen “.

4. Geben Sie Ihrem Schlüssel einen beschreibenden Namen (z. B. „Mein lokaler MCP-Schlüssel“) und wählen Sie den entsprechenden Bereich aus (z. B. „Alle Datenquellen“ oder wählen Sie bestimmte aus).

5. Klicken Sie auf „ Erstellen “.

6. Wichtig: Kopiere den generierten API-Schlüssel sofort und bewahre ihn sicher auf. Nach dem Schließen des Dialogs ist er nicht mehr sichtbar.

Installation

Installation mit UV (empfohlen)

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

# Create a virtual environment and install dependencies
uv venv
source .venv/bin/activate  # On Windows use: .venv\\Scripts\\activate
uv pip install -e .

Installation mit pip

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

# Create a virtual environment and install dependencies
python -m venv .venv
source .venv/bin/activate  # On Windows use: .venv\\Scripts\\activate
pip install -e .

Installation über Smithery

So installieren Sie CodeAlive für Claude Desktop automatisch über Smithery :

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

Konfiguration

Konfigurieren Sie den Server mithilfe von Umgebungsvariablen oder Befehlszeilenargumenten.

Umgebungsvariablen

Die folgenden Umgebungsvariablen werden unterstützt:

• CODEALIVE_API_KEY : Ihr CodeAlive-API-Schlüssel. (Erforderlich, sofern nicht über --api-key übergeben)

Befehlszeilenoptionen

• --api-key : Ihr CodeAlive-API-Schlüssel. Überschreibt die Umgebungsvariable CODEALIVE_API_KEY .

• --transport : Transporttyp: "stdio" (Standard) oder "sse" .

• --host : Hostadresse für SSE-Transport (Standard: 0.0.0.0 ).

• --port : Port für SSE-Transport (Standard: 8000 ).

• --debug : Aktiviert den Debug-Modus mit ausführlicher Protokollierung in der Standardausgabe/im Standardfehler.

Integration mit KI-Clients

Nachfolgend finden Sie Konfigurationsbeispiele für gängige KI-Clients. Denken Sie daran, Platzhalter wie /path/to/your/codealive-mcp und YOUR_API_KEY_HERE durch Ihre tatsächlichen Werte zu ersetzen. Die Verwendung von Umgebungsvariablen ( env Block) wird generell empfohlen, anstatt den API-Schlüssel direkt in die Konfigurationsdatei einzugeben.

Weitermachen

1. Konfigurieren Sie den MCP-Server in der .continue/config.yaml Ihres Projekts oder global in ~/.continue/config.yaml :

   # ~/.continue/config.yaml or ./.continue/config.yaml
   mcpServers:
     - name: CodeAlive
       command: /path/to/your/codealive-mcp/.venv/bin/python # Or use 'uv' if preferred (see Cursor example)
       args:
         - /path/to/your/codealive-mcp/src/codealive_mcp_server.py
         - --debug # Optional: Enable debug logging
       env:
         CODEALIVE_API_KEY: YOUR_API_KEY_HERE

2. Neustart Fortsetzen oder Konfiguration neu laden.

Claude Desktop

1. Bearbeiten Sie Ihre Claude Desktop-Konfigurationsdatei:

   • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

   • Windows: %APPDATA%\Claude\claude_desktop_config.json (normalerweise C:\Users\YourUsername\AppData\Roaming\Claude\claude_desktop_config.json )

2. Fügen Sie die MCP-Serverkonfiguration hinzu:

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

   (Stellen Sie sicher, dass die Zusammenführung korrekt erfolgt, wenn die Datei bereits Inhalt hat.)

3. Starten Sie Claude Desktop vollständig neu.

Visual Studio Code mit GitHub Copilot

1. Öffnen Sie die VS Code-Einstellungen (JSON) mithilfe der Befehlspalette ( Ctrl+Shift+P oder Cmd+Shift+P ) und wählen Sie „Einstellungen: Benutzereinstellungen öffnen (JSON)“.

2. Fügen Sie die MCP-Serverkonfiguration zu Ihrer settings.json hinzu:

   {
     // ... other settings ...
     "mcp": {
       "servers": {
         "codealive": {
           "command": "uv",
           "args": [
             "--directory",
             "/path/to/your/codealive-mcp", // Path to the MCP server project root
             "run",
             "python",
             "src/codealive_mcp_server.py",
             "--debug" // Optional: Enable debug logging
           ],
           "env": {
             "CODEALIVE_API_KEY": "YOUR_API_KEY_HERE"
           }
         }
       }
     }
     // ... other settings ...
   }

   (Stellen Sie sicher, dass dies korrekt mit den vorhandenen Einstellungen zusammengeführt wird.)

3. Starten Sie VS Code neu. Stellen Sie sicher, dass die GitHub Copilot-Erweiterung so konfiguriert ist, dass sie möglicherweise MCP-Server verwendet, falls dies aufgrund ihrer Version/Einstellungen erforderlich ist.

Cursor

1. Öffnen Sie die Cursoreinstellungen ( Cmd+, oder Ctrl+, ).

2. Navigieren Sie im linken Bereich zum Abschnitt „MCP“.

3. Klicken Sie auf „Neuen globalen MCP-Server hinzufügen“.

4. Geben Sie die folgende JSON-Konfiguration ein und aktualisieren Sie die Pfade und den API-Schlüssel:

   {
     "mcpServers": {
       "codealive": {
         "command": "uv",
         "args": [
           "--directory",
           "/path/to/your/codealive-mcp", // Path to the MCP server project root
           "run",
           "python",
           "src/codealive_mcp_server.py",
           "--debug" // Optional: Enable debug logging
         ],
         "env": {
           "CODEALIVE_API_KEY": "YOUR_API_KEY_HERE"
         }
       }
     }
   }

5. Speichern Sie die Konfiguration.

6. Starten Sie Cursor vollständig neu.

Python direkt verwenden

Wenn Sie uv nicht verwenden möchten, können Sie das Serverskript direkt mit dem Python-Interpreter aus Ihrer virtuellen Umgebung aufrufen. Aktualisieren Sie den command und args in den Client-Konfigurationen entsprechend.

Claude Desktop mit Python

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

Cursor mit Python

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

Fehlerbehebung

Wenn der MCP-Server mit Ihrem AI-Client nicht ordnungsgemäß funktioniert, führen Sie die folgenden Schritte aus:

1. Debug-Protokollierung aktivieren: Fügen Sie den args in der MCP-Konfiguration Ihres Clients das Flag --debug hinzu. Dadurch werden ausführliche Protokolle des MCP-Servers in dessen Standardausgabe/Fehlerstrom ausgegeben. Wohin dieser Strom fließt, hängt davon ab, wie der Client den MCP-Prozess verwaltet.

2. Überprüfen Sie die MCP-Serverausgabe:

   • Versuchen Sie, den Serverbefehl direkt in Ihrem Terminal auszuführen (aktivieren Sie zuerst die virtuelle Umgebung):

     # Activate venv first!
     export CODEALIVE_API_KEY="YOUR_API_KEY_HERE"
     python src/codealive_mcp_server.py --debug --transport stdio

   • Suchen Sie nach Fehlermeldungen, insbesondere im Zusammenhang mit der Validierung des API-Schlüssels oder Verbindungsproblemen.

3. Client-Protokolle prüfen: Konsultieren Sie die Dokumentation oder die Einstellungen Ihres spezifischen KI-Clients, um dessen Protokolldateien zu finden. Suchen Sie nach Fehlern beim Starten oder Kommunizieren mit dem „codealive“-MCP-Server.

   • Claude Desktop:

     • Überprüfen Sie die Hauptanwendungsprotokolle.

     • Suchen Sie nach MCP-spezifischen Protokollen:

       • macOS: ~/Library/Logs/Claude/mcp.log und ~/Library/Logs/Claude/mcp-server-codealive.log

       • Windows: %LOCALAPPDATA%\Claude\Logs\mcp.log und %LOCALAPPDATA%\Claude\Logs\mcp-server-codealive.log (Der Pfad lautet normalerweise C:\Users\YourUsername\AppData\Local\Claude\Logs )

   • Cursor:

     • Verwenden Sie die Befehlspalette ( Cmd+Shift+P / Ctrl+Shift+P ) -> Developer: Toggle Developer Tools -> Registerkarte Konsole (für Fehler auf Browserebene).

     • Überprüfen Sie das Ausgabefenster: Gehen Sie zu View -> Output (oder klicken Sie unten auf Output ). Suchen Sie im Dropdown-Menü rechts im Ausgabefenster nach einem Kanal namens CodeAlive , MCP oder einem anderen Kanal, der mit dem Serverprozess in Zusammenhang steht. Dieser enthält häufig die direkte Standardausgabe/Standardfehlerausgabe des MCP-Servers, wenn --debug aktiviert ist.

     • Verwenden Sie die Befehlspalette -> Developer: Open Logs Folder . Überprüfen Sie darin enthaltene Dateien, insbesondere solche, die sich auf den Hauptprozess oder den Erweiterungshost beziehen.

     • Speicherorte der Protokollordner:

       • macOS: ~/Library/Application Support/Cursor/logs/

       • Windows: %APPDATA%\Cursor\logs\ (Normalerweise C:\Users\YourUsername\AppData\Roaming\Cursor\logs\ )

   • VS Code (Weiter / Copilot):

     • Verwenden Sie die Befehlspalette ( Cmd+Shift+P / Ctrl+Shift+P ) -> Developer: Toggle Developer Tools -> Registerkarte Konsole (für Fehler auf Browserebene).

     • Überprüfen Sie das Ausgabefenster: Gehen Sie zu View -> Output (oder klicken Sie im unteren Bereich Output ). Suchen Sie im Dropdown-Menü rechts im Ausgabefenster nach einem Kanal namens CodeAlive , MCP , GitHub Copilot oder Continue . Die MCP-Serverprotokolle (insbesondere mit --debug ) werden möglicherweise hierher geleitet.

     • Verwenden Sie die Befehlspalette -> Developer: Show Logs... -> Wählen Sie Extension Host aus der Dropdown-Liste. Suchen Sie nach Fehlern im Zusammenhang mit Copilot- oder Continue-Erweiterungen, die versuchen, über MCP zu kommunizieren.

     • Für Continue-spezifische Protokolle: Verwenden Sie die Befehlspalette -> Continue: Focus on Continue Console View (erfordert die Aktivierung von Continue: Enable Console in den Einstellungen). Siehe „Continue Troubleshooting Documents“ .

4. Konfiguration überprüfen: Überprüfen Sie die command , args und env sowie -werte in der MCP-Konfigurationsdatei Ihres Clients. Stellen Sie sicher, dass die JSON/YAML-Syntax korrekt ist.

5. API-Schlüssel: Stellen Sie sicher, dass Ihr CODEALIVE_API_KEY korrekt ist.

Wenn die Probleme weiterhin bestehen, sollten Sie ein Problem im CodeAlive MCP-Server-Repository (sofern verfügbar) mit relevanten Protokollen und Konfigurationsdetails (unter Maskierung Ihres API-Schlüssels) öffnen.

Sie können sich für weitere Unterstützung auch an unser Support-Team unter support@codealive.dev wenden.

Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – Einzelheiten finden Sie in der Datei LICENSE .