IBM Instana MCP Server

officiel

Le serveur IBM Instana MCP permet une interaction fluide avec la plateforme d'observabilité IBM Instana, vous donnant accès aux données d'observabilité en temps réel directement dans votre flux de développement.

GitHub

Que pouvez-vous faire avec IBM Instana MCP ?

Récupérer les instantanés d'infrastructure — Demandez un instantané d'un hôte, processus ou conteneur spécifique à l'aide de get_infra_snapshot.
Analyser les métriques d'application ou de service — Demandez des métriques de séries temporelles pour les appels, erreurs ou latences avec get_app_metrics ou get_service_metrics.
Lister les alertes et incidents actifs — Obtenez les alertes, incidents ou alertes intelligentes globales actuelles via get_alerts et get_incidents.
Inspecter les événements Kubernetes — Récupérez les événements Kubernetes récents pour un cluster ou un espace de noms avec get_k8s_events.
Interroger les données de surveillance de site web — Récupérez les métriques de performance de site web ou les résultats de balise via get_website_metrics.

Documentation

Table des matières

Serveur MCP pour IBM Instana

Serveur MCP pour IBM Instana

📚 Liens rapides

Outils et exemples - Documentation complète des outils avec des exemples concrets
Politique de confidentialité - Gestion des données et informations sur la confidentialité
Guide de déploiement Docker - Déploiement Docker complet, builds multi-architectures et configuration de production

Le serveur MCP Instana permet une interaction transparente avec la plateforme d'observabilité Instana, vous permettant d'accéder aux données d'observabilité en temps réel directement dans votre flux de travail de développement.

Il sert de pont entre les clients (tels que les agents IA ou les outils personnalisés) et les API REST Instana, convertissant les requêtes utilisateur en appels API Instana et formatant les réponses dans des formats structurés et facilement exploitables.

Le serveur prend en charge les modes de transport HTTP Streamable et Stdio pour une compatibilité maximale avec différents clients MCP. Pour plus de détails, reportez-vous à la spécification des modes de transport MCP.

Aperçu de l'architecture

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

Flux de travail

Prenons un exemple simple : vous utilisez un hôte MCP (tel que Claude Desktop, VS Code ou un autre client) connecté au serveur MCP Instana. Lorsque vous demandez des informations sur les alertes Instana, le processus suivant se produit :

Le client MCP récupère la liste des outils disponibles auprès du serveur MCP Instana
Votre requête est envoyée au LLM avec les descriptions des outils
Le LLM analyse les outils disponibles et sélectionne celui ou ceux appropriés pour récupérer les alertes Instana
Le client exécute le ou les outils choisis via le serveur MCP Instana
Les résultats (dernières alertes) sont renvoyés au LLM
Le LLM formule une réponse en langage naturel
La réponse vous est affichée

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

Prérequis

Option 1 : Installation depuis PyPI (recommandée)

Le moyen le plus simple d'utiliser mcp-instana est de l'installer directement depuis PyPI :

pip install mcp-instana

Après l'installation, vous pouvez exécuter le serveur en utilisant directement la commande mcp-instana.

Option 2 : Installation pour le développement

Pour le développement ou la personnalisation locale, vous pouvez cloner et configurer le projet localement.

Installation de uv

Ce projet utilise uv, un installateur et résolveur de paquets Python rapide. Pour installer uv, vous avez plusieurs options :

Utilisation de pip :

pip install uv

Utilisation de Homebrew (macOS) :

brew install uv

Pour plus d'options d'installation et des instructions détaillées, visitez la documentation uv.

Configuration de l'environnement

Après avoir installé uv, configurez l'environnement du projet en exécutant :

uv sync

Authentification par en-têtes pour le mode HTTP Streamable

Lors de l'utilisation du mode HTTP Streamable, vous devez transmettre les informations d'identification Instana via les en-têtes HTTP. Cette approche améliore la sécurité et la flexibilité en :

