IBM Instana MCP Server

offiziell

Der IBM Instana MCP Server ermöglicht eine nahtlose Interaktion mit der IBM Instana Observability-Plattform und erlaubt den direkten Zugriff auf Echtzeit-Observability-Daten innerhalb Ihres Entwicklungsworkflows.

GitHub

Dieses MCP ausprobierenGesponsert

Was kann man mit IBM Instana MCP machen?

Anwendungsleistung abfragen — Fragen Sie nach Anwendungsmetriken, Warnungen oder Katalogdetails mit app-Kategorie-Tools wie get_app_metrics oder get_app_alerts.
Infrastrukturzustand überwachen — Rufen Sie Infrastrukturressourcen, Topologie und Metriken über infra-Tools wie get_infra_metrics oder get_infra_topology ab.
Ereignisse und Vorfälle verfolgen — Greifen Sie mit events-Tools wie get_k8s_events oder get_agent_status auf Kubernetes-Ereignisse oder Agentenüberwachungsdaten zu.
Website-Überwachung analysieren — Rufen Sie Website-Metriken, Kataloginformationen oder Konfiguration mit website-Tools wie get_website_metrics oder get_website_config ab.
Tools nach Kategorie filtern — Aktivieren Sie beim Start nur benötigte Tool-Kategorien mit dem --tools-Flag (z. B. --tools infra,events), um die Leistung zu optimieren.

Dokumentation

Inhaltsverzeichnis

MCP Server für IBM Instana

MCP Server für IBM Instana

📚 Schnellzugriff

Tools & Beispiele - Umfassende Tool-Dokumentation mit Praxisbeispielen
Datenschutzerklärung - Informationen zur Datenverarbeitung und zum Datenschutz
Docker-Bereitstellungsleitfaden - Umfassende Docker-Bereitstellung, Multi-Architektur-Builds und Produktionssetup

Der Instana MCP-Server ermöglicht eine nahtlose Interaktion mit der Instana-Observability-Plattform und erlaubt Ihnen den direkten Zugriff auf Echtzeit-Observability-Daten in Ihrem Entwicklungsworkflow.

Er dient als Brücke zwischen Clients (wie KI-Agenten oder benutzerdefinierten Tools) und den Instana-REST-APIs, indem er Benutzeranfragen in Instana-API-Anfragen umwandelt und die Antworten in strukturierte, leicht konsumierbare Formate formatiert.

Der Server unterstützt sowohl Streamable HTTP als auch Stdio-Transportmodi für maximale Kompatibilität mit verschiedenen MCP-Clients. Weitere Details finden Sie in der MCP-Transportmodi-Spezifikation.

Architekturübersicht

graph LR
    subgraph "Application Host Process"
        MH[MCP Host]
        MSI[Instana MCP Server]
        MST[ProductA MCP Server]
        MSC[ProductB MCP Server]

        MH <--> MSI
        MH <--> MSC
        MH <--> MST
    end

    subgraph "Remote Service"
        II[Instana Instance]
        TI[ProductA Instance]
        CI[ProductB Instance]

        MSI <--> II
        MST <--> TI
        MSC <--> CI
    end

    subgraph "LLM"
        L[LLM]
        MH <--> L
    end

Workflow

Betrachten Sie ein einfaches Beispiel: Sie verwenden einen MCP-Host (wie Claude Desktop, VS Code oder einen anderen Client), der mit dem Instana MCP-Server verbunden ist. Wenn Sie Informationen zu Instana-Alerts anfordern, läuft der folgende Prozess ab:

Der MCP-Client ruft die Liste der verfügbaren Tools vom Instana MCP-Server ab
Ihre Anfrage wird zusammen mit den Tool-Beschreibungen an das LLM gesendet
Das LLM analysiert die verfügbaren Tools und wählt die geeigneten für den Abruf von Instana-Alerts aus
Der Client führt die ausgewählten Tools über den Instana MCP-Server aus
Die Ergebnisse (neueste Alerts) werden an das LLM zurückgegeben
Das LLM formuliert eine Antwort in natürlicher Sprache
Die Antwort wird Ihnen angezeigt

sequenceDiagram
    participant User
    participant ChatBot as MCP Host
    participant MCPClient as MCP Client
    participant MCPServer as Instana MCP Server
    participant LLM
    participant Instana as Instana Instance

    ChatBot->>MCPClient: Load available tools from MCP Server
    MCPClient->>MCPServer: Request available tool list
    MCPServer->>MCPClient: Return list of available tools
    User->>ChatBot: Ask "Show me the latest alerts from Instana for application robot-shop"
    ChatBot->>MCPClient: Forward query
    MCPClient->>LLM: Send query and tool description
    LLM->>MCPClient: Select appropriate tool(s) for Instana alert query
    MCPClient->>MCPServer: Execute selected tool(s)
    MCPServer->>Instana: Retrieve alerts for application robot-shop
    MCPServer->>MCPClient: Send alerts of Instana result
    MCPClient->>LLM: Forward alerts of Instana
    LLM->>ChatBot: Generate natural language response for Instana alerts
    ChatBot->>User: Show Instana alert response

Voraussetzungen

Option 1: Installation von PyPI (empfohlen)

Der einfachste Weg, mcp-instana zu verwenden, ist die direkte Installation von PyPI:

pip install mcp-instana

Nach der Installation können Sie den Server direkt mit dem Befehl mcp-instana ausführen.

Option 2: Entwicklungsumgebung

Für die Entwicklung oder lokale Anpassung können Sie das Projekt klonen und lokal einrichten.

Installation von uv

Dieses Projekt verwendet uv, einen schnellen Python-Paketinstaller und -Resolver. Für die Installation von uv haben Sie mehrere Optionen:

Mit pip:

pip install uv

Mit Homebrew (macOS):

brew install uv

Weitere Installationsoptionen und detaillierte Anweisungen finden Sie in der uv-Dokumentation.

Einrichten der Umgebung

Nach der Installation von uv richten Sie die Projektumgebung mit folgendem Befehl ein:

uv sync

Header-basierte Authentifizierung für Streamable HTTP-Modus

Bei Verwendung des Streamable HTTP-Modus müssen Sie die Instana-Anmeldeinformationen über HTTP-Header übergeben. Dieser Ansatz erhöht Sicherheit und Flexibilität durch:

Vermeidung der Speicherung von Anmeldeinformationen in Umgebungsvariablen
Ermöglichung der Verwendung unterschiedlicher Anmeldeinformationen für verschiedene Anfragen
Unterstützung gemeinsamer Umgebungen, in denen die Änderung von Umgebungsvariablen eingeschränkt ist
Unterstützung sowohl der API-Token- als auch der Session-basierten Authentifizierung

Unterstützte Authentifizierungsmodi:

1. API-Token-Authentifizierung (direkte API-Aufrufe)

Erforderliche Header:

