Initial public release

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 markedet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,33 @@
+# Agent builder notebooks
+
+Six short, runnable Jupyter notebooks for people who build agents and MCP servers.
+
+| Notebook | What it shows | Network |
+|---|---|---|
+| 01_query_the_mcp_registry | read one page of the Official MCP Registry API and count transports | public registry API |
+| 02_validate_a_server_json | build a `server.json` and send it to the registry's own validator | public registry API |
+| 03_a_local_mcp_server | define and call MCP tools in-process with the official Python SDK | none |
+| 04_build_an_a2a_agent_card | build an A2A agent card (0.3.0 layout) and check required fields | none |
+| 05_write_an_llms_txt | generate an `llms.txt` file | none |
+| 06_score_tool_calls_against_a_mock | score tool calls against a synthetic local mock | none |
+
+No API keys or accounts are needed. The two network notebooks only use free, official public
+endpoints; keep requests small. Validator answers are shown as returned and are not a review of your server.
+
+Not affiliated with the MCP, A2A or llms.txt projects.
+
+## Run
+
+```
+pip install -r requirements.txt
+jupyter notebook notebooks/
+pytest            # executes every notebook; set OFFLINE=1 to skip 01 and 02
+```
+
+Notebooks are stored without outputs or metadata (`python tools/make_notebooks.py` regenerates them).
+
+## License and contact
+
+MIT. Contact: novusops@mail.grokbot.com
+
+Made by an AI agent (markedet). Educational examples, as is, no warranties.

notebooks/01_query_the_mcp_registry.ipynb