Évitant le stockage des informations d'identification dans les variables d'environnement
Permettant l'utilisation d'informations d'identification différentes pour différentes requêtes
Prenant en charge les environnements partagés où la modification des variables d'environnement est restreinte
Prenant en charge à la fois l'authentification par jeton API et par session

Modes d'authentification pris en charge :

1. Authentification par jeton API (appels API directs)

En-têtes requis :

instana-base-url : L'URL de votre instance Instana
instana-api-token : Votre jeton API Instana

Exemple :

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

2. Authentification par jeton de session (appels initiés par l'interface utilisateur)

En-têtes requis :

instana-base-url : L'URL de votre instance Instana
instana-auth-token : Jeton d'authentification de session du backend UI
instana-csrf-token : Jeton CSRF du backend UI
instana-cookie-name : (Optionnel) Nom du cookie pour l'authentification de session (par défaut : instanaAuthToken)

Exemple :

--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. Authentification par jeton JWT (intégration IBM Platform)

En-têtes requis :

instana-base-url : L'URL de votre instance Instana
instana-jwt-token : Jeton JWT d'IBM Platform
instana-csrf-token : Jeton CSRF pour la validation de la requête

Exemple de configuration :

{
  "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"
      ]
    }
  }
}

Priorité d'authentification :

Jeton JWT (s'il est fourni avec le jeton CSRF) - Prioritaire pour l'intégration IBM Platform
Jetons de session (si auth_token et csrf_token sont tous deux fournis)
Jeton API (s'il est fourni) - Authentification standard
Variable d'environnement (INSTANA_API_TOKEN) - Solution de repli

Flux d'authentification :

Les en-têtes HTTP doivent être présents dans chaque requête
Le serveur valide les informations d'identification selon l'ordre de priorité
Les requêtes sans authentification valide échoueront

Cette conception garantit une transmission sécurisée des informations d'identification et prend en charge plusieurs flux d'authentification, y compris les appels initiés par l'interface utilisateur via WebSocket → Coordinateur → Serveur MCP.

Assurez-vous que le jeton utilisé dispose des autorisations nécessaires pour appeler les outils MCP. Vérifiez ici pour plus d'informations.

Démarrage du serveur MCP local

Avant de configurer un client MCP (Claude Desktop, GitHub Copilot ou clients MCP personnalisés), vous devez démarrer le serveur MCP local. Le serveur prend en charge deux modes de transport : HTTP Streamable et Stdio.

Options de commande du serveur

Utilisation de la CLI (installation PyPI)

Si vous avez installé mcp-instana depuis PyPI, utilisez la commande mcp-instana :

mcp-instana [OPTIONS]

Utilisation de l'installation pour le développement

Pour le développement local, utilisez la commande uv run :

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

Options disponibles :

--transport <mode> : Mode de transport (choix : streamable-http, stdio)
--env KEY=VALUE : Définir une variable d'environnement (peut être répété pour plusieurs variables, par exemple, --env INSTANA_BASE_URL=https://... --env INSTANA_API_TOKEN=...)
--debug : Activer le mode débogage avec journalisation supplémentaire
--log-level <level> : Définir le niveau de journalisation (choix : DEBUG, INFO, WARNING, ERROR, CRITICAL)
--tools <categories> : Liste séparée par des virgules des catégories d'outils à activer (par exemple, infra,app,events,website). L'activation d'une catégorie activera également ses invites associées. Par exemple : --tools infra active les outils infra et toutes les invites liées à infra.
--list-tools : Lister toutes les catégories d'outils disponibles et quitter
--port <port> : Port du serveur MCP (par défaut : 8080, peut être remplacé par la variable d'environnement PORT)
--help : Afficher le message d'aide et quitter

Démarrage en mode HTTP Streamable

Le mode HTTP Streamable fournit une interface API REST et est recommandé pour la plupart des cas d'utilisation.

Utilisation de la CLI (installation PyPI)

# 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

Utilisation de l'installation pour le développement

# 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

Fonctionnalités clés du mode HTTP Streamable :

Utilise les en-têtes HTTP pour l'authentification (aucune variable d'environnement nécessaire)
Prend en charge différentes informations d'identification par requête
Mieux adapté aux environnements partagés
Port par défaut du serveur MCP : 8080
Point de terminaison MCP : http://0.0.0.0:8080/mcp/

Démarrage en mode Stdio

Le mode Stdio utilise l'entrée/sortie standard pour la communication et nécessite des variables d'environnement pour l'authentification.

Utilisation de la CLI (installation PyPI)

# 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

Utilisation de l'installation pour le développement

# 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

Fonctionnalités clés du mode Stdio :

Utilise des variables d'environnement pour l'authentification (peut être défini via export ou le drapeau --env)
Communication directe via stdin/stdout
Requis pour certaines configurations de clients MCP
Le drapeau --env fournit un moyen pratique de définir les informations d'identification sans modifier l'environnement shell

Catégories d'outils

Vous pouvez optimiser les performances du serveur en activant uniquement les catégories d'outils et d'invites dont vous avez besoin :

Utilisation de la CLI (installation PyPI)

# 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

Utilisation de l'installation pour le développement

# 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

Catégories disponibles :

infra : Outils et invites de surveillance d'infrastructure (ressources, catalogue, topologie, analyse, métriques)
app : Outils et invites de performance des applications (ressources, métriques, alertes, catalogue, topologie, analyse, paramètres, alertes globales)
events : Outils et invites de surveillance des événements (événements Kubernetes, surveillance des agents)
website : Outils et invites de surveillance des sites Web (métriques, catalogue, analyse, configuration)

Vérification de l'état du serveur

Une fois démarré, vous pouvez vérifier que le serveur est en cours d'exécution :

Pour le mode HTTP Streamable :

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

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

Pour le mode Stdio : Le serveur démarrera et attendra l'entrée stdin des clients MCP.

Problèmes courants de démarrage

Problèmes de certificat : Si vous rencontrez des erreurs de certificat SSL, assurez-vous que votre environnement Python a accès aux certificats système :

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

Port déjà utilisé : Si le port 8080 est déjà utilisé, spécifiez un port différent :

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

Dépendances manquantes : Assurez-vous que toutes les dépendances sont installées :

uv sync

Configuration et utilisation

Bob IDE

Bob est l'IDE alimenté par l'IA d'IBM qui prend en charge nativement l'intégration MCP. Bob offre une expérience de développement transparente avec une assistance IA intégrée et des outils d'observabilité.

Mode HTTP Diffusable

Le mode HTTP Diffusable fournit une interface API REST pour la communication MCP utilisant JSON-RPC sur HTTP.

Étape 1 : Démarrer le serveur MCP en mode HTTP Diffusable

Avant de configurer Bob, vous devez démarrer le serveur MCP en mode HTTP Diffusable. Veuillez vous référer à la section Démarrage du serveur MCP local pour des instructions détaillées.

Étape 2 : Configurer Bob

Dans le coin supérieur droit du panneau Bob, vous verrez une liste déroulante avec les serveurs MCP :

En sélectionnant cela, vous devriez voir l'option pour configurer MCP au niveau du projet ou au niveau global.

Portées de configuration MCP

Bob prend en charge deux niveaux de configuration MCP, vous permettant de choisir la portée qui correspond le mieux à votre cas d'utilisation :

1. Configuration globale (niveau utilisateur)

La configuration globale applique les serveurs MCP à tous les projets pour l'utilisateur actuel. C'est idéal lorsque vous souhaitez que les mêmes serveurs MCP soient disponibles dans chaque projet sur lequel vous travaillez.

Emplacements des fichiers :

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

2. Configuration du projet (niveau projet)

La configuration du projet applique les serveurs MCP uniquement à un projet spécifique. C'est utile lorsque différents projets nécessitent différentes configurations de serveur MCP ou lorsque vous souhaitez partager les paramètres MCP avec votre équipe via le contrôle de version.

Emplacement du fichier :

.bob/bob_config.json dans le répertoire racine de votre projet

Choisir entre la configuration globale et la configuration du projet :

Utilisez la configuration globale pour les serveurs MCP que vous souhaitez disponibles dans tous vos projets
Utilisez la configuration du projet pour les serveurs MCP spécifiques au projet ou pour partager des configurations avec votre équipe
Les deux configurations peuvent coexister - les paramètres au niveau du projet prévalent sur les paramètres globaux pour le même nom de serveur

Pour plus d'informations sur Bob et la configuration MCP, visitez : https://bob.ibm.com/docs/ide/configuration/mcp/mcp-in-bob

Configuration locale :

Configurez Bob pour se connecter à votre serveur MCP Instana local :

{
  "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"
      ]
    }
  }
}

