de en es ja ko ru zh

Prometheus MCP Server

Name: Prometheus MCP Server
Author: pab1it0

by pab1it0

Overview Schema Source Related Servers Discussions Admin

Python

Remote

Prometheus MCP Server

Ein Model Context Protocol (MCP)-Server für Prometheus.

Dies ermöglicht den Zugriff auf Ihre Prometheus-Metriken und -Abfragen über standardisierte MCP-Schnittstellen, sodass KI-Assistenten PromQL-Abfragen ausführen und Ihre Metrikdaten analysieren können.

Merkmale

[x] PromQL-Abfragen gegen Prometheus ausführen
[x] Metriken entdecken und erkunden
- [x] Liste der verfügbaren Metriken
- [x] Metadaten für bestimmte Metriken abrufen
- [x] Sofortige Abfrageergebnisse anzeigen
- [x] Ergebnisse der Bereichsabfrage mit unterschiedlichen Schrittweiten anzeigen
[x] Authentifizierungsunterstützung
- [x] Grundlegende Authentifizierung über Umgebungsvariablen
- [x] Bearer-Token-Authentifizierung aus Umgebungsvariablen
[x] Unterstützung für Docker-Containerisierung
[x] Bereitstellung interaktiver Tools für KI-Assistenten

Die Liste der Tools ist konfigurierbar, sodass Sie auswählen können, welche Tools dem MCP-Client zur Verfügung gestellt werden sollen. Dies ist nützlich, wenn Sie bestimmte Funktionen nicht nutzen oder das Kontextfenster nicht zu sehr beanspruchen möchten.

Related MCP server: Prometheus MCP Server

Verwendung

Stellen Sie sicher, dass Ihr Prometheus-Server von der Umgebung aus zugänglich ist, in der Sie diesen MCP-Server ausführen.
Konfigurieren Sie die Umgebungsvariablen für Ihren Prometheus-Server, entweder über eine .env Datei oder über Systemumgebungsvariablen:

# Required: Prometheus configuration
PROMETHEUS_URL=http://your-prometheus-server:9090

# Optional: Authentication credentials (if needed)
# Choose one of the following authentication methods if required:

# For basic auth
PROMETHEUS_USERNAME=your_username
PROMETHEUS_PASSWORD=your_password

# For bearer token auth
PROMETHEUS_TOKEN=your_token

# Optional: For multi-tenant setups like Cortex, Mimir or Thanos
ORG_ID=your_organization_id

Fügen Sie die Serverkonfiguration zu Ihrer Client-Konfigurationsdatei hinzu. Beispiel für Claude Desktop:

{
  "mcpServers": {
    "prometheus": {
      "command": "uv",
      "args": [
        "--directory",
        "<full path to prometheus-mcp-server directory>",
        "run",
        "src/prometheus_mcp_server/main.py"
      ],
      "env": {
        "PROMETHEUS_URL": "http://your-prometheus-server:9090",
        "PROMETHEUS_USERNAME": "your_username",
        "PROMETHEUS_PASSWORD": "your_password"
      }
    }
  }
}

Hinweis: Wenn in Claude Desktop Error: spawn uv ENOENT angezeigt wird, müssen Sie möglicherweise den vollständigen Pfad zu uv angeben oder die Umgebungsvariable NO_UV=1 in der Konfiguration festlegen.

Docker-Nutzung

Dieses Projekt umfasst Docker-Unterstützung für einfache Bereitstellung und Isolierung.

Vorgefertigtes Docker-Image

Am einfachsten lässt sich dieses Projekt mit dem vorgefertigten Image aus dem GitHub Container Registry verwenden:

docker pull ghcr.io/pab1it0/prometheus-mcp-server:latest

Sie können auch bestimmte Versionen mit Tags verwenden:

docker pull ghcr.io/pab1it0/prometheus-mcp-server:1.0.0

Lokales Erstellen des Docker-Images

Wenn Sie das Image lieber selbst erstellen möchten:

docker build -t prometheus-mcp-server .

Ausführen mit Docker

Sie können den Server mit Docker auf verschiedene Arten ausführen:

Verwenden von Docker Run mit dem vorgefertigten Image:

docker run -it --rm \
  -e PROMETHEUS_URL=http://your-prometheus-server:9090 \
  -e PROMETHEUS_USERNAME=your_username \
  -e PROMETHEUS_PASSWORD=your_password \
  ghcr.io/pab1it0/prometheus-mcp-server:latest

Verwenden von Docker Run mit einem lokal erstellten Image:

docker run -it --rm \
  -e PROMETHEUS_URL=http://your-prometheus-server:9090 \
  -e PROMETHEUS_USERNAME=your_username \
  -e PROMETHEUS_PASSWORD=your_password \
  prometheus-mcp-server

Verwenden von Docker-Compose:

Erstellen Sie eine .env Datei mit Ihren Prometheus-Anmeldeinformationen und führen Sie dann Folgendes aus:

docker-compose up

Ausführen mit Docker in Claude Desktop

Um den Containerserver mit Claude Desktop zu verwenden, aktualisieren Sie die Konfiguration zur Verwendung von Docker mit den Umgebungsvariablen:

{
  "mcpServers": {
    "prometheus": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e", "PROMETHEUS_URL",
        "-e", "PROMETHEUS_USERNAME",
        "-e", "PROMETHEUS_PASSWORD",
        "ghcr.io/pab1it0/prometheus-mcp-server:latest"
      ],
      "env": {
        "PROMETHEUS_URL": "http://your-prometheus-server:9090",
        "PROMETHEUS_USERNAME": "your_username",
        "PROMETHEUS_PASSWORD": "your_password"
      }
    }
  }
}

Diese Konfiguration übergibt die Umgebungsvariablen von Claude Desktop an den Docker-Container, indem sie das Flag -e nur mit dem Variablennamen verwendet und die tatsächlichen Werte im env bereitstellt.

Hinweis zur Docker-Implementierung : Das Docker-Setup wurde aktualisiert und entspricht nun der Struktur des Chess-MCP-Projekts, das nachweislich mit Claude einwandfrei funktioniert. Die neue Implementierung verwendet einen mehrstufigen Build-Prozess und führt das Einstiegspunktskript direkt ohne zwischengeschaltetes Shell-Skript aus. Dieser Ansatz gewährleistet die korrekte Handhabung von stdin/stdout für die MCP-Kommunikation.

Entwicklung

Beiträge sind willkommen! Bitte melden Sie ein Problem oder senden Sie einen Pull Request, wenn Sie Vorschläge oder Verbesserungen haben.

Dieses Projekt verwendet uv zur Verwaltung von Abhängigkeiten. Installieren Sie uv gemäß den Anweisungen für Ihre Plattform:

curl -LsSf https://astral.sh/uv/install.sh | sh

Anschließend können Sie eine virtuelle Umgebung erstellen und die Abhängigkeiten mit folgendem Befehl installieren:

uv venv
source .venv/bin/activate  # On Unix/macOS
.venv\Scripts\activate     # On Windows
uv pip install -e .

Projektstruktur

Das Projekt wurde mit einer src Verzeichnisstruktur organisiert:

prometheus-mcp-server/
├── src/
│   └── prometheus_mcp_server/
│       ├── __init__.py      # Package initialization
│       ├── server.py        # MCP server implementation
│       ├── main.py          # Main application logic
├── Dockerfile               # Docker configuration
├── docker-compose.yml       # Docker Compose configuration
├── .dockerignore            # Docker ignore file
├── pyproject.toml           # Project configuration
└── README.md                # This file

Testen

Das Projekt umfasst eine umfassende Testsuite, die die Funktionalität sicherstellt und hilft, Regressionen zu vermeiden.

Führen Sie die Tests mit pytest aus:

# Install development dependencies
uv pip install -e ".[dev]"

# Run the tests
pytest

# Run with coverage report
pytest --cov=src --cov-report=term-missing

Die Tests sind wie folgt organisiert:

Konfigurationsvalidierungstests
Serverfunktionalitätstests
Fehlerbehandlungstests
Hauptanwendungstests

Wenn Sie neue Funktionen hinzufügen, fügen Sie bitte auch entsprechende Tests hinzu.

Werkzeuge

Werkzeug	Kategorie	Beschreibung
`execute_query`	Abfrage	Führen Sie eine PromQL-Sofortabfrage gegen Prometheus aus
`execute_range_query`	Abfrage	Führen Sie eine PromQL-Bereichsabfrage mit Startzeit, Endzeit und Schrittintervall aus
`list_metrics`	Entdeckung	Listen Sie alle verfügbaren Metriken in Prometheus auf
`get_metric_metadata`	Entdeckung	Abrufen von Metadaten für eine bestimmte Metrik
`get_targets`	Entdeckung	Erhalten Sie Informationen zu allen Scrape-Zielen

Lizenz

MIT

Available Tools

6 tools

execute_queryExecute PromQL QueryC

Read-onlyIdempotent

Execute a PromQL instant query against Prometheus

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes
`time`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