instana-base-url: Ihre Instana-Instanz-URL
instana-api-token: Ihr Instana-API-Token

Beispiel:

--header "instana-base-url: https://your-instance.instana.io"
--header "instana-api-token: your-api-token"

2. Session-Token-Authentifizierung (UI-initiiert)

Erforderliche Header:

instana-base-url: Ihre Instana-Instanz-URL
instana-auth-token: Session-Authentifizierungstoken vom UI-Backend
instana-csrf-token: CSRF-Token vom UI-Backend
instana-cookie-name: (Optional) Cookie-Name für die Session-Authentifizierung (Standard: instanaAuthToken)

Beispiel:

--header "instana-base-url: https://your-instance.instana.io"
--header "instana-auth-token: your-session-token"
--header "instana-csrf-token: your-csrf-token"
--header "instana-cookie-name: in-token"

3. JWT-Token-Authentifizierung (IBM Platform-Integration)

Erforderliche Header:

instana-base-url: Ihre Instana-Instanz-URL
instana-jwt-token: JWT-Token von der IBM Platform
instana-csrf-token: CSRF-Token für die Anfragevalidierung

Beispielkonfiguration:

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://0.0.0.0:8080/mcp",
        "--allow-http",
        "--header",
        "instana-base-url: https://your-instana-instance.instana.io",
        "--header",
        "instana-jwt-token: your_jwt_token_here",
        "--header",
        "instana-csrf-token: your_csrf_token_here"
      ]
    }
  }
}

Authentifizierungspriorität:

JWT-Token (falls mit CSRF-Token bereitgestellt) - hat Vorrang für die IBM Platform-Integration
Session-Tokens (falls sowohl auth_token als auch csrf_token bereitgestellt)
API-Token (falls bereitgestellt) - Standardauthentifizierung
Umgebungsvariable (INSTANA_API_TOKEN) - Fallback

Authentifizierungsablauf:

HTTP-Header müssen in jeder Anfrage vorhanden sein
Der Server validiert die Anmeldeinformationen basierend auf der Prioritätsreihenfolge
Anfragen ohne gültige Authentifizierung schlagen fehl

Dieses Design gewährleistet die sichere Übertragung von Anmeldeinformationen und unterstützt mehrere Authentifizierungsabläufe, einschließlich UI-initiierten Aufrufen über WebSocket → Coordinator → MCP-Server.

Stellen Sie sicher, dass das verwendete Token über die erforderlichen Berechtigungen zum Aufrufen von MCP-Tools verfügt. Weitere Informationen finden Sie hier.

Starten des lokalen MCP-Servers

Bevor Sie einen MCP-Client (Claude Desktop, GitHub Copilot oder benutzerdefinierte MCP-Clients) konfigurieren, müssen Sie den lokalen MCP-Server starten. Der Server unterstützt zwei Transportmodi: Streamable HTTP und Stdio.

Server-Befehlsoptionen

Verwendung der CLI (PyPI-Installation)

Wenn Sie mcp-instana von PyPI installiert haben, verwenden Sie den Befehl mcp-instana:

mcp-instana [OPTIONS]

Verwendung der Entwicklungsumgebung

Für die lokale Entwicklung verwenden Sie den Befehl uv run:

uv run src/core/server.py [OPTIONS]

Verfügbare Optionen:

