Scout Monitoring MCP

Scout Monitoring MCP

Dieses Repository enthält Code, um lokal einen MCP-Server auszuführen, der über Scouts API auf Daten von https://www.scoutapm.com zugreifen kann. Wir stellen ein Docker-Image bereit, das von deinem KI-Assistenten gepullt und ausgeführt werden kann, um auf Scout-Monitoring-Daten zuzugreifen.

Damit gelangen die Performance- und Fehlerdaten von Scout Monitoring direkt in die Hände deines KI-Assistenten. Für Rails, Django, FastAPI, Laravel und mehr. Nutze es, um Traces und Fehler mit Zeilennummern-Informationen zu erhalten, die die KI nutzen kann, um Korrekturen direkt in deinem Editor und deiner Codebasis anzusetzen. N+1-Queries, langsame Endpunkte, langsame Queries, Speicherbloat, Durchsatzprobleme – all deine liebsten Performance-Probleme werden aufgedeckt und genau dort erklärt, wo du gerade arbeitest.

Wenn das dein Leben ein kleines bisschen besser macht, warum nicht :star: geben?!

Einrichtungsassistent

Der einfachste Weg, den Scout MCP zu konfigurieren und zu nutzen, ist unser interaktiver Einrichtungsassistent. Er übernimmt alle Voraussetzungen und Installationsschritte für dich.

Ausführen via npx:

npx @scout_apm/wizard

Aus dem Quellcode bauen und ausführen:

cd ./wizard
npm install
npm run build
node dist/wizard.js

Der Assistent führt dich durch:

• Auswahl deiner KI-Coding-Plattform (Cursor, Claude Code, Claude Desktop)
• Eingabe deines Scout-API-Keys
• Automatische Konfiguration der MCP-Server-Einstellungen

Unterstützte Plattformen

Der Assistent unterstützt derzeit die Einrichtung für:

• Cursor – Konfiguriert die MCP-Einstellungen automatisch
• Claude Code (CLI) – Gibt den korrekten auszuführenden Befehl an
• Claude Desktop – Aktualisiert die Konfigurationsdatei für Windows/Mac

Für alle anderen gibt er JSON aus, das du in die MCP-Konfiguration deines KI-Assistenten kopieren/einfügen kannst.

Voraussetzungen

Der Assistent ist ein großartiger Einstieg, aber du kannst alles auch manuell einrichten. Du musst ein Scout-Monitoring-Konto haben oder erstellen und einen API-Key beziehen.

1. https://scoutapm.com/users/sign_up?utm_source=github&utm_medium=github&utm_campaign=scout-mcp-local
2. Installiere den Scout Agent in deiner Anwendung und sende Scout-Daten!
   • Ruby
   • Python
   • PHP
   • Wenn du das lokal ausprobierst, stelle sicher, dass monitor: true, errors_enabled: true in deiner Konfiguration gesetzt sind, für die beste Erfahrung
3. Besuche die Einstellungen, um einen API-Key zu beziehen oder zu erstellen
   • Dies ist nicht dein „Agent Key“, sondern der „API Key“, der auf der Einstellungsseite erstellt werden kann
   • Dies ist ein schreibgeschützter Key, der nur auf Daten in deinem Konto zugreifen kann
4. Installiere Docker. Die folgenden Anweisungen gehen davon aus, dass du einen Docker-Container starten kannst

Der MCP-Server startet derzeit nicht ohne gesetzten API-Key, entweder in der Umgebung oder über ein Kommandozeilenargument beim Start.

Installation

Wir empfehlen die Verwendung des bereitgestellten Docker-Images, um den MCP-Server auszuführen. Es ist dafür gedacht, von deinem KI-Assistenten gestartet und mit deinem Scout-API-Key konfiguriert zu werden. Viele lokale Clients erlauben es, einen Befehl zum Ausführen des MCP-Servers an einer bestimmten Stelle anzugeben. Einige Beispiele sind unten aufgeführt.