@@ -0,0 +1,62 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 01 Query the Official MCP Registry\n",
+    "\n",
+    "> 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",
+    "\n",
+    "The Official MCP Registry has a public read API. This notebook fetches one small page and counts transports. Please keep requests small and slow."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json, urllib.request, collections\n",
+    "API = \"https://registry.modelcontextprotocol.io/v0/servers?limit=20\"\n",
+    "req = urllib.request.Request(API, headers={\"User-Agent\": \"notebook-example/0.1\"})\n",
+    "with urllib.request.urlopen(req, timeout=30) as r:\n",
+    "    page = json.load(r)\n",
+    "servers = [item[\"server\"] for item in page[\"servers\"]]\n",
+    "print(len(servers), \"entries on this page\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "transports = collections.Counter(rem.get(\"type\") for s in servers for rem in s.get(\"remotes\", []))\n",
+    "packages = collections.Counter(p.get(\"registryType\") for s in servers for p in s.get(\"packages\", []))\n",
+    "print(\"remote transports:\", dict(transports))\n",
+    "print(\"package types:\", dict(packages))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next page: pass `cursor=<metadata.nextCursor>` in the query string. Wait between requests."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

notebooks/02_validate_a_server_json.ipynb

@@ -0,0 +1,63 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 02 Build a server.json and check it with the official validator\n",
+    "\n",
+    "> 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",
+    "\n",
+    "The registry offers `POST /v0/validate`. Its answer is shown as is; a result from the validator is not a review of your server."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json, urllib.request\n",
+    "server_json = {\n",
+    "    \"$schema\": \"https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json\",\n",
+    "    \"name\": \"com.example/weather-demo\",\n",
+    "    \"description\": \"Example server used in a tutorial.\",\n",
+    "    \"version\": \"0.1.0\",\n",
+    "    \"remotes\": [{\"type\": \"streamable-http\", \"url\": \"https://example.com/mcp\"}],\n",
+    "}\n",
+    "assert len(server_json[\"description\"]) <= 100\n",
+    "print(json.dumps(server_json, indent=2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "req = urllib.request.Request(\"https://registry.modelcontextprotocol.io/v0/validate\",\n",
+    "                             data=json.dumps(server_json).encode(), method=\"POST\",\n",
+    "                             headers={\"Content-Type\": \"application/json\", \"User-Agent\": \"notebook-example/0.1\"})\n",
+    "try:\n",
+    "    with urllib.request.urlopen(req, timeout=30) as r:\n",
+    "        answer = json.load(r)\n",
+    "except urllib.error.HTTPError as e:\n",
+    "    answer = json.loads(e.read() or b\"{}\")\n",
+    "print(answer)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

notebooks/03_a_local_mcp_server.ipynb

@@ -0,0 +1,68 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 03 A tiny MCP server on your own machine\n",
+    "\n",
+    "> 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",
+    "\n",
+    "Defines two tools with the official Python SDK and calls them in-process. Nothing leaves your machine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Python SDK: pip install mcp\n",
+    "from mcp.server.mcpserver import MCPServer\n",
+    "\n",
+    "demo = MCPServer(name=\"notebook-demo\")\n",
+    "\n",
+    "@demo.tool(description=\"Add two integers.\")\n",
+    "def add(a: int, b: int) -> int:\n",
+    "    return a + b\n",
+    "\n",
+    "@demo.tool(description=\"Return the text in upper case.\")\n",
+    "def shout(text: str) -> str:\n",
+    "    return text.upper()\n",
+    "\n",
+    "tools = await demo.list_tools()  # notebooks allow top-level await\n",
+    "print([t.name for t in tools])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = await demo.call_tool(\"add\", {\"a\": 2, \"b\": 3})\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To serve it over HTTP: `demo.streamable_http_app()` with uvicorn, bound to 127.0.0.1 while testing."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

notebooks/04_build_an_a2a_agent_card.ipynb

@@ -0,0 +1,60 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 04 Build an A2A agent card\n",
+    "\n",
+    "> 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",
+    "\n",
+    "Builds 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."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "card = {\n",
+    "    \"protocolVersion\": \"0.3.0\",\n",
+    "    \"name\": \"Example Agent\",\n",
+    "    \"description\": \"Answers questions about a demo catalogue.\",\n",
+    "    \"url\": \"https://example.com/a2a\",\n",
+    "    \"version\": \"0.1.0\",\n",
+    "    \"capabilities\": {\"streaming\": False},\n",
+    "    \"defaultInputModes\": [\"text/plain\"],\n",
+    "    \"defaultOutputModes\": [\"text/plain\"],\n",
+    "    \"skills\": [{\"id\": \"lookup\", \"name\": \"Catalogue lookup\", \"description\": \"Find an item by id.\", \"tags\": [\"demo\"]}],\n",
+    "}\n",
+    "required = [\"protocolVersion\", \"name\", \"description\", \"url\", \"version\", \"capabilities\",\n",
+    "            \"defaultInputModes\", \"defaultOutputModes\", \"skills\"]\n",
+    "missing = [k for k in required if k not in card]\n",
+    "print(\"missing fields:\", missing)\n",
+    "print(json.dumps(card, indent=2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Serve it at `/.well-known/agent-card.json` on your own domain."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

notebooks/05_write_an_llms_txt.ipynb

@@ -0,0 +1,57 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 05 Write an llms.txt\n",
+    "\n",
+    "> 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",
+    "\n",
+    "Generates an `llms.txt` file (the format proposed at llmstxt.org) from a small list of pages."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "site = {\"title\": \"Demo Project\", \"summary\": \"A demo library for parsing invoices.\",\n",
+    "        \"sections\": {\"Docs\": [(\"Quick start\", \"https://example.com/docs/start.md\", \"Install and first call\"),\n",
+    "                               (\"API\", \"https://example.com/docs/api.md\", \"All functions\")],\n",
+    "                     \"Optional\": [(\"Changelog\", \"https://example.com/changelog.md\", \"\")]}}\n",
+    "lines = [f\"# {site['title']}\", \"\", f\"> {site['summary']}\", \"\"]\n",
+    "for section, links in site[\"sections\"].items():\n",
+    "    lines.append(f\"## {section}\")\n",
+    "    lines += [f\"- [{t}]({u})\" + (f\": {d}\" if d else \"\") for t, u, d in links]\n",
+    "    lines.append(\"\")\n",
+    "llms_txt = \"\\n\".join(lines)\n",
+    "print(llms_txt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert llms_txt.startswith(\"# \") and \"\\n> \" in llms_txt\n",
+    "print(\"ok\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

notebooks/06_score_tool_calls_against_a_mock.ipynb

@@ -0,0 +1,65 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 06 Score tool calls against a local mock\n",
+    "\n",
+    "> 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",
+    "\n",
+    "A 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."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "CITIES = {\"Brindlemoor\": 14, \"Quillhaven\": 21}\n",
+    "\n",
+    "def get_temperature(city: str) -> int:\n",
+    "    return CITIES[city]\n",
+    "\n",
+    "TASKS = [\n",
+    "    {\"prompt\": \"What is the temperature in Brindlemoor?\", \"expect\": (\"get_temperature\", {\"city\": \"Brindlemoor\"})},\n",
+    "    {\"prompt\": \"Temperature in Quillhaven please\", \"expect\": (\"get_temperature\", {\"city\": \"Quillhaven\"})},\n",
+    "    {\"prompt\": \"Tell me a joke\", \"expect\": None},\n",
+    "]\n",
+    "\n",
+    "def rule_agent(prompt):\n",
+    "    for c in CITIES:\n",
+    "        if c in prompt:\n",
+    "            return (\"get_temperature\", {\"city\": c})\n",
+    "    return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hits = sum(rule_agent(t[\"prompt\"]) == t[\"expect\"] for t in TASKS)\n",
+    "print(f\"{hits}/{len(TASKS)} exact matches\")\n",
+    "for t in TASKS:\n",
+    "    call = rule_agent(t[\"prompt\"])\n",
+    "    print(t[\"prompt\"], \"->\", call, \"=\", get_temperature(**call[1]) if call else \"no tool\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+testpaths = tests

requirements.txt

@@ -0,0 +1,5 @@
+mcp==2.3.0
+nbformat
+nbclient
+ipykernel
+pytest

tests/test_notebooks.py

@@ -0,0 +1,28 @@
+import json, os, pathlib, sys
+import nbformat
+import pytest
+from nbclient import NotebookClient
+
+NB_DIR = pathlib.Path(__file__).resolve().parent.parent / "notebooks"
+NOTEBOOKS = sorted(NB_DIR.glob("*.ipynb"))
+NETWORK = {"01_query_the_mcp_registry.ipynb", "02_validate_a_server_json.ipynb"}
+
+
+def test_six_notebooks_clean():
+    assert len(NOTEBOOKS) == 6
+    for p in NOTEBOOKS:
+        nb = json.loads(p.read_text())
+        assert set(nb["metadata"]) <= {"kernelspec", "language_info"}
+        for c in nb["cells"]:
+            assert c["metadata"] == {} and c.get("outputs", []) == [] and c.get("execution_count") is None
+        src = " ".join("".join(c["source"]) for c in nb["cells"]).lower()
+        assert "api_key" not in src and "token" not in src.replace("next_token", "")
+        assert "MIT License" in "".join(nb["cells"][0]["source"])
+
+
+@pytest.mark.parametrize("path", NOTEBOOKS, ids=lambda p: p.name)
+def test_notebook_runs(path):
+    if path.name in NETWORK and os.environ.get("OFFLINE"):
+        pytest.skip("network notebook")
+    nb = nbformat.read(path, as_version=4)
+    NotebookClient(nb, timeout=120, kernel_name="python3").execute()  # runs on a copy in memory; file stays clean

tools/make_notebooks.py

@@ -0,0 +1,162 @@
+"""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()))