--transport <mode>: Transportmodus (Auswahl: streamable-http, stdio)
--env KEY=VALUE: Umgebungsvariable setzen (kann für mehrere Variablen wiederholt werden, z. B. --env INSTANA_BASE_URL=https://... --env INSTANA_API_TOKEN=...)
--debug: Debug-Modus mit zusätzlicher Protokollierung aktivieren
--log-level <level>: Protokollierungsebene festlegen (Auswahl: DEBUG, INFO, WARNING, ERROR, CRITICAL)
--tools <categories>: Kommagetrennte Liste der zu aktivierenden Tool-Kategorien (z. B. infra,app,events,website). Die Aktivierung einer Kategorie aktiviert auch die zugehörigen Prompts. Beispiel: --tools infra aktiviert die Infra-Tools und alle Infra-bezogenen Prompts.
--list-tools: Alle verfügbaren Tool-Kategorien auflisten und beenden
--port <port>: MCP-Server-Port (Standard: 8080, kann mit der PORT-Umgebungsvariable überschrieben werden)
--verify-ssl: SSL-Zertifikatsprüfung für ausgehende Instana-API-Aufrufe aktivieren. Entspricht dem Setzen von INSTANA_SSL_VERIFY=true. Die SSL-Prüfung ist standardmäßig deaktiviert.
--help: Hilfemeldung anzeigen und beenden

Starten im Streamable HTTP-Modus

Der Streamable HTTP-Modus bietet eine REST-API-Schnittstelle und wird für die meisten Anwendungsfälle empfohlen.

Verwendung der CLI (PyPI-Installation)

# Start with all tools enabled (default)
mcp-instana --transport streamable-http

# Start with debug logging
mcp-instana --transport streamable-http --debug

# Start with a specific log level
mcp-instana --transport streamable-http --log-level WARNING

# Start with specific tool categories only
mcp-instana --transport streamable-http --tools infra,events

# Combine options (specific log level, custom tools)
mcp-instana --transport streamable-http --log-level DEBUG --tools app,events

Verwendung der Entwicklungsumgebung

# Start with all tools enabled (default)
uv run src/core/server.py --transport streamable-http

# Start with debug logging
uv run src/core/server.py --transport streamable-http --debug

# Start with a specific log level
uv run src/core/server.py --transport streamable-http --log-level WARNING

# Start with specific tool and prompts categories only
uv run src/core/server.py --transport streamable-http --tools infra,events

# Start with custom port
uv run src/core/server.py --transport streamable-http --port 9000

# Combine options (specific log level, custom tools and prompts)
uv run src/core/server.py --transport streamable-http --log-level DEBUG --tools app,events

Hauptmerkmale des Streamable HTTP-Modus:

Verwendet HTTP-Header für die Authentifizierung (keine Umgebungsvariablen erforderlich)
Unterstützt unterschiedliche Anmeldeinformationen pro Anfrage
Besser geeignet für gemeinsame Umgebungen
MCP-Server-Standardport: 8080
MCP-Endpunkt: http://0.0.0.0:8080/mcp/

Starten im Stdio-Modus

Der Stdio-Modus verwendet Standard-Eingabe/Ausgabe für die Kommunikation und erfordert Umgebungsvariablen für die Authentifizierung.

Verwendung der CLI (PyPI-Installation)

# Option 1: Set environment variables first
export INSTANA_BASE_URL="https://your-instana-instance.instana.io"
export INSTANA_API_TOKEN="your_instana_api_token"

# Start the server (stdio is the default if no transport specified)
mcp-instana

# Or explicitly specify stdio mode
mcp-instana --transport stdio

# Option 2: Use --env flag to set environment variables directly
mcp-instana --env INSTANA_BASE_URL=https://your-instana-instance.instana.io --env INSTANA_API_TOKEN=your_instana_api_token

# Or with explicit stdio mode
mcp-instana --transport stdio --env INSTANA_BASE_URL=https://your-instana-instance.instana.io --env INSTANA_API_TOKEN=your_instana_api_token

Verwendung der Entwicklungsumgebung

# Option 1: Set environment variables first
export INSTANA_BASE_URL="https://your-instana-instance.instana.io"
export INSTANA_API_TOKEN="your_instana_api_token"

# Start the server (stdio is the default if no transport specified)
uv run src/core/server.py

# Or explicitly specify stdio mode
uv run src/core/server.py --transport stdio

# Option 2: Use --env flag to set environment variables directly
uv run src/core/server.py --env INSTANA_BASE_URL=https://your-instana-instance.instana.io --env INSTANA_API_TOKEN=your_instana_api_token

# Or with explicit stdio mode
uv run src/core/server.py --transport stdio --env INSTANA_BASE_URL=https://your-instana-instance.instana.io --env INSTANA_API_TOKEN=your_instana_api_token

Hauptmerkmale des Stdio-Modus:

Verwendet Umgebungsvariablen für die Authentifizierung (kann über export oder das Flag --env gesetzt werden)
Direkte Kommunikation über stdin/stdout
Erforderlich für bestimmte MCP-Client-Konfigurationen
Das Flag --env bietet eine bequeme Möglichkeit, Anmeldeinformationen zu setzen, ohne die Shell-Umgebung zu ändern

Tool-Kategorien

Sie können die Serverleistung optimieren, indem Sie nur die benötigten Tool- und Prompt-Kategorien aktivieren:

Verwendung der CLI (PyPI-Installation)

# List all available categories
mcp-instana --list-tools

# Enable specific categories
mcp-instana --transport streamable-http --tools infra,app
mcp-instana --transport streamable-http --tools events

Verwendung der Entwicklungsumgebung

# List all available categories
uv run src/core/server.py --list-tools

# Enable specific categories
uv run src/core/server.py --transport streamable-http --tools infra,app
uv run src/core/server.py --transport streamable-http --tools events

Verfügbare Kategorien:

infra: Infrastruktur-Überwachungstools und -Prompts (Ressourcen, Katalog, Topologie, Analyse, Metriken)
app: Anwendungsleistungstools und -Prompts (Ressourcen, Metriken, Alerts, Katalog, Topologie, Analyse, Einstellungen, globale Alerts)
events: Ereignisüberwachungstools und -Prompts (Kubernetes-Ereignisse, Agent-Überwachung)
website: Website-Überwachungstools und -Prompts (Metriken, Katalog, Analyse, Konfiguration)

SSL-Zertifikatsprüfung

Die SSL-Zertifikatsprüfung für ausgehende Instana-API-Aufrufe ist standardmäßig deaktiviert. Dies gilt sowohl für den Streamable HTTP- als auch für den Stdio-Transportmodus.

Um die SSL-Zertifikatsprüfung zu aktivieren, verwenden Sie entweder die CLI-Option --verify-ssl oder die Umgebungsvariable INSTANA_SSL_VERIFY.

Verwenden der CLI-Option

uv run src/core/server.py --verify-ssl

Die Option --verify-ssl entspricht der folgenden Einstellung:

export INSTANA_SSL_VERIFY=true

Verwenden der Umgebungsvariable

export INSTANA_SSL_VERIFY=true
uv run src/core/server.py

Die SSL-Überprüfung ist deaktiviert, wenn INSTANA_SSL_VERIFY auf 0, false oder no gesetzt ist (Groß-/Kleinschreibung wird nicht beachtet) oder nicht gesetzt ist. Jeder andere Wert aktiviert die Überprüfung – verwenden Sie true, 1 oder yes als übliche Optionen.

Verwenden eines benutzerdefinierten CA-Bündels

Wenn die SSL-Überprüfung aktiviert ist, wird standardmäßig das System-CA-Bündel verwendet. Um ein benutzerdefiniertes CA-Zertifikatsbündel zu verwenden, setzen Sie INSTANA_CA_BUNDLE:

export INSTANA_SSL_VERIFY=true
export INSTANA_CA_BUNDLE=/path/to/ca-bundle.crt
uv run src/core/server.py

INSTANA_CA_BUNDLE wird nur verwendet, wenn die SSL-Zertifikatsüberprüfung aktiviert ist.

Der Server protokolliert den effektiven SSL-Überprüfungsstatus beim Start, sodass Sie sofort bestätigen können, ob Ihre Umgebungsvariable oder Ihr CLI-Flag übernommen wurde.

Überprüfen des Serverstatus

Nach dem Start können Sie überprüfen, ob der Server läuft:

Für den Streamable-HTTP-Modus:

# Check MCP server
curl http://0.0.0.0:8080/mcp/

# Or with custom port
curl http://0.0.0.0:9000/mcp/

Für den Stdio-Modus: Der Server startet und wartet auf stdin-Eingaben von MCP-Clients.

Häufige Startprobleme

SSL-/Zertifikatsprobleme: Siehe den Abschnitt SSL-Zertifikatsüberprüfung oben für Konfigurationsoptionen. Wenn SSL-Fehler bei aktivierter Überprüfung auftreten und Sie macOS verwenden, stellen Sie sicher, dass Ihre Python-Umgebung Zugriff auf Systemzertifikate hat:

# macOS - Install certificates for Python
/Applications/Python\ 3.13/Install\ Certificates.command

Port bereits belegt: Wenn Port 8080 bereits belegt ist, geben Sie einen anderen Port an:

uv run src/core/server.py --transport streamable-http --port 9000

Fehlende Abhängigkeiten: Stellen Sie sicher, dass alle Abhängigkeiten installiert sind:

uv sync

Einrichtung und Verwendung

Bob IDE

Bob ist eine KI-gestützte IDE von IBM, die MCP-Integration nativ unterstützt. Bob bietet ein nahtloses Entwicklungserlebnis mit integrierter KI-Unterstützung und Observability-Tools.

Streamable-HTTP-Modus

Der Streamable-HTTP-Modus bietet eine REST-API-Schnittstelle für die MCP-Kommunikation über JSON-RPC über HTTP.

Schritt 1: Starten Sie den MCP-Server im Streamable-HTTP-Modus

Bevor Sie Bob konfigurieren, müssen Sie den MCP-Server im Streamable-HTTP-Modus starten. Weitere Anweisungen finden Sie im Abschnitt Starten des lokalen MCP-Servers.

Schritt 2: Bob konfigurieren

In der oberen rechten Ecke des Bob-Bedienfelds sehen Sie ein Dropdown-Menü mit MCP-Servern:

Nach der Auswahl sollten Sie die Option sehen, MCP auf Projektebene oder globaler Ebene zu konfigurieren.

MCP-Konfigurationsbereiche

Bob unterstützt zwei Ebenen der MCP-Konfiguration, sodass Sie den Bereich wählen können, der am besten zu Ihrem Anwendungsfall passt:

1. Globale Konfiguration (Benutzerebene)

Die globale Konfiguration wendet MCP-Server auf alle Projekte des aktuellen Benutzers an. Dies ist ideal, wenn Sie dieselben MCP-Server in jedem Projekt verfügbar haben möchten, an dem Sie arbeiten.

Dateispeicherorte:

macOS: ~/Library/Application Support/Bob/bob_config.json
Windows: %APPDATA%\Bob\bob_config.json
Linux: ~/.config/Bob/bob_config.json

2. Projektkonfiguration (Projektebene)

Die Projektkonfiguration wendet MCP-Server nur auf ein bestimmtes Projekt an. Dies ist nützlich, wenn verschiedene Projekte unterschiedliche MCP-Serverkonfigurationen erfordern oder wenn Sie MCP-Einstellungen über Versionskontrolle mit Ihrem Team teilen möchten.

Dateispeicherort:

.bob/bob_config.json im Stammverzeichnis Ihres Projekts

Auswahl zwischen globaler und Projektkonfiguration:

Verwenden Sie die globale Konfiguration für MCP-Server, die Sie in allen Ihren Projekten verfügbar haben möchten
Verwenden Sie die Projektkonfiguration für projektspezifische MCP-Server oder um Konfigurationen mit Ihrem Team zu teilen
Beide Konfigurationen können nebeneinander bestehen – projektspezifische Einstellungen haben Vorrang vor globalen Einstellungen für denselben Servernamen

Weitere Informationen zu Bob und MCP-Konfiguration finden Sie unter: https://bob.ibm.com/docs/ide/configuration/mcp/mcp-in-bob

Lokale Konfiguration:

Konfigurieren Sie Bob, um eine Verbindung zu Ihrem lokalen Instana-MCP-Server herzustellen:

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "npx",
      "args": [
        "mcp-remote", "http://0.0.0.0:8080/mcp/",
        "--allow-http",
        "--header", "instana-base-url: https://your-instana-instance.instana.io",
        "--header", "instana-api-token: your_instana_api_token"
      ]
    }
  }
}