Das Docker-Image ist auf Docker Hub verfügbar.

Natürlich kannst du dieses Repo auch jederzeit klonen und den MCP-Server direkt ausführen; uv oder andere Umgebungsverwaltungstools werden empfohlen.

Einen lokalen Client konfigurieren (z. B. Claude/Cursor/VS Code Copilot)

Wenn du den MCP manuell konfigurieren möchtest, bedeutet das in der Regel nur, einen Befehl zum Ausführen des MCP-Servers mit deinem API-Key in der Umgebung in der Konfiguration deines KI-Assistenten anzugeben. Hier ist die Form des JSON (der Schlüssel auf oberster Ebene variiert):

{
  "mcpServers": {
    "scout-apm": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "--env", "SCOUT_API_KEY", "scoutapp/scout-mcp-local"],
      "env": { "SCOUT_API_KEY": "your_scout_api_key_here"}
    }
  }
}

claude mcp add scoutmcp -e SCOUT_API_KEY=your_scout_api_key_here -- docker run --rm -i -e SCOUT_API_KEY scoutapp/scout-mcp-local

{
  "mcpServers": {
    "scout-apm": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "--env", "SCOUT_API_KEY", "scoutapp/scout-mcp-local"],
      "env": { "SCOUT_API_KEY": "your_scout_api_key_here"}
    }
  }
}

Den Scout Monitoring MCP verwenden

Scouts MCP ist dafür gedacht, Fehler- und Performance-Daten direkt in die ... Hände? deines KI-Assistenten zu legen. Nutze es, um Traces und Fehler mit Zeilennummern-Informationen zu erhalten, die die KI nutzen kann, um Korrekturen direkt in deinem Editor anzusetzen.

Die meisten Assistenten zeigen dir sowohl rohe Tool-Aufrufe als auch führen Analysen durch. Desktop-Assistenten können ohne Weiteres benutzerdefinierte JS-Anwendungen erstellen, um beliebige Daten zu erkunden. In Code-Editoren integrierte Assistenten können Trace-Daten und Fehler-Backtraces nutzen, um Korrekturen direkt in deiner Codebasis vorzunehmen.

Kombiniere Scouts MCP mit den anderen Tools deines KI-Assistenten, um:

• Umfangreiche GitHub/GitLab-Issues basierend auf Fehler- und Performance-Daten zu erstellen
• JIRA unterhaltsam zu machen – lass deinen KI-Assistenten Tickets mit allen Details erstellen
• PRs zu generieren, die bestimmte Fehler und Performance-Probleme beheben

Tools

Der Scout MCP stellt die folgenden Tools für den Zugriff auf Scout-APM-Daten bereit:

• list_apps – Listet verfügbare Scout-APM-Anwendungen auf, mit optionaler Filterung nach dem Datum der letzten Aktivität
• get_app_metrics – Ruft einzelne Metrikdaten (response_time, throughput usw.) für eine bestimmte Anwendung ab
• get_app_endpoints – Ruft alle Endpunkte einer Anwendung mit aggregierten Performance-Metriken ab
• get_endpoint_metrics – Ruft Timeseries-Metriken für einen bestimmten Endpunkt in einer Anwendung ab
• get_app_endpoint_traces – Ruft aktuelle Traces für eine App ab, gefiltert auf einen bestimmten Endpunkt
• get_app_trace – Ruft einen einzelnen Trace mit allen Spans und detaillierten Ausführungsinformationen ab
• get_app_error_groups – Ruft aktuelle Fehlergruppen für eine App ab, optional gefiltert nach Endpunkt
• get_app_insights – Ruft Performance-Insights ab, einschließlich N+1-Queries, Speicherbloat und langsamen Queries

Ressourcen

Der Scout MCP stellt Konfigurationsvorlagen als Ressourcen bereit, die dein KI-Assistent lesen und anwenden kann:

