Tools & Protocols
The interfaces between AI and the real world.
31 lessons · 0 visual stories
0/31 complete · 0%
#LessonTypeLanguagesTimeOpen
01The Tool Interface — Why Agents Need Structured I/OA language model produces tokens. A program takes actions. The gap between those two is the tool interface: a contract that lets the model request an action and the host execute it. Every 2026 stack — function calling on OpenAI, Anthropic, and Gemini; MCP's `tools/call`; A2A's task parts — is a different encoding of the same four-step loop. This lesson names the loop and shows the minimum machinery to run it.Learn—45 min↗ Official lesson02Function Calling Deep Dive — OpenAI, Anthropic, GeminiThe three frontier providers converged on the same tool-call loop in 2024 and then diverged on everything else. OpenAI uses `tools` and `tool_calls`. Anthropic uses `tool_use` and `tool_result` blocks. Gemini uses `functionDeclarations` and unique-id correlation. This lesson diffs the three side by side so code that ships on one provider does not break when you port it.Build—75 min↗ Official lesson03Parallel Tool Calls and Streaming with ToolsThree independent weather lookups serialized is three round trips. Run them in parallel and total time collapses to the slowest single call. Every frontier provider now emits multiple tool calls in a single turn. The payoff is real; the plumbing is subtle. This lesson walks both halves: the parallel fan-out and the streamed-argument reassembly, with emphasis on the id-correlation trap.Build—75 min↗ Official lesson04Structured Output — JSON Schema, Pydantic, Zod, Constrained Decoding"Ask the model nicely to return JSON" fails 5 to 15 percent of the time, even on frontier models. Structured outputs close that gap with constrained decoding: the model is literally prevented from emitting a token that would violate the schema. OpenAI's strict mode, Anthropic's schema-typed tool use, Gemini's `responseSchema`, Pydantic AI's `output_type`, and Zod's `.parse` are five surface forms of the same idea. This lesson builds the schema validator and the strict-mode contract learners will use for every production extraction pipeline.Build—75 min↗ Official lesson05Tool Schema Design — Naming, Descriptions, Parameter ConstraintsA correct tool fails silently when the model cannot tell when to use it. Naming, descriptions, and parameter shapes drive 10 to 20 percentage-point swings in tool-selection accuracy on benchmarks like StableToolBench and MCPToolBench++. This lesson names the design rules that separate a tool a model picks reliably from a tool a model mis-fires.Learn—45 min↗ Official lesson06MCP Fundamentals: Stateless Requests and JSON-RPCModern MCP has no handshake and no protocol session. Each request must carry enough metadata to be understood, authorized, routed, and retried on its own.LearnPython55 min↗ Official lesson07Building an MCP Server: Stateless Python and TypeScriptA modern MCP server does not remember a handshake. It validates the metadata on every request, runs one handler, and returns one typed result.BuildPython, TypeScript85 min↗ Official lesson08Building an MCP Client: Discovery, Routing, and Dual-Era FallbackA modern MCP client repeats its contract on every request. Its hardest compatibility decision is knowing when an old server is truly old and when a modern server is reporting a correctable error.BuildPython85 min↗ Official lesson09MCP Transports: stdio and Stateless Streamable HTTPTransport carries MCP messages. It does not supply missing protocol state. In `2026-07-28`, local stdio and remote Streamable HTTP both carry self-describing requests.LearnPython65 min↗ Official lesson10MCP Resources and Prompts: Addressable Context for Stateless ServersTools perform operations. Resources expose addressable content. Prompts package user-selected message templates. A good MCP server keeps those contracts separate and predictable.BuildPython60 min↗ Official lesson11MCP Model Input: Sampling Migration and Stateless MRTRMCP 2026-07-28 deprecates Sampling for new designs and removes the server-to-client request channel. If an existing workflow still needs the client's model, the server returns an `input_required` result and the client retries the original request with the model output. The reasoning loop becomes explicit, bounded, and stateless at the protocol layer.BuildPython75 min↗ Official lesson12Explicit Scope and Stateless ElicitationRoots are deprecated in MCP 2026-07-28 and were never a security sandbox. Put scope in visible tool arguments or resource URIs, authorize it on the server, and use MRTR when a tool genuinely needs user input. The user sees the decision, the model sees the handle, and any server instance can process the retry.BuildPython60 min↗ Official lesson13MCP Tasks Extension: Durable Work on a Stateless CoreStateless MCP does not mean every operation must finish in one request. The official Tasks extension gives long-running work an explicit durable handle. A server can return that handle from `tools/call`, any instance can answer `tasks/get`, and client input arrives through `tasks/update` without reviving protocol sessions.BuildPython90 min↗ Official lesson14MCP Apps on the Stateless ProtocolAn interactive result is still an MCP tool and resource exchange. The 2026-07-28 core makes that exchange self-contained, while the Apps extension adds the sandboxed browser surface.BuildPython75 min↗ Official lesson15MCP Security: Poisoned Metadata, Routing, and MRTR StateStateless does not mean trustless. It means every request exposes the evidence a server and gateway need to validate the call independently.LearnPython60 min↗ Official lesson16MCP Authorization: CIMD, Issuer Binding, PKCE, and Step-UpA remote MCP request is stateless, but its authorization is not anonymous. Bind every credential to the issuer that created it and every token to the resource that receives it.BuildPython90 min↗ Official lesson17Stateless MCP Gateways and Registry AdmissionA gateway should make every route explicit. The 2026-07-28 protocol gives it method, name, version, capability, identity, cache, and trace boundaries without a transport session.LearnPython75 min↗ Official lesson18MCP Auth in Production: Issuer-Bound Enrollment and TokensLesson 16 built the OAuth 2.1 state machine. This lesson hardens its production boundaries for MCP 2026-07-28: Client ID Metadata Documents first, deprecated dynamic registration only for compatibility, authorization-response issuer validation, issuer-keyed client credentials, JWKS refresh, and audience-pinned tokens on every stateless request.Build—90 min↗ Official lesson19A2A — Agent-to-Agent ProtocolMCP is agent-to-tool. A2A (Agent2Agent) is agent-to-agent — an open protocol for letting opaque agents built on different frameworks collaborate. Released by Google in April 2025, donated to the Linux Foundation in June 2025, reaching v1.0 in April 2026 with 150+ supporters including AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow. It absorbed IBM's ACP and added the AP2 payments extension. This lesson walks the Agent Card, Task lifecycle, and the two transport bindings.Build—75 min↗ Official lesson20OpenTelemetry GenAI — Tracing Tool Calls End-to-EndAn agent calls five tools, three MCP servers, and two sub-agents. You need one trace across all of it. The OpenTelemetry GenAI semantic conventions (stable attributes in v1.37 and up) are the 2026 standard, natively supported by Datadog, Langfuse, Arize Phoenix, OpenLLMetry, and AgentOps. This lesson names the required attributes, walks the span hierarchy (agent → LLM → tool), and ships a stdlib span emitter you can plug into any OTel exporter.Build—75 min↗ Official lesson21LLM Routing Layer — LiteLLM, OpenRouter, PortkeyProvider lock-in is expensive. Different tool-calling workloads suit different models. Routing gateways give one API surface, retries, failover, cost tracking, and guardrails. Three archetypes dominate 2026: LiteLLM (open-source self-hosted), OpenRouter (managed SaaS), Portkey (production-grade, open-sourced in March 2026). This lesson names the decision criteria and walks a stdlib routing gateway.Learn—45 min↗ Official lesson22Agent Skills: Portable Contract and Runtime BoundaryA skill is not a long prompt with a better filename. It is a discoverable package of instructions, resources, and executable helpers that enters an agent's context through a runtime contract.Build—90 min↗ Official lesson23Capstone: Stateless Tool EcosystemA production agent system is a set of boundaries, not a pile of features. This capstone separates a readable in-process simulation from the protocol clients, authorization server, sandbox, and telemetry exporter a real deployment still needs.Build—120 min↗ Official lesson24Skill Discovery and Progressive DisclosureA skill becomes useful before its body is loaded. Its name and description earn a place in the catalog; its deeper files earn context only when the task reaches them.Build—105 min↗ Official lesson25Skill Invocation and RoutingInvocation is an authority decision followed by a relevance decision. A good description helps the model choose; a good policy decides whether that choice is allowed.Build—105 min↗ Official lesson26Skill Permissions, Sandboxes, and TrustA skill can suggest an action. Only the host can authorize it, only an isolation boundary can contain it, and only verification can tell you whether it worked.Build—120 min↗ Official lesson27Skill Evals, Packaging, and PortabilityA skill is finished when its package survives linting, routes on the right requests, improves a measured task, stays inside policy, and degrades honestly on another host.Build—150 min↗ Official lesson28MCP Tool Contracts and ContentA tool is safe to automate only when discovery, arguments, results, pagination, and transport metadata agree on one contract.BuildPython120 min↗ Official lesson29MCP Reliability, Cancellation, and Flow ControlA request ID correlates a message. It does not make a side effect safe, stop a worker, or protect a stream from a slow consumer.BuildPython120 min↗ Official lesson30MCP Registry Supply Chain: Admission, Drift, and RollbackA registry entry tells you what a publisher declared. Production admission proves what you fetched, what you observed, what you approved, and what you can safely restore.BuildPython90 min↗ Official lesson31MCP Conformance Engineering: Versioning, Evidence, and OperationsA server is not conformant because its happy path worked through one SDK. Conformance lives at the wire, at version boundaries, through intermediaries, and during rollback.BuildPython100 min↗ Official lesson