Remote-Konfiguration:

Konfigurieren Sie Bob, um eine Verbindung zu einem entfernten Instana-MCP-Server herzustellen (z. B. bereitgestellt auf IBM Code Engine):

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "npx",
      "args": [
        "mcp-remote", "https://app-instana-750.1zetetanw8ul.us-east.codeengine.appdomain.cloud/mcp/",
        "--allow-http",
        "--header", "instana-base-url: https://your-instana-instance.instana.io",
        "--header", "instana-api-token: your_instana_api_token"
      ]
    }
  }
}

Hinweis: Für die Verwendung von npx empfehlen wir, zuerst NVM (Node Version Manager) zu installieren und dann Node.js damit zu installieren. Installationsanweisungen finden Sie unter: https://nodejs.org/en/download

Schritt 3: Verbindung testen

Nachdem Sie die MCP-Konfiguration eingerichtet haben, sollte der neu konfigurierte MCP-Server als aktiviert angezeigt werden. Ein grüner Punkt zeigt an, dass der Server erfolgreich läuft.

Sie können jetzt Abfragen in der Bob-IDE ausführen:

get me all applications from Instana in the last 24 hours

Stdio-Modus

Konfiguration über CLI (PyPI-Installation – empfohlen):

Option 1: Verwenden von Umgebungsvariablen in der Konfiguration:

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "mcp-instana",
      "args": ["--transport", "stdio"],
      "env": {
        "INSTANA_BASE_URL": "https://your-instana-instance.instana.io",
        "INSTANA_API_TOKEN": "your_instana_api_token"
      }
    }
  }
}

Option 2: Verwenden des Flags --env (alternative Methode):

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "mcp-instana",
      "args": [
        "--transport", "stdio",
        "--env", "INSTANA_BASE_URL=https://your-instana-instance.instana.io",
        "--env", "INSTANA_API_TOKEN=your_instana_api_token"
      ]
    }
  }
}

Hinweis: Wenn Sie Fehler wie „command not found" erhalten, verwenden Sie den vollständigen Pfad zu mcp-instana. Finden Sie ihn mit which mcp-instana und verwenden Sie diesen Pfad stattdessen.

Konfiguration über Entwicklungsinstallation:

Option 1: Verwenden von Umgebungsvariablen in der Konfiguration:

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "uv",
      "args": [
        "--directory",
        "<path-to-mcp-instana-folder>",
        "run",
        "src/core/server.py"
      ],
      "env": {
        "INSTANA_BASE_URL": "https://your-instana-instance.instana.io",
        "INSTANA_API_TOKEN": "your_instana_api_token"
      }
    }
  }
}

Option 2: Verwenden des Flags --env (alternative Methode):

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "uv",
      "args": [
        "--directory",
        "<path-to-mcp-instana-folder>",
        "run",
        "src/core/server.py",
        "--env", "INSTANA_BASE_URL=https://your-instana-instance.instana.io",
        "--env", "INSTANA_API_TOKEN=your_instana_api_token"
      ]
    }
  }
}

Claude Desktop

Claude Desktop unterstützt sowohl den Streamable-HTTP- als auch den Stdio-Modus für die MCP-Integration.

Konfigurieren Sie Claude Desktop, indem Sie die Konfigurationsdatei bearbeiten:

Dateispeicherorte:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Streamable-HTTP-Modus

Der Streamable-HTTP-Modus bietet eine REST-API-Schnittstelle für die MCP-Kommunikation über JSON-RPC über HTTP.

Schritt 1: Starten Sie den MCP-Server im Streamable-HTTP-Modus

Bevor Sie Claude Desktop konfigurieren, müssen Sie den MCP-Server im Streamable-HTTP-Modus starten. Weitere Anweisungen finden Sie im Abschnitt Starten des lokalen MCP-Servers.

Schritt 2: Claude Desktop konfigurieren

Konfigurieren Sie Claude Desktop so, dass Instana-Anmeldeinformationen über Header übergeben werden:

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "npx",
      "args": [
        "mcp-remote", "http://0.0.0.0:8080/mcp/",
        "--allow-http",
        "--header", "instana-base-url: https://your-instana-instance.instana.io",
        "--header", "instana-api-token: your_instana_api_token"
      ]
    }
  }
}

Schritt 3: Verbindung testen

Starten Sie Claude Desktop neu. Sie sollten nun den Instana-MCP-Server in der Claude-Desktop-Oberfläche sehen, wie unten gezeigt:

Sie können jetzt Abfragen in Claude Desktop ausführen:

get me all endpoints from Instana

Stdio-Modus

Konfiguration über CLI (PyPI-Installation – empfohlen):