• scoutapm://config-resources/{framework} – Einrichtungsanweisungen für unterstützte Frameworks oder Bibliotheken (rails, django, flask, fastapi)
• scoutapm://config-resources/list – Listet alle verfügbaren Konfigurationsvorlagen auf
• scoutapm://metrics – Liste aller verfügbaren Metriken für Scout APM

Nützliche Prompts

Einrichtung & Konfiguration

• „Hilf mir, Scout-Monitoring für meine Rails-Anwendung einzurichten“
• „Erstelle eine Scout-APM-Konfigurationsdatei für mein Django-Projekt mit dem Key ABC123“

Performance & Monitoring

• „Fasse die verfügbaren Tools im Scout Monitoring MCP zusammen.“
• „Finde die langsamsten Endpunkte für App my-app-name in den letzten 7 Tagen. Erstelle eine Tabelle mit den Ergebnissen, einschließlich der durchschnittlichen Antwortzeit, des Durchsatzes und der P95-Antwortzeit.“
• „Zeige mir die häufigsten Fehler für App Foo in den letzten 24 Stunden. Hole die neuesten Fehlerdetails, untersuche das Backtrace und schlage eine Korrektur vor.“
• „Hole aktuelle N+1-Insights für App Bar. Ziehe den spezifischen Trace per ID und hilf mir, ihn basierend auf den Backtrace-Daten zu optimieren.“

Token-Nutzung

Wir sind derzeit mehr daran interessiert, die verfügbaren Informationen zu erweitern, als die Antwortgröße unserer MCP-Tools streng zu kontrollieren. Wenn dein KI-Assistent ein konfigurierbares Token-Limit hat (z. B. Claude Code export MAX_MCP_OUTPUT_TOKENS=50000), empfehlen wir, es großzügig hoch anzusetzen, z. B. 50.000 Tokens.

Lokale Entwicklung

Wir verwenden uv und taskipy, um Umgebungen zu verwalten und Aufgaben für dieses Projekt auszuführen.

Mit Inspector ausführen

uv run task dev

Im Inspector verbinden, um den API-Key hinzuzufügen, auf STDIO-Transport setzen

Das Docker-Image bauen

docker build -t scout-mcp-local .

Release

1. Branch erstellen und Versionen mit uv run python bump_versions.py erhöhen
2. Mergen lassen
3. Ein GitHub-Release mit der neuen Version erstellen (gh release create v2025.11.3 --generate-notes --draft)

Das Veröffentlichen des Releases pusht den v*-Tag, und die CI veröffentlicht das Docker-Image, das PyPI-Paket und dann die Einträge in der MCP Registry:

• server.json → com.scoutapm/scout-mcp-local (dieser Server; seine Version wird durch bump_versions.py erhöht)
• server.remote.json → com.scoutapm/scout-monitoring (der gehostete Server unter https://scoutapm.com/mcp). Erhöhe seine version manuell, wenn du seine Metadaten änderst; unveränderte Versionen werden übersprungen.

MCP-Registry-Key

Die Registry verifiziert, dass uns der Namespace com.scoutapm/* gehört, über einen DNS-TXT-Record am Apex von scoutapm.com, der einen Ed25519-Public-Key enthält. Die CI meldet sich mit dem passenden Private-Key aus dem Repository-Secret MCP_REGISTRY_PRIVATE_KEY an. Zum Rotieren:

openssl genpkey -algorithm Ed25519 -out key.pem
# Public key for the TXT record: replace the existing v=MCPv1 record, don't add a second one
echo "v=MCPv1; k=ed25519; p=$(openssl pkey -in key.pem -pubout -outform DER | tail -c 32 | base64)"
# Private key (hex) for the MCP_REGISTRY_PRIVATE_KEY secret
openssl pkey -in key.pem -noout -text | grep -A3 "priv:" | tail -n +2 | tr -d ' :\n'

Für die Bots:

mcp-name: com.scoutapm/scout-mcp-local