#!/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. 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()) 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 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())