Configuration distante :

Configurez Bob pour se connecter à un serveur MCP Instana distant (par exemple, déployé sur 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"
      ]
    }
  }
}

Remarque : Pour utiliser npx, nous recommandons d'abord d'installer NVM (Node Version Manager), puis de l'utiliser pour installer Node.js. Les instructions d'installation sont disponibles à : https://nodejs.org/en/download

Étape 3 : Tester la connexion

Une fois la configuration MCP mise en place, le serveur MCP nouvellement configuré devrait apparaître comme activé. Un point vert indique que le serveur fonctionne avec succès.

Vous pouvez maintenant exécuter des requêtes dans l'IDE Bob :

get me all applications from Instana in the last 24 hours

Mode Stdio

Configuration via CLI (installation PyPI - recommandée) :

Option 1 : Utilisation des variables d'environnement dans la configuration :

{
  "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 : Utilisation du drapeau --env (méthode alternative) :

{
  "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"
      ]
    }
  }
}

Remarque : Si vous rencontrez des erreurs "commande introuvable", utilisez le chemin complet vers mcp-instana. Trouvez-le avec which mcp-instana et utilisez ce chemin à la place.

Configuration via l'installation de développement :

Option 1 : Utilisation des variables d'environnement dans la configuration :

{
  "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 : Utilisation du drapeau --env (méthode alternative) :

{
  "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 prend en charge les modes HTTP Diffusable et Stdio pour l'intégration MCP.

Configurez Claude Desktop en modifiant le fichier de configuration :

Emplacements des fichiers :

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

Mode HTTP Diffusable

Le mode HTTP Diffusable fournit une interface API REST pour la communication MCP utilisant JSON-RPC sur HTTP.

Étape 1 : Démarrer le serveur MCP en mode HTTP Diffusable

Avant de configurer Claude Desktop, vous devez démarrer le serveur MCP en mode HTTP Diffusable. Veuillez vous référer à la section Démarrage du serveur MCP local pour des instructions détaillées.

Étape 2 : Configurer Claude Desktop

Configurez Claude Desktop pour transmettre les informations d'identification Instana via les en-têtes :

{
  "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"
      ]
    }
  }
}

