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

Was kann man mit IBM Instana MCP machen?

Infrastruktur-Snapshots abrufen — Fordern Sie einen Snapshot eines bestimmten Hosts, Prozesses oder Containers mit get_infra_snapshot an.
Anwendungs- oder Servicemetriken analysieren — Fordern Sie Zeitreihenmetriken für Aufrufe, Fehler oder Latenz mit get_app_metrics oder get_service_metrics an.
Aktive Warnungen und Vorfälle auflisten — Erhalten Sie aktuelle Warnungen, Vorfälle oder globale Smart Alerts über get_alerts und get_incidents.
Kubernetes-Ereignisse überprüfen — Rufen Sie aktuelle Kubernetes-Ereignisse für einen Cluster oder Namespace mit get_k8s_events ab.
Website-Überwachungsdaten abfragen — Rufen Sie Website-Leistungsmetriken oder Beacon-Ergebnisse über get_website_metrics ab.

Dokumentation

Inhaltsverzeichnis

MCP-Server für IBM Instana

MCP-Server für IBM Instana

📚 Schnellzugriff

Werkzeuge & Beispiele - Umfassende Werkzeugdokumentation mit praxisnahen Beispielen
Datenschutzrichtlinie - Informationen zur Datenverarbeitung und zum Datenschutz
Docker-Bereitstellungsleitfaden - Umfassende Docker-Bereitstellung, Multi-Architektur-Builds und Produktionseinrichtung

Der Instana-MCP-Server ermöglicht eine nahtlose Interaktion mit der Instana-Observability-Plattform, sodass Sie direkt in Ihrem Entwicklungsworkflow auf Echtzeit-Observability-Daten zugreifen können.

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

Der Server unterstützt sowohl den Streamable-HTTP- als auch den Stdio-Transportmodus 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

Arbeitsablauf

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-Alarmen anfordern, läuft folgender Prozess ab:

Der MCP-Client ruft die Liste der verfügbaren Werkzeuge vom Instana-MCP-Server ab
Ihre Anfrage wird zusammen mit den Werkzeugbeschreibungen an das LLM gesendet
Das LLM analysiert die verfügbaren Werkzeuge und wählt das/die geeignete(n) zum Abrufen von Instana-Alarmen aus
Der Client führt das/die gewählte(n) Werkzeug(e) über den Instana-MCP-Server aus
Ergebnisse (neueste Alarme) werden an das LLM zurückgegeben
Das LLM formuliert eine natürlichsprachliche Antwort
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: Entwicklungsinstallation

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

uv installieren

Dieses Projekt verwendet uv, einen schnellen Python-Paketinstaller und -Resolver. Um uv zu installieren, haben Sie mehrere Möglichkeiten:

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 wie folgt ein:

uv sync

Header-basierte Authentifizierung für den Streamable-HTTP-Modus

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

Vermeidung der Speicherung von Anmeldeinformationen in Umgebungsvariablen
Ermöglichung der Verwendung unterschiedlicher Anmeldeinformationen für verschiedene Anfragen
Unterstützung gemeinsam genutzter Umgebungen, in denen die Änderung von Umgebungsvariablen eingeschränkt ist
Unterstützung sowohl der API-Token- als auch der sitzungsbasierten 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. Sitzungstoken-Authentifizierung (UI-initiierte Aufrufe)

Erforderliche Header:

instana-base-url: Ihre Instana-Instanz-URL
instana-auth-token: Sitzungsauthentifizierungstoken vom UI-Backend
instana-csrf-token: CSRF-Token vom UI-Backend
instana-cookie-name: (Optional) Cookie-Name für die Sitzungsauthentifizierung (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-Plattform-Integration)

Erforderliche Header:

