Files
cp1-agents/scripts/render_mcp_server.py
Jonathan Boniface c14a94f33b
Some checks failed
check agents / check (push) Failing after 12s
Add hyperscaler discovery MCP servers and Well-Architected guidance
azure-discovery, aws-discovery and gcp-discovery collect read-only metadata
on servers, workloads, Kubernetes clusters, networks, data stores, policies
and provider recommendations. Credentials arrive per call from the vault.
Replies are paged, scrubbed of secrets and anonymised, and throttled calls
back off. cloud-knowledge searches each provider's Well-Architected guidance
from fixed lists only, so no customer detail can leave the platform.

Adds shared skills, the render and test tooling, a public Python Dockerfile
until the hardened base image is reachable, the customer access guide, the
implementation plan and the Vault Service platform issue.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 20:11:57 +00:00

130 lines
6.1 KiB
Python

#!/usr/bin/env python3
"""Render an MCP server definition through the platform's MCP Server Builder.
Runs the builder's own code -- MCPServerService._generate_code_files over the template in
packages/mcp-server-template -- the way packages/agent-builder-api/scripts/render_mcp_reference.py renders
the reference server, so the output is what the wizard would produce from the same definition.
A definition may also carry three things the builder has no field for:
shared_code files, relative to the definition, placed ahead of the first tool's code. The rendered image
holds only the template's files, so code several servers share is inlined rather than imported.
verify_tool the tool that really tests a connection. The builder reserves verify_connection and generates
a stub that always fails, to be finished by hand; this finishes it.
extra_requirements packages added to the template's requirements.txt, each pinned to an exact version.
The builder silently falls back to a NotImplementedError stub for a tool whose code it rejects. This script
refuses to write anything when that happens, and prints why each tool was rejected.
Usage (needs pydantic, pyyaml, httpx and pymongo for bson):
python3 scripts/render_mcp_server.py mcp-servers/alz-discovery-sample.server.yaml \
--out mcp-servers/alz-discovery-sample \
--platform ~/platform-engineering/kyndryl-agent-builder/modernization-platform
"""
from __future__ import annotations
import argparse
import logging
import sys
import types
from datetime import datetime
from pathlib import Path
import yaml
def load_builder(platform: Path):
api = platform / "packages" / "agent-builder-api"
if not (api / "src" / "services" / "mcp_server_service.py").exists():
raise SystemExit(f"{api} is not the agent-builder-api package")
sys.path.insert(0, str(api))
# The service imports the database client at module level; rendering never touches it.
stub = types.ModuleType("src.database.mongodb_client")
stub.get_mongodb_client = lambda *a, **k: None
sys.modules.setdefault("src.database.mongodb_client", stub)
from src.models import mcp_server_schemas as schemas
from src.services.mcp_server_service import MCPServerService
return schemas, MCPServerService
def build_server(schemas, data: dict):
now = datetime(2026, 1, 1) # fixed, so rendering twice gives the same files
tools = []
for tool in data["tools"]:
parameters = [schemas.ToolParameter(**p) for p in tool.get("parameters", [])]
tools.append(schemas.MCPToolResponse(
id=f"id-{tool['name']}", name=tool["name"], display_name=tool["display_name"],
description=" ".join(str(tool["description"]).split()), parameters=parameters,
parameters_schema=schemas.ToolParameterSchema.from_parameters(parameters), return_type="object",
implementation_notes=tool.get("implementation_notes"), ai_implementation=tool.get("ai_implementation"),
created_at=now, updated_at=now,
))
return schemas.MCPServerResponse(
id=data["server_id"], server_id=data["server_id"], name=data["name"],
description=" ".join(str(data["description"]).split()), version=data["version"], port=data["port"],
connection_fields=[schemas.ConnectionField(**f) for f in data.get("connection_fields", [])],
tools=tools, created_by="code_generated", created_at=now, updated_at=now,
)
class _Rejections(logging.Handler):
def __init__(self):
super().__init__(logging.WARNING)
self.messages = []
def emit(self, record):
message = record.getMessage()
if "not used" in message:
self.messages.append(message)
def main(argv=None) -> int:
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("definition", type=Path)
parser.add_argument("--out", type=Path, required=True, help="folder to write the server into")
parser.add_argument("--platform", type=Path, required=True, help="the modernization-platform checkout")
args = parser.parse_args(argv)
schemas, service = load_builder(args.platform.expanduser())
data = yaml.safe_load(args.definition.read_text())
shared = "\n\n\n".join((args.definition.parent / path).read_text() for path in data.get("shared_code", []))
if shared:
data["tools"][0]["ai_implementation"] = f"{shared}\n\n\n{data['tools'][0]['ai_implementation']}"
rejections = _Rejections()
logging.getLogger().addHandler(rejections)
files = service()._generate_code_files(build_server(schemas, data)).all_files()
stubbed = [t["name"] for t in data["tools"] if f"Tool '{t['name']}' needs implementation" in files["server.py"]
or f"async def {t['name']}(" not in files["server.py"]]
if rejections.messages or stubbed:
for message in rejections.messages:
print(f"rejected: {message}", file=sys.stderr)
print(f"not rendered from the definition: {stubbed or 'see above'}; nothing written", file=sys.stderr)
return 1
verify_tool = data.get("verify_tool")
if verify_tool:
start = files["server.py"].index(" # TODO: check the connection against the upstream")
end = files["server.py"].index('Implement verify_connection in server.py."', start)
end = files["server.py"].index(" }\n", end) + len(" }\n")
files["server.py"] = files["server.py"][:start] + f" return await {verify_tool}(arguments)\n" + files["server.py"][end:]
extra = data.get("extra_requirements", [])
if extra:
files["requirements.txt"] = files["requirements.txt"].rstrip() + "\n\n# Added by this server's definition\n" \
+ "\n".join(extra) + "\n"
for path, content in files.items():
target = args.out / path
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text(content)
print(f"Wrote {len(files)} files to {args.out} ({len(data['tools'])} tools)")
return 0
if __name__ == "__main__":
raise SystemExit(main())