Option 1: Verwenden von Umgebungsvariablen in der Konfiguration:

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "mcp-instana",
      "args": ["--transport", "stdio"],
      "env": {
        "INSTANA_BASE_URL": "https://your-instana-instance.instana.io",
        "INSTANA_API_TOKEN": "your_instana_api_token"
      }
    }
  }
}

Option 2: Verwenden des Flags --env (alternative Methode):

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "mcp-instana",
      "args": [
        "--transport", "stdio",
        "--env", "INSTANA_BASE_URL=https://your-instana-instance.instana.io",
        "--env", "INSTANA_API_TOKEN=your_instana_api_token"
      ]
    }
  }
}

Konfiguration über Entwicklungsinstallation:

Option 1: Verwenden von Umgebungsvariablen in der Konfiguration:

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "uv",
      "args": [
        "--directory",
        "<path-to-mcp-instana-folder>",
        "run",
        "src/core/server.py"
      ],
      "env": {
        "INSTANA_BASE_URL": "https://your-instana-instance.instana.io",
        "INSTANA_API_TOKEN": "your_instana_api_token"
      }
    }
  }
}

Option 2: Verwenden des Flags --env (alternative Methode):

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "uv",
      "args": [
        "--directory",
        "<path-to-mcp-instana-folder>",
        "run",
        "src/core/server.py",
        "--env", "INSTANA_BASE_URL=https://your-instana-instance.instana.io",
        "--env", "INSTANA_API_TOKEN=your_instana_api_token"
      ]
    }
  }
}

Kiro-Einrichtung

Kiro ist eine agentische IDE und keine Erweiterung, die in VS Code oder eine andere IDE heruntergeladen werden kann.

Schritt 1: Laden Sie Kiro für Ihr Betriebssystem von https://kiro.dev/. herunter und installieren Sie es.

Schritt 2: Starten Sie nach der Installation Kiro und öffnen Sie ein beliebiges Projekt in der IDE. alt text

Schritt 3: Klicken Sie auf das Kiro-Symbol (Geist) in der linken Seitenleiste, um auf die Funktionen von Kiro zuzugreifen. alt text

Schritt 4: Wählen Sie das Symbol „Konfiguration bearbeiten" in der oberen rechten Ecke des Abschnitts „MCP-Server". alt text

Schritt 5: Öffnen Sie die MCP-Serverkonfigurationsdatei (mcp.json) und konfigurieren Sie sie basierend auf Ihrem bevorzugten Übertragungsmodus:

Streamable-HTTP-Modus (für Kiro empfohlen)

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "npx",
      "args": [
        "mcp-remote", "http://0.0.0.0:8080/mcp/",
        "--allow-http",
        "--header", "instana-base-url: https://your-instana-instance.instana.io",
        "--header", "instana-api-token: your_instana_api_token"
      ]
    }
  }
}

Hinweis: Stellen Sie sicher, dass Sie den MCP-Server im Streamable-HTTP-Modus starten, bevor Sie diese Konfiguration verwenden:

mcp-instana --transport streamable-http

Stdio-Modus

Option 1: Verwenden von Umgebungsvariablen in der Konfiguration:

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "mcp-instana",
      "args": ["--transport", "stdio"],
      "env": {
        "INSTANA_BASE_URL": "https://your-instana-instance.instana.io",
        "INSTANA_API_TOKEN": "your_instana_api_token"
      }
    }
  }
}

Option 2: Verwenden des Flags --env (alternative Methode):

{
  "mcpServers": {
    "Instana MCP Server": {
      "command": "mcp-instana",
      "args": [
        "--transport", "stdio",
        "--env", "INSTANA_BASE_URL=https://your-instana-instance.instana.io",
        "--env", "INSTANA_API_TOKEN=your_instana_api_token"
      ]
    }
  }
}

Schritt 6: Nach dem Speichern der Datei klicken Sie auf die Schaltfläche „MCP aktivieren" und Sie sehen Ihren MCP-Server und seine verfügbaren Tools im unteren linken Bereich von Kiro. alt text

Schritt 7: Gehen Sie zum KI-Chat-Bedienfeld, geben Sie eine Eingabeaufforderung zu Ihrem MCP-Server ein und sehen Sie die Antwort direkt in Kiro. alt text

GitHub Copilot

GitHub Copilot unterstützt die MCP-Integration über die VS-Code-Konfiguration. Für die GitHub-Copilot-Integration mit VS Code lesen Sie diese Einrichtungsanleitung.

Streamable-HTTP-Modus

Schritt 1: Starten Sie den MCP-Server im Streamable-HTTP-Modus

Bevor Sie VS Code konfigurieren, müssen Sie den MCP-Server im Streamable-HTTP-Modus starten. Weitere Anweisungen finden Sie im Abschnitt Starten des lokalen MCP-Servers.

Schritt 2: VS Code konfigurieren

Lesen Sie MCP-Server in VS Code verwenden für die detaillierte Konfiguration.

Sie können .vscode/mcp.json direkt erstellen oder aktualisieren mit der folgenden Konfiguration:

{
  "servers": {
    "Instana MCP Server": {
      "command": "npx",
      "args": [
        "mcp-remote", "http://0.0.0.0:8080/mcp/",
        "--allow-http",
        "--header", "instana-base-url: https://your-instana-instance.instana.io",
        "--header", "instana-api-token: your_instana_api_token"
      ],
      "env": {
        "PATH": "/usr/local/bin:/bin:/usr/bin",
        "SHELL": "/bin/sh"
      }
    }
  }
}

Hinweis: Ersetzen Sie die folgenden Werte durch Ihre tatsächliche Konfiguration:

instana-base-url: Ihre Instana-Instanz-URL
instana-api-token: Ihr Instana-API-Token
command: Aktualisieren Sie den npx-Pfad, damit er der Node.js-Installation Ihres Systems entspricht (z. B. /path/to/your/node/bin/npx)
Umgebungsvariablen: Passen Sie PATH und andere Umgebungsvariablen nach Bedarf für Ihr System an

Stdio-Modus

Schritt 1: VS-Code-MCP-Konfiguration erstellen

Verwendung der CLI (PyPI-Installation – empfohlen):

Erstellen Sie .vscode/mcp.json im Stammverzeichnis Ihres Projekts:

Option 1: Verwenden von Umgebungsvariablen in der Konfiguration:

{
  "servers": {
    "Instana MCP Server": {
      "command": "mcp-instana",
      "args": ["--transport", "stdio"],
      "env": {
        "INSTANA_BASE_URL": "https://your-instana-instance.instana.io",
        "INSTANA_API_TOKEN": "your_instana_api_token"
      }
    }
  }
}

Option 2: Verwenden des Flags --env (alternative Methode):

