Server data from the Official MCP Registry
MCP server for the Open Telekom Cloud Price Calculator API (eu-de, eu-nl, eu-ch2).
MCP server for the Open Telekom Cloud Price Calculator API (eu-de, eu-nl, eu-ch2).
Well-structured MCP server for OTC pricing with proper authentication via environment variables, reasonable permissions scoped to pricing data APIs, and good code quality. Minor findings include broad exception handling in tools and the docs sync script's use of subprocess (not in runtime path). No malicious patterns or security vulnerabilities detected. Supply chain analysis found 6 known vulnerabilities in dependencies (0 critical, 4 high severity). Package verification found 1 issue.
4 files analyzed · 11 issues found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
This plugin requests these system permissions. Most are normal for its category.
Add this to your MCP configuration file:
{
"mcpServers": {
"io-github-seaser0-otc-pricing-mcp": {
"args": [
"otc-pricing-mcp"
],
"command": "uvx"
}
}
}From the project's GitHub README.
An open-source Model Context Protocol (MCP) server for the Open Telekom Cloud (OTC) Price Calculator API.
Expose OTC pricing data to Claude and other LLM clients with full observability (structured logging, Prometheus metrics, health checks).
Status: v0.1.3 — STDIO + SSE transports, Kubernetes deployment, full observability
Model Context Protocol is a standard that enables LLM applications (like Claude) to interact with external tools and data sources. This server supports two transports:
| Transport | How it works | Best for |
|---|---|---|
| STDIO | Claude launches the server as a subprocess; communication is over stdin/stdout | Local Claude Desktop, CLI tools |
| SSE | Server-Sent Events over HTTP — Claude connects to a URL | Remote/hosted deployments, web clients |
This server gives Claude access to OTC pricing data and the user-manual / API-reference documentation through 9 specialized tools, on whichever transport you prefer.
Example Use Cases:
find_compute_flavor tool → gets pricing data → answers youcompare_billing_models tool → does the analysis → shows savingsRequirements: Python 3.12+
# Clone the repository
git clone https://github.com/seaser0/otc-pricing-mcp.git
cd otc-pricing-mcp
# Install dependencies
uv sync
# Run the server
python -m otc_pricing_mcp
What You'll See:
{"event": "mcp_server_starting", "transports": ["stdio", "sse"], "port": 8080, ...}
{"event": "mcp_server_ready", "status": "accepting_connections", ...}
The server now listens for MCP connections on both stdin/stdout and http://localhost:8080/sse.
Option A — STDIO (local, Claude Desktop)
{
"mcpServers": {
"otc-pricing": {
"command": "python",
"args": ["-m", "otc_pricing_mcp"],
"env": {
"LOG_LEVEL": "INFO",
"METRICS_PORT": "8080"
}
}
}
}
Option B — SSE (remote, Kubernetes)
Point any MCP client that supports SSE transport at the hosted endpoint:
{
"mcpServers": {
"otc-pricing": {
"url": "https://mcp-otc-pricing.example.com/sse"
}
}
}
Or test locally while running the server:
# In a second terminal:
curl -N http://localhost:8080/sse
# event: endpoint
# data: /messages/?session_id=<uuid>
Once connected, Claude can call any of the 7 available tools. See the Tools Reference section below.
The server exposes 7 MCP tools for different pricing queries:
list_servicesPurpose: Get all available OTC services
Input: None
Output: List of service names and metadata
Example Claude usage:
"What OTC services are available for pricing?"
list_regionsPurpose: Get available OTC regions
Input: None
Output: List of region codes (eu-de, eu-nl, eu-ch2, etc.)
Example Claude usage:
"What regions does OTC support?"
get_service_schemaPurpose: Get filterable/returnable columns for a service
Input:
service (string): Service name (e.g., "ecs", "evs", "obs", "s3", "rds")Output: Schema with filterable and returnable column names
Example Claude usage:
"What columns can I filter on for ECS pricing?"
query_pricingPurpose: Query pricing data with flexible filtering
Input:
services (array): List of service names (e.g., ["ecs", "evs"])region (string, optional): Filter by region (e.g., "eu-de")max_results (integer, optional): Max results to return (default: 5000)Output: Pricing rows matching the filter
Example Claude usage:
"Show me ECS and EVS pricing in the eu-de region"
find_compute_flavorPurpose: Find compute (ECS) instances by vCPU/RAM/OS
Input:
v_cpu (integer): Number of virtual CPUsram_gb (number): RAM in GiBos (string, optional): Operating system (Linux, Windows, etc.)region (string, optional): Region (default: eu-de)Output: Matching ECS instance types with pricing
Example Claude usage:
"Find a Linux ECS instance with 4 CPUs and 16GB RAM in eu-nl"
estimate_monthly_costPurpose: Calculate monthly cost for multiple resources
Input:
items (array): Resources with:
id (string): Product ID (e.g., "OTC_S3M1_LI")quantity (number, optional): How many units (default: 1)hours_per_month (number, optional): Usage hours (default: 730)Output: Itemized costs with monthly total
Example Claude usage:
"Calculate monthly cost for 100GB S3 storage and an ECS instance"
compare_billing_modelsPurpose: Compare PAYG vs Reserved Instance pricing
Input:
product_id (string): Product ID (e.g., "OTC_S3M1_LI")quantity (number, optional): Quantity (default: 1)hours_per_month (number, optional): Usage hours (default: 730)Output: Cost comparison for PAYG, 12mo, 24mo, 36mo reserved
Example Claude usage:
"Compare PAYG vs 12/24/36 month reserved pricing for ECS"
search_otc_docsPurpose: Full-text search across the indexed OTC user manual and API reference
Input:
query (string): Search terms (BM25-ranked, AND of tokens)scope (string, optional): public | swiss | both (default: both)service (string, optional): Restrict to one service repo (e.g. elastic-cloud-server)top_k (integer, optional): 1-50, default 5Output: Ranked list of {url, title, h2, h3, snippet, service, cloud, upstream_commit} hits.
The index ships with the package and is rebuilt weekly from the upstream
opentelekomcloud-docs/<service> Sphinx/RST repos (Apache-2.0); the runtime
never touches the Anubis-gated docs.otc.t-systems.com HTML.
Example Claude usage:
"Find the OTC docs page that explains S3-flavor ECS specifications"
get_otc_doc_sectionPurpose: Fetch the body of one indexed documentation page (or one of its sections) as Markdown
Input:
url (string): Canonical URL as returned by search_otc_docs (with or without #anchor)section (string, optional): H2/H3 heading filter (case-insensitive substring)Output: {url, title, sections: [{h2, h3, anchor, body}, ...], matched, ...}
Example Claude usage:
"Show me the EVS Disk Types and Performance section"
Control the server behavior with environment variables:
| Variable | Default | Description |
|---|---|---|
LOG_LEVEL | INFO | Logging level: DEBUG, INFO, WARNING, ERROR |
METRICS_PORT | 8080 | Port for metrics/health endpoints |
METRICS_HOST | 0.0.0.0 | Bind address for the HTTP server (set to 127.0.0.1 for non-container runs) |
OTC_PRICING_API_BASE | https://calculator.otc-service.com/en/open-telekom-price-api/ | OTC API endpoint |
OTC_DOCS_DB | (auto) | Override path to the docs FTS5 index (default: bundled data/otc_docs.sqlite3) |
Example:
LOG_LEVEL=DEBUG METRICS_PORT=9090 python -m otc_pricing_mcp
This server is built with production-grade observability so you can debug issues and monitor performance.
Every action is logged as JSON, making logs machine-readable for aggregation and analysis.
Start the server with DEBUG logging:
LOG_LEVEL=DEBUG python -m otc_pricing_mcp 2>&1
You'll see JSON logs like:
{"timestamp": "2026-05-06T18:00:00.123456Z", "event": "tool_invocation_start", "tool": "query_pricing", "request_id": "550e8400-e29b-41d4-a716-446655440000", "arguments": {"services": ["ecs"]}}
{"timestamp": "2026-05-06T18:00:00.234567Z", "event": "upstream_request_start", "service": "ecs", "request_id": "550e8400-e29b-41d4-a716-446655440000"}
{"timestamp": "2026-05-06T18:00:00.345678Z", "event": "upstream_request_success", "service": "ecs", "request_id": "550e8400-e29b-41d4-a716-446655440000", "status_code": 200, "duration_seconds": 0.111, "attempt": 1, "items_returned": 42}
{"timestamp": "2026-05-06T18:00:00.456789Z", "event": "tool_invocation_success", "tool": "query_pricing", "request_id": "550e8400-e29b-41d4-a716-446655440000", "duration_seconds": 0.333}
Key fields in every log:
timestamp: When the event happened (ISO 8601)event: What happened (tool_invocation_start, upstream_request_success, etc.)request_id: Unique ID for this request (same across all related logs)Logs are printed to stderr, so redirect to a file or log aggregator:
python -m otc_pricing_mcp 2>/var/log/otc-pricing-mcp.log
Pipe to jq for pretty printing:
python -m otc_pricing_mcp 2>&1 | jq .
The uvicorn server exposes all endpoints on port 8080:
| Path | Method | Description |
|---|---|---|
/sse | GET | MCP SSE transport — connect your MCP client here |
/messages/ | POST | MCP SSE message handler (used internally by the client) |
/healthz | GET | Liveness probe — always 200 if the process is up |
/readyz | GET | Readiness probe — 200 when OTC API is reachable, 503 otherwise |
/metrics | GET | Prometheus metrics in text exposition format |
Health Checks:
# Liveness check (always 200 if process is up)
curl http://localhost:8080/healthz
# {"status": "ok", "service": "otc-pricing-mcp"}
# Readiness check (verifies OTC API is reachable)
curl http://localhost:8080/readyz
# {"status": "ready", "upstream": "ok", "api_response_time": 0.042}
Prometheus Metrics:
curl http://localhost:8080/metrics
Returns Prometheus format metrics:
# HELP otc_pricing_mcp_requests_total Total MCP tool requests (success and failure)
# TYPE otc_pricing_mcp_requests_total counter
otc_pricing_mcp_requests_total{status="success",tool="query_pricing"} 5.0
otc_pricing_mcp_requests_total{status="error",tool="query_pricing"} 1.0
# HELP otc_pricing_mcp_request_duration_seconds MCP tool request duration in seconds
# TYPE otc_pricing_mcp_request_duration_seconds histogram
otc_pricing_mcp_request_duration_seconds_bucket{le="0.005",tool="query_pricing"} 0.0
otc_pricing_mcp_request_duration_seconds_bucket{le="0.01",tool="query_pricing"} 1.0
...
# HELP otc_pricing_mcp_upstream_requests_total Total upstream OTC API requests (success and failure)
# TYPE otc_pricing_mcp_upstream_requests_total counter
otc_pricing_mcp_upstream_requests_total{service="ecs",status="success"} 10.0
otc_pricing_mcp_upstream_requests_total{service="ecs",status="error"} 2.0
...
Available Metrics:
otc_pricing_mcp_requests_total{tool, status}: Count of tool invocationsotc_pricing_mcp_request_duration_seconds{tool}: Tool execution timeotc_pricing_mcp_upstream_requests_total{service, status}: Count of API callsotc_pricing_mcp_upstream_duration_seconds{service}: API call latencyUsing Prometheus:
Add to your prometheus.yml:
scrape_configs:
- job_name: 'otc-pricing-mcp'
static_configs:
- targets: ['localhost:8080']
Then query in Prometheus:
rate(otc_pricing_mcp_requests_total[5m]) # Requests per second
histogram_quantile(0.95, otc_pricing_mcp_request_duration_seconds_bucket) # p95 latency
Check the logs:
LOG_LEVEL=DEBUG python -m otc_pricing_mcp 2>&1 | jq 'select(.event == "upstream_request_success") | {service, duration_seconds}'
Check metrics:
curl http://localhost:8080/metrics | grep upstream_duration_seconds
Look for error logs:
LOG_LEVEL=DEBUG python -m otc_pricing_mcp 2>&1 | jq 'select(.event == "tool_invocation_error")'
Example error log:
{
"event": "tool_invocation_error",
"tool": "query_pricing",
"request_id": "550e8400-e29b-41d4-a716-446655440000",
"error": "list index out of range",
"error_type": "IndexError",
"duration_seconds": 0.001,
"exc_info": true
}
Check readiness endpoint:
curl -v http://localhost:8080/readyz
# HTTP/1.1 503 Service Unavailable
# {"status": "not_ready", "upstream": "unreachable", "error": "..."}
Check metrics:
curl http://localhost:8080/metrics | grep upstream_requests_total
# Will show increased error counts
Use request_id to trace a request:
# Get the request_id from any log
LOG_LEVEL=DEBUG python -m otc_pricing_mcp 2>&1 | jq 'select(.request_id == "550e8400-e29b-41d4-a716-446655440000")'
This shows all logs for that request in order:
# Clone repo
git clone https://github.com/seaser0/otc-pricing-mcp.git
cd otc-pricing-mcp
# Install with dev dependencies
uv sync
# Run tests
uv run pytest tests/ -v
# Check code quality
uv run ruff check src/
uv run mypy src/ --strict
# With debug logging
LOG_LEVEL=DEBUG python -m otc_pricing_mcp
# In another terminal, test the endpoints
curl http://localhost:8080/healthz | jq .
curl http://localhost:8080/metrics
docker build -t otc-pricing-mcp:latest .
docker run \
--name otc-pricing-mcp \
-e LOG_LEVEL=INFO \
-e METRICS_PORT=8080 \
-p 8080:8080 \
otc-pricing-mcp:latest
See deploy/kubernetes/ for the full manifest set (Deployment, Service, Ingress, NetworkPolicy, ServiceMonitor, PodDisruptionBudget).
When self-hosting on Kubernetes, connect remote clients to your ingress hostname:
https://mcp-otc-pricing.example.com/sse
Key features:
selfHeal: true and prune: trueClaude Client
│
├─ STDIO transport (local) ──┐
│ stdin/stdout │
│ ▼
└─ SSE transport (remote) MCP Server (server.py)
GET /sse - List tools
POST /messages/ - Route tool calls
- Log invocations
- Record metrics
│
▼
HTTP Client (client.py)
- Build request
- Retry logic
- Parse response
│
▼
OTC Price Calculator API
Both transports share the same MCP Server instance and run concurrently in the same asyncio event loop.
| Component | Purpose |
|---|---|
__main__.py | Entry point — runs STDIO + uvicorn SSE concurrently |
server.py | MCP server, routes tool calls, logs invocations |
client.py | HTTP client for OTC API, retry logic, API logging |
tools/ | Tool implementations (discovery, pricing, estimation) |
observability/http_server.py | Starlette app — SSE transport + health/metrics routes |
observability/ | Logging, Prometheus metrics, request context |
models.py | Data models (validated with Pydantic) |
normalize.py | Price parsing and formatting |
Stories 0–9 are complete. The following are post-v1.0 enhancements:
Caching
Advanced Querying
Cost Analysis Tools
Multi-Cloud Support
User Preferences
Better Error Recovery
Performance Optimizations
Observability Enhancements
Testing Improvements
API Stability
We welcome contributions! See CONTRIBUTING.md for:
Quick PR Checklist:
uv run pytest tests/uv run ruff check src/uv run mypy src/ --strictuv run bandit -r src/Apache License 2.0 — see LICENSE file.
Copyright: seaser0 (s34s3r@gmail.com)
Questions or Issues?
LOG_LEVEL=DEBUG python -m otc_pricing_mcp 2>&1 | jq .Want to Report a Security Issue? See SECURITY.md for responsible disclosure.
| Story | Feature | Status |
|---|---|---|
| 0 | Project setup, API client, data models | ✅ Done |
| 1 | Catalog discovery tools | ✅ Done |
| 2 | Pricing query tools | ✅ Done |
| 3 | Multi-service fan-out | ✅ Done |
| 4 | Comprehensive testing | ✅ Done |
| 5 | Security & container hardening | ✅ Done |
| 6 | CI/CD pipeline (GHCR image, PyPI, SBOM, GitHub Release) | ✅ Done |
| 7 | Observability (structured logging, Prometheus metrics, health probes) | ✅ Done |
| 8 | ArgoCD deployment (Kubernetes, SSE transport, remote endpoint) | ✅ Done |
| 9 | Open source documentation (README, server.json, community docs) | ✅ Done |
See docs/ directory for detailed documentation:
docs/ci-cd.md — CI/CD workflow detailsdocs/deployment.md — Deployment guidedocs/security.md — Security features and considerationsBuilt with ❤️ by seaser0
Last updated: 2026-05-07
Be the first to review this server!
by Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
by Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
by mcp-marketplace · Developer Tools
Create, build, and publish Python MCP servers to PyPI — conversationally.
by Microsoft · Content & Media
Convert files (PDF, Word, Excel, images, audio) to Markdown for LLM consumption
by mcp-marketplace · Developer Tools
Scaffold, build, and publish TypeScript MCP servers to npm — conversationally
by mcp-marketplace · Finance
Free stock data and market news for any MCP-compatible AI assistant.