Présentation détaillée du projet Grafana MCP Server

Aperçu du projet

Grafana MCP Server est un serveur basé sur le Protocole de Contexte de Modèle (Model Context Protocol, MCP), spécialement conçu pour l'intégration avec les instances Grafana et leur écosystème. Ce projet offre aux agents d'IA (comme Claude Desktop) la capacité d'accéder et de manipuler diverses fonctionnalités de Grafana.

Fonctionnalités principales

Gestion des tableaux de bord

• Recherche de tableaux de bord : Récupération et localisation rapides de tableaux de bord spécifiques.
• Obtention de tableaux de bord : Obtention de la configuration complète d'un tableau de bord via son UID.
• Mise à jour/Création de tableaux de bord : Modification dynamique ou création de nouveaux tableaux de bord (attention aux limites de la fenêtre de contexte).

Intégration des sources de données

• Gestion des sources de données : Liste et obtention des informations des sources de données.
• Prise en charge des requêtes multi-sources de données :
  • Prometheus : Exécution de requêtes PromQL pour obtenir des données de métriques.
  • Loki : Exécution de requêtes LogQL pour récupérer des données de logs.
  • Tempo : Requête de données de traçage distribué.
  • Pyroscope : Requête de données d'analyse de performance.

Requête de métadonnées

• Métadonnées Prometheus : Obtention des métadonnées des métriques, des noms de métriques, des noms de labels et des valeurs de labels.
• Métadonnées Loki : Obtention des noms de labels de logs, des valeurs de labels et des informations statistiques.

Gestion des événements et des alertes

• Gestion des événements : Recherche, création, mise à jour et fermeture d'événements.
• Règles d'alerte : Liste et obtention des informations des règles d'alerte, obtention de l'état des alertes.
• Gestion des points de contact : Liste, création et modification des points de contact d'alerte.

Intégration de Grafana OnCall

• Gestion des plannings : Liste et gestion des plans de service.
• Informations de service : Obtention des détails du service et de l'utilisateur de service actuel.
• Gestion des équipes et des utilisateurs : Gestion des équipes et des informations des utilisateurs.
• Gestion des groupes d'alertes : Liste des groupes d'alertes.

Fonctionnalités d'investigation Sift

• Investigation intelligente : Lancement d'investigations Sift et consultation des résultats.
• Gestion des investigations : Création, liste et obtention des informations d'investigation.
• Fonctionnalités d'analyse : Obtention des résultats de l'analyse d'investigation.
• Identification des schémas d'erreurs : Recherche de schémas d'erreurs dans les logs.
• Analyse de performance : Identification des requêtes lentes.

Configuration des outils

Ce projet offre des options de configuration d'outils flexibles, vous permettant d'activer ou de désactiver des catégories de fonctionnalités spécifiques :

Nom de l'outil	Catégorie	Description
search_dashboards	Search	Rechercher des tableaux de bord
get_dashboard_by_uid	Dashboard	Obtenir un tableau de bord par UID
update_dashboard	Dashboard	Mettre à jour ou créer un nouveau tableau de bord
list_datasources	Datasources	Lister les sources de données
query_prometheus	Prometheus	Exécuter une requête Prometheus
query_loki_logs	Loki	Interroger et récupérer des logs
list_incidents	Incident	Lister les événements
list_alert_rules	Alerting	Lister les règles d'alerte
list_oncall_schedules	OnCall	Lister les plannings OnCall
find_error_pattern_logs	Sift	Rechercher des schémas d'erreurs

Utilisez l'indicateur --disable-<category> pour désactiver une catégorie d'outils spécifique. Par exemple, utilisez --disable-oncall pour désactiver les outils liés à OnCall.

Installation et configuration

Méthodes d'installation

1. Image Docker

docker pull mcp/grafana
docker run -p 8000:8000 -e GRAFANA_URL=http://localhost:3000 -e GRAFANA_API_KEY=<your_token> mcp/grafana

2. Téléchargement du fichier binaire

Téléchargez la dernière version depuis la page des releases et placez-la dans le répertoire $PATH.

3. Compilation à partir des sources

GOBIN="$HOME/go/bin" go install github.com/grafana/mcp-grafana/cmd/mcp-grafana@latest

Paramètres de configuration

Prérequis

1. Créez un compte de service dans Grafana et attribuez-lui les autorisations suffisantes.
2. Générez un token de compte de service.

Configuration de Claude Desktop

Utilisation du fichier binaire :

{
  "mcpServers": {
    "grafana": {
      "command": "mcp-grafana",
      "args": [],
      "env": {
        "GRAFANA_URL": "http://localhost:3000",
        "GRAFANA_API_KEY": "<your service account token>"
      }
    }
  }
}

Utilisation de Docker :

{
  "mcpServers": {
    "grafana": {
      "command": "docker",
      "args": [
        "run", "--rm", "-p", "8000:8000",
        "-e", "GRAFANA_URL", "-e", "GRAFANA_API_KEY",
        "mcp/grafana"
      ],
      "env": {
        "GRAFANA_URL": "http://localhost:3000",
        "GRAFANA_API_KEY": "<your service account token>"
      }
    }
  }
}

Mode débogage

Activez le mode débogage en ajoutant l'indicateur -debug pour fournir des logs détaillés des requêtes et réponses HTTP :

{
  "mcpServers": {
    "grafana": {
      "command": "mcp-grafana",
      "args": ["-debug"],
      "env": {
        "GRAFANA_URL": "http://localhost:3000",
        "GRAFANA_API_KEY": "<your service account token>"
      }
    }
  }
}

Développement et tests

Configuration de l'environnement de développement

# Lancer le serveur
make run

# Construire l'image Docker
make build-image

# Lancer le conteneur Docker
docker run -it --rm -p 8000:8000 mcp-grafana:latest

Types de tests

Tests unitaires

make test-unit
# Ou
make test

Tests d'intégration

# Nécessite le lancement d'un conteneur Docker
make test-integration

Tests cloud

# Nécessite une instance Grafana cloud et des identifiants
make test-cloud

Tests complets

# Lancer une instance Grafana locale
docker-compose up -d

# Exécuter tous les tests
make test-all

Qualité du code

Analyse du code

make lint

Vérification du schéma JSON

Ce projet contient un linter personnalisé pour vérifier les virgules non échappées dans les balises de structure jsonschema :

make lint-jsonschema

Architecture technique

• Langage de programmation : Go
• Protocole : Model Context Protocol (MCP)
• Méthode de communication : stdin/stdout ou SSE (Server-Sent Events)
• Clients pris en charge : Claude Desktop et autres clients compatibles MCP

Cas d'utilisation

1. Surveillance pilotée par l'IA : Permettre aux agents d'IA d'interroger et d'analyser intelligemment les données de surveillance.
2. Automatisation des opérations : Créer et gérer automatiquement des tableaux de bord et des règles d'alerte via l'IA.
3. Réponse intelligente aux incidents : Utiliser l'IA pour analyser les logs et les métriques, localiser et résoudre rapidement les problèmes.
4. Exploitation des données : Permettre à l'IA d'extraire des informations précieuses à partir de données de surveillance complexes.

Ce projet représente une nouvelle tendance dans l'intégration de l'IA avec les outils de surveillance traditionnels, offrant aux développeurs un pont puissant reliant les assistants d'intelligence artificielle et l'écosystème Grafana.