C2.7/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already provide readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds no behavioral context beyond what is in the schema and annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is concise but overly terse. It could be improved with more structure while remaining short.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 0% schema coverage and no description of parameters, the tool is incomplete for an agent. The output schema exists, but the description does not mention it or the nature of the return value.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, yet the description does not explain the parameters. It fails to clarify that 'query' is the PromQL expression and 'time' is optional evaluation time.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Execute') and the resource ('PromQL instant query against Prometheus'). It distinguishes from the sibling tool 'execute_range_query' which handles range queries.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like 'execute_range_query'. There is no mention of typical use cases or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

execute_range_queryExecute PromQL Range QueryB

Read-onlyIdempotent

Execute a PromQL range query with start time, end time, and step interval

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes
`start`	Yes
`end`	Yes
`step`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

B3.4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds that it uses PromQL with time parameters, but does not disclose potential failures, pagination, or rate limits. For a tool with rich annotations, the description adds modest extra context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no extraneous words. It efficiently communicates the core action and key parameters.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 4-parameter tool with an output schema and comprehensive annotations, the description provides adequate context. It names the parameters and states the tool's purpose. Minor gaps include lack of format details and error behavior, but overall it is mostly complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description partially compensates by naming the parameters (start time, end time, step interval). However, it does not specify expected formats (e.g., Unix timestamps or RFC3339) or explain the query parameter beyond 'PromQL range query', leaving ambiguity.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool executes a PromQL range query with start time, end time, and step interval. However, it does not distinguish this from the sibling tool 'execute_query', which likely handles instant queries, missing an opportunity for differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No usage guidance is provided. The description does not specify when to use this tool over alternatives (e.g., for time-range versus instant queries), nor does it mention prerequisites or conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_metric_metadataGet Metric MetadataA

Read-onlyIdempotent

Get metadata (type, help, unit) for metrics. Returns all metric metadata when no metric name is provided. Use filter_pattern to search metric names and descriptions.

ParametersJSON Schema

Name	Required	Description	Default
`metric`	No
`filter_pattern`	No
`limit`	No
`offset`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, openWorldHint. The description adds that it returns all metadata when no metric is given and how to use filter_pattern. No contradictions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two efficient sentences with no redundancy. The first defines purpose, the second provides usage guidance. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With output schema present, description covers primary functionality. However, it omits explanation of pagination parameters (limit, offset), which could be important for large result sets. Otherwise complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so description must compensate. It explains metric (optional, returns all if null) and filter_pattern (search). But it does not cover limit/offset, leaving pagination behavior unclear. Adequate but not fully compensating.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves metadata (type, help, unit) for metrics. It specifies behavior when no metric name is provided (returns all) and mentions filter_pattern for searching. This distinguishes it from siblings like list_metrics and execute_query.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit guidance on using filter_pattern to search. However, it does not mention when not to use the tool or alternatives, but the context is clear enough for an agent to decide.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_targetsGet Scrape TargetsA

Read-onlyIdempotent

Get information about all scrape targets

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the description reinforces that it is a read operation. It adds that it returns information about all scrape targets, but does not detail what information is included. The output schema likely covers the return format.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence of 8 words, front-loaded with the key action and resource. Every word is meaningful with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no parameters and an existing output schema, the description is reasonably complete. It states the purpose and scope (all targets). A minor gap is the lack of mention of potential pagination or limits, but the output schema likely handles that.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and schema description coverage is trivially 100%. The description does not need to add parameter details. The baseline for 0 parameters is 4, and no additional information is necessary.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Get' and the resource 'scrape targets', indicating it retrieves information on all scrape targets. It distinguishes from sibling tools like execute_query or get_metric_metadata which perform different operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives, such as when to use list_metrics or get_metric_metadata. It lacks explicit context or exclusions for sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

health_checkHealth CheckA

Read-onlyIdempotent

Health check endpoint for container monitoring and status verification

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds context about container monitoring and status verification, which aligns with annotations and provides additional behavioral clarity.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, front-loaded with key information, no wasted words. Highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero parameters and an existing output schema (indicated by 'has output schema: true'), the description is complete enough to understand the tool's purpose and basic behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters are defined, and schema coverage is 100%. Baseline score of 4 applies since the description does not need to compensate for missing parameter details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it is a health check endpoint for container monitoring and status verification. Specific verb and resource, and it clearly distinguishes from sibling tools like execute_query and list_metrics.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for checking system status but does not provide explicit guidance on when to use versus alternatives or when not to use. Usage is implied by the tool's purpose and sibling context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_metricsList Available MetricsA

