- Scripts to run workflows from a YAML context or run inputs (kab_run_workflow.py, with --input name=@file), store per-project discovery connections, bootstrap agent MCP keys, refresh the KAB token, publish reports and build estate snapshots. - Hyperscaler discovery servers extended in place; cloud-knowledge folded into them. - deploy/crucible-kab-dev.yaml: the Discovery package agent and the Assessment agents. - Platform issue write-ups and current-wiring notes under docs/platform-issues/. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1522 lines
70 KiB
Python
1522 lines
70 KiB
Python
"""Azure Discovery
|
|
===============
|
|
|
|
Read-only discovery of a customer's Azure estate - servers, workloads, Kubernetes clusters, networks, data stores, policies and Advisor findings - through Azure Resource Graph.
|
|
|
|
Generated by Agent Builder Platform - MCP Server Builder
|
|
Version: 0.1.6
|
|
Template: mcp-server-template 1.1.0
|
|
|
|
Features:
|
|
- JSON-RPC 2.0 over HTTP (MCP standard)
|
|
- Bearer token authentication
|
|
- Health check endpoint
|
|
- Structured logging (JSON, one object per line)
|
|
|
|
Environment Variables:
|
|
- MCP_REGISTRATION_API_KEY: Authentication key for Gateway registration (required)
|
|
- MCP_SERVER_PORT: Server port (default: 8111)
|
|
- MCP_SERVER_NAME: Display name for the server
|
|
- LOG_LEVEL: Logging level (default: INFO)
|
|
- LOG_FORMAT: json (default) or console
|
|
"""
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
import json
|
|
import inspect
|
|
import time
|
|
import traceback
|
|
import asyncio
|
|
import logging
|
|
import secrets
|
|
from typing import Dict, Any, List, Optional, Union # noqa: F401
|
|
from collections import OrderedDict
|
|
from contextlib import asynccontextmanager
|
|
from datetime import datetime, timezone
|
|
|
|
import structlog
|
|
from fastapi import FastAPI, HTTPException, Depends, Request
|
|
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
|
|
from pydantic import BaseModel, Field, StrictInt, StrictStr
|
|
|
|
import mcp_connection
|
|
|
|
# Additional imports from tool implementations
|
|
import base64
|
|
import hashlib
|
|
import httpx
|
|
|
|
TEMPLATE_VERSION = '1.1.0'
|
|
|
|
# What this server needs to reach its upstream, advertised to the gateway on initialize (None: nothing)
|
|
CONNECTION_SCHEMA = {'type': 'object',
|
|
'title': 'Azure Discovery',
|
|
'description': "Read-only discovery of a customer's Azure estate - servers, "
|
|
'workloads, Kubernetes clusters, networks, data stores, policies and '
|
|
'Advisor findings - through Azure Resource Graph.',
|
|
'properties': {'tenant_id': {'type': 'string',
|
|
'title': 'Tenant ID',
|
|
'description': "The customer's Microsoft Entra tenant "
|
|
'id.'},
|
|
'client_id': {'type': 'string',
|
|
'title': 'Client ID',
|
|
'description': 'The application (client) id of the '
|
|
'read-only app registration.'},
|
|
'client_secret': {'type': 'string',
|
|
'title': 'Client secret',
|
|
'description': "The app registration's client "
|
|
'secret.',
|
|
'writeOnly': True,
|
|
'format': 'password'},
|
|
'access_token': {'type': 'string',
|
|
'title': 'Access token',
|
|
'description': 'For a short trial only, instead of '
|
|
'the three fields above. A token from '
|
|
'az account get-access-token. It '
|
|
'expires within about an hour and '
|
|
"carries that person's own Azure "
|
|
'permissions.',
|
|
'writeOnly': True,
|
|
'format': 'password'},
|
|
'scope_root': {'type': 'string',
|
|
'title': 'Scope root',
|
|
'description': 'What may be read: '
|
|
'managementGroups/<id>, '
|
|
'subscriptions/<id>, or one resource '
|
|
'group, '
|
|
'subscriptions/<id>/resourceGroups/<name>.'},
|
|
'cloud': {'type': 'string',
|
|
'title': 'Cloud',
|
|
'description': 'public, usgov or china. Default public.'}},
|
|
'required': ['scope_root'],
|
|
'additionalProperties': False}
|
|
VERIFY_TOOL = 'verify_connection'
|
|
|
|
# ============================================
|
|
# Configuration
|
|
# ============================================
|
|
|
|
def _load_env_file() -> None:
|
|
"""Read the `.env` next to this file, so `cp .env.example .env` and `python server.py` work.
|
|
|
|
Variables that are already set win, so a container's or a pipeline's settings are never overridden.
|
|
The image does not contain a `.env`, so this does nothing there.
|
|
"""
|
|
path = globals().get("__file__")
|
|
if not path:
|
|
return
|
|
try:
|
|
from dotenv import load_dotenv
|
|
except ImportError:
|
|
return
|
|
load_dotenv(os.path.join(os.path.dirname(os.path.abspath(path)), ".env"))
|
|
|
|
|
|
_load_env_file()
|
|
|
|
|
|
class Config:
|
|
"""Server configuration from environment variables"""
|
|
|
|
# Server Identity
|
|
SERVER_ID = os.getenv("MCP_SERVER_ID", 'azure-discovery')
|
|
SERVER_NAME = os.getenv("MCP_SERVER_NAME", 'Azure Discovery')
|
|
SERVER_VERSION = os.getenv("MCP_SERVER_VERSION", '0.1.6')
|
|
# MCP_SERVER_PORT, or SERVER_PORT as the ConfigMaps in the tools repo name it
|
|
SERVER_PORT = int(os.getenv("MCP_SERVER_PORT") or os.getenv("SERVER_PORT") or "8111")
|
|
|
|
# Authentication (REQUIRED for MCP Gateway registration)
|
|
# Generate secure key: openssl rand -hex 32
|
|
MCP_REGISTRATION_API_KEY = os.getenv("MCP_REGISTRATION_API_KEY", "").strip()
|
|
# The placeholder from .env.example is not a key: a server started with it unchanged has no key.
|
|
if MCP_REGISTRATION_API_KEY.startswith("<"):
|
|
MCP_REGISTRATION_API_KEY = ""
|
|
|
|
# Feature Flags
|
|
REQUIRE_AUTH = os.getenv("REQUIRE_AUTH", "true").lower() == "true"
|
|
# Applies when CONNECTION_SCHEMA is set: refuse a call that arrives without the tenant's connection
|
|
# instead of falling back to this server's own environment. Set to false only for local runs.
|
|
REQUIRE_VAULT_CONNECTION = os.getenv("REQUIRE_VAULT_CONNECTION", "true").lower() == "true"
|
|
|
|
# Logging: LOG_FORMAT is "json" (one object per line, for log stores) or "console" (for reading by eye)
|
|
LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
|
|
LOG_FORMAT = os.getenv("LOG_FORMAT", "json").lower()
|
|
|
|
config = Config()
|
|
|
|
# ============================================
|
|
# Logging Configuration
|
|
# ============================================
|
|
|
|
def sanitize_log(value: Any, max_length: int = 200) -> str:
|
|
"""Make a caller-supplied value safe to log: one line, no control characters, bounded."""
|
|
if not isinstance(value, str):
|
|
value = str(value)
|
|
# Written with .replace() because that is the pattern CodeQL recognises as a
|
|
# barrier for py/log-injection (CWE-117).
|
|
value = value.replace("\n", "").replace("\r", "")
|
|
return re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]", "", value)[:max_length]
|
|
|
|
|
|
def _add_server_identity(_logger, _method, event_dict):
|
|
event_dict.setdefault("server_id", config.SERVER_ID)
|
|
event_dict.setdefault("server_name", config.SERVER_NAME)
|
|
event_dict.setdefault("server_version", config.SERVER_VERSION)
|
|
return event_dict
|
|
|
|
|
|
_LEADING_KEYS = (
|
|
"timestamp", "level", "event", "logger", "server_id", "server_name", "server_version",
|
|
"request_id", "method", "tool",
|
|
)
|
|
|
|
|
|
def _scrub_secrets(_logger, _method, event_dict):
|
|
"""The last step before a line is written: no credential reaches the log, whoever logged it."""
|
|
return mcp_connection.scrub(event_dict)
|
|
|
|
|
|
def _lead_with_common_keys(_logger, _method, event_dict):
|
|
"""Every line starts with the same fields in the same order; the event's own follow."""
|
|
lead = {key: event_dict.pop(key) for key in _LEADING_KEYS if key in event_dict}
|
|
lead.update(event_dict)
|
|
return lead
|
|
|
|
|
|
def configure_logging() -> None:
|
|
"""Send every log line, ours and the libraries', to stdout in one format."""
|
|
level = getattr(logging, config.LOG_LEVEL, logging.INFO)
|
|
shared = [
|
|
structlog.contextvars.merge_contextvars,
|
|
structlog.stdlib.add_logger_name,
|
|
structlog.stdlib.add_log_level,
|
|
structlog.processors.TimeStamper(fmt="iso", utc=True),
|
|
_add_server_identity,
|
|
]
|
|
renderer = (
|
|
structlog.dev.ConsoleRenderer(colors=False)
|
|
if config.LOG_FORMAT == "console"
|
|
else structlog.processors.JSONRenderer()
|
|
)
|
|
structlog.configure(
|
|
processors=shared + [
|
|
structlog.stdlib.PositionalArgumentsFormatter(),
|
|
structlog.processors.StackInfoRenderer(),
|
|
structlog.processors.format_exc_info,
|
|
structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
|
|
],
|
|
logger_factory=structlog.stdlib.LoggerFactory(),
|
|
wrapper_class=structlog.stdlib.BoundLogger,
|
|
cache_logger_on_first_use=True,
|
|
)
|
|
handler = logging.StreamHandler(sys.stdout)
|
|
handler.mcp_server_handler = True
|
|
handler.setFormatter(structlog.stdlib.ProcessorFormatter(
|
|
foreign_pre_chain=shared,
|
|
processors=[
|
|
structlog.stdlib.ProcessorFormatter.remove_processors_meta,
|
|
structlog.processors.format_exc_info,
|
|
_lead_with_common_keys,
|
|
_scrub_secrets,
|
|
renderer,
|
|
],
|
|
))
|
|
root = logging.getLogger()
|
|
root.handlers = [h for h in root.handlers if not getattr(h, "mcp_server_handler", False)] + [handler]
|
|
root.setLevel(level)
|
|
# httpx logs every request URL at INFO, and an upstream URL often carries a key: keep those lines for DEBUG
|
|
for name in ("httpx", "httpcore"):
|
|
logging.getLogger(name).setLevel(level if level <= logging.DEBUG else logging.WARNING)
|
|
# uvicorn installs its own handlers; route them through ours so every line has the same shape
|
|
for name in ("uvicorn", "uvicorn.error", "uvicorn.access"):
|
|
uvicorn_logger = logging.getLogger(name)
|
|
uvicorn_logger.handlers.clear()
|
|
uvicorn_logger.propagate = True
|
|
|
|
|
|
configure_logging()
|
|
logger = structlog.get_logger(__name__)
|
|
|
|
# ============================================
|
|
# Per-request connection
|
|
# ============================================
|
|
|
|
CONNECTION_METHODS = ("tools/call", "resources/read", "prompts/get")
|
|
|
|
|
|
def get_connection() -> Dict[str, Any]:
|
|
"""The connection fields the gateway sent with this request; empty when it sent none."""
|
|
return dict(mcp_connection.active() or {})
|
|
|
|
|
|
_client_cache: "OrderedDict[str, Any]" = OrderedDict()
|
|
_CLIENT_CACHE_MAX = 32
|
|
|
|
|
|
def get_upstream_client(kind, build):
|
|
"""The upstream client of type `kind` for this request's connection.
|
|
|
|
`build(connection)` runs once per distinct (kind, connection), so two tools that talk to different
|
|
upstreams with the same tenant connection each get their own client.
|
|
"""
|
|
if not isinstance(kind, str) or not kind:
|
|
raise TypeError("get_upstream_client needs a client kind, for example get_upstream_client('jira', build)")
|
|
key = f"{kind}:{mcp_connection.fingerprint(mcp_connection.active())}"
|
|
client = _client_cache.get(key)
|
|
if client is None:
|
|
client = build(get_connection())
|
|
_client_cache[key] = client
|
|
while len(_client_cache) > _CLIENT_CACHE_MAX:
|
|
_close_client(_client_cache.popitem(last=False)[1])
|
|
else:
|
|
_client_cache.move_to_end(key)
|
|
return client
|
|
|
|
|
|
_closing_tasks: set = set()
|
|
|
|
|
|
def _close_client(client) -> None:
|
|
"""Release the connections of a client that left the cache (an httpx client holds a pool of sockets).
|
|
|
|
Closes with `aclose()`, `close()` or `dispose()` (an httpx client, most clients, a SQLAlchemy engine); a client
|
|
with none of them is left to the garbage collector. A failure to close is logged and never reaches the
|
|
request that happened to evict it.
|
|
"""
|
|
close = getattr(client, "aclose", None) or getattr(client, "close", None) or getattr(client, "dispose", None)
|
|
if close is None:
|
|
return
|
|
try:
|
|
result = close()
|
|
if inspect.isawaitable(result):
|
|
try:
|
|
task = asyncio.get_running_loop().create_task(result)
|
|
except RuntimeError: # no loop to run it on
|
|
result.close()
|
|
return
|
|
_closing_tasks.add(task) # a task nobody refers to can be collected before it finishes
|
|
task.add_done_callback(_closing_tasks.discard)
|
|
except Exception as error:
|
|
logger.warning("client_close_failed", error_type=type(error).__name__, error=sanitize_log(error))
|
|
|
|
|
|
async def _close_all_clients() -> None:
|
|
"""On shutdown: close every cached client and wait for the closes already under way."""
|
|
while _client_cache:
|
|
_close_client(_client_cache.popitem(last=False)[1])
|
|
if _closing_tasks:
|
|
await asyncio.gather(*list(_closing_tasks), return_exceptions=True)
|
|
|
|
|
|
def check_connection(profile: Optional[Dict[str, Any]]) -> None:
|
|
"""Refuse a call with no connection (unless the environment may be used) or with an incomplete one."""
|
|
if not profile:
|
|
if config.REQUIRE_VAULT_CONNECTION:
|
|
raise ValueError(
|
|
"No connection was sent with this request: no credential is stored for this tenant. "
|
|
"Store one under Credentials, or set REQUIRE_VAULT_CONNECTION=false to use this "
|
|
"server's own environment."
|
|
)
|
|
return
|
|
missing = mcp_connection.missing_fields(profile, CONNECTION_SCHEMA)
|
|
if missing:
|
|
raise ValueError("The connection sent with this request is missing: " + ", ".join(missing))
|
|
|
|
|
|
def render_prompt(template: str, values: Dict[str, Any]) -> str:
|
|
"""Fill {{name}} markers in a prompt template; a marker with no value is left as written."""
|
|
return re.sub(
|
|
r"\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}",
|
|
lambda m: str(values[m.group(1)]) if m.group(1) in values else m.group(0),
|
|
template,
|
|
)
|
|
|
|
# ============================================
|
|
# Authentication
|
|
# ============================================
|
|
|
|
security = HTTPBearer(auto_error=False)
|
|
|
|
async def verify_mcp_registration_key(
|
|
credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)
|
|
) -> bool:
|
|
"""
|
|
Verify MCP registration API key for /messages endpoint.
|
|
|
|
This is the industry-standard Bearer token authentication pattern.
|
|
"""
|
|
# Skip auth if disabled (for testing only!)
|
|
if not config.REQUIRE_AUTH:
|
|
logger.warning("auth_disabled", detail="testing mode only")
|
|
return True
|
|
|
|
if not credentials:
|
|
logger.warning("auth_missing_credentials")
|
|
raise HTTPException(
|
|
status_code=401,
|
|
detail="Missing authentication credentials. Include 'Authorization: Bearer <token>' header.",
|
|
headers={"WWW-Authenticate": "Bearer"}
|
|
)
|
|
|
|
provided_key = credentials.credentials
|
|
expected_key = config.MCP_REGISTRATION_API_KEY
|
|
|
|
if not expected_key:
|
|
logger.error("auth_key_not_configured")
|
|
raise HTTPException(
|
|
status_code=500,
|
|
detail="Server authentication not configured"
|
|
)
|
|
|
|
if not secrets.compare_digest(provided_key.encode("utf-8"), expected_key.encode("utf-8")):
|
|
logger.warning("auth_invalid_key")
|
|
raise HTTPException(
|
|
status_code=401,
|
|
detail="Invalid authentication credentials",
|
|
headers={"WWW-Authenticate": "Bearer"}
|
|
)
|
|
|
|
return True
|
|
|
|
# ============================================
|
|
# MCP Protocol Models
|
|
# ============================================
|
|
|
|
class MCPRequest(BaseModel):
|
|
"""JSON-RPC 2.0 request (MCP standard)"""
|
|
jsonrpc: str = "2.0"
|
|
id: Union[StrictStr, StrictInt] # JSON-RPC allows a string or a number; the reply echoes it unchanged
|
|
method: str
|
|
params: Dict[str, Any] = Field(default_factory=dict)
|
|
|
|
class MCPResponse(BaseModel):
|
|
"""JSON-RPC 2.0 response (MCP standard)"""
|
|
jsonrpc: str = "2.0"
|
|
id: Union[StrictStr, StrictInt]
|
|
result: Optional[Dict[str, Any]] = None
|
|
error: Optional[Dict[str, Any]] = None
|
|
|
|
# ============================================
|
|
# Tool Definitions
|
|
# ============================================
|
|
|
|
TOOLS_REGISTRY = [
|
|
{
|
|
"name": 'azure_check_connection',
|
|
"description": 'Test the stored connection: sign in and read the scope root. Returns no customer data.',
|
|
"inputSchema": {'type': 'object', 'properties': {}, 'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_list_accounts',
|
|
"description": 'List the estate structure: management groups, subscriptions and resource groups.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'kind': {'type': 'string',
|
|
'description': 'One of: subscriptions, management_groups, '
|
|
'resource_groups.'},
|
|
'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_list_resources',
|
|
"description": 'List every resource in scope, or one resource type, with id, type, location and tags.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'resource_type': {'type': 'string',
|
|
'description': 'Optional ARM type, such as '
|
|
'microsoft.compute/virtualmachines.'},
|
|
'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_query_resources',
|
|
"description": "Run a read-only Azure Resource Graph KQL query over the connection's scope. Secrets and people are removed from the results.",
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'query': {'type': 'string',
|
|
'description': 'KQL starting with a Resource Graph table.'},
|
|
'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': ['query']}
|
|
},
|
|
{
|
|
"name": 'azure_get_resource_metadata',
|
|
"description": "Read-only provider metadata for one resource inside the connection's scope.",
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'resource_id': {'type': 'string',
|
|
'description': 'The full ARM resource id.'},
|
|
'scope_entry_id': {'type': 'string',
|
|
'description': 'The scope entry this answers, '
|
|
'echoed in the reply.'}},
|
|
'required': ['resource_id']}
|
|
},
|
|
{
|
|
"name": 'azure_list_servers',
|
|
"description": 'List virtual machines, scale sets or managed disks.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'kind': {'type': 'string',
|
|
'description': 'One of: virtual_machines, scale_sets, disks.'},
|
|
'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_list_workloads',
|
|
"description": 'List App Service, Container Apps or Container Instances workloads.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'kind': {'type': 'string',
|
|
'description': 'One of: app_service, container_apps, '
|
|
'container_instances.'},
|
|
'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_list_kubernetes_clusters',
|
|
"description": 'List AKS clusters with version, node pools and networking. Stops at the cloud control plane.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_get_network_topology',
|
|
"description": 'List virtual networks with their subnets and peerings, or route tables, NSGs, gateways, load balancers, private endpoints or public IPs.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'kind': {'type': 'string',
|
|
'description': 'One of: virtual_networks, route_tables, '
|
|
'network_security_groups, gateways, '
|
|
'load_balancers, private_endpoints, '
|
|
'public_ips.'},
|
|
'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_list_data_stores',
|
|
"description": 'List SQL, Cosmos DB, storage account, PostgreSQL, MySQL or Redis metadata. Never rows, documents or blobs.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'kind': {'type': 'string',
|
|
'description': 'One of: sql, cosmos_db, storage_accounts, '
|
|
'postgresql, mysql, redis.'},
|
|
'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_list_organization_policies',
|
|
"description": 'List Azure Policy assignments, definitions, initiatives, exemptions or compliance states.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'kind': {'type': 'string',
|
|
'description': 'One of: assignments, definitions, '
|
|
'initiatives, exemptions, compliance.'},
|
|
'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_list_resource_policies',
|
|
"description": 'List Key Vault access policies (never secret values), storage network rules or resource locks. Principals are anonymised.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'subscription_id': {'type': 'string',
|
|
'description': 'For resource_locks. Needed when '
|
|
'the scope root is a management '
|
|
'group.'},
|
|
'kind': {'type': 'string',
|
|
'description': 'One of: key_vault_access, '
|
|
'storage_network_rules, resource_locks.'},
|
|
'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_list_recommendations',
|
|
"description": 'List Azure Advisor recommendations, each with a common Well-Architected pillar.',
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'page_size': {'type': 'integer',
|
|
'description': 'Items per page, up to 200. Default 50.'},
|
|
'page_token': {'type': 'string',
|
|
'description': 'next_page_token from the previous '
|
|
'reply.'}},
|
|
'required': []}
|
|
},
|
|
{
|
|
"name": 'azure_search_well_architected',
|
|
"description": "Search the Azure Well-Architected Framework's guidance by pillar and topic. Both come from fixed lists, so no customer detail leaves the platform. Microsoft Learn is public, so no credential is used.",
|
|
"inputSchema": {'type': 'object',
|
|
'properties': {'pillar': {'type': 'string',
|
|
'description': 'reliability, security, cost, operations, '
|
|
'performance or sustainability.'},
|
|
'topic': {'type': 'string',
|
|
'description': 'One of the fixed topics; an invalid value '
|
|
'lists them.'}},
|
|
'required': ['pillar', 'topic']}
|
|
},
|
|
{
|
|
"name": 'verify_connection',
|
|
"description": (
|
|
"Check that the connection sent with this request works against the upstream, and say who it "
|
|
"authenticated as. Makes no change."
|
|
),
|
|
"inputSchema": {'type': 'object', 'properties': {}, 'required': []}
|
|
}
|
|
]
|
|
|
|
# ============================================
|
|
# Resource Definitions
|
|
# ============================================
|
|
|
|
RESOURCES_REGISTRY = []
|
|
|
|
# ============================================
|
|
# Prompt Definitions
|
|
# ============================================
|
|
|
|
PROMPT_TEMPLATES = {}
|
|
|
|
PROMPTS_REGISTRY = [
|
|
{
|
|
"name": name,
|
|
"description": prompt["description"],
|
|
"arguments": [
|
|
{"name": a["name"], "description": a["description"], "required": a["required"]}
|
|
for a in prompt["arguments"]
|
|
],
|
|
}
|
|
for name, prompt in PROMPT_TEMPLATES.items()
|
|
]
|
|
|
|
# ============================================
|
|
# Tool Implementations
|
|
# ============================================
|
|
|
|
DEFAULT_PAGE_SIZE = 50
|
|
|
|
MAX_PAGE_SIZE = 200
|
|
|
|
MAX_RESPONSE_BYTES = 200000
|
|
|
|
RETRY_ATTEMPTS = 5
|
|
|
|
RETRY_MAX_WAIT_SECONDS = 20
|
|
|
|
RETRY_BUDGET_SECONDS = 60
|
|
|
|
SECRET_KEYS = (
|
|
"userdata", "customdata", "customscript", "protectedsettings", "connectionstring", "connectionstrings",
|
|
"appsettings", "env", "envvars", "environmentvariables", "variables", "password", "adminpassword", "secret",
|
|
"secretvalue", "sastoken", "accesskey", "primarykey", "secondarykey", "privatekey", "kubeconfig", "credentials",
|
|
)
|
|
|
|
SCALAR_SAFE_KEYS = ("env",)
|
|
|
|
PERSON_KEYS = (
|
|
"createdby", "lastmodifiedby", "updatedby", "creator", "owner", "owneremail", "contact", "contactemail", "email",
|
|
"objectid", "principalid", "principalname", "userprincipalname",
|
|
)
|
|
|
|
PRINCIPAL_KINDS = {"user": "[user]", "group": "[group]", "domain": "[domain]", "principal": "[user]",
|
|
"principalSet": "[group]", "deleted": "[user]"}
|
|
|
|
NON_PERSON_EMAIL_DOMAINS = ("gserviceaccount.com",)
|
|
|
|
def _clean_text(text: str) -> str:
|
|
"""Anonymise people inside a string: emails, AWS IAM users, and session names, which are often emails."""
|
|
def email(match):
|
|
return match.group(0) if match.group(0).lower().endswith(NON_PERSON_EMAIL_DOMAINS) else "[email]"
|
|
|
|
text = re.sub(r"arn:aws[a-z-]*:iam::\d{12}:user/[^\s\"',]+", "[user]", text)
|
|
text = re.sub(r"(arn:aws[a-z-]*:sts::\d{12}:assumed-role/[^/\s\"',]+)/[^\s\"',]+", r"\1/[session]", text)
|
|
# Bounded, and skipped without an @: an unbounded pattern takes minutes on one long string.
|
|
if "@" not in text:
|
|
return text
|
|
return re.sub(r"[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,255}\.[A-Za-z]{2,24}", email, text)
|
|
|
|
def _anonymise_member(value: str) -> str:
|
|
"""One IAM member, such as user:a@b.example. Service accounts stay: Discovery shows what can reach what."""
|
|
kind = value.split(":", 1)[0]
|
|
if ":" in value and kind == "serviceAccount":
|
|
return value
|
|
if ":" in value and kind in PRINCIPAL_KINDS:
|
|
return PRINCIPAL_KINDS[kind]
|
|
return _clean_text(value)
|
|
|
|
def _scalar(value) -> bool:
|
|
return value is None or isinstance(value, (str, bool, int, float))
|
|
|
|
def _scrub(value, key: str = ""):
|
|
"""Drop secrets and anonymise people, however deep. Every tool's reply passes through here."""
|
|
lowered = key.lower().replace("_", "").replace("-", "")
|
|
if lowered in SECRET_KEYS and not (lowered in SCALAR_SAFE_KEYS and _scalar(value)):
|
|
return "[redacted]"
|
|
if lowered in PERSON_KEYS:
|
|
return "[user]"
|
|
if isinstance(value, dict):
|
|
tag = str(value.get("Key", value.get("key", ""))).lower().replace("_", "").replace("-", "")
|
|
cleaned = {k: _scrub(v, str(k)) for k, v in value.items()}
|
|
for name in ("Value", "value"):
|
|
if name in cleaned and tag in PERSON_KEYS:
|
|
cleaned[name] = "[user]"
|
|
elif name in cleaned and tag in SECRET_KEYS and not (tag in SCALAR_SAFE_KEYS and _scalar(cleaned[name])):
|
|
cleaned[name] = "[redacted]"
|
|
return cleaned
|
|
if isinstance(value, (list, tuple)):
|
|
return [_scrub(v, "members" if lowered == "members" else "") for v in value]
|
|
if isinstance(value, str):
|
|
return _anonymise_member(value) if lowered == "members" else _clean_text(value)
|
|
if value is None or isinstance(value, (bool, int, float)):
|
|
return value
|
|
return str(value)
|
|
|
|
def _retry_delay(response, attempt: int) -> float:
|
|
"""How long the provider asked us to wait: Retry-After, or Resource Graph's hh:mm:ss quota reset."""
|
|
reset = response.headers.get("x-ms-user-quota-resets-after", "")
|
|
if reset.count(":") == 2:
|
|
hours, minutes, seconds = reset.split(":")
|
|
return int(hours) * 3600 + int(minutes) * 60 + float(seconds)
|
|
try:
|
|
return float(response.headers.get("retry-after", ""))
|
|
except ValueError:
|
|
return float(2 ** attempt)
|
|
|
|
async def _with_backoff(send):
|
|
"""Send, waiting when the provider throttles. The waits stay well inside the 120-second limit on an MCP call."""
|
|
waited = 0.0
|
|
response = await send()
|
|
for attempt in range(RETRY_ATTEMPTS):
|
|
if response.status_code not in (429, 503):
|
|
return response
|
|
delay = min(_retry_delay(response, attempt), RETRY_MAX_WAIT_SECONDS)
|
|
if waited + delay > RETRY_BUDGET_SECONDS:
|
|
return response
|
|
logger.info("upstream_throttled", status=response.status_code, wait_seconds=delay)
|
|
await asyncio.sleep(delay)
|
|
waited += delay
|
|
response = await send()
|
|
return response
|
|
|
|
def _page_size(arguments: Dict[str, Any]) -> int:
|
|
try:
|
|
size = int(arguments.get("page_size") or DEFAULT_PAGE_SIZE)
|
|
except (TypeError, ValueError):
|
|
return DEFAULT_PAGE_SIZE
|
|
return max(1, min(size, MAX_PAGE_SIZE))
|
|
|
|
def _read_page(arguments: Dict[str, Any]):
|
|
"""(upstream token, items of that upstream page already returned)."""
|
|
token = arguments.get("page_token")
|
|
if not token:
|
|
return None, 0
|
|
state = json.loads(base64.urlsafe_b64decode(str(token).encode()).decode())
|
|
return state["u"], int(state["s"])
|
|
|
|
def _write_page(upstream, skip: int) -> str:
|
|
return base64.urlsafe_b64encode(json.dumps({"u": upstream, "s": skip}).encode()).decode()
|
|
|
|
def _evidence_ref(tool: str, arguments: Dict[str, Any], payload) -> str:
|
|
asked = {k: v for k, v in arguments.items() if k != "page_token"}
|
|
blob = json.dumps([tool, asked, payload], sort_keys=True, default=str)
|
|
return "sha256:" + hashlib.sha256(blob.encode()).hexdigest()
|
|
|
|
def _collected_at() -> str:
|
|
return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
|
|
|
|
def _refuse(code: str, message: str) -> Dict[str, Any]:
|
|
return {"success": False, "error": {"code": code, "message": message}}
|
|
|
|
def _upstream_failed(provider: str, error: Exception) -> Dict[str, Any]:
|
|
"""Name the failure and never its text: an upstream error can quote a request or an identity."""
|
|
status = getattr(getattr(error, "response", None), "status_code", None)
|
|
code = getattr(error, "response", None)
|
|
if isinstance(code, dict):
|
|
status = code.get("Error", {}).get("Code")
|
|
logger.warning("upstream_call_failed", provider=provider, error_type=type(error).__name__, status=status)
|
|
detail = f" ({status})" if status else ""
|
|
return _refuse("upstream_failed", f"{provider} refused or failed the call: {type(error).__name__}{detail}")
|
|
|
|
def _page_result(provider: str, tool: str, arguments: Dict[str, Any], items: List[Any], used, upstream_next,
|
|
skip: int = 0, extra: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
|
|
"""One page of scrubbed items, cut at MAX_RESPONSE_BYTES; the token resumes exactly where the cut fell."""
|
|
remaining = [_scrub(item) for item in items[skip:]]
|
|
kept, size = [], 0
|
|
for item in remaining:
|
|
size += len(json.dumps(item, default=str))
|
|
if kept and size > MAX_RESPONSE_BYTES:
|
|
break
|
|
kept.append(item)
|
|
if len(kept) < len(remaining):
|
|
next_token = _write_page(used, skip + len(kept))
|
|
else:
|
|
next_token = _write_page(upstream_next, 0) if upstream_next else None
|
|
data = {"provider": provider, "items": kept, "count": len(kept), "next_page_token": next_token,
|
|
"collected_at": _collected_at(), "evidence_ref": _evidence_ref(tool, arguments, kept)}
|
|
data.update(extra or {})
|
|
return {"success": True, "data": data}
|
|
|
|
def _one_result(provider: str, tool: str, arguments: Dict[str, Any], metadata: Any) -> Dict[str, Any]:
|
|
clean = _scrub(metadata)
|
|
return {"success": True, "data": {"provider": provider, "metadata": clean, "collected_at": _collected_at(),
|
|
"evidence_ref": _evidence_ref(tool, arguments, clean)}}
|
|
|
|
AZURE_CLOUDS = {
|
|
"public": {"login": "https://login.microsoftonline.com", "arm": "https://management.azure.com"},
|
|
"usgov": {"login": "https://login.microsoftonline.us", "arm": "https://management.usgovcloudapi.net"},
|
|
"china": {"login": "https://login.chinacloudapi.cn", "arm": "https://management.chinacloudapi.cn"},
|
|
}
|
|
|
|
AZURE_GRAPH_VERSION = "2022-10-01"
|
|
|
|
AZURE_LOCKS_VERSION = "2020-05-01"
|
|
|
|
AZURE_TABLES = ("resources", "resourcecontainers", "policyresources", "advisorresources", "networkresources")
|
|
|
|
AZURE_TOKENS = {}
|
|
|
|
AZURE_SERVERS = {
|
|
"virtual_machines": ["microsoft.compute/virtualmachines"],
|
|
"scale_sets": ["microsoft.compute/virtualmachinescalesets"],
|
|
"disks": ["microsoft.compute/disks"],
|
|
}
|
|
|
|
AZURE_WORKLOADS = {
|
|
"app_service": ["microsoft.web/sites", "microsoft.web/serverfarms"],
|
|
"container_apps": ["microsoft.app/containerapps", "microsoft.app/managedenvironments"],
|
|
"container_instances": ["microsoft.containerinstance/containergroups"],
|
|
}
|
|
|
|
AZURE_KUBERNETES = {"clusters": ["microsoft.containerservice/managedclusters"]}
|
|
|
|
AZURE_NETWORK = {
|
|
"virtual_networks": ["microsoft.network/virtualnetworks"],
|
|
"route_tables": ["microsoft.network/routetables"],
|
|
"network_security_groups": ["microsoft.network/networksecuritygroups"],
|
|
"gateways": ["microsoft.network/virtualnetworkgateways", "microsoft.network/expressroutecircuits",
|
|
"microsoft.network/natgateways", "microsoft.network/azurefirewalls",
|
|
"microsoft.network/applicationgateways"],
|
|
"load_balancers": ["microsoft.network/loadbalancers"],
|
|
"private_endpoints": ["microsoft.network/privateendpoints"],
|
|
"public_ips": ["microsoft.network/publicipaddresses"],
|
|
}
|
|
|
|
AZURE_DATA = {
|
|
"sql": ["microsoft.sql/servers", "microsoft.sql/servers/databases"],
|
|
"cosmos_db": ["microsoft.documentdb/databaseaccounts"],
|
|
"storage_accounts": ["microsoft.storage/storageaccounts"],
|
|
"postgresql": ["microsoft.dbforpostgresql/flexibleservers", "microsoft.dbforpostgresql/servers"],
|
|
"mysql": ["microsoft.dbformysql/flexibleservers", "microsoft.dbformysql/servers"],
|
|
"redis": ["microsoft.cache/redis", "microsoft.cache/redisenterprise"],
|
|
}
|
|
|
|
AZURE_ORG_POLICIES = {
|
|
"assignments": ["microsoft.authorization/policyassignments"],
|
|
"definitions": ["microsoft.authorization/policydefinitions"],
|
|
"initiatives": ["microsoft.authorization/policysetdefinitions"],
|
|
"exemptions": ["microsoft.authorization/policyexemptions"],
|
|
"compliance": ["microsoft.policyinsights/policystates"],
|
|
}
|
|
|
|
AZURE_RESOURCE_POLICIES = {
|
|
"key_vault_access": ["microsoft.keyvault/vaults"],
|
|
"storage_network_rules": ["microsoft.storage/storageaccounts"],
|
|
}
|
|
|
|
AZURE_PILLARS = {"cost": "cost", "security": "security", "highavailability": "reliability",
|
|
"performance": "performance", "operationalexcellence": "operations"}
|
|
|
|
AZURE_RESOURCE_GROUP = r"[-\w.()]{1,90}"
|
|
|
|
def _azure_root(connection: Dict[str, Any]) -> tuple:
|
|
"""(managementGroups or subscriptions, its id, the resource group or None) from the connection's scope root."""
|
|
parts = str(connection.get("scope_root", "")).strip("/").split("/")
|
|
if len(parts) == 2 and parts[0] in ("managementGroups", "subscriptions") and parts[1]:
|
|
return parts[0], parts[1], None
|
|
if (len(parts) == 4 and parts[0] == "subscriptions" and parts[1] and parts[2].lower() == "resourcegroups"
|
|
and re.fullmatch(AZURE_RESOURCE_GROUP, parts[3]) and not parts[3].endswith(".")):
|
|
return "subscriptions", parts[1], parts[3]
|
|
raise ValueError("scope_root must be managementGroups/<id>, subscriptions/<id> or "
|
|
"subscriptions/<id>/resourceGroups/<name>")
|
|
|
|
def _azure_scope(connection: Dict[str, Any]) -> Dict[str, List[str]]:
|
|
"""The query scope: the connection's root, and nothing the caller can widen."""
|
|
kind, identifier, _ = _azure_root(connection)
|
|
return {kind: [identifier]}
|
|
|
|
def _azure_scoped_query(query: str, connection: Dict[str, Any]) -> str:
|
|
"""The query narrowed to the connection's resource group, when its scope root names one.
|
|
|
|
Resource Graph scopes by subscription or management group only, so a resource group is a filter placed straight
|
|
after the table. Rows outside any resource group (the subscription itself, subscription-wide policy assignments
|
|
and Advisor findings) still apply to the group, so they stay. A join, union or lookup could read a second table
|
|
without the filter, so a resource-group scope refuses them.
|
|
"""
|
|
_, _, group = _azure_root(connection)
|
|
if group is None:
|
|
return query
|
|
if re.search(r"\b(join|union|lookup)\b", query, re.IGNORECASE):
|
|
raise PermissionError("a resource-group scope allows no join, union or lookup")
|
|
table, bar, rest = query.partition("|")
|
|
narrowed = f"{table.strip()} | where isempty(resourceGroup) or resourceGroup =~ '{group}'"
|
|
return f"{narrowed} |{rest}" if bar else narrowed
|
|
|
|
def _azure_endpoints(connection: Dict[str, Any]) -> Dict[str, str]:
|
|
return AZURE_CLOUDS.get(str(connection.get("cloud") or "public"), AZURE_CLOUDS["public"])
|
|
|
|
def _azure_client():
|
|
return get_upstream_client("azure", lambda c: httpx.AsyncClient(timeout=100))
|
|
|
|
async def _azure_token(connection: Dict[str, Any]) -> str:
|
|
"""A token for Resource Graph: the short-lived one stored for a trial, or one signed in with the app registration."""
|
|
if connection.get("access_token"):
|
|
return str(connection["access_token"])
|
|
if not all(connection.get(f) for f in ("tenant_id", "client_id", "client_secret")):
|
|
raise ValueError("the connection needs access_token, or tenant_id, client_id and client_secret")
|
|
key = hashlib.sha256(json.dumps(connection, sort_keys=True).encode()).hexdigest()
|
|
cached = AZURE_TOKENS.get(key)
|
|
now = time.time()
|
|
if cached and cached[1] > now + 60:
|
|
return cached[0]
|
|
endpoints = _azure_endpoints(connection)
|
|
response = await _azure_client().post(
|
|
f"{endpoints['login']}/{connection['tenant_id']}/oauth2/v2.0/token",
|
|
data={"grant_type": "client_credentials", "client_id": connection["client_id"],
|
|
"client_secret": connection["client_secret"], "scope": f"{endpoints['arm']}/.default"})
|
|
response.raise_for_status()
|
|
body = response.json()
|
|
AZURE_TOKENS[key] = (body["access_token"], now + int(body.get("expires_in", 3600)))
|
|
return body["access_token"]
|
|
|
|
async def _azure_graph(query: str, top: int, skip_token: Optional[str] = None) -> Dict[str, Any]:
|
|
connection = get_connection()
|
|
options = {"$top": top, "resultFormat": "objectArray"}
|
|
if skip_token:
|
|
options["$skipToken"] = skip_token
|
|
token = await _azure_token(connection)
|
|
response = await _with_backoff(lambda: _azure_client().post(
|
|
f"{_azure_endpoints(connection)['arm']}/providers/Microsoft.ResourceGraph/resources",
|
|
params={"api-version": AZURE_GRAPH_VERSION}, headers={"Authorization": f"Bearer {token}"},
|
|
json={"query": _azure_scoped_query(query, connection), "options": options, **_azure_scope(connection)}))
|
|
response.raise_for_status()
|
|
return response.json()
|
|
|
|
async def _azure_page(tool: str, arguments: Dict[str, Any], query: str, finish=None) -> Dict[str, Any]:
|
|
try:
|
|
upstream, skip = _read_page(arguments)
|
|
except (ValueError, KeyError, TypeError):
|
|
return _refuse("invalid_page_token", "page_token isn't one this server issued")
|
|
try:
|
|
body = await _azure_graph(query, _page_size(arguments), upstream)
|
|
except PermissionError as error:
|
|
return _refuse("outside_scope", str(error))
|
|
except Exception as error:
|
|
return _upstream_failed("azure", error)
|
|
items = [finish(i) for i in body.get("data", [])] if finish else body.get("data", [])
|
|
return _page_result("azure", tool, arguments, items, upstream, body.get("$skipToken"), skip)
|
|
|
|
def _azure_type_query(table: str, types: List[str]) -> str:
|
|
listed = ", ".join(f"'{t}'" for t in types)
|
|
return f"{table} | where type in~ ({listed}) | order by id asc"
|
|
|
|
async def _azure_kind(tool: str, arguments: Dict[str, Any], kinds: Dict[str, List[str]], table: str = "Resources",
|
|
default: Optional[str] = None, finish=None) -> Dict[str, Any]:
|
|
kind = arguments.get("kind") or default or next(iter(kinds))
|
|
if kind not in kinds:
|
|
return _refuse("unknown_kind", "kind must be one of: " + ", ".join(kinds))
|
|
return await _azure_page(tool, arguments, _azure_type_query(table, kinds[kind]), finish)
|
|
|
|
def _azure_recommendation(item: Dict[str, Any]) -> Dict[str, Any]:
|
|
category = str(item.get("properties", {}).get("category", ""))
|
|
return {**item, "pillar": AZURE_PILLARS.get(category.lower(), "other"), "provider_category": category}
|
|
|
|
async def _azure_lock_subscription(arguments: Dict[str, Any]):
|
|
"""The subscription to read locks from, or None. Resource Graph, under the connection's scope, sets the boundary."""
|
|
kind, identifiers = next(iter(_azure_scope(get_connection()).items()))
|
|
wanted = arguments.get("subscription_id")
|
|
if kind == "subscriptions":
|
|
return identifiers[0] if wanted in (None, identifiers[0]) else None
|
|
if not wanted or not re.fullmatch(r"[A-Za-z0-9\-]+", str(wanted)):
|
|
return None
|
|
query = f"ResourceContainers | where type =~ 'microsoft.resources/subscriptions' and subscriptionId =~ '{wanted}'"
|
|
return wanted if (await _azure_graph(query, 1)).get("data") else None
|
|
|
|
async def _azure_locks(tool: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Resource locks, from ARM: Resource Graph doesn't hold them, and answers 0 whether or not any exist."""
|
|
try:
|
|
upstream, skip = _read_page(arguments)
|
|
except (ValueError, KeyError, TypeError):
|
|
return _refuse("invalid_page_token", "page_token isn't one this server issued")
|
|
connection = get_connection()
|
|
try:
|
|
subscription = await _azure_lock_subscription(arguments)
|
|
if not subscription:
|
|
return _refuse("outside_scope", "subscription_id must name a subscription under this connection's scope")
|
|
group = _azure_root(connection)[2]
|
|
within = f"/resourceGroups/{group}" if group else ""
|
|
base = f"{_azure_endpoints(connection)['arm']}/subscriptions/{subscription}{within}/providers/Microsoft.Authorization/locks"
|
|
# A page token carries ARM's next link, and the bearer token goes wherever it points, so it must stay here.
|
|
url = upstream or f"{base}?api-version={AZURE_LOCKS_VERSION}"
|
|
if not url.startswith(f"{base}?"):
|
|
return _refuse("invalid_page_token", "page_token isn't one this server issued")
|
|
token = await _azure_token(connection)
|
|
response = await _with_backoff(lambda: _azure_client().get(url, headers={"Authorization": f"Bearer {token}"}))
|
|
response.raise_for_status()
|
|
body = response.json()
|
|
except Exception as error:
|
|
return _upstream_failed("azure", error)
|
|
return _page_result("azure", tool, arguments, body.get("value", []), upstream, body.get("nextLink"), skip,
|
|
{"subscription_id": subscription, "kind": "resource_locks"})
|
|
|
|
KNOWLEDGE_SERVERS = {
|
|
"azure": {"url": "https://learn.microsoft.com/api/mcp", "tool": "microsoft_docs_search",
|
|
"framework": "Azure Well-Architected Framework"},
|
|
"aws": {"url": "https://aws-mcp.eu-west-1.api.aws/mcp", "tool": "aws___search_documentation",
|
|
"framework": "AWS Well-Architected Framework"},
|
|
"gcp": {"url": "https://developerknowledge.googleapis.com/mcp", "tool": "search_documents",
|
|
"framework": "Google Cloud Well-Architected Framework"},
|
|
}
|
|
|
|
KNOWLEDGE_PILLARS = ("reliability", "security", "cost", "operations", "performance", "sustainability")
|
|
|
|
KNOWLEDGE_TOPICS = (
|
|
"landing zone", "resource organization", "identity and access", "network segmentation", "hybrid connectivity",
|
|
"encryption", "logging and monitoring", "backup and recovery", "disaster recovery", "high availability",
|
|
"scaling", "kubernetes", "containers", "virtual machines", "databases", "storage", "serverless", "governance",
|
|
"policy enforcement", "tagging", "cost allocation", "migration", "incident response", "patching",
|
|
)
|
|
|
|
KNOWLEDGE_MAX_TEXT = 4000
|
|
|
|
def _knowledge_client():
|
|
return get_upstream_client("knowledge", lambda c: httpx.AsyncClient(timeout=60, follow_redirects=False))
|
|
|
|
def _knowledge_message(response) -> Dict[str, Any]:
|
|
"""The JSON-RPC reply, whether it came back as JSON or as a server-sent event."""
|
|
if "text/event-stream" in response.headers.get("content-type", ""):
|
|
lines = [line[5:].strip() for line in response.text.splitlines() if line.startswith("data:")]
|
|
return json.loads(lines[-1]) if lines else {}
|
|
return response.json()
|
|
|
|
async def _knowledge_post(provider: str, connection: Dict[str, Any], body: Dict[str, Any],
|
|
session: Optional[str] = None, auth: Optional[Dict[str, str]] = None):
|
|
"""auth: headers a discovery server supplies from its own connection (gcp-discovery's OAuth token), used in
|
|
place of the stored API key."""
|
|
url = KNOWLEDGE_SERVERS[provider]["url"]
|
|
headers = {"Accept": "application/json, text/event-stream", "Content-Type": "application/json"}
|
|
if session:
|
|
headers["Mcp-Session-Id"] = session
|
|
if auth:
|
|
headers.update(auth)
|
|
elif provider == "gcp":
|
|
headers["X-Goog-Api-Key"] = connection.get("google_api_key", "")
|
|
content = json.dumps(body)
|
|
if provider == "aws":
|
|
import boto3
|
|
from botocore.auth import SigV4Auth
|
|
from botocore.awsrequest import AWSRequest
|
|
|
|
def sign():
|
|
credentials = boto3.Session(aws_access_key_id=connection.get("aws_access_key_id"),
|
|
aws_secret_access_key=connection.get("aws_secret_access_key")).get_credentials()
|
|
request = AWSRequest(method="POST", url=url, data=content, headers=headers)
|
|
SigV4Auth(credentials, "aws-mcp", "eu-west-1").add_auth(request)
|
|
return dict(request.headers)
|
|
|
|
headers = await asyncio.to_thread(sign)
|
|
response = await _with_backoff(lambda: _knowledge_client().post(url, content=content, headers=headers))
|
|
response.raise_for_status()
|
|
return response
|
|
|
|
async def _knowledge_session(provider: str, connection: Dict[str, Any], auth: Optional[Dict[str, str]] = None) -> Optional[str]:
|
|
response = await _knowledge_post(provider, connection, {
|
|
"jsonrpc": "2.0", "id": 1, "method": "initialize",
|
|
"params": {"protocolVersion": "2025-06-18", "capabilities": {},
|
|
"clientInfo": {"name": "kab-cp1-discovery", "version": "0.1.0"}}}, auth=auth)
|
|
return response.headers.get("mcp-session-id")
|
|
|
|
async def _knowledge_tools(provider: str, connection: Dict[str, Any], session: Optional[str] = None,
|
|
auth: Optional[Dict[str, str]] = None) -> List[Dict[str, Any]]:
|
|
session = session or await _knowledge_session(provider, connection, auth)
|
|
response = await _knowledge_post(provider, connection, {"jsonrpc": "2.0", "id": 2, "method": "tools/list"}, session, auth)
|
|
return _knowledge_message(response).get("result", {}).get("tools", [])
|
|
|
|
def _knowledge_argument(tool: Dict[str, Any]) -> str:
|
|
"""The search tool's query argument. Vendors name it differently and may change it, so it's read from the tool."""
|
|
schema = tool.get("inputSchema", {})
|
|
properties = schema.get("properties", {})
|
|
for name in list(schema.get("required", [])) + list(properties):
|
|
if properties.get(name, {}).get("type") == "string":
|
|
return name
|
|
return "query"
|
|
|
|
async def _knowledge_search(provider: str, connection: Dict[str, Any], query: str,
|
|
auth: Optional[Dict[str, str]] = None) -> List[Dict[str, Any]]:
|
|
session = await _knowledge_session(provider, connection, auth)
|
|
name = KNOWLEDGE_SERVERS[provider]["tool"]
|
|
tools = {t.get("name"): t for t in await _knowledge_tools(provider, connection, session, auth)}
|
|
if name not in tools:
|
|
raise LookupError(f"{provider} no longer offers {name}")
|
|
response = await _knowledge_post(provider, connection, {
|
|
"jsonrpc": "2.0", "id": 3, "method": "tools/call",
|
|
"params": {"name": name, "arguments": {_knowledge_argument(tools[name]): query}}}, session, auth)
|
|
message = _knowledge_message(response)
|
|
results = []
|
|
for part in message.get("result", {}).get("content", []):
|
|
if part.get("type") != "text":
|
|
continue
|
|
try:
|
|
parsed = json.loads(part["text"])
|
|
except ValueError:
|
|
parsed = {"content": part["text"]}
|
|
found = parsed.get("results", parsed) if isinstance(parsed, dict) else parsed
|
|
for item in found if isinstance(found, list) else [found]:
|
|
if isinstance(item, dict):
|
|
results.append({"title": item.get("title"), "url": item.get("contentUrl") or item.get("url"),
|
|
"text": str(item.get("content") or item.get("text") or "")[:KNOWLEDGE_MAX_TEXT]})
|
|
return results
|
|
|
|
async def _knowledge_tool(provider: str, tool: str, arguments: Dict[str, Any], connection: Dict[str, Any],
|
|
auth: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
|
|
"""One provider's `<provider>_search_well_architected` tool: fixed pillar and topic in, guidance excerpts out."""
|
|
pillar, topic = arguments.get("pillar"), arguments.get("topic")
|
|
if pillar not in KNOWLEDGE_PILLARS:
|
|
return _refuse("invalid_argument", "pillar must be one of: " + ", ".join(KNOWLEDGE_PILLARS))
|
|
if topic not in KNOWLEDGE_TOPICS:
|
|
return _refuse("invalid_argument", "topic must be one of: " + ", ".join(KNOWLEDGE_TOPICS))
|
|
query = f"{KNOWLEDGE_SERVERS[provider]['framework']} {pillar} {topic}"
|
|
try:
|
|
results = await _knowledge_search(provider, connection, query, auth)
|
|
except Exception as error:
|
|
return _upstream_failed(provider, error)
|
|
return {"success": True, "data": {"provider": provider, "pillar": pillar, "topic": topic, "results": results,
|
|
"collected_at": _collected_at(), "evidence_ref": _evidence_ref(tool, arguments, results)}}
|
|
|
|
async def azure_check_connection(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
try:
|
|
group = _azure_root(get_connection())[2]
|
|
query = "ResourceContainers | where type =~ 'microsoft.resources/subscriptions/resourcegroups' | summarize count()" if group else "ResourceContainers | summarize count()"
|
|
body = await _azure_graph(query, 1)
|
|
except Exception as error:
|
|
return {"ok": False, "message": _upstream_failed("azure", error)["error"]["message"]}
|
|
if group and not any(int(v or 0) for row in body.get("data", []) for v in row.values()):
|
|
return {"ok": False, "message": "Signed in, but the resource group in the scope root was not found or is not readable."}
|
|
return {"ok": True, "message": "Signed in and read the scope root."}
|
|
|
|
async def azure_list_accounts(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
kinds = {"subscriptions": ["microsoft.resources/subscriptions"], "management_groups": ["microsoft.management/managementgroups"], "resource_groups": ["microsoft.resources/subscriptions/resourcegroups"]}
|
|
return await _azure_kind("azure_list_accounts", arguments, kinds, "ResourceContainers", "subscriptions")
|
|
|
|
async def azure_list_resources(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
kind = arguments.get("resource_type")
|
|
if kind and not re.fullmatch(r"[A-Za-z0-9./]+", str(kind)):
|
|
return _refuse("invalid_argument", "resource_type must be an ARM type")
|
|
where = f" | where type =~ '{kind}'" if kind else ""
|
|
return await _azure_page("azure_list_resources", arguments, f"Resources{where} | project id, name, type, location, resourceGroup, subscriptionId, tags | order by id asc")
|
|
|
|
async def azure_query_resources(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
query = str(arguments.get("query") or "").strip()
|
|
if not query or len(query) > 4000:
|
|
return _refuse("invalid_argument", "query is required, up to 4000 characters")
|
|
if query.split("|")[0].strip().lower() not in AZURE_TABLES:
|
|
return _refuse("invalid_argument", "query must start with one of: " + ", ".join(AZURE_TABLES))
|
|
return await _azure_page("azure_query_resources", arguments, query)
|
|
|
|
async def azure_get_resource_metadata(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
resource_id = str(arguments.get("resource_id") or "")
|
|
if not re.fullmatch(r"/subscriptions/[A-Za-z0-9\-]+(/[A-Za-z0-9._()\-]+)+", resource_id):
|
|
return _refuse("invalid_argument", "resource_id must be a full ARM resource id")
|
|
try:
|
|
body = await _azure_graph(f"Resources | where id =~ '{resource_id}'", 1)
|
|
except Exception as error:
|
|
return _upstream_failed("azure", error)
|
|
if not body.get("data"):
|
|
return _refuse("outside_scope", "no such resource inside this connection's scope")
|
|
return _one_result("azure", "azure_get_resource_metadata", arguments, body["data"][0])
|
|
|
|
async def azure_list_servers(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
return await _azure_kind("azure_list_servers", arguments, AZURE_SERVERS)
|
|
|
|
async def azure_list_workloads(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
return await _azure_kind("azure_list_workloads", arguments, AZURE_WORKLOADS)
|
|
|
|
async def azure_list_kubernetes_clusters(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
return await _azure_kind("azure_list_kubernetes_clusters", arguments, AZURE_KUBERNETES)
|
|
|
|
async def azure_get_network_topology(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
return await _azure_kind("azure_get_network_topology", arguments, AZURE_NETWORK)
|
|
|
|
async def azure_list_data_stores(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
return await _azure_kind("azure_list_data_stores", arguments, AZURE_DATA)
|
|
|
|
async def azure_list_organization_policies(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
return await _azure_kind("azure_list_organization_policies", arguments, AZURE_ORG_POLICIES, "PolicyResources", "assignments")
|
|
|
|
async def azure_list_resource_policies(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
if arguments.get("kind") == "resource_locks":
|
|
return await _azure_locks("azure_list_resource_policies", arguments)
|
|
return await _azure_kind("azure_list_resource_policies", arguments, AZURE_RESOURCE_POLICIES)
|
|
|
|
async def azure_list_recommendations(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
query = "AdvisorResources | where type =~ 'microsoft.advisor/recommendations' | order by id asc"
|
|
return await _azure_page("azure_list_recommendations", arguments, query, _azure_recommendation)
|
|
|
|
async def azure_search_well_architected(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
return await _knowledge_tool("azure", "azure_search_well_architected", arguments, {}, None)
|
|
|
|
async def verify_connection(arguments: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Check that the connection sent with this request works against the upstream. Makes no change."""
|
|
connection = get_connection()
|
|
if not connection:
|
|
return {"ok": False, "message": "No connection was sent with this request."}
|
|
missing = mcp_connection.missing_fields(connection, CONNECTION_SCHEMA)
|
|
if missing:
|
|
return {"ok": False, "message": "The connection is missing: " + ", ".join(missing)}
|
|
|
|
return await azure_check_connection(arguments)
|
|
|
|
|
|
# Tool function registry
|
|
TOOL_FUNCTIONS = {
|
|
'azure_check_connection': azure_check_connection,
|
|
'azure_list_accounts': azure_list_accounts,
|
|
'azure_list_resources': azure_list_resources,
|
|
'azure_query_resources': azure_query_resources,
|
|
'azure_get_resource_metadata': azure_get_resource_metadata,
|
|
'azure_list_servers': azure_list_servers,
|
|
'azure_list_workloads': azure_list_workloads,
|
|
'azure_list_kubernetes_clusters': azure_list_kubernetes_clusters,
|
|
'azure_get_network_topology': azure_get_network_topology,
|
|
'azure_list_data_stores': azure_list_data_stores,
|
|
'azure_list_organization_policies': azure_list_organization_policies,
|
|
'azure_list_resource_policies': azure_list_resource_policies,
|
|
'azure_list_recommendations': azure_list_recommendations,
|
|
'azure_search_well_architected': azure_search_well_architected,
|
|
'verify_connection': verify_connection,
|
|
}
|
|
|
|
# ============================================
|
|
# Resource Implementations
|
|
# ============================================
|
|
|
|
|
|
# Resource read handlers by uri
|
|
RESOURCE_HANDLERS = {
|
|
|
|
}
|
|
|
|
# ============================================
|
|
# FastAPI Application
|
|
# ============================================
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
"""Application lifespan manager"""
|
|
logger.info(
|
|
"server_starting",
|
|
port=config.SERVER_PORT,
|
|
auth_required=config.REQUIRE_AUTH,
|
|
tools=len(TOOLS_REGISTRY),
|
|
resources=len(RESOURCES_REGISTRY),
|
|
prompts=len(PROMPTS_REGISTRY),
|
|
template_version=TEMPLATE_VERSION,
|
|
)
|
|
|
|
# Validate configuration
|
|
if config.REQUIRE_AUTH and not config.MCP_REGISTRATION_API_KEY:
|
|
logger.error(
|
|
"registration_key_not_set",
|
|
hint="Set MCP_REGISTRATION_API_KEY before starting the server",
|
|
)
|
|
|
|
yield
|
|
|
|
await _close_all_clients()
|
|
logger.info("server_stopping")
|
|
|
|
app = FastAPI(
|
|
title=config.SERVER_NAME,
|
|
version=config.SERVER_VERSION,
|
|
description="Read-only discovery of a customer's Azure estate - servers, workloads, Kubernetes clusters, networks, data stores, policies and Advisor findings - through Azure Resource Graph.",
|
|
lifespan=lifespan
|
|
)
|
|
|
|
|
|
# FastAPI's default answer to an invalid request repeats it, and the request can carry the tenant's connection
|
|
mcp_connection.install_invalid_request_handler(
|
|
app, lambda fields: logger.warning("invalid_request", fields=sanitize_log(fields))
|
|
)
|
|
|
|
# ============================================
|
|
# Health Check Endpoint
|
|
# ============================================
|
|
|
|
@app.get("/health")
|
|
async def health_check():
|
|
"""
|
|
Health check endpoint (no authentication required).
|
|
|
|
Used by:
|
|
- MCP Gateway health monitoring
|
|
- Kubernetes liveness/readiness probes
|
|
- Load balancers
|
|
"""
|
|
# Answers without a key, so it says only what a probe needs: not how authentication is set up
|
|
return {
|
|
"status": "healthy" if config.MCP_REGISTRATION_API_KEY else "degraded",
|
|
"server_id": config.SERVER_ID,
|
|
"server_name": config.SERVER_NAME,
|
|
"version": config.SERVER_VERSION,
|
|
"timestamp": datetime.now(timezone.utc).isoformat(),
|
|
}
|
|
|
|
# ============================================
|
|
# MCP Authentication Info Endpoint
|
|
# ============================================
|
|
|
|
@app.get("/.well-known/mcp-auth")
|
|
async def mcp_auth_info():
|
|
"""
|
|
MCP Authentication Information Endpoint (PUBLIC - no auth required).
|
|
|
|
Exposes authentication requirements for Gateway registration.
|
|
"""
|
|
return {
|
|
"auth_required": config.REQUIRE_AUTH,
|
|
"auth_type": "bearer",
|
|
"description": "Include 'Authorization: Bearer <MCP_REGISTRATION_API_KEY>' header",
|
|
"env_var": "MCP_REGISTRATION_API_KEY"
|
|
}
|
|
|
|
# ============================================
|
|
# MCP Protocol /messages Endpoint
|
|
# ============================================
|
|
|
|
class _MethodNotFound(Exception):
|
|
"""The JSON-RPC method is not one this server answers."""
|
|
|
|
|
|
async def dispatch_mcp_request(request: MCPRequest) -> MCPResponse:
|
|
"""Run one JSON-RPC request; every outcome, errors included, is an MCPResponse."""
|
|
# The tenant's connection, bound for this request only so tools reach the right account
|
|
connection_token = mcp_connection.bind(mcp_connection.from_params(request.params))
|
|
try:
|
|
if CONNECTION_SCHEMA is not None and request.method in CONNECTION_METHODS:
|
|
check_connection(mcp_connection.active())
|
|
|
|
if request.method == "initialize":
|
|
result = {
|
|
"protocolVersion": "1.0.0",
|
|
"serverInfo": {
|
|
"name": config.SERVER_NAME,
|
|
"version": config.SERVER_VERSION,
|
|
"server_id": config.SERVER_ID
|
|
},
|
|
"capabilities": {
|
|
"tools": True,
|
|
"resources": False,
|
|
"prompts": False
|
|
},
|
|
"authentication": {
|
|
"type": "bearer",
|
|
"description": "Requires MCP_REGISTRATION_API_KEY in Authorization header"
|
|
}
|
|
}
|
|
if CONNECTION_SCHEMA is not None:
|
|
result["_meta"] = mcp_connection.schema_meta(CONNECTION_SCHEMA, verify_tool=VERIFY_TOOL)
|
|
return MCPResponse(id=request.id, result=result)
|
|
|
|
elif request.method == "tools/list":
|
|
return MCPResponse(id=request.id, result={"tools": TOOLS_REGISTRY})
|
|
|
|
elif request.method == "tools/call":
|
|
tool_name = request.params.get("name")
|
|
arguments = request.params.get("arguments")
|
|
if arguments is None:
|
|
arguments = {}
|
|
|
|
if not tool_name:
|
|
raise ValueError("Missing 'name' in params")
|
|
if not isinstance(tool_name, str):
|
|
raise ValueError("'name' must be a string")
|
|
if not isinstance(arguments, dict):
|
|
raise ValueError("'arguments' must be an object")
|
|
|
|
structlog.contextvars.bind_contextvars(tool=sanitize_log(tool_name))
|
|
tool_func = TOOL_FUNCTIONS.get(tool_name)
|
|
if not tool_func:
|
|
raise ValueError(f"Unknown tool: {tool_name}")
|
|
|
|
result = await tool_func(arguments)
|
|
if isinstance(result, dict) and result.get("success") is False and isinstance(result.get("error"), str):
|
|
# A failed call's message often quotes the upstream URL, which may carry a key
|
|
result = {**result, "error": mcp_connection.scrub(result["error"])}
|
|
|
|
reply = {
|
|
"content": [
|
|
{
|
|
"type": "text",
|
|
"text": json.dumps(result) if isinstance(result, dict) else str(result)
|
|
}
|
|
]
|
|
}
|
|
if isinstance(result, dict) and result.get("success") is False:
|
|
# A tool that reports failure is an error to the caller too (MCP: isError), not a normal result
|
|
reply["isError"] = True
|
|
return MCPResponse(id=request.id, result=reply)
|
|
|
|
elif request.method == "resources/list":
|
|
return MCPResponse(id=request.id, result={"resources": RESOURCES_REGISTRY})
|
|
|
|
elif request.method == "resources/read":
|
|
uri = request.params.get("uri")
|
|
if not uri:
|
|
raise ValueError("Missing 'uri' in params")
|
|
structlog.contextvars.bind_contextvars(resource=sanitize_log(uri))
|
|
handler = RESOURCE_HANDLERS.get(uri)
|
|
if not handler:
|
|
raise ValueError(f"Unknown resource: {uri}")
|
|
content = await handler(uri)
|
|
mime_type = next((r["mimeType"] for r in RESOURCES_REGISTRY if r["uri"] == uri), "text/plain")
|
|
text = content if isinstance(content, str) else json.dumps(content)
|
|
return MCPResponse(id=request.id, result={
|
|
"contents": [{"uri": uri, "mimeType": mime_type, "text": text}]
|
|
})
|
|
|
|
elif request.method == "prompts/list":
|
|
return MCPResponse(id=request.id, result={"prompts": PROMPTS_REGISTRY})
|
|
|
|
elif request.method == "prompts/get":
|
|
prompt_name = request.params.get("name")
|
|
prompt = PROMPT_TEMPLATES.get(prompt_name) if isinstance(prompt_name, str) else None
|
|
if prompt is None:
|
|
raise ValueError(f"Unknown prompt: {prompt_name}")
|
|
structlog.contextvars.bind_contextvars(prompt=sanitize_log(prompt_name))
|
|
supplied = request.params.get("arguments") or {}
|
|
values = {a["name"]: a["default"] for a in prompt["arguments"] if a["default"] is not None}
|
|
values.update(supplied)
|
|
missing = [a["name"] for a in prompt["arguments"] if a["required"] and a["name"] not in values]
|
|
if missing:
|
|
raise ValueError("Missing prompt argument(s): " + ", ".join(missing))
|
|
return MCPResponse(id=request.id, result={
|
|
"description": prompt["description"],
|
|
"messages": [{
|
|
"role": "user",
|
|
"content": {"type": "text", "text": render_prompt(prompt["template"], values)},
|
|
}],
|
|
})
|
|
|
|
else:
|
|
raise _MethodNotFound(f"Unknown method: {request.method}")
|
|
|
|
except _MethodNotFound as e:
|
|
logger.warning("mcp_method_not_found", error=sanitize_log(mcp_connection.redact(e)))
|
|
return MCPResponse(id=request.id, error={"code": -32601, "message": mcp_connection.redact(e)})
|
|
except NotImplementedError as e:
|
|
message = mcp_connection.redact(e)
|
|
logger.warning("tool_not_implemented", error=sanitize_log(message))
|
|
return MCPResponse(id=request.id, error={"code": -32601, "message": message})
|
|
except ValueError as e:
|
|
message = mcp_connection.redact(e)
|
|
logger.warning("mcp_client_error", error=sanitize_log(message))
|
|
return MCPResponse(id=request.id, error={"code": -32602, "message": message})
|
|
except Exception as e:
|
|
# The message of an unexpected error is not shown to the caller and is redacted before it is logged;
|
|
# a tool may have put the connection's credential in it.
|
|
logger.error(
|
|
"mcp_unexpected_error",
|
|
error_type=type(e).__name__,
|
|
error=sanitize_log(mcp_connection.redact(e)),
|
|
traceback=sanitize_log(mcp_connection.redact(traceback.format_exc())),
|
|
)
|
|
return MCPResponse(id=request.id, error={"code": -32603, "message": "Internal server error"})
|
|
finally:
|
|
mcp_connection.unbind(connection_token)
|
|
|
|
|
|
@app.post("/messages")
|
|
async def handle_mcp_message(
|
|
request: MCPRequest,
|
|
http_request: Request,
|
|
authenticated: bool = Depends(verify_mcp_registration_key)
|
|
) -> MCPResponse:
|
|
"""
|
|
MCP protocol message handler (JSON-RPC 2.0 over HTTP).
|
|
|
|
This is the STANDARD MCP endpoint for Gateway integration.
|
|
Requires Bearer token authentication (MCP_REGISTRATION_API_KEY).
|
|
|
|
Supported Methods:
|
|
- initialize: Protocol handshake and capability exchange
|
|
- tools/list: Discover available tools
|
|
- tools/call: Execute a specific tool
|
|
- resources/list: List available resources
|
|
- prompts/list: List available prompts
|
|
"""
|
|
started = time.monotonic()
|
|
structlog.contextvars.clear_contextvars()
|
|
structlog.contextvars.bind_contextvars(
|
|
request_id=sanitize_log(http_request.headers.get("x-request-id") or str(request.id)),
|
|
method=sanitize_log(request.method),
|
|
)
|
|
try:
|
|
response = await dispatch_mcp_request(request)
|
|
completed = {}
|
|
if CONNECTION_SCHEMA is not None and request.method in CONNECTION_METHODS:
|
|
# Which connection served the call: a short id, never the credential
|
|
completed["connection"] = mcp_connection.fingerprint(mcp_connection.from_params(request.params))
|
|
logger.info(
|
|
"mcp_request_completed",
|
|
outcome="error" if response.error else ("tool_error" if (response.result or {}).get("isError") else "ok"),
|
|
error_code=(response.error or {}).get("code"),
|
|
duration_ms=round((time.monotonic() - started) * 1000, 1),
|
|
**completed,
|
|
)
|
|
return response
|
|
finally:
|
|
structlog.contextvars.clear_contextvars()
|
|
|
|
# ============================================
|
|
# Entry Point
|
|
# ============================================
|
|
|
|
if __name__ == "__main__":
|
|
import uvicorn
|
|
uvicorn.run(
|
|
"server:app",
|
|
host="0.0.0.0",
|
|
port=config.SERVER_PORT,
|
|
log_level=logging.getLevelName(getattr(logging, config.LOG_LEVEL, logging.INFO)).lower(),
|
|
log_config=None, # configure_logging() owns the format
|
|
access_log=True,
|
|
reload=False # Set to True for development
|
|
)
|