{
  "servers": {
    "Instana MCP Server": {
      "command": "mcp-instana",
      "args": [
        "--transport", "stdio",
        "--env", "INSTANA_BASE_URL=https://your-instana-instance.instana.io",
        "--env", "INSTANA_API_TOKEN=your_instana_api_token"
      ]
    }
  }
}

Verwendung der Entwicklungsinstallation:

Erstellen Sie .vscode/mcp.json im Stammverzeichnis Ihres Projekts:

Option 1: Verwenden von Umgebungsvariablen in der Konfiguration:

{
  "servers": {
    "Instana MCP Server": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/your/project/mcp-instana",
        "run",
        "src/core/server.py"
      ],
      "env": {
        "INSTANA_BASE_URL": "https://your-instana-instance.instana.io",
        "INSTANA_API_TOKEN": "your_instana_api_token"
      }
    }
  }
}

Option 2: Verwenden des Flags --env (alternative Methode):

{
  "servers": {
    "Instana MCP Server": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/your/project/mcp-instana",
        "run",
        "src/core/server.py",
        "--env", "INSTANA_BASE_URL=https://your-instana-instance.instana.io",
        "--env", "INSTANA_API_TOKEN=your_instana_api_token"
      ]
    }
  }
}

Hinweis: Ersetzen Sie die folgenden Werte durch Ihre tatsächliche Konfiguration:

Für die CLI-Installation: Stellen Sie sicher, dass mcp-instana in Ihrem PATH ist
Für die Entwicklungsinstallation:
- command: Aktualisieren Sie den uv-Pfad, damit er der uv-Installation Ihres Systems entspricht (z. B. /path/to/your/uv/bin/uv oder /usr/local/bin/uv)
- --directory: Aktualisieren Sie mit dem absoluten Pfad zu Ihrem mcp-instana-Projektverzeichnis
INSTANA_BASE_URL: Ihre Instana-Instanz-URL
INSTANA_API_TOKEN: Ihr Instana-API-Token

Schritt 2: Server in VS Code verwalten

Öffnen Sie .vscode/mcp.json – Sie sehen die Serververwaltungssteuerungen oben
Klicken Sie auf Start neben Instana MCP Server, um den Server zu starten
Der Ausführungsstatus zusammen mit der Anzahl der Tools zeigt an, dass der Server läuft

Schritt 3: Integration testen

Wechseln Sie im GitHub Copilot in den Agentenmodus und laden Sie die Tools neu. Hier ist ein Beispiel für eine GitHub-Copilot-Antwort:

GitHub Copilot Response

Mistral AI

Mistral AI unterstützt die MCP-Integration ausschließlich über den Streamable-HTTP-Modus.

Schritt 1: Starten Sie den MCP-Server im Streamable-HTTP-Modus

Starten Sie den MCP-Server im Streamable-HTTP-Modus, indem Sie Ihre Instana-Anmeldeinformationen angeben. Führen Sie den folgenden Befehl aus:

uv run src/core/server.py --transport streamable-http \
  --api-token "your_instana_api_token" \
  --base-url "https://your-instana-instance.instana.io" \
  --port 8080

Schritt 2: Portweiterleitung mit Ngrok einrichten

Konfigurieren Sie die Portweiterleitung, um Ihren lokalen Server verfügbar zu machen. Befolgen Sie die Ngrok-Einrichtungsdokumentation für detaillierte Anweisungen.

Schritt 3: Mistral AI konfigurieren

Navigieren Sie zur Registerkarte Intelligence in der linken Seitenleiste und wählen Sie Connectors
Klicken Sie auf Connector hinzufügen
Erstellen Sie einen benutzerdefinierten Connector, indem Sie einen Connector-Namen und die über Ngrok weitergeleitete MCP-Server-URL eingeben
Starten Sie eine neue Chat-Sitzung und überprüfen Sie, ob MCP-Tools aktiviert sind. Sie können die Antwort hier anzeigen

Verbinden mit mehreren Instana-MCP-Servern

Sie können Ihren MCP-Client so konfigurieren, dass er eine Verbindung zu mehreren Instanzen herstellt. Unten finden Sie eine Beispielkonfiguration:

{
  "mcpServers": {
    "Instana MCP Server1": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://0.0.0.0:8080/mcp/",
        "--allow-http",
        "--header",
        "instana-base-url: ENV1_INSTANA_URL",
        "--header",
        "instana-api-token: ENV1_INSTANA_API_TOKEN"
      ]
    },
    "Instana MCP Server2": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://0.0.0.0:8080/mcp/",
        "--allow-http",
        "--header",
        "instana-base-url: ENV2_INSTANA_URL",
        "--header",
        "instana-api-token: ENV2_INSTANA_API_TOKEN"
      ]
    }
  }
}

Um einen bestimmten Server anzusprechen, stellen Sie sicher, dass:

Der Server mit dem entsprechenden Umgebungsnamen in der MCP-Konfiguration konfiguriert ist (z. B. Instana MCP Server1)
Die Eingabeaufforderung den Server-/Umgebungsnamen explizit erwähnt. Die Anfrage wird dann an den entsprechend konfigurierten Server weitergeleitet. Wenn in der Eingabeaufforderung kein Server/keine Umgebung explizit erwähnt wird, verwendet MCP den ersten in der Konfiguration definierten Server als Standard-Server.

Hinweis: Wenn der angeforderte Server nicht erreichbar ist oder ausfällt, verhält sich MCP wie erwartet und leitet den API-Fehler weiter. Der Benutzer erhält den entsprechenden von der API zurückgegebenen Fehler, der angibt, dass der Server nicht verfügbar ist. MCP verlässt sich auf die Verfügbarkeit der zugrunde liegenden API und führt kein automatisches Failover durch.

Unterstützte Funktionen

Verfügbare Tools

Tool	Kategorie	Beschreibung
`manage_applications`	Anwendung & Infrastruktur	Einheitliches Tool für die Verwaltung von Anwendungsmetriken, Alert-Konfigurationen, Einstellungen und Katalog
`manage_websites`	Website-Überwachung	Einheitlicher Smart-Router für Website-Analyse, Katalog, Konfiguration und erweiterte Konfigurationsoperationen
`manage_custom_dashboards`	Benutzerdefinierte Dashboards	Einheitliches Tool für die Verwaltung von CRUD-Operationen für benutzerdefinierte Dashboards
`manage_infrastructure`	Infrastruktur	Einheitlicher Smart-Router für Infrastruktur-Analyse, Katalog (`get_plugin_schema`) und Snapshot-Ressourcenoperationen
`manage_automation`	Automatisierung	Einheitlicher Smart-Router für Automatisierung: Aktionskatalog durchsuchen und Ausführungsverlauf anzeigen
`manage_events`	Ereignisse	Einheitlicher Smart-Router für Ereignisüberwachung: Ereignis nach ID abrufen, Ereignisse nach IDs abrufen, Kubernetes-Ereignisse, Agent-Überwachungsereignisse und alle Ereignisse
`manage_slo`	SLO-Management	Einheitlicher Smart-Router für SLO-Konfigurationen, Berichte, Alerts und Korrekturfenster mit intelligenter Zeitzonenverwaltung
`manage_releases`	Release-Management	Einheitlicher Smart-Router für Release-Verfolgung: Releases mit Paginierung und Namensfilterung auflisten, Release-Details abrufen, Releases mit Zeitzonenunterstützung erstellen/aktualisieren/löschen
`manage_maintenance_windows`	Wartungsfenster	Einheitlicher Smart-Router für die Verwaltung des Lebenszyklus von Wartungsfenstern: Wartungsfenster erstellen, ändern, schließen und auflisten mit Vorlagenunterstützung und ServiceNow-Integration
`manage_mobile_apps`	Mobile-App-Überwachung	Einheitlicher Smart-Router für Mobile-App-Überwachung: Beacons analysieren, Leistungsmetriken, Session Replay, Konfiguration und Alert-Management
`manage_synthetics`	Synthetisches Monitoring	Einheitlicher Smart-Router für synthetisches Monitoring: Katalog, Metriken, Einstellungen (nur Lesezugriff) und Test-Wiedergabeergebnisse