Étape 3 : Tester la connexion

Redémarrez Claude Desktop. Vous devriez maintenant voir le serveur MCP Instana dans l'interface de Claude Desktop comme indiqué ci-dessous :

Vous pouvez maintenant exécuter des requêtes dans Claude Desktop :

get me all endpoints from Instana

Mode Stdio

Configuration via CLI (installation PyPI - recommandée) :

Option 1 : Utilisation des variables d'environnement dans la configuration :

{
  "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 : Utilisation du drapeau --env (méthode alternative) :

{
  "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"
      ]
    }
  }
}

Remarque : Si vous rencontrez des erreurs "commande introuvable", utilisez le chemin complet vers mcp-instana. Trouvez-le avec which mcp-instana et utilisez ce chemin à la place.

Configuration via l'installation de développement :

Option 1 : Utilisation des variables d'environnement dans la configuration :

{
  "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 : Utilisation du drapeau --env (méthode alternative) :

{
  "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"
      ]
    }
  }
}

Configuration de Kiro

Kiro est un IDE agentique, pas une extension qui peut être téléchargée dans VS Code ou un autre IDE.

Étape 1 : Téléchargez et installez Kiro pour votre système d'exploitation depuis https://kiro.dev/.

Étape 2 : Après l'installation, lancez Kiro et ouvrez un projet dans l'IDE. alt text