Read-onlyIdempotent

List all available metrics in Prometheus with optional pagination support

ParametersJSON Schema

Name	Required	Description	Default
`limit`	No
`offset`	No
`filter_pattern`	No
`refresh_cache`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the description's note about pagination adds minor behavioral context but is not necessary for safety awareness. No contradictions with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence of 10 words, directly stating the purpose and key feature. No unnecessary information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description does not cover the purpose of filter_pattern or refresh_cache, nor how pagination behaves (defaults, total count). Given 4 undocumented parameters, the description is incomplete for a full understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%. The description only hints at pagination (limit/offset) but does not explain filter_pattern or refresh_cache. It fails to compensate for missing schema descriptions on 4 parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'List all available metrics in Prometheus', specifying the exact resource and action. It distinguishes itself from sibling tools like execute_query and get_metric_metadata by focusing on enumeration of metrics.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description mentions optional pagination, indicating when to use pagination parameters. However, it lacks explicit guidance on when to use this tool versus alternatives like get_metric_metadata for detailed metric information.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

6 tool updatesv1.2.2May 1, 2026
- Changedexecute_query3 fields changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
  - removedInput schema / properties / query / title
```
Removed value: -"Query"
```
  - removedInput schema / properties / time / title
```
Removed value: -"Time"
```
- Changedexecute_range_query5 fields changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
  - removedInput schema / properties / end / title
```
Removed value: -"End"
```
  - removedInput schema / properties / query / title
```
Removed value: -"Query"
```
  - removedInput schema / properties / start / title
```
Removed value: -"Start"
```
  - removedInput schema / properties / step / title
```
Removed value: -"Step"
```
- Changedget_metric_metadata14 fields changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
  - addedInput schema / properties / filter_pattern
```
Added value: +{
+  "anyOf": [
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null
+}
```
  - addedInput schema / properties / limit
```
Added value: +{
+  "anyOf": [
+    {
+      "type": "integer"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null
+}
```
  - addedInput schema / properties / metric / anyOf
```
Added value: +[
+  {
+    "type": "string"
+  },
+  {
+    "type": "null"
+  }
+]
```
  - addedInput schema / properties / metric / default
```
Added value: +null
```
  - removedInput schema / properties / metric / title
```
Removed value: -"Metric"
```
  - removedInput schema / properties / metric / type
```
Removed value: -"string"
```
  - addedInput schema / properties / offset
```
Added value: +{
+  "default": 0,
+  "type": "integer"
+}
```
  - removedInput schema / required
```
Removed value: -[
-  "metric"
-]
```
  - addedOutput schema / properties / result / anyOf
```
Added value: +[
+  {
+    "items": {
+      "additionalProperties": true,
+      "type": "object"
+    },
+    "type": "array"
+  },
+  {
+    "additionalProperties": true,
+    "type": "object"
+  }
+]
```
  - removedOutput schema / properties / result / items
```
Removed value: -{
-  "additionalProperties": true,
-  "type": "object"
-}
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / properties / result / type
```
Removed value: -"array"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedget_targets1 field changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedhealth_check1 field changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedlist_metrics5 fields changed
  - addedInput schema / additionalProperties
```
Added value: +false
```
  - removedInput schema / properties / filter_pattern / title
```
Removed value: -"Filter Pattern"
```
  - removedInput schema / properties / limit / title
```
Removed value: -"Limit"
```
  - removedInput schema / properties / offset / title
```
Removed value: -"Offset"
```
  - addedInput schema / properties / refresh_cache
```
Added value: +{
+  "default": false,
+  "type": "boolean"
+}
```

6 tool updatesv1.0.0Jan 3, 2026

Changedexecute_query2 fields changed

removedInput schema / title

Removed value: -"execute_queryArguments"

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "additionalProperties": true,
+  "type": "object"
+}

Changedexecute_range_query2 fields changed

removedInput schema / title

Removed value: -"execute_range_queryArguments"

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "additionalProperties": true,
+  "type": "object"
+}

Changedget_metric_metadata2 fields changed

removedInput schema / title

Removed value: -"get_metric_metadataArguments"

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "properties": {
+    "result": {
+      "items": {
+        "additionalProperties": true,
+        "type": "object"
+      },
+      "title": "Result",
+      "type": "array"
+    }
+  },
+  "required": [
+    "result"
+  ],
+  "title": "_WrappedResult",
+  "type": "object",
+  "x-fastmcp-wrap-result": true
+}

