FastMCP SonarQube Metriken

Übersicht

Dieses Projekt bietet eine Reihe von Tools zum Abrufen von Informationen über SonarQube-Projekte unter Verwendung des FastMCP-Frameworks (Fast Model Context Protocol). Es dient als Schnittstelle zu SonarQube und ermöglicht es Benutzern, programmgesteuert auf Metriken, historische Daten und Komponentenzweig-Metriken für bestimmte Projekte zuzugreifen. Dieser automatisierte Zugriff ermöglicht die Berichterstattung, Analyse und Integration von SonarQube-Daten mit anderen Systemen.

Das Projekt zeichnet sich dadurch aus, dass es einen vereinfachten, nachrichtenbasierten Ansatz für die Interaktion mit der SonarQube-API bietet und die Komplexität direkter API-Aufrufe und Datenverarbeitung abstrahiert. Es wurde für Entwickler, DevOps-Ingenieure und Analysten entwickelt, die SonarQube-Daten in ihre Arbeitsabläufe integrieren oder benutzerdefinierte Berichtslösungen erstellen müssen.

Dieses Repository enthält speziell die Client- und Serverkomponenten, die die Kommunikation und den Datenabruf erleichtern. Der Server stellt Tools zum Abrufen von Daten aus SonarQube bereit, während der Client eine Befehlszeilenschnittstelle für Benutzer bietet, um diese Tools aufzurufen und die Ergebnisse anzuzeigen. Jedes interne Modul trägt zu diesem Ziel bei, indem es spezifische Funktionen wie API-Interaktion, Datenverarbeitung und Client-Server-Kommunikation kapselt.

Der im Projekt enthaltene Client dient nur zum Testen der Funktionsweise des Codes; wir empfehlen die Verwendung von Claude Desktop oder die Entwicklung eines eigenen benutzerdefinierten Clients.

DENKEN SIE DARAN, DASS DIESES REPO NOCH IN ARBEIT IST UND EINIGE FUNKTIONEN MÖGLICHERWEISE NICHT PERFEKT SIND.

Related MCP server: MCP QQ Music Test Server

Gehostete Bereitstellung

Eine gehostete Bereitstellung ist auf Fronteir AI verfügbar.

Unterstützte MCP-Tools

• get_status: Führt eine Gesundheitsprüfung der konfigurierten SonarQube-Instanz durch.

• create_sonarqube_project: Erstellt ein neues SonarQube-Projekt. Erfordert Administratorrechte.

• delete_sonarqube_project: Löscht ein SonarQube-Projekt. Erfordert Administratorrechte. MIT VORSICHT VERWENDEN!

• list_projects: Listet alle zugänglichen SonarQube-Projekte auf, optional gefiltert nach Name oder Schlüssel.

• get_sonarqube_metrics: Ruft angegebene Metriken (Bugs, Schwachstellen, Code-Smells, Abdeckung, Duplizierungsdichte) für einen bestimmten SonarQube-Projektschlüssel ab.

• get_sonarqube_metrics_history: Ruft historische Metriken (Bugs, Schwachstellen, Code-Smells, Abdeckung, Duplizierungsdichte) für ein bestimmtes SonarQube-Projekt unter Verwendung von /api/measures/search_history ab. Optionale Datumsfilter können angewendet werden.

• get_sonarqube_component_tree_metrics: Ruft Metrikwerte für alle Komponenten (z. B. Dateien oder Verzeichnisse) in einem Projekt unter Verwendung von /api/measures/component_tree ab. Behandelt automatisch die Paginierung, um alle Ergebnisse abzurufen.

• get_project_issues: Ruft SonarQube-Probleme für ein bestimmtes Projekt ab, optional gefiltert nach Typ, Schweregrad und Lösungsstatus. Gibt bis zu limit Ergebnisse zurück (Standard: 10).

Technologiestack

• Sprache: Python

• Frameworks: FastMCP

• Bibliotheken: httpx, pydantic, dotenv, asyncio, json, pathlib, typing, base64

• Tools: SonarQube API

Verzeichnisstruktur

├── client_test.py - Client application for testing and interacting with the server.
├── server.py - Server application exposing tools to retrieve SonarQube metrics.
├── client_tool.py - Client with a graphical interface to interact with the SonarQube server.
├── client_langchain.py - Command-line client to interact with the FastMCP server and SonarQube tools via LangChain
├── .env - Environment configuration file (stores SonarQube URL and token).
└── README.md - Project documentation.