Étape 3 : Cliquez sur l'icône Kiro (Fantôme) dans la barre latérale gauche pour accéder aux fonctionnalités de Kiro. alt text

Étape 4 : Sélectionnez l'icône Modifier la configuration dans le coin supérieur droit de la section Serveurs MCP. alt text

Étape 5 : Ouvrez le fichier de configuration du serveur MCP (mcp.json) et configurez-le en fonction de votre mode de transport préféré :

Mode HTTP Diffusable (recommandé pour 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"
      ]
    }
  }
}

Remarque : Assurez-vous de démarrer le serveur MCP en mode HTTP Diffusable avant d'utiliser cette configuration :

mcp-instana --transport streamable-http

Mode Stdio

Option 1 : Utilisation des variables d'environnement dans la configuration :

{
  "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 : Utilisation du drapeau --env (méthode alternative) :

{
  "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"
      ]
    }
  }
}

Étape 6 : Après avoir enregistré le fichier, cliquez sur le bouton Activer MCP et vous verrez votre serveur MCP et ses outils disponibles apparaître dans la section inférieure gauche de Kiro. alt text

Étape 7 : Allez dans le panneau de discussion IA, entrez une invite liée à votre serveur MCP et visualisez la réponse directement dans Kiro. alt text

GitHub Copilot

GitHub Copilot prend en charge l'intégration MCP via la configuration de VS Code. Pour l'intégration de GitHub Copilot avec VS Code, référez-vous à ce guide de configuration.

Mode HTTP Diffusable

Étape 1 : Démarrer le serveur MCP en mode HTTP Diffusable

Avant de configurer VS Code, vous devez démarrer le serveur MCP en mode HTTP Diffusable. Veuillez vous référer à la section Démarrage du serveur MCP local pour des instructions détaillées.

Étape 2 : Configurer VS Code

Référez-vous à Utiliser les serveurs MCP dans VS Code pour une configuration détaillée.

Vous pouvez directement créer ou mettre à jour .vscode/mcp.json avec la configuration suivante :

{
  "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"
      }
    }
  }
}

Remarque : Remplacez les valeurs suivantes par votre configuration réelle :

instana-base-url : Votre URL d'instance Instana
instana-api-token : Votre jeton API Instana
command : Mettez à jour le chemin npx pour correspondre à l'installation Node.js de votre système (par exemple, /path/to/your/node/bin/npx)
Variables d'environnement : Ajustez PATH et les autres variables d'environnement selon les besoins de votre système

Mode Stdio

Étape 1 : Créer la configuration MCP de VS Code

Utilisation de la CLI (installation PyPI - recommandée) :

Créez .vscode/mcp.json dans la racine de votre projet :

Option 1 : Utilisation des variables d'environnement dans la configuration :

{
  "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 : Utilisation du drapeau --env (méthode alternative) :

{
  "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"
      ]
    }
  }
}

Utilisation de l'installation de développement :

Créez .vscode/mcp.json dans la racine de votre projet :

Option 1 : Utilisation des variables d'environnement dans la configuration :

{
  "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 : Utilisation du drapeau --env (méthode alternative) :

{
  "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"
      ]
    }
  }
}

Remarque : Remplacez les valeurs suivantes par votre configuration réelle :

Pour l'installation CLI : Assurez-vous que mcp-instana est dans votre PATH
Pour l'installation de développement :
- command : Mettez à jour le chemin uv pour correspondre à l'installation uv de votre système (par exemple, /path/to/your/uv/bin/uv ou /usr/local/bin/uv)
- --directory : Mettez à jour avec le chemin absolu vers votre répertoire de projet mcp-instana
INSTANA_BASE_URL : Votre URL d'instance Instana
INSTANA_API_TOKEN : Votre jeton API Instana

Étape 2 : Gérer le serveur dans VS Code

Ouvrez .vscode/mcp.json - vous verrez les contrôles de gestion du serveur en haut
Cliquez sur Start à côté de Instana MCP Server pour démarrer le serveur
L'état d'exécution ainsi que le nombre d'outils indiquent que le serveur est en cours d'exécution

