Some checks failed
check agents / check (push) Failing after 12s
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>
130 lines
6.1 KiB
Python
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())
|