| """Write the notebooks with empty outputs and minimal metadata.""" |
| import pathlib |
| import nbformat as nbf |
|
|
| ROOT = pathlib.Path(__file__).resolve().parent.parent / "notebooks" |
| HEAD = ("> Made by an AI agent (markedet). Educational examples, as is, no warranties. MIT License.\n" |
| "> Uses only free official endpoints or code that runs on your own machine. No API keys needed.\n") |
|
|
| NB = {} |
|
|
| NB["01_query_the_mcp_registry"] = [ |
| ("md", "# 01 Query the Official MCP Registry\n\n" + HEAD + "\nThe Official MCP Registry has a public read API. " |
| "This notebook fetches one small page and counts transports. Please keep requests small and slow."), |
| ("code", """import json, urllib.request, collections |
| API = "https://registry.modelcontextprotocol.io/v0/servers?limit=20" |
| req = urllib.request.Request(API, headers={"User-Agent": "notebook-example/0.1"}) |
| with urllib.request.urlopen(req, timeout=30) as r: |
| page = json.load(r) |
| servers = [item["server"] for item in page["servers"]] |
| print(len(servers), "entries on this page")"""), |
| ("code", """transports = collections.Counter(rem.get("type") for s in servers for rem in s.get("remotes", [])) |
| packages = collections.Counter(p.get("registryType") for s in servers for p in s.get("packages", [])) |
| print("remote transports:", dict(transports)) |
| print("package types:", dict(packages))"""), |
| ("md", "Next page: pass `cursor=<metadata.nextCursor>` in the query string. Wait between requests."), |
| ] |
|
|
| NB["02_validate_a_server_json"] = [ |
| ("md", "# 02 Build a server.json and check it with the official validator\n\n" + HEAD + |
| "\nThe registry offers `POST /v0/validate`. Its answer is shown as is; a result from the validator " |
| "is not a review of your server."), |
| ("code", """import json, urllib.request |
| server_json = { |
| "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json", |
| "name": "com.example/weather-demo", |
| "description": "Example server used in a tutorial.", |
| "version": "0.1.0", |
| "remotes": [{"type": "streamable-http", "url": "https://example.com/mcp"}], |
| } |
| assert len(server_json["description"]) <= 100 |
| print(json.dumps(server_json, indent=2))"""), |
| ("code", """req = urllib.request.Request("https://registry.modelcontextprotocol.io/v0/validate", |
| data=json.dumps(server_json).encode(), method="POST", |
| headers={"Content-Type": "application/json", "User-Agent": "notebook-example/0.1"}) |
| try: |
| with urllib.request.urlopen(req, timeout=30) as r: |
| answer = json.load(r) |
| except urllib.error.HTTPError as e: |
| answer = json.loads(e.read() or b"{}") |
| print(answer)"""), |
| ] |
|
|
| NB["03_a_local_mcp_server"] = [ |
| ("md", "# 03 A tiny MCP server on your own machine\n\n" + HEAD + |
| "\nDefines two tools with the official Python SDK and calls them in-process. Nothing leaves your machine."), |
| ("code", """# Python SDK: pip install mcp |
| from mcp.server.mcpserver import MCPServer |
| |
| demo = MCPServer(name="notebook-demo") |
| |
| @demo.tool(description="Add two integers.") |
| def add(a: int, b: int) -> int: |
| return a + b |
| |
| @demo.tool(description="Return the text in upper case.") |
| def shout(text: str) -> str: |
| return text.upper() |
| |
| tools = await demo.list_tools() # notebooks allow top-level await |
| print([t.name for t in tools])"""), |
| ("code", """result = await demo.call_tool("add", {"a": 2, "b": 3}) |
| print(result)"""), |
| ("md", "To serve it over HTTP: `demo.streamable_http_app()` with uvicorn, bound to 127.0.0.1 while testing."), |
| ] |
|
|
| NB["04_build_an_a2a_agent_card"] = [ |
| ("md", "# 04 Build an A2A agent card\n\n" + HEAD + |
| "\nBuilds a minimal agent card in the A2A 0.3.0 layout and checks the required fields locally. " |
| "A2A 1.0 changed parts of the card; check the current spec before you publish one."), |
| ("code", """import json |
| card = { |
| "protocolVersion": "0.3.0", |
| "name": "Example Agent", |
| "description": "Answers questions about a demo catalogue.", |
| "url": "https://example.com/a2a", |
| "version": "0.1.0", |
| "capabilities": {"streaming": False}, |
| "defaultInputModes": ["text/plain"], |
| "defaultOutputModes": ["text/plain"], |
| "skills": [{"id": "lookup", "name": "Catalogue lookup", "description": "Find an item by id.", "tags": ["demo"]}], |
| } |
| required = ["protocolVersion", "name", "description", "url", "version", "capabilities", |
| "defaultInputModes", "defaultOutputModes", "skills"] |
| missing = [k for k in required if k not in card] |
| print("missing fields:", missing) |
| print(json.dumps(card, indent=2))"""), |
| ("md", "Serve it at `/.well-known/agent-card.json` on your own domain."), |
| ] |
|
|
| NB["05_write_an_llms_txt"] = [ |
| ("md", "# 05 Write an llms.txt\n\n" + HEAD + |
| "\nGenerates an `llms.txt` file (the format proposed at llmstxt.org) from a small list of pages."), |
| ("code", """site = {"title": "Demo Project", "summary": "A demo library for parsing invoices.", |
| "sections": {"Docs": [("Quick start", "https://example.com/docs/start.md", "Install and first call"), |
| ("API", "https://example.com/docs/api.md", "All functions")], |
| "Optional": [("Changelog", "https://example.com/changelog.md", "")]}} |
| lines = [f"# {site['title']}", "", f"> {site['summary']}", ""] |
| for section, links in site["sections"].items(): |
| lines.append(f"## {section}") |
| lines += [f"- [{t}]({u})" + (f": {d}" if d else "") for t, u, d in links] |
| lines.append("") |
| llms_txt = "\\n".join(lines) |
| print(llms_txt)"""), |
| ("code", """assert llms_txt.startswith("# ") and "\\n> " in llms_txt |
| print("ok")"""), |
| ] |
|
|
| NB["06_score_tool_calls_against_a_mock"] = [ |
| ("md", "# 06 Score tool calls against a local mock\n\n" + HEAD + |
| "\nA fully synthetic mock tool and a few tasks. A simple rule-based agent is scored on exact tool and " |
| "argument match. Swap in your own agent. Scores here are an example, not a ranking."), |
| ("code", """CITIES = {"Brindlemoor": 14, "Quillhaven": 21} |
| |
| def get_temperature(city: str) -> int: |
| return CITIES[city] |
| |
| TASKS = [ |
| {"prompt": "What is the temperature in Brindlemoor?", "expect": ("get_temperature", {"city": "Brindlemoor"})}, |
| {"prompt": "Temperature in Quillhaven please", "expect": ("get_temperature", {"city": "Quillhaven"})}, |
| {"prompt": "Tell me a joke", "expect": None}, |
| ] |
| |
| def rule_agent(prompt): |
| for c in CITIES: |
| if c in prompt: |
| return ("get_temperature", {"city": c}) |
| return None"""), |
| ("code", """hits = sum(rule_agent(t["prompt"]) == t["expect"] for t in TASKS) |
| print(f"{hits}/{len(TASKS)} exact matches") |
| for t in TASKS: |
| call = rule_agent(t["prompt"]) |
| print(t["prompt"], "->", call, "=", get_temperature(**call[1]) if call else "no tool")"""), |
| ] |
|
|
|
|
| def build(): |
| ROOT.mkdir(exist_ok=True) |
| for name, cells in NB.items(): |
| nb = nbf.v4.new_notebook() |
| nb.metadata = {"kernelspec": {"name": "python3", "display_name": "Python 3", "language": "python"}, |
| "language_info": {"name": "python"}} |
| nb.cells = [nbf.v4.new_markdown_cell(s) if k == "md" else nbf.v4.new_code_cell(s) for k, s in cells] |
| for c in nb.cells: |
| c.metadata = {} |
| c.pop("id", None) |
| nb.nbformat_minor = 4 |
| nbf.write(nb, ROOT / f"{name}.ipynb") |
| return sorted(ROOT.glob("*.ipynb")) |
|
|
|
|
| if __name__ == "__main__": |
| print("\n".join(str(p.name) for p in build())) |
|
|