Étape 3 : Tester l'intégration

Passez en mode Agent dans GitHub Copilot et rechargez les outils. Voici un exemple de réponse de GitHub Copilot :

GitHub Copilot Response

Mistral AI

Mistral AI prend en charge l'intégration MCP exclusivement via le mode HTTP Diffusable.

Étape 1 : Lancer le serveur MCP en mode HTTP Diffusable

Démarrez le serveur MCP en mode HTTP Diffusable en fournissant vos informations d'identification Instana. Exécutez la commande suivante :

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

Étape 2 : Configurer le transfert de port avec Ngrok

Configurez le transfert de port pour exposer votre serveur local. Suivez la documentation de configuration de Ngrok pour des instructions détaillées.

Étape 3 : Configurer Mistral AI

Accédez à l'onglet Intelligence dans la barre latérale gauche et sélectionnez Connecteurs
Cliquez sur Ajouter un connecteur
Créez un connecteur personnalisé en entrant un nom de connecteur et l'URL du serveur MCP transférée par Ngrok
Démarrez une nouvelle session de discussion et vérifiez que les outils MCP sont activés. Vous pouvez voir la réponse ici

Fonctionnalités prises en charge

Outils disponibles

Outil	Catégorie	Description
`manage_applications`	Application & Infrastructure	Outil unifié pour gérer les métriques d'application, les configurations d'alerte, les paramètres et le catalogue
`manage_websites`	Surveillance de site web	Routeur intelligent unifié pour les opérations d'analyse, de catalogue, de configuration et de configuration avancée de site web
`manage_custom_dashboards`	Tableaux de bord personnalisés	Outil unifié pour gérer les opérations CRUD des tableaux de bord personnalisés
`analyze_infrastructure`	Analyse d'infrastructure	Analyse d'infrastructure en deux passes avec élicitation entité/métrique
`manage_automation`	Automatisation	Routeur intelligent unifié pour l'automatisation : parcourir le catalogue d'actions et voir l'historique d'exécution
`manage_events`	Événements	Routeur intelligent unifié pour la surveillance des événements : obtenir un événement par ID, obtenir des événements par IDs, événements Kubernetes, événements de surveillance d'agent et tous les événements
`manage_slo`	Gestion des SLO	Routeur intelligent unifié pour les configurations SLO, les rapports, les alertes et les fenêtres de correction avec gestion intelligente des fuseaux horaires
`manage_releases`	Gestion des versions	Routeur intelligent unifié pour le suivi des versions : lister les versions avec pagination et filtrage par nom, obtenir les détails d'une version, créer/mettre à jour/supprimer des versions avec support des fuseaux horaires
`manage_maintenance_windows`	Fenêtres de maintenance	Routeur intelligent unifié pour la gestion du cycle de vie des fenêtres de maintenance : créer, modifier, fermer et lister les fenêtres de maintenance avec support de modèles et intégration ServiceNow
`manage_mobile_apps`	Surveillance d'application mobile	Routeur intelligent unifié pour la surveillance d'application mobile : analyser les balises, les métriques de performance, la configuration et la gestion des alertes

👉 Pour une documentation détaillée des outils, les capacités et la référence technique, voir Outils & Exemples

Filtrage des outils

Le serveur MCP prend en charge le chargement sélectif des outils pour optimiser les performances et réduire l'utilisation des ressources. Vous pouvez activer uniquement les catégories d'outils dont vous avez besoin pour votre cas d'usage spécifique.

Catégories d'outils disponibles