👉 Detaillierte Tool-Dokumentation, Funktionen und technische Referenz finden Sie unter Tools & Beispiele

Tool-Filterung

Der MCP-Server unterstützt selektives Tool-Laden, um die Leistung zu optimieren und den Ressourcenverbrauch zu reduzieren. Sie können nur die Tool-Kategorien aktivieren, die Sie für Ihren spezifischen Anwendungsfall benötigen.

Verfügbare Tool-Kategorien

router: Einheitliches Anwendungs- und Infrastruktur-Management
- manage_instana_resources: Ein einziges Tool für Anwendungsmetriken, Alert-Konfigurationen, Einstellungen und Katalog
- Unterstützt Anwendungsperspektiven, Endpunkte, Dienste und manuelle Dienste
- Verwaltet sowohl anwendungsspezifische als auch globale Alert-Konfigurationen
- Bietet Zugriff auf Anwendungs-Tag-Katalog und Metrik-Katalog
dashboard: Verwaltung benutzerdefinierter Dashboards
- manage_custom_dashboards: CRUD-Operationen für benutzerdefinierte Dashboards
- Unterstützt Erstellung, Abruf, Aktualisierung und Löschung von Dashboards
- Verwaltet teilbare Benutzer und API-Tokens für Dashboards
infra: Infrastruktur-Management-Tools
- manage_infrastructure: Einheitlicher Smart-Router für Infrastruktur-Analyse, Katalog und Snapshot-Ressourcenoperationen
- get_plugin_schema kombiniert get_metrics + get_tag_catalog in einem einzigen API-Aufruf
- Unterstützt dynamisch alle in Ihrer Instana-Installation verfügbaren Entitätstypen (automatisch aus dem API-Katalog geladen)
- Umfasst JVM, Kubernetes, Docker, Hosts, Datenbanken, Message Queues sowie alle benutzerdefinierten oder neu hinzugefügten Entitätstypen
- Flexible Metrik-Aggregation, Filterung, Gruppierung und Zeitbereichsabfragen
automation: Tools für Automatisierungsaktionen
- manage_automation: Unified Smart Router für Automatisierungskatalog und Ausführungsverlauf
- Aktionskatalog: Aktionen durchsuchen, Details abrufen, nach Name/Beschreibung suchen, nach Anwendungs- oder Snapshot-ID filtern
- Aktionsverlauf: Ausführungsinstanzen mit Filterung auflisten, Ausführungsdetails abrufen
events: Tools für Ereignisüberwachung
- Ereignisse: Kubernetes-Ereignisse, Agentenüberwachung und Systemereignisverfolgung
website: Tools für Website-Überwachung
- Website-Metriken: Leistungsmessung für Websites
- Website-Katalog: Website-Metadaten und -Definitionen
- Website-Analyse: Leistungsanalyse für Websites
- Website-Konfiguration: Verwaltung der Website-Konfiguration
slo: Verwaltung von Service Level Objectives (SLO)
- manage_slo: Unified Smart Router für umfassende SLO-Operationen
- Konfigurationsverwaltung: Erstellen, Lesen, Aktualisieren, Löschen von SLO-Konfigurationen mit Unterstützung für zeitbasierte und ereignisbasierte Indikatoren
- Berichtserstellung: Detaillierte SLO-Berichte mit SLI-Werten, Fehlerbudgets, Burn Rates und Zeitreihendiagrammen generieren
- Alert-Konfiguration: SLO-Alert-Konfigurationen für Fehlerbudget-Überwachung und Burn-Rate-Verfolgung verwalten
- Korrekturfenster: Wartungsfenster erstellen und verwalten, um geplante Ausfallzeiten von SLO-Berechnungen auszuschließen
- Intelligente Zeitzonenbehandlung: Automatische Ermittlung der Zeitzone für Datum/Uhrzeit-Eingaben zur Sicherstellung eines genauen Zeitkontexts
- Zweistufige Ermittlung: Interaktive Parametererfassung für komplexe Operationen, die mehrere Eingaben erfordern
releases: Release-Tracking und Deployment-Verwaltung
- manage_releases: Unified Smart Router für Release-Operationen
- Releases auflisten: Alle Releases mit effizienter Paginierung (page_number, page_size) und namensbasierter Filterung abrufen
- Release-Details: Spezifische Release-Informationen per ID abrufen, einschließlich Anwendungen, Diensten und Scopes
- Erstellen/Aktualisieren/Löschen: Vollständige CRUD-Operationen für die Release-Verwaltung
- Intelligente Zeitzonenbehandlung: Automatische Ermittlung der Zeitzone für Release-Startzeiten
- Effiziente Paginierung: Redundantes Datenabrufen durch ordnungsgemäße seitenbasierte Navigation vermeiden
- Namensfilterung: Groß-/Kleinschreibung-unabhängige Teilstring-Übereinstimmung zum Auffinden von Releases nach Name
maintenance_window: Lebenszyklusverwaltung von Wartungsfenstern
- manage_maintenance_windows: Unified Smart Router für Wartungsfenster-Operationen
- Fensteroperationen: Wartungsfenster erstellen, ändern, schließen und auflisten (aktiv, geplant, alle, abgelaufen)
- Massenoperationen: Wartungsfenster für mehrere Anwendungen gleichzeitig erstellen
- Vorlagenunterstützung: Vordefinierte Vorlagen für häufige Szenarien (Deployment, Datenbankmigration, Infrastruktur-Upgrade, Notfall, Routine)
- Wiederkehrende Fenster: Unterstützung für wiederkehrende Wartungsfenster im RFC-5545-RRULE-Format
- ServiceNow-Integration: Optionale Integration mit ServiceNow-Change-Requests
- Validierung: Parametervalidierung vor der Fenstererstellung
- Flexible Dauer: Dauer in Minuten, Stunden oder Tagen angeben
mobile_app: Überwachung mobiler Anwendungen
- manage_mobile_apps: Unified Smart Router für Überwachungsoperationen mobiler Apps
- Session Replay: Paginierte Session-Replay-Action-Beacons nach Mobile-App-ID und Session-ID abrufen (resource_type="session_replay")
- Beacon-Analyse: Mobile-App-Beacon-Daten mit Gruppierung und Filterung abfragen
- Leistungsmetriken: Sitzungsdauer, Absturzraten und HTTP-Request-Leistung verfolgen
- Geografische Analyse: Benutzerverteilung nach Land, Stadt und Region analysieren
- Geräteanalyse: Leistung über verschiedene Geräte, Plattformen und OS-Versionen hinweg überwachen
- Konfigurationsverwaltung: Mobile-App-Konfigurationen, Geo-Location- und IP-Maskierungseinstellungen verwalten
- Alert-Verwaltung: Alert-Konfigurationen für mobile Apps konfigurieren und verwalten
synthetics: Verwaltung synthetischer Überwachung
- manage_synthetics: Unified Smart Router für alle Operationen der synthetischen Überwachung
- Katalog: Gültige Metrik-IDs und Tag-Namen vor dem Erstellen von Abfragen ermitteln
- Metriken: Aggregierte Antwortzeiten und Erfolgsraten abrufen, gruppiert nach Standort oder Testname
- Einstellungen: Tests und Standorte mit automatischer Namensauflösung auflisten und nachschlagen; Rechenzentrum (Managed) vs. selbst gehostete (Private) PoPs identifizieren
- Test-Wiedergabe: Rohergebnisse pro Ausführung, LAST_VALUE-Analysen, Erfolgsraten-Zusammenfassungen pro Standort und Detaildatei-Downloads (LOGS, HAR, Screenshots)