Erste Schritte

Voraussetzungen

• Python 3.7+

• SonarQube-Instanz mit API-Zugriff

• Ein SonarQube-API-Token mit entsprechenden Berechtigungen

• FastMCP installiert (pip install fastmcp)

• httpx installiert (pip install httpx)

• pydantic installiert (pip install pydantic)

• python-dotenv installiert (pip install python-dotenv)

Allgemeine Build-Schritte

1. Repository klonen: git clone <repository_url>

2. In das Projektverzeichnis navigieren: cd fastmcp-sonarqube-metrics

3. Umgebungsvariablen einrichten: Erstellen Sie eine .env-Datei im Stammverzeichnis des Projekts mit folgendem Inhalt:

   SONARQUBE_URL=<your_sonarqube_url>
   SONARQUBE_TOKEN=<your_sonarqube_token>
   TRANSPORT=<stdio or sse>
   GEMINI_API_KEY=<your-gemini-api_key>
   GEMINI_MODEL=<your-gemini-model> (Optional)

   Das Schema ist für OpenAI und Groq identisch, falls Sie AzureOpenAI verwenden möchten:

   SONARQUBE_URL=<your_sonarqube_url>
   SONARQUBE_TOKEN=<your_sonarqube_token>
   TRANSPORT=<stdio or sse>
   AZURE_OPENAI_API_KEY=<your-azureopenai-api_key>
   AZURE_OPENAI_ENDPOINT=<your-azureopenai-endpoint>
   AZURE_DEPLOYMENT=<your-azureopenai-deployment>
   AZURE_API_VERSION=<your-azureopenai-api_version>

   Ersetzen Sie <your_sonarqube_url> durch die URL Ihrer SonarQube-Instanz (z. B. http://localhost:9000) und <your_sonarqube_token> durch Ihr SonarQube-API-Token.

4. Server ausführen: python server.py

5. Client ausführen: python client_test.py (Optional, nur zum Testen)

6. Mit Ihrem Client verbinden: Befolgen Sie die offizielle Dokumentation

Modulverwendung

Server (server.py)

Das Modul server.py definiert den FastMCP-Server, der Tools zum Abrufen von SonarQube-Metriken bereitstellt. Es initialisiert den Server, lädt Umgebungsvariablen, definiert die verfügbaren Tools und verwaltet die Kommunikation mit der SonarQube-API. Um den Server zu verwenden, müssen Sie die Umgebungsvariablen SONARQUBE_URL und SONARQUBE_TOKEN festlegen. Der Server wird durch direktes Ausführen des Skripts server.py gestartet.

Client (client_test.py)

Das Modul client_test.py definiert den FastMCP-Client, der mit dem Server interagiert. Es fordert den Benutzer zur Eingabe eines SonarQube-Projektschlüssels auf, verbindet sich mit dem Server, ruft die Tools get_sonarqube_metrics und get_sonarqube_component_tree_metrics auf und zeigt die Ergebnisse an. Um den Client zu verwenden, müssen Sie das Skript client_test.py direkt ausführen, bei Aufforderung einen gültigen SonarQube-Projektschlüssel angeben und den Transporttyp in der .env-Datei auf stdio setzen.

Client_tool (client_tool.py)

Das Modul client_tool.py implementiert den FastMCP-Client mit einer Tkinter-basierten grafischen Oberfläche zur Interaktion mit dem SonarQube-Server. Beim Start konfiguriert es Logger, um unwesentliche Meldungen zu unterdrücken, lädt Umgebungsvariablen und startet das Chat-Backend (ChatBackend) im Hintergrund, das ein LLM und die vom Server über stdio bereitgestellten MCP-Tools verwendet. Das Frontend (ChatGUI) verwaltet das Tkinter-Fenster, zeigt den Nachrichtenverlauf in einem scrollbaren Bereich an und ermöglicht es dem Benutzer, Befehle an den Server zu senden – wobei bei Bedarf ein gültiger SonarQube-Projektschlüssel abgefragt wird. Um den Client zu verwenden, führen Sie einfach das Skript client_tool.py aus und interagieren Sie über die GUI.

Client_langchain (client_langchain.py)

Das Modul client_langchain.py bietet einen Befehlszeilen-Client zur Interaktion mit dem FastMCP-Server und den SonarQube-Tools über LangChain. Beim Start lädt es Umgebungsvariablen und konfiguriert das gewählte LLM. Es stellt eine stdio-Verbindung zum Server (server.py) her, initialisiert die MCP-Sitzung und lädt verfügbare Tools (Gesundheitsprüfung, aktuelle und historische Metriken, Projektliste, Abruf von Problemen). Ein detaillierter System-Prompt beschreibt jedes Tool und seine Parameter. In einer interaktiven Schleife liest es Benutzereingaben von der Konsole, aktualisiert den Nachrichtenverlauf, ruft den React-Agenten auf und gibt die formatierte Antwort aus.

Beispiel: Integration des Tools get_sonarqube_metrics in ein externes Projekt

Um das Tool get_sonarqube_metrics in einem externen Projekt zu verwenden, können Sie einen Client erstellen, der eine Verbindung zum FastMCP-Server herstellt und das Tool aufruft. Hier ist ein grundlegendes Beispiel:

import asyncio
from fastmcp import Client
from fastmcp.types import TextContent

async def get_metrics(project_key: str):
    server_path = "server.py" # Adjust if necessary
    client = Client(server_path)
    try:
        async with client:
            result = await client.call_tool(
                "get_sonarqube_metrics", {"project_key": project_key}
            )
            if result:
                content = result[0]
                if isinstance(content, TextContent):
                    metrics = json.loads(content.text)
                    print(metrics)
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    asyncio.run(get_metrics("your-project-key")) # Replace with your project key

Dieses Beispiel zeigt, wie man einen Client erstellt, eine Verbindung zum Server herstellt, das Tool get_sonarqube_metrics mit einem Projektschlüssel aufruft und die Ergebnisse verarbeitet. Sie müssen die Variable server_path an den tatsächlichen Speicherort des Skripts server.py in Ihrer Umgebung anpassen.

ArchAI-SonarQube Chat (GUI)

Ein leichtgewichtiger Tkinter-Client, der über stdio eine Verbindung zum FastMCP-Server herstellt und eine Echtzeit-Chat-Schnittstelle zum Abfragen von SonarQube-Metriken, Durchsuchen von Komponentenbäumen und Ausführen von Gesundheitsprüfungen über einen LLM-gesteuerten Assistenten bereitstellt.

Verwendung mit TRANSPORT=SSE

Sie können die Transportschicht des Clients auf Server-Sent Events (SSE) umstellen, indem Sie die Umgebungsvariable TRANSPORT festlegen, bevor Sie die GUI starten. Dies ermöglicht Echtzeit-Updates in eine Richtung vom FastMCP-Server. Wenn der Server im SSE-Modus gestartet wird, wird eine persistente HTTP-Verbindung auf Port 8001 geöffnet. Dies ermöglicht Ihnen die Verbindung über kompatible Schnittstellen wie den MCP Inspector.*

1. Server im SSE-Modus starten

   uv run mcp dev "<server_name>" 

2. MCP Inspector öffnen Ein Link (z. B. http://127.0.0.1:6274) wird bereitgestellt, um den MCP Inspector in Ihrem Browser zu starten.

3. SSE im MCP Inspector konfigurieren

   • Wählen Sie SSE als Transporttyp

   • Geben Sie die URL ein: http://localhost:8001/sse

4. Verbindung initiieren

5. Verfügbare Tools durchsuchen Im Bereich Tools sehen Sie:

   • get_status

   • get_sonarqube_metrics

   • get_sonarqube_metrics_history

   • get_sonarqube_component_tree_metrics

   • list_projects

   • get_project_issues

6. Tool auswählen und aufrufen Wählen Sie zum Beispiel get_project_issues und geben Sie Folgendes an:

   • project_key: der SonarQube-Projektschlüssel

   • issue_type (optional): z. B. BUG, CODE_SMELL

   • severity (optional): z. B. MAJOR, CRITICAL

   • resolved (optional): true oder false

   • limit (optional): maximale Anzahl der zurückzugebenden Probleme

7. Ausführen und Ergebnisse abrufen Der Server ruft die entsprechende SonarQube-API auf und gibt eine formatierte JSON-Antwort zurück.

Verwendung mit Claude Desktop

Sie können diesen Server mit fastmcp direkt in Claude Desktop installieren:

1. Stellen Sie sicher, dass FastMCP installiert ist (pip install fastmcp oder uv pip install fastmcp).

2. Konfigurieren Sie Claude für Desktop für die MCP-Server, die Sie verwenden möchten (unter Windows mit VSCode): code $env:AppData\Claude\claude_desktop_config.json

3. Fügen Sie Ihren Server hinzu und speichern Sie:

{
    "mcpServers": {
        "fastmcp-sonarqube-metrics": {
            "command": "uv",
            "args": [
                "--directory",
                "/ABSOLUTE/PATH/TO/PARENT/FOLDER/fastmcp-sonarqube-metrics",
                "run",
                "server.py"
            ]
        }
    }
}

4. Starten Sie es durch Ausführen von:

 uv --directory  /ABSOLUTE/PATH/TO/PARENT/FOLDER/fastmcp-sonarqube-metrics run server.py

5. Starten Sie Claude Desktop neu, falls es lief. Das Tool "FastMCP SonarQube Metrics" sollte nun verfügbar sein.

Funktionsanalyse

1. Hauptaufgaben des Systems

Die Hauptaufgabe des Systems besteht darin, als Brücke zwischen einem Benutzer und der SonarQube-API zu fungieren und eine vereinfachte Möglichkeit zum Abrufen von Projektqualitätsmetriken bereitzustellen. Es kapselt die Komplexität der SonarQube-API und bietet eine Reihe von Tools, die einfach aufgerufen und in automatisierte Arbeitsabläufe integriert werden können. Zu den Kerndiensten gehören das Abrufen von Metriken, das Abrufen historischer Daten und das Untersuchen von Metriken auf Komponentenebene innerhalb eines SonarQube-Projekts. Der grundlegende Dienst ist der FastMCP-Server, der die Tool-Definitionen und die Client-Server-Kommunikation verwaltet.

2. Probleme, die das System löst

Das System löst das Problem des programmgesteuerten Zugriffs auf SonarQube-Daten, ohne dass Benutzer direkt mit der SonarQube-API interagieren müssen. Es adressiert den Bedarf an automatisierter Berichterstattung, Analyse und Integration von SonarQube-Metriken mit anderen Systemen. Insbesondere vereinfacht es Aufgaben wie:

• Erstellen regelmäßiger Berichte zu Codequalitätsmetriken.

• Überwachen von Trends in der Codequalität im Zeitverlauf.

• Identifizieren problematischer Komponenten innerhalb eines Projekts.

• Integration von SonarQube-Daten mit anderen Entwicklungstools.

Die Architektur löst diese Probleme durch die Bereitstellung einer Reihe klar definierter Tools, die die Komplexität der SonarQube-API abstrahieren und eine konsistente Schnittstelle für den Datenzugriff bieten.

3. Interaktion von Modulen und Komponenten

Das System besteht aus zwei Hauptkomponenten: dem Client und dem Server. Der Client initiiert Anfragen an den Server und gibt das auszuführende Tool sowie alle Eingabeparameter an. Der Server empfängt die Anfrage, interagiert mit der SonarQube-API, verarbeitet die Daten und sendet die Ergebnisse an den Client zurück.

Die Interaktion zwischen Client und Server wird durch das FastMCP-Framework erleichtert, das die Nachrichtenübermittlung und Serialisierung übernimmt. Der Server definiert die verfügbaren Tools mit dem Dekorator @mcp.tool(), der die Funktionen als aufrufbare Endpunkte registriert. Der Client ruft diese Tools mit der Methode client.call_tool() auf, die eine Nachricht mit dem Toolnamen und den Eingabeparametern an den Server sendet.

Der Server verwendet die Bibliothek httpx, um asynchrone HTTP-Anfragen an die SonarQube-API zu stellen. Er konstruiert die API-URLs und Anfrageparameter basierend auf dem auszuführenden Tool und den vom Client bereitgestellten Eingabeparametern. Der Server analysiert dann die JSON-Antworten der SonarQube-API und extrahiert die relevanten Metrikwerte.

4. Benutzerorientierte vs. Systemorientierte Funktionen

Die benutzerorientierte Funktionalität des Systems