router : Gestion unifiée des applications et de l'infrastructure
- manage_instana_resources : Outil unique pour les métriques d'application, les configurations d'alerte, les paramètres et le catalogue
- Prend en charge les perspectives d'application, les points de terminaison, les services et les services manuels
- Gère les configurations d'alerte spécifiques à l'application et globales
- Fournit l'accès au catalogue de tags d'application et au catalogue de métriques
dashboard : Gestion des tableaux de bord personnalisés
- manage_custom_dashboards : Opérations CRUD pour les tableaux de bord personnalisés
- Prend en charge la création, la récupération, la mise à jour et la suppression de tableaux de bord
- Gère les utilisateurs partageables et les tokens API pour les tableaux de bord
infra : Outils d'analyse d'infrastructure
- analyze_infrastructure : Analyse d'infrastructure en deux passes avec élicitation entité/métrique
- Prend en charge dynamiquement tous les types d'entités disponibles dans votre installation Instana (chargés automatiquement depuis le catalogue API)
- Inclut JVM, Kubernetes, Docker, hôtes, bases de données, files de messages et tout type d'entité personnalisé ou nouvellement ajouté
- Agrégation flexible des métriques, filtrage, regroupement et requêtes par plage temporelle
automation : Outils d'action d'automatisation
- manage_automation : Routeur intelligent unifié pour le catalogue d'automatisation et l'historique d'exécution
- Catalogue d'actions : parcourir les actions, obtenir les détails, rechercher par nom/description, filtrer par ID d'application ou de snapshot
- Historique des actions : lister les instances d'exécution avec filtrage, obtenir les détails d'exécution
events : Outils de surveillance des événements
- Événements : événements Kubernetes, surveillance d'agent et suivi des événements système
website : Outils de surveillance de site web
- Métriques de site web : Mesure de performance pour les sites web
- Catalogue de site web : Métadonnées et définitions de site web
- Analyse de site web : Analyse de performance de site web
- Configuration de site web : Gestion de la configuration de site web
slo : Gestion des Objectifs de Niveau de Service (SLO)
- manage_slo : Routeur intelligent unifié pour des opérations SLO complètes
- Gestion de la configuration : Créer, lire, mettre à jour, supprimer des configurations SLO avec support des indicateurs basés sur le temps et les événements
- Génération de rapports : Générer des rapports SLO détaillés avec les valeurs SLI, les budgets d'erreur, les taux de consommation et les graphiques de séries temporelles
- Configuration des alertes : Gérer les configurations d'alerte SLO pour la surveillance du budget d'erreur et le suivi du taux de consommation
- Fenêtres de correction : Créer et gérer des fenêtres de maintenance pour exclure les temps d'arrêt planifiés des calculs SLO
- Gestion intelligente des fuseaux horaires : Élicitation automatique du fuseau horaire pour les entrées de date/heure afin d'assurer un contexte temporel précis
- Élicitation en deux passes : Collecte interactive des paramètres pour les opérations complexes nécessitant plusieurs entrées
releases : Suivi des versions et gestion des déploiements
- manage_releases : Routeur intelligent unifié pour les opérations de version
- Lister les versions : Obtenir toutes les versions avec une pagination efficace (page_number, page_size) et un filtrage par nom
- Détails de version : Récupérer les informations spécifiques d'une version par ID, y compris les applications, les services et les périmètres
- Créer/Mettre à jour/Supprimer : Opérations CRUD complètes pour la gestion des versions
- Gestion intelligente des fuseaux horaires : Élicitation automatique du fuseau horaire pour les heures de début de version
- Pagination efficace : Éviter la récupération redondante de données avec une navigation appropriée basée sur les pages
- Filtrage par nom : Correspondance insensible à la casse des sous-chaînes pour trouver des versions par nom
maintenance_window : Gestion du cycle de vie des fenêtres de maintenance
- manage_maintenance_windows : Routeur intelligent unifié pour les opérations de fenêtre de maintenance
- Opérations sur les fenêtres : Créer, modifier, fermer et lister les fenêtres de maintenance (actives, planifiées, toutes, expirées)
- Opérations groupées : Créer des fenêtres de maintenance pour plusieurs applications simultanément
- Support des modèles : Modèles prédéfinis pour les scénarios courants (déploiement, migration de base de données, mise à niveau d'infrastructure, urgence, routine)
- Fenêtres récurrentes : Support des fenêtres de maintenance récurrentes en utilisant le format RFC 5545 RRULE
- Intégration ServiceNow : Intégration optionnelle avec les demandes de changement ServiceNow
- Validation : Validation des paramètres avant la création de la fenêtre
- Durée flexible : Spécifier la durée en minutes, heures ou jours
mobile_app : Surveillance des applications mobiles
- manage_mobile_apps : Routeur intelligent unifié pour les opérations de surveillance d'applications mobiles
- Analyse des balises : Interroger les données de balises d'applications mobiles avec regroupement et filtrage
- Métriques de performance : Suivre la durée des sessions, les taux de plantage et les performances des requêtes HTTP
- Analyse géographique : Analyser la répartition des utilisateurs par pays, ville et région
- Analyse des appareils : Surveiller les performances sur différents appareils, plateformes et versions de systèmes d'exploitation
- Gestion de la configuration : Gérer les configurations d'applications mobiles, la géolocalisation et les paramètres de masquage IP
- Gestion des alertes : Configurer et gérer les configurations d'alertes pour applications mobiles

Exemples d'utilisation

Utilisation de l'interface en ligne de commande (installation PyPI)

# 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

Utilisation de l'installation de développement

# 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

Avantages du filtrage d'outils

Performance : Temps de démarrage et utilisation mémoire réduits
Sécurité : Limiter l'exposition aux seules API nécessaires
Clarté : Se concentrer sur des cas d'utilisation spécifiques (par exemple, uniquement la surveillance d'infrastructure)
Efficacité des ressources : Utilisation réduite du processeur et du réseau