Changedget_targets2 fields changed

removedInput schema / title
```
Removed value: -"get_targetsArguments"
```

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "additionalProperties": {
+    "items": {
+      "additionalProperties": true,
+      "type": "object"
+    },
+    "type": "array"
+  },
+  "type": "object"
+}

Addedhealth_check

Changedlist_metrics5 fields changed

addedInput schema / properties / filter_pattern

Added value: +{
+  "anyOf": [
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Filter Pattern"
+}

addedInput schema / properties / limit

Added value: +{
+  "anyOf": [
+    {
+      "type": "integer"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Limit"
+}

addedInput schema / properties / offset

Added value: +{
+  "default": 0,
+  "title": "Offset",
+  "type": "integer"
+}

removedInput schema / title
```
Removed value: -"list_metricsArguments"
```

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "additionalProperties": true,
+  "type": "object"
+}

5 tool updatesMay 3, 2025
- First observedexecute_query
- First observedexecute_range_query
- First observedget_metric_metadata
- First observedget_targets
- First observedlist_metrics

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A3.7/5.0

Scored 2026-05-01 20:40 across 6 tools

Disambiguation5/5

Each tool has a clearly distinct purpose: query types (instant vs range), metadata retrieval, target info, health check, and metric listing. No overlap.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case (e.g., execute_query, get_metric_metadata). No deviations.

Tool Count5/5

Six tools cover the essential Prometheus operations without being excessive or insufficient. Well-scoped for the server's purpose.

Completeness4/5

Core CRUD-like operations for queries and metadata are present. Minor gaps like alert management or rule configuration are missing but not critical for the primary use case.

Maintenance

ActivityMaintained

ResponsivenessWithin a week

Resources

GitHub Repository

Need Help?

Reddit Discussion

Related Servers

Related MCP Connectors

Foam Observability
io.github.foam-ai
Query application logs, traces, and metrics from your AI coding assistant via Foam's MCP server.
Observability Monitoring Developer Tools
2
Cortex B
io.cortex.mcp
The Cortex MCP server provides read-only access to real-time engineering context from the Cortex developer portal, allowing AI coding assistants to answer natural language questions about your organization's catalog (microservices, libraries, domains, teams, infrastructure), scorecards (engineering standards and best practices), initiatives (goals and deadlines), and Engineering Intelligence metrics. It includes tools for querying documentation, tracking personal entities, and accessing AI-assisted insights across the entire Cortex ecosystem.
Developer Tools Monitoring Observability
502
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
238
Google GKE A
com.googleapis.container
The Google GKE MCP server is a managed Model Context Protocol server that provides AI applications with tools to manage Google Kubernetes Engine (GKE) clusters and Kubernetes resources. It exposes a structured, discoverable interface that allows AI agents to interact with GKE and Kubernetes APIs, enabling them to inspect cluster configurations, retrieve Kubernetes resource YAMLs, monitor operations like cluster upgrades, diagnose issues, and optimize costs—all without needing to parse text output or use complex kubectl commands.
Cloud Platforms Virtualization Observability
232

Related MCP Servers

Prometheus MCP Server
Monitoring Search
moohoorama
A
license
Not graded
quality
D
maintenance
A tool that enables access to Prometheus metrics data through a Model Context Protocol server, allowing interaction with monitoring data using natural language.
Updated a year ago (2025-05-02 01:46 UTC)
MIT
Prometheus MCP Server
Monitoring Observability
yanmxa
A
license
B
quality
F
maintenance
A Model Context Protocol server that enables AI assistants to query Prometheus metrics, discover available data, and analyze system performance through natural language interactions.
Updated a year ago (2025-08-13 12:12 UTC)
5
103 npm
MIT
Prometheus MCP Server
Monitoring Observability
ArkTechNWA
A
license
Not graded
quality
D
maintenance
Enables AI assistants to query Prometheus metrics, monitor alerts, and analyze system health through read-only access to your Prometheus server with built-in query safety and optional AI-powered metric analysis.
Updated 9 months ago (2025-12-30 00:13 UTC)
MIT
Prometheus MCP Server
Monitoring Observability
Jayanth-Kulkarni-Avesha
A
license
Not graded
quality
D
maintenance
Enables AI assistants to execute PromQL queries and discover metrics across multiple Prometheus tenants using the Model Context Protocol. It supports single and multi-tenant configurations with secure authentication for instant and range query analysis.
Updated a year ago (2025-07-23 13:24 UTC)
MIT

Appeared in Searches

How to Retrieve Console Logs