Anwendungsbeispiele

Verwendung der CLI (PyPI-Installation)

# Enable only router (unified app/infra management) and events tools
mcp-instana --tools router,events --transport streamable-http

# Enable only infrastructure analysis tools
mcp-instana --tools infra --transport streamable-http

# Enable router and infrastructure analysis
mcp-instana --tools router,infra --transport streamable-http

# Enable events and website tools
mcp-instana --tools events,website --transport streamable-http

# Enable dashboard and router tools
mcp-instana --tools dashboard,router --transport streamable-http

# Enable releases and events tools
mcp-instana --tools releases,events --transport streamable-http

# Enable maintenance window and events tools
mcp-instana --tools maintenance_window,events --transport streamable-http

# Enable all tools (default behavior)
mcp-instana --transport streamable-http

# List all available tool categories and their tools
mcp-instana --list-tools

Verwendung der Entwicklungsinstallation

# Enable only router (unified app/infra management) and events tools
uv run src/core/server.py --tools router,events --transport streamable-http

# Enable only infrastructure analysis tools
uv run src/core/server.py --tools infra --transport streamable-http

# Enable router and infrastructure analysis
uv run src/core/server.py --tools router,infra --transport streamable-http

# Enable events and website tools
uv run src/core/server.py --tools events,website --transport streamable-http

# Enable dashboard and router tools
uv run src/core/server.py --tools dashboard,router --transport streamable-http

# Enable releases and events tools
uv run src/core/server.py --tools releases,events --transport streamable-http

# Enable maintenance window and events tools
uv run src/core/server.py --tools maintenance_window,events --transport streamable-http

# Enable all tools (default behavior)
uv run src/core/server.py --transport streamable-http

# List all available tool categories and their tools
uv run src/core/server.py --list-tools

Vorteile der Tool-Filterung

Leistung: Reduzierte Startzeit und Speichernutzung
Sicherheit: Begrenzung der Exposition auf nur notwendige APIs
Klarheit: Fokussierung auf spezifische Anwendungsfälle (z. B. nur Infrastrukturüberwachung)
Ressourceneffizienz: Geringere CPU- und Netzwerkauslastung

👉 Für Anwendungsbeispiele und Prompts siehe Beispiel-Prompts

Docker-Bereitstellung

Der MCP-Instana-Server kann für Produktionsumgebungen mit Docker bereitgestellt werden. Das Docker-Setup ist für Sicherheit, Leistung und minimale Ressourcennutzung optimiert.

Erstellen des Docker-Images

Voraussetzungen

Docker installiert und ausgeführt
Zugriff auf den Quellcode des Projekts

Erstellen und Ausführen

# Build the image
docker build -t mcp-instana:latest .

# Build with a specific tag
docker build -t mcp-instana:<image_tag> .

# Run the container (credentials are supplied via HTTP headers at request time)
docker run -p 8080:8080 mcp-instana

# Run with a custom host port
docker run -p 8081:8080 mcp-instana

📖 Für umfassende Docker-Dokumentation einschließlich Multi-Architektur-Builds, .dockerignore, Sicherheits-Best-Practices und Produktionsbereitstellungsbeispiele siehe DOCKER.md.

Fehlerbehebung

Docker-Probleme

Container startet nicht

# Check container logs
docker logs <container_id>
# Common issues:
# 1. Port already in use
# 2. Invalid container image
# 3. Missing dependencies
# Credentials are passed via HTTP headers from the MCP client

Verbindungsprobleme

# Test container connectivity (expects 406 from a bare GET — means server is up)
curl http://localhost:8080/mcp
# Check port mapping
docker port <container_id>

Leistungsprobleme

# Check container resource usage
docker stats <container_id>
# Monitor container health
docker inspect <container_id> | grep -A 10 Health

Allgemeine Probleme

GitHub Copilot
- Wenn Probleme mit GitHub Copilot auftreten, versuchen Sie, den Server in der Datei mcp.json zu starten/stoppen/neu zu starten, und lassen Sie jeweils nur einen Server laufen.
Zertifikatsprobleme
- Wenn Zertifikatsprobleme auftreten, wie z. B. [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate:
  - Überprüfen Sie, ob Sie den Instana-API-Endpunkt mit curl oder wget mit SSL-Verifizierung erreichen können.
    - Wenn das funktioniert, kann Ihre Python-Umgebung das Zertifikat möglicherweise nicht verifizieren und hat möglicherweise keinen Zugriff auf dieselben Zertifikate wie Ihre Shell oder Ihr System. Stellen Sie sicher, dass Ihre Python-Umgebung Systemzertifikate verwendet (macOS). Sie können dies tun, indem Sie Zertifikate in Python installieren: /Applications/Python\ 3.13/Install\ Certificates.command
  - Wenn Sie den Endpunkt mit SSL-Verifizierung nicht erreichen können, versuchen Sie es ohne. Wenn das funktioniert, überprüfen Sie die CA-Zertifikate Ihres Systems und stellen Sie sicher, dass sie aktuell sind.