Agentic AI: Build AI Agents with MCP, FastMCP & Pydantic AI

A chatbot can only talk. An agent can act. In this lesson you will see exactly what turns a language model into an agent: the tool-calling loop. We break down why LLMs need tools, how a request travels from the user to a tool and back, and the simple loop that sits behind every agent you will build in this course.

The Model Context Protocol sounds complicated. It is not. Under the hood it is JSON-RPC 2.0 and just three method names: initialize, tools/list, and tools/call. You will learn the exact message shapes an agent and a tool server exchange, so MCP stops being a buzzword and becomes something you can read and write by hand.

Writing MCP by hand is tedious. FastMCP does it for you. With a single decorator, a plain Python function becomes a fully described agent tool: your type hints become the input schema and your docstring becomes the description. In this lesson you build a working MCP tool server in about ten lines and see why the contract can never drift from your code.

Time to connect the brain to the hands. Using Pydantic AI and a local model, you build an agent that actually does something: it writes a real file to disk. You will see who decides to call a tool, why the docstring matters so much, and the three arguments that define an agent. By the end you have a complete agent running on your own machine.

One agent is useful. Several working together are powerful. The key idea is simple: a specialist agent can be wrapped as a tool of a manager agent. You will build a manager that delegates to a research agent and a booking agent, keep read-only and money-spending tools cleanly separated, and add a confirmation safety latch before any risky action runs.

To build good agents, you should understand the model driving them. This lesson opens the box: text becomes tokens, tokens become embeddings, and attention lets the model decide what matters. We keep it intuitive and visual, covering the path from raw text through embeddings and self-attention to the model that powers your agent.

Before you can shrink a model, you need to know how it stores numbers. Here you convert a number to 16-bit floating point by hand: one sign bit, five exponent bits, ten mantissa bits, and the bias that ties it together. You will understand why FP16 halves memory versus FP32 and where it overflows, which sets up everything about quantization.

This is the math that makes local models practical. You will see how quantization maps full-precision weights into a handful of levels with a simple scale, why a 4GB model can shrink to around 1GB, and the real tradeoff between file size and precision. GGUF stops being a mystery format and becomes something you understand.

Ollama is the easiest way to run a quantized model locally. In this short lesson you learn what Ollama actually is: llama.cpp behind an OpenAI-shaped HTTP API. You will point your agent code at a local endpoint, swap the base URL, and run everything offline with no API keys and no cloud bills.

This is the capstone. Starting from an empty notebook, you wrap your agent in a FastAPI service and secure it with JWT authentication, so only requests carrying a valid token can reach it. You will follow the full flow: reject a request with no token, log in for a bearer token, call the agent, and confirm a forged token is turned away. By the end you have a real, secured agent API you could deploy.