instana-base-url: Ihre Instana-Instanz-URL
instana-jwt-token: JWT-Token von der IBM-Plattform
instana-csrf-token: CSRF-Token zur 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-Plattform-Integration
Sitzungstoken (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 eine sichere Übertragung von Anmeldeinformationen und unterstützt mehrere Authentifizierungsabläufe, einschließlich UI-initiierter Aufrufe über WebSocket → Koordinator → MCP-Server.

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

Starten des lokalen MCP-Servers

Bevor Sie einen MCP-Client konfigurieren (Claude Desktop, GitHub Copilot oder benutzerdefinierte MCP-Clients), 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 Entwicklungsinstallation

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>: Protokollierungsstufe festlegen (Auswahl: DEBUG, INFO, WARNING, ERROR, CRITICAL)
--tools <categories>: Durch Kommas getrennte Liste der zu aktivierenden Werkzeugkategorien (z. B. infra,app,events,website). Das Aktivieren einer Kategorie aktiviert auch die zugehörigen Prompts. Beispiel: --tools infra aktiviert die Infra-Werkzeuge und alle Infra-bezogenen Prompts.
--list-tools: Alle verfügbaren Werkzeugkategorien auflisten und beenden
--port <port>: MCP-Server-Port (Standard: 8080, kann mit der Umgebungsvariable PORT überschrieben werden)
--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 Entwicklungsinstallation

# 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 zur Authentifizierung (keine Umgebungsvariablen erforderlich)
Unterstützt unterschiedliche Anmeldeinformationen pro Anfrage
Besser geeignet für gemeinsam genutzte Umgebungen
MCP-Server-Standardport: 8080
MCP-Endpunkt: http://0.0.0.0:8080/mcp/

Starten im Stdio-Modus

Der Stdio-Modus verwendet Standardeingabe/-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 Entwicklungsinstallation

# 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 festzulegen, ohne die Shell-Umgebung zu ändern

Werkzeugkategorien

Sie können die Serverleistung optimieren, indem Sie nur die benötigten Werkzeug- 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 Entwicklungsinstallation

# 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überwachungswerkzeuge und -prompts (Ressourcen, Katalog, Topologie, Analyse, Metriken)
app: Anwendungsleistungswerkzeuge und -prompts (Ressourcen, Metriken, Alarme, Katalog, Topologie, Analyse, Einstellungen, globale Alarme)
events: Ereignisüberwachungswerkzeuge und -prompts (Kubernetes-Ereignisse, Agentenüberwachung)
website: Website-Überwachungswerkzeuge und -prompts (Metriken, Katalog, Analyse, Konfiguration)

Serverstatus überprüfen

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

Zertifikatsprobleme: Wenn SSL-Zertifikatsfehler auftreten, stellen Sie sicher, dass Ihre Python-Umgebung Zugriff auf die Systemzertifikate hat:

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

Port bereits in Verwendung: Wenn Port 8080 bereits verwendet wird, 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 die KI-gestützte IDE von IBM, die MCP-Integration nativ unterstützt. Bob bietet eine nahtlose Entwicklungserfahrung mit integrierter KI-Unterstützung und Observability-Werkzeugen.

Streamable-HTTP-Modus

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

Schritt 1: Starten des MCP-Servers im Streamable-HTTP-Modus

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

Schritt 2: Bob konfigurieren

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

Wenn Sie dieses auswählen, sollten Sie die Option sehen, MCP auf Projektebene oder auf 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 projektübergreifend für den aktuellen Benutzer 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 die Versionskontrolle mit Ihrem Team teilen möchten.

Dateispeicherort:

.bob/bob_config.json im Stammverzeichnis Ihres Projekts

Wahl zwischen globaler und Projektkonfiguration:

Verwenden Sie die globale Konfiguration für MCP-Server, die Sie projektübergreifend 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 koexistieren – Einstellungen auf Projektebene haben Vorrang vor globalen Einstellungen für denselben Servernamen

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

Lokale Konfiguration:

Konfigurieren Sie Bob so, dass eine Verbindung zu Ihrem lokalen Instana MCP-Server hergestellt wird:

{
  "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 so, dass eine Verbindung zu einem entfernten Instana MCP-Server hergestellt wird (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: Um npx zu verwenden, empfehlen wir, zuerst NVM (Node Version Manager) zu installieren und damit dann Node.js zu installieren. Installationsanweisungen finden Sie unter: https://nodejs.org/en/download

Schritt 3: Verbindung testen

Sobald 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 nun 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: Umgebungsvariablen in der Konfiguration verwenden:

{
  "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: --env-Flag verwenden (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 Fehler wie „Befehl nicht gefunden“ auftreten, 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: Umgebungsvariablen in der Konfiguration verwenden:

{
  "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: --env-Flag verwenden (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 mittels JSON-RPC über HTTP.

Schritt 1: Starten des MCP-Servers im Streamable-HTTP-Modus

Bevor Sie Claude Desktop konfigurieren, müssen Sie den MCP-Server im Streamable-HTTP-Modus starten. Detaillierte 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 dargestellt:

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

get me all endpoints from Instana

Stdio-Modus

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

Option 1: Umgebungsvariablen in der Konfiguration verwenden:

{
  "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: --env-Flag verwenden (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: Umgebungsvariablen in der Konfiguration verwenden:

{
  "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: --env-Flag verwenden (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-Setup

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 Kiro nach der Installation 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-Server-Konfigurationsdatei (mcp.json) und konfigurieren Sie sie basierend auf Ihrem bevorzugten Transportmodus:

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

{
  "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: Umgebungsvariablen in der Konfiguration verwenden:

{
  "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: --env-Flag verwenden (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: Klicken Sie nach dem Speichern der Datei auf die Schaltfläche „MCP aktivieren“. Ihr MCP-Server und seine verfügbaren Werkzeuge werden dann im unteren linken Bereich von Kiro angezeigt. alt text

Schritt 7: Gehen Sie zum KI-Chat-Panel, geben Sie eine Eingabeaufforderung zu Ihrem MCP-Server ein und sehen Sie sich die Antwort direkt in Kiro an. 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 Setup-Anleitung.

Streamable-HTTP-Modus

Schritt 1: Starten des MCP-Servers im Streamable-HTTP-Modus

Bevor Sie VS Code konfigurieren, müssen Sie den MCP-Server im Streamable-HTTP-Modus starten. Detaillierte 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 eine detaillierte Konfiguration.

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

{
  "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 entsprechend der Node.js-Installation Ihres Systems (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

Über CLI (PyPI-Installation – empfohlen):

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

Option 1: Umgebungsvariablen in der Konfiguration verwenden:

{
  "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: --env-Flag verwenden (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"
      ]
    }
  }
}

Über Entwicklungsinstallation:

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

Option 1: Umgebungsvariablen in der Konfiguration verwenden:

{
  "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: --env-Flag verwenden (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 entsprechend der uv-Installation Ihres Systems (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 Serververwaltung oben
Klicken Sie auf Start neben Instana MCP Server, um den Server zu starten
Der Ausführungsstatus zusammen mit der Anzahl der Werkzeuge zeigt an, dass der Server läuft

Schritt 3: Integration testen

Wechseln Sie in GitHub Copilot in den Agent-Modus und laden Sie die Werkzeuge 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 des MCP-Servers 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-Setup-Dokumentation für detaillierte Anweisungen.

Schritt 3: Mistral AI konfigurieren

Navigieren Sie in der linken Seitenleiste zur Registerkarte Intelligence 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 die MCP-Werkzeuge aktiviert sind. Sie können die Antwort hier einsehen

Unterstützte Funktionen

Verfügbare Werkzeuge

Werkzeug	Kategorie	Beschreibung
`manage_applications`	Anwendung & Infrastruktur	Einheitliches Werkzeug zur Verwaltung von Anwendungsmetriken, Alarmkonfigurationen, Einstellungen und Katalog
`manage_websites`	Website-Überwachung	Einheitlicher intelligenter Router für Website-Analyse, Katalog, Konfiguration und erweiterte Konfigurationsoperationen
`manage_custom_dashboards`	Benutzerdefinierte Dashboards	Einheitliches Werkzeug zur Verwaltung von CRUD-Operationen für benutzerdefinierte Dashboards
`analyze_infrastructure`	Infrastrukturanalyse	Zwei-Phasen-Infrastrukturanalyse mit Entitäts-/Metrikermittlung
`manage_automation`	Automatisierung	Einheitlicher intelligenter Router für Automatisierung: Aktionskatalog durchsuchen und Ausführungsverlauf anzeigen
`manage_events`	Ereignisse	Einheitlicher intelligenter 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 intelligenter Router für SLO-Konfigurationen, Berichte, Alarme und Korrekturfenster mit intelligenter Zeitzonenbehandlung
`manage_releases`	Release-Management	Einheitlicher intelligenter Router für Release-Tracking: Releases mit Paginierung und Namensfilterung auflisten, Release-Details abrufen, Releases mit Zeitzonenunterstützung erstellen/aktualisieren/löschen
`manage_maintenance_windows`	Wartungsfenster	Einheitlicher intelligenter Router für das Lebenszyklusmanagement von Wartungsfenstern: Erstellen, Ändern, Schließen und Auflisten von Wartungsfenstern mit Vorlagenunterstützung und ServiceNow-Integration
`manage_mobile_apps`	Überwachung mobiler Apps	Einheitlicher intelligenter Router für die Überwachung mobiler Apps: Beacons, Leistungsmetriken, Konfiguration und Alarmverwaltung analysieren

👉 Ausführliche Werkzeugdokumentation, Funktionen und technische Referenz finden Sie unter Werkzeuge & Beispiele

Werkzeugfilterung

Der MCP-Server unterstützt das selektive Laden von Werkzeugen, um die Leistung zu optimieren und die Ressourcennutzung zu reduzieren. Sie können nur die Werkzeugkategorien aktivieren, die Sie für Ihren spezifischen Anwendungsfall benötigen.

Verfügbare Werkzeugkategorien

router: Einheitliches Anwendungs- und Infrastrukturmanagement
- manage_instana_resources: Einzelnes Werkzeug für Anwendungsmetriken, Alarmkonfigurationen, Einstellungen und Katalog
- Unterstützt Anwendungsperspektiven, Endpunkte, Dienste und manuelle Dienste
- Verwaltet sowohl anwendungsspezifische als auch globale Alarmkonfigurationen
- Bietet Zugriff auf den Anwendungs-Tag-Katalog und den Metrikkatalog
dashboard: Verwaltung benutzerdefinierter Dashboards
- manage_custom_dashboards: CRUD-Operationen für benutzerdefinierte Dashboards
- Unterstützt Erstellung, Abruf, Aktualisierung und Löschung von Dashboards
- Verwaltet freigabefähige Benutzer und API-Tokens für Dashboards
infra: Infrastrukturanalyse-Werkzeuge
- analyze_infrastructure: Zwei-Phasen-Infrastrukturanalyse mit Entitäts-/Metrikermittlung
- Unterstützt dynamisch alle in Ihrer Instana-Installation verfügbaren Entitätstypen (automatisch aus dem API-Katalog geladen)
- Umfasst JVM, Kubernetes, Docker, Hosts, Datenbanken, Nachrichtenwarteschlangen und alle benutzerdefinierten oder neu hinzugefügten Entitätstypen
- Flexible Metrikaggregation, Filterung, Gruppierung und Zeitbereichsabfragen
automation: Automatisierungsaktions-Werkzeuge
- manage_automation: Einheitlicher intelligenter 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: Ereignisüberwachungs-Werkzeuge
- Ereignisse: Kubernetes-Ereignisse, Agent-Überwachung und Systemereignisverfolgung
website: Website-Überwachungs-Werkzeuge
- Website-Metriken: Leistungsmessung für Websites
- Website-Katalog: Website-Metadaten und -Definitionen
- Website-Analyse: Website-Leistungsanalyse
- Website-Konfiguration: Website-Konfigurationsverwaltung
slo: Service Level Objective (SLO)-Management
- manage_slo: Einheitlicher intelligenter Router für umfassende SLO-Operationen
- Konfigurationsmanagement: SLO-Konfigurationen mit Unterstützung für zeitbasierte und ereignisbasierte Indikatoren erstellen, lesen, aktualisieren, löschen
- Berichterstellung: Detaillierte SLO-Berichte mit SLI-Werten, Fehlerbudgets, Burn-Rates und Zeitreihendiagrammen generieren
- Alarmkonfiguration: SLO-Alarmkonfigurationen für Fehlerbudgetüberwachung und Burn-Rate-Tracking verwalten
- Korrekturfenster: Wartungsfenster erstellen und verwalten, um geplante Ausfallzeiten von SLO-Berechnungen auszuschließen
- Intelligente Zeitzonenbehandlung: Automatische Zeitzonenermittlung für Datums-/Zeiteingaben, um einen genauen Zeitkontext sicherzustellen
- Zwei-Phasen-Ermittlung: Interaktive Parametererfassung für komplexe Operationen, die mehrere Eingaben erfordern
releases: Release-Tracking und Bereitstellungsmanagement
- manage_releases: Einheitlicher intelligenter 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 nach ID abrufen, einschließlich Anwendungen, Diensten und Geltungsbereichen
- Erstellen/Aktualisieren/Löschen: Vollständige CRUD-Operationen für das Release-Management
- Intelligente Zeitzonenbehandlung: Automatische Zeitzonenermittlung für Release-Startzeiten
- Effiziente Paginierung: Redundante Datenabrufe durch ordnungsgemäße seitenbasierte Navigation vermeiden
- Namensfilterung: Groß-/Kleinschreibung ignorierende Teilzeichenfolgensuche, um Releases nach Namen zu finden
maintenance_window: Lebenszyklusmanagement für Wartungsfenster
- manage_maintenance_windows: Einheitlicher intelligenter Router für Wartungsfensteroperationen
- 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, database_migration, infrastructure_upgrade, emergency, 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: Mobile-App-Überwachung
- manage_mobile_apps: Einheitlicher intelligenter Router für Mobile-App-Überwachungsvorgänge
- Beacon-Analyse: Abfrage von Mobile-App-Beacon-Daten mit Gruppierung und Filterung
- Leistungsmetriken: Verfolgung von Sitzungsdauer, Absturzraten und HTTP-Anfrageleistung
- Geografische Analyse: Analyse der Benutzerverteilung nach Land, Stadt und Region
- Geräteanalyse: Überwachung der Leistung über verschiedene Geräte, Plattformen und Betriebssystemversionen hinweg
- Konfigurationsverwaltung: Verwaltung von Mobile-App-Konfigurationen, Geostandort- und IP-Maskierungseinstellungen
- Alarmverwaltung: Konfiguration und Verwaltung von Mobile-App-Alarmkonfigurationen

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: Beschränkung des Zugriffs auf nur notwendige APIs
Klarheit: Fokussierung auf spezifische Anwendungsfälle (z. B. nur Infrastrukturüberwachung)
Ressourceneffizienz: Geringere CPU- und Netzwerknutzung

👉 Für Anwendungsbeispiele und Prompts siehe Beispiel-Prompts

Docker-Bereitstellung

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

Docker-Architektur

Das Projekt verwendet eine Zwei-Dateien-Strategie für die Abhängigkeitsverwaltung:

pyproject.toml

Zweck: Einheitliche Konfiguration für Entwicklung und Produktion
Abhängigkeiten: Alle wesentlichen Abhängigkeiten mit optionalen Entwicklungsabhängigkeiten
Verwendung: Lokale Entwicklung, Tests, CI/CD und Docker-Produktions-Builds
Vorteile: Einzige Quelle der Wahrheit für alle Abhängigkeiten, vereinfachte Wartung

Erstellen des Docker-Images

Voraussetzungen

Docker installiert und ausgeführt
Zugriff auf den Projektquellcode
Docker BuildKit für Multi-Architektur-Builds (standardmäßig in neueren Docker-Versionen aktiviert)

Build-Befehl

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

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

#### **Run Command**
# Run the container (no credentials needed in the container)
docker run -p 8080:8080 mcp-instana

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

📖 Für umfassende Docker-Dokumentation, einschließlich Multi-Architektur-Builds, Docker Compose-Setup, Sicherheitsbest Practices und Beispielen für die Produktionsbereitstellung, 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
docker exec -it <container_id> curl http://127.0.0.1:8080/health
# 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/neuzustarten und nur einen Server gleichzeitig laufen zu lassen.
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 nicht mit SSL-Verifizierung 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.