Building Agents with Model Context Protocol - Full Workshop with Mahesh Murag of Anthropic
Video by AI Engineer on YouTube · 1 h 44 min · uploaded March 2025
Notes and analysis by BrainTube, written from the video. Not affiliated with AI Engineer. Watch on YouTube
In short
Mahesh Murag explains MCP from the inside: why Anthropic built it, how tools, resources and prompts are split by who controls them, and how sampling plus composability let agents call other agents. The design reasoning is the best part and still holds. The auth, transport and registry sections describe plans as of early 2025, and several of those details changed in later spec revisions.
The argument
The talk argues that MCP is the missing bottom layer of the augmented LLM: the standard way an agent reaches retrieval, tools and memory without the builder wiring each one in advance. Murag starts from the N times M problem, where every AI app writes its own glue for every data source, and borrows the fix from the Language Server Protocol: build a server once and any compatible client can use it. He then pushes further. Because a client and a server are logical roles, one program can be both, so agents can be stacked into trees. Sampling lets a server ask the client's model for a completion, so intelligence and cost stay with the application at the top. A registry and well-known endpoints would let agents find new servers at runtime. The result he describes is an agent that can grow its own capabilities while each layer keeps control over its part of the interaction.
Key ideas, with timestamps
- 2:00
LSP is the model
He places MCP after REST APIs and the Language Server Protocol, which lets one Go language server work in any compatible IDE. MCP copies that shape for AI apps. At 6:00 he names the problem it removes: N clients times M integrations, each built by hand.
- 7:00
Separation of concerns inside a company
His enterprise example is a platform team that owns a vector database. Before MCP, every product team wrote its own access, prompting and chunking logic for it. With MCP that team publishes one server, and other teams build on it the way they would call a microservice.
- 10:02
Model, application and user control
Tools are model-controlled: the LLM decides when to call them. Resources are application-controlled; in Claude Desktop they appear as attachments the user or app adds to the chat. Prompts are user-controlled templates, shown at 13:01 as slash commands in the Zed editor that expand into a longer predefined prompt.
- 24:02
GitHub plus Asana in one chat
In the demo, Claude Desktop calls a list issues tool on a GitHub server, ranks the issues, then uses an Asana server with about 30 tools (list workspaces, search projects, create tasks) without being told the project name. He stresses that he built neither server and that each is a couple of hundred lines of code.
- 30:02
Agents declared, not wired
Using LastMile AI's open source mcp-agent framework, he defines three sub-agents in about 80 lines of Python: a researcher with Brave search, fetch and filesystem servers, a fact checker with the same servers, and a report writer with only fetch and filesystem. An orchestrator plans the steps for a report on quantum computing and cybersecurity.
- 46:02
How many tools is too many
Asked about limits, he says current models handle roughly 50 to 100 tools, and Claude a couple of hundred in his experience. Past that he suggests a tool that searches tools, or groups of tools exposed progressively by task. At 48:03 he adds that he wrote each of the roughly 15 launch servers in about 45 minutes with Claude.
- 53:01
Sampling and composability
Sampling lets a server request a completion from the client, passing model preferences, a system prompt, temperature and max tokens, while the client can refuse or cap it. At 56:01 he adds that any program can be both client and server, so a research agent can serve Claude Desktop and also call fetch and search servers below it.
- 1:13:00
Remote servers, auth and the registry
He demos OAuth 2.0 against a Slack server over SSE in the Inspector: the server runs the handshake, keeps the Slack token and gives the client a session token. From 1:22:00 he previews an official registry API above npm and PyPI, and at 1:39:01 a well-known MCP JSON file a site like Shopify could publish.
What it gets right
The control split is the most useful idea here, and many shorter explainers skip it. Asking who decides when something enters the context (the model, the app or the user) explains why resources and prompts exist at all, which an audience member challenges at 14:00. Murag's answer holds up: tools alone can move data, but they give the app and the user no say.
The enterprise vector database example is also well chosen. Most teams meet MCP as a way to plug public services into a chat app. The bigger payoff inside a company is ownership: one team maintains retrieval quality, chunking and access rules, and everyone else consumes a stable interface.
He is honest about open questions. On observability, retries and versioning he says best practices are still emerging, and he admits at 1:28:15 that Claude has no special MCP advantage beyond being good at tool use.
What it leaves out or has since changed
- Transports. At 1:32:02 he describes stdio for local servers and SSE for remote ones. Later spec revisions replaced the HTTP plus SSE transport with Streamable HTTP, so check the current spec before building a remote server.
- Who holds the token. The demo has the MCP server run the OAuth flow and hold the third party token. Later versions of the authorization spec moved toward treating the MCP server as a resource server, with a separate authorization server issuing tokens. The core concern raised at 1:17:01, whether servers should hold tokens, was a fair one.
- Roadmap items. Tool annotations such as read versus write (1:08:07), elicitation and the registry were plans at the time. Several have since shipped in some form, so treat this section as history, not documentation.
- Security. The talk says to be judicious about which servers you connect to, but it does not cover the specific risk that tool descriptions and tool results land in the model's context. A malicious server can steer the model through them. Composed agent trees make this worse, since every layer passes text upward.
- Tool count. "Good up to a couple hundred" tools is optimistic for most setups. Each tool description costs context, and selection gets less reliable as similar tools pile up. His own suggestions, tool search and progressive groups, are the better default.
- Sampling in practice. He calls sampling underused. That was true, and it is still uneven, because many clients did not implement it, so a server design that depends on it can fail on popular clients.
How this applies to memory across AI tools
At 27:00 Murag draws the augmented LLM with three arrows: retrieval, tools and memory, and he says MCP is the layer under all three. That is the practical takeaway for knowledge work. If your notes, transcripts and documents sit behind one MCP server, every client you use reaches the same material, and you stop rebuilding context per app. See what an MCP memory server is for the general pattern.
The control split matters here too. Search over a knowledge base fits a model-controlled tool, because the model should decide when it lacks information, which is exactly his answer at 15:00 about vector databases. A fixed reference document fits a resource the app attaches. BrainTube follows the tool pattern: it saves YouTube videos with their transcripts, articles, PDFs and podcasts into one compiled knowledge base and exposes it as an MCP server, so Claude, ChatGPT, Cursor and other MCP clients can search it. For how this differs from built-in chat memory, read persistent AI memory across tools.
Who should watch it
Watch it if you build agents or MCP servers and want the reasoning behind the protocol from someone who worked on it. The first 30 minutes (philosophy, the control split and the Claude Desktop demo) are the core; jump to 30:02 for the mcp-agent code, 53:01 for sampling and composability, and 1:35:17 for self-evolving agents and the registry. The Q&A is long and the audio questions are often hard to hear, so skim it. Skip it if you want a build tutorial, or if you need current transport and auth details, because those parts reflect the spec as of the video's early 2025 upload.
Frequently asked
- What is the difference between MCP tools, resources and prompts?
- They differ by who controls them. Tools are called by the model when it decides it needs them. Resources are data the application chooses to load, such as files shown as attachments. Prompts are templates the user triggers, often as slash commands.
- What is MCP sampling?
- Sampling lets an MCP server ask the client to run an LLM completion on its behalf. The server sends a prompt and preferences such as model size, temperature and max tokens. The client keeps control of the model, cost and privacy, and can refuse the request.
- Does MCP replace agent frameworks like LangGraph?
- No. MCP standardises how an agent reaches tools and data. Frameworks still handle the agent loop, planning, context management and orchestration. Many frameworks now ship adapters that load MCP servers as tools.
Keep videos like this one searchable
BrainTube saves YouTube videos with their transcripts into one compiled knowledge base that Claude, ChatGPT, Cursor and other MCP clients can search.
Go deeper
More video notes
- MCP Servers Explained & Built · Tech With Tim
- MCP Explained Simply — What It Is and Why It Exists · TechWorld with Nana
- How Model Context Protocol (MCP) actually works · Google Cloud Tech
- MCP Tutorial: Build Your First MCP Server and Client from Scratch (Free Labs) · KodeKloud
Are you the creator and want this page changed or removed? Contact us and we will act within 48 hours.