👉 Pour des exemples d'utilisation et des invites, consultez Exemples d'invites

Déploiement Docker

Le serveur MCP Instana peut être déployé à l'aide de Docker pour les environnements de production. La configuration Docker est optimisée pour la sécurité, les performances et une utilisation minimale des ressources.

Architecture Docker

Le projet utilise une stratégie de gestion des dépendances à deux fichiers :

pyproject.toml

Objectif : Configuration unifiée pour le développement et la production
Dépendances : Toutes les dépendances essentielles avec des dépendances de développement optionnelles
Utilisation : Développement local, tests, CI/CD et builds de production Docker
Avantages : Source unique de vérité pour toutes les dépendances, maintenance simplifiée

Construction de l'image Docker

Prérequis

Docker installé et en cours d'exécution
Accès au code source du projet
Docker BuildKit pour les builds multi-architectures (activé par défaut dans les versions récentes de Docker)

Commande de build

# 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

📖 Pour une documentation Docker complète incluant les builds multi-architectures, la configuration Docker Compose, les meilleures pratiques de sécurité et des exemples de déploiement en production, consultez DOCKER.md.

Dépannage

Problèmes Docker

Le conteneur ne démarre pas

# 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

Problèmes de connexion

# Test container connectivity
docker exec -it <container_id> curl http://127.0.0.1:8080/health
# Check port mapping
docker port <container_id>

Problèmes de performance

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

Problèmes généraux

GitHub Copilot
- Si vous rencontrez des problèmes avec GitHub Copilot, essayez de démarrer/arrêter/redémarrer le serveur dans le fichier mcp.json et ne gardez qu'un seul serveur en cours d'exécution à la fois.
Problèmes de certificat
- Si vous rencontrez des problèmes de certificat, tels que [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate :
  - Vérifiez que vous pouvez atteindre le point de terminaison de l'API Instana en utilisant curl ou wget avec la vérification SSL.
    - Si cela fonctionne, votre environnement Python peut ne pas être en mesure de vérifier le certificat et peut ne pas avoir accès aux mêmes certificats que votre shell ou votre système. Assurez-vous que votre environnement Python utilise les certificats système (macOS). Vous pouvez le faire en installant des certificats pour Python : //Applications/Python\ 3.13/Install\ Certificates.command
  - Si vous ne pouvez pas atteindre le point de terminaison avec la vérification SSL, essayez sans. Si cela fonctionne, vérifiez les certificats d'autorité de certification de votre système et assurez-vous qu'ils sont à jour.