MCP
The Model Context Protocol is an open standard that defines how AI applications connect with external tools, data sources, and other contextual resources.
Vibe Engineering
MCP is a protocol standard that lets AI agents discover and invoke external tools and services through a uniform interface.
- How it is used
- Connects agents to external tools and current project information through a consistent interface.
- How deep it goes
- Explains client-server architecture and worked integration workflows, then addresses governance and context costs rather than protocol implementation details.
- Examples
- Uses a React profile card, Figma design tokens, Context7 library research, and Metals language-server access.
- What you can do after
- Operate and configure curated MCP integrations while weighing security, context cost, and alternatives.
Grokking AI Applications
The Model Context Protocol is an open standard for discovering and invoking tools exposed by servers for use by AI applications and agents.
- How it is used
- Connects AI applications and agents to reusable tools through a shared discovery and invocation protocol.
- How deep it goes
- Explains server and client roles, then demonstrates Python tool definition, discovery, and invocation.
- Examples
- Uses a culinary travel assistant with recipe, itinerary, and email tools, plus a Python calculator server.
- What you can do after
- Builds a Python MCP server and client that list and invoke a calculator tool.
AI Agents in Action, Second Edition
The Model Context Protocol is an open protocol for connecting AI applications and models with external tools, data sources, and contextual resources.
- How it is used
- Connects agents to reusable external tools, data sources, and agent workflows through MCP servers.
- How deep it goes
- Works through server discovery, deployment, and tool conversion, but stops short of a full production operations manual.
- Examples
- Uses a journal server with record and load tools and a research server launched as a subprocess.
- What you can do after
- Apply MCP using FastMCP and MCPServerStdio to expose tools and connect an agent.
Build AI-Enhanced Web Apps
A standardized protocol for connecting AI applications and agents with externally provided tools, prompts, resources, and data sources.
- How it is used
- Connects AI web applications to reusable external tools and data through a standardized client-server interface.
- How deep it goes
- Explains server components and communication flow, then walks through local server, client, and agent integrations.
- Examples
- Uses a Next.js chat app that fetches random jokes through a local MCP server and external API.
- What you can do after
- Apply it via the Vercel AI SDK and LangChain.js to connect MCP tools to Next.js assistants.
Build an AI Agent (From Scratch)
Model Context Protocol is an open protocol that standardizes how AI applications connect to tools, prompts, resources, and external services.
- How it is used
- Connects an agent’s tool-calling loop to reusable external tools without building each integration from scratch.
- How deep it goes
- Explains host–client–server roles and discovery and execution interfaces, then implements a server; identifies prompts and resources but focuses on tools.
- Examples
- Uses a custom Tavily web-search server and compares its exposed tool with those of the official Tavily server.
- What you can do after
- Apply it via FastMCP to expose an existing Python function and connect a client that discovers the tool.
Build a Multi-Agent System (from Scratch)
Model Context Protocol is an open standard for connecting AI applications with external tools and contextual resources.
- How it is used
- Extends an LLM agent with third-party tools and access to external resources.
- How deep it goes
- Explains client-server architecture, transports, and tool-call execution, then introduces framework integration classes.
- Examples
- Uses ToolCall and ToolCallResult objects to trace a request executed on an external MCP server.
- What you can do after
- Build an agent integration around MCPTool and MCPToolProvider for server-backed tools.
Read how Build a Multi-Agent System (from Scratch) explains MCP →
AI Agents and Applications
The Model Context Protocol is a standard protocol for services to expose tools that AI applications can discover and access.
- How it is used
- Standardizes how agents discover and use tools exposed by external services.
- How deep it goes
- Explains client/server architecture and server integration, focusing on tools while deferring deeper coverage of prompts and other resources.
- Examples
- Uses an AccuWeather server and a workflow combining local calculation, remote database access, and local formatting.
- What you can do after
- Apply it using FastMCP 2 or the TypeScript MCP SDK, and test servers with MCP Inspector.
Designing AI Systems
MCP, or the Model Context Protocol, is a standard protocol for connecting AI applications to servers that expose tools and other contextual capabilities.
- How it is used
- Connects AI applications to external tools through a shared protocol and a platform-managed Tool Service.
- How deep it goes
- Explains integration economics, host-client-server roles, platform registration, and security boundaries without detailing protocol implementation.
- Examples
- Illustrates GitHub server registration and discovery, plus a replaceable web search provider in an agent loop.
- What you can do after
- Operate/configure MCP server registration through a Tool Service with namespaces, credential references, policies, and rate limits.
AI Governance
MCP is a protocol for connecting AI applications to external tools and data sources.
- How it is used
- Standardizes agent connections to external tools and data sources through a uniform server interface.
- How deep it goes
- Explains server discovery and security risks through permission, tool-description, and dynamic-discovery scenarios, without detailing protocol implementation.
- Examples
- Illustrates risks with Asana cross-tenant leakage, a malicious postmark-mcp update, and a GitHub integration requesting excessive permissions.
- What you can do after
- Evaluate MCP integrations for excessive permissions, poisoned tool descriptions, changing tool inventories, and unverified server behavior.
Architecting an Apache Iceberg Lakehouse
The Model Context Protocol is a standardized protocol that lets large language models interact with external data, tools, and services through governed calls.
- How it is used
- Enables AI-native consumption of governed lakehouse data, tools, metrics, and workflows through standardized calls.
- How deep it goes
- Explains architecture, interactions, examples, and safeguards, but stops short of specifying server implementation details.
- Examples
- Uses dataset discovery, natural-language querying, governed metric retrieval, forecasting, and downstream workflow triggering.
- What you can do after
- Operate/configure AI agents that discover, query, and act on governed lakehouse capabilities through MCP servers.
Read how Architecting an Apache Iceberg Lakehouse explains MCP →
Building Reliable AI Systems
A protocol for connecting AI applications and agents to external data sources and tools.
- How it is used
- Connects AI agents to external tools and data sources through standardized interfaces.
- How deep it goes
- Develops tool discovery, server implementation, and production safeguards while distinguishing standardized interfaces from backend logic and security.
- Examples
- Uses product search, email, inventory checks, notifications, and payment processing to illustrate external tool integration.
- What you can do after
- Apply it via FastMCP to expose Python functions as discoverable tools with structured interfaces and production safeguards.
Financial AI in Practice
MCP is a protocol for standardizing how AI models or agents interact with external tools and data sources.
- How it is used
- Standardizes how financial AI agents access approved tools and shared data assets.
- How deep it goes
- Explains the integration rationale and client discovery in pseudocode, but omits client setup and server details.
- Examples
- Illustrates tool discovery for charting and community search, and controlled access to a user behavior mart for retention.
- What you can do after
- Evaluate MCP against function wrappers, internal registries, API gateways, and custom service layers for controlled agent access.
Spring AI in Action
The Model Context Protocol is an open protocol for connecting AI applications with external tools and sources of contextual information.
- How it is used
- Connects generative AI applications with reusable collections of external tools and contextual resources.
- How deep it goes
- Defines servers, clients, tool invocation, and transports, while deferring Streamable HTTP support in Spring AI 1.0.0.
- Examples
- Uses integrations such as PostgreSQL, GitHub, Google Maps, and Claude Desktop configurations.
- What you can do after
- Apply MCP via Spring AI to reuse external tools in AI applications and extend LLM functionality.
Investing for Programmers
A model context protocol is a standardized interface that lets AI agents connect to external data sources and retrieve data in a consistent format.
- How it is used
- Connects AI agents to external data during response generation.
- How deep it goes
- Defines the interface, compares it with RAG and web search, and stops short of implementation details.
- Examples
- Uses an agent querying the latest stock share price while generating an answer.
- What you can do after
- Apply it via an MCP interface to let an LLM retrieve current external data during answer generation.
Claude at Work
The Model Context Protocol is an open standard for connecting AI models to external systems through discoverable, permissioned operations.
- How it is used
- Connects Claude to external systems through discoverable, permissioned operations.
- How deep it goes
- Describes middleware, operation discovery, read/write access, OAuth sign-in, and per-action controls.
- Examples
- Uses email search, ticket updates, and a drafted email requiring approval as examples.
- What you can do after
- Configure connectors in Claude Desktop and choose whether operations run, require confirmation, or remain blocked.
Introduction to Generative AI, Second Edition
The Model Context Protocol is an open standard for secure, two-way connections between external data sources, services, and AI-powered tools.
- How it is used
- Connects AI agents with external data and services through standardized server-client interactions.
- How deep it goes
- Explains servers, clients, data functions, prompt templates, and executable tools, but not implementation details.
- Examples
- Uses Splunk log queries, time-based log filtering, and automated log-irregularity analysis as concrete examples.
- What you can do after
- Apply it via MCP clients to request information and actions from services that provide MCP servers.
Read how Introduction to Generative AI, Second Edition explains MCP →
Authorization in Action
Model Context Protocol is a standard protocol for connecting AI applications to external tools and data sources.
- How it is used
- Connects AI agents with external tools and data through discoverable, structured tool invocations.
- How deep it goes
- Defines tool exposure, schemas, and server-side translation, but leaves authorization decisions to separate policy mechanisms.
- Examples
- Uses document search, calendar access, database queries, workflow actions, and an ACME document-search API.
- What you can do after
- Apply MCP to expose and invoke external capabilities without writing custom integration code for every system.
Building Distributed Applications that Work
Model Context Protocol is a protocol for connecting language-model applications with external tools, data sources, and capabilities through a standardized interface.
- How it is used
- Connects coding agents to current Aspire information while they work on an existing application.
- How deep it goes
- Defines the relationship between MCP and agentic tool calling, but does not specify MCP configuration or protocol details in the supplied excerpt.
- Examples
- Uses an Aspire setup and a refactoring scenario involving file inspection, code changes, and repeated test runs.
- What you can do after
- Evaluate/understand why a coding agent needs current external information and how tool results support iterative changes.
Read how Building Distributed Applications that Work explains MCP →
Architecting for Autonomy
An open protocol for connecting AI applications, models, or agents with external tools, data sources, and contextual capabilities through defined interfaces.
- How it is used
- Connects agent applications with approved enterprise tools and resources through standardized discovery and invocation.
- How deep it goes
- Explains MCP’s host-client-server interaction and governance boundary, but defers full business authority to conversational contracts and wrappers.
- Examples
- Uses a manufacturing quality investigation involving production history, non-conformance signals, and lot 2418 containment.
- What you can do after
- Operate/configure MCP through bounded tools while separating technical invocation from business authority and evidence obligations.
Context Engineering
The Model Context Protocol is a protocol that enables external servers to expose tools, resources, and prompts to AI applications.
- How it is used
- Provides a context federation layer for dynamically accessing external tools, data, and reusable prompts.
- How deep it goes
- Explains capability discovery and client-server separation, and distinguishes the protocol from model-facing tool invocation.
- Examples
- Illustrates a bug investigation combining a bug-report function, git diff, and project documentation exposed by an MCP server.
- What you can do after
- Evaluate/understand where MCP fits in an agent architecture and which controls external tool use can require.
Building LLM Applications with DSPy
Model Context Protocol is a standard protocol for connecting language-model applications with external tools and data sources.
- How it is used
- Connects an agentic application to external services, including retrieval tools exposed by an MCP server.
- How deep it goes
- Defines host, client, server, and stdio/HTTP connections, stopping short of a broader protocol treatment.
- Examples
- Uses a host connected to three MCP servers and a server exposing WixQA retrieval methods.
- What you can do after
- Understand how a host uses clients to communicate with servers and execute tools.
Also covered in
- Hugging Face in Action
- Server-Side WebAssembly
- Reinforcement Learning from Human Feedback
- Designing AI AgentsIn early access (MEAP)
What to know first
- AI agentAn AI agent is a computational system that uses artificial intelligence to interpret information and select or perform actions toward goals while interacting with an environment.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- toolA software tool is a capability or utility that enables a person or system to perform a defined task or operation.
Related concepts
- toolconfigures · A software tool is a capability or utility that enables a person or system to perform a defined task or operation.
- contractcontrasts with · A contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- A2Acontrasts with · A2A is an open interoperability protocol that enables software agents to discover, communicate, and coordinate with one another across systems.
- client-server architectureuses · Client-server architecture is a distributed computing pattern in which clients request services or resources from servers that provide them.
- N×M integration problemaddresses · The N×M integration problem is the growth in custom integrations that results when each of N applications must connect independently to each of M external systems or providers.
- schemauses · A data schema is a formal specification of the structure, fields, types, relationships, and constraints of data.
Questions about MCP
What is MCP?
The Model Context Protocol is an open standard that defines how AI applications connect with external tools, data sources, and other contextual resources.
Which Manning books explain MCP?
Vibe Engineering, Grokking AI Applications, AI Agents in Action, Second Edition, Build AI-Enhanced Web Apps, Build an AI Agent (From Scratch), Build a Multi-Agent System (from Scratch), AI Agents and Applications, Designing AI Systems and 13 more.
What should I know before learning MCP?
Manning books that teach MCP usually introduce AI agent, language model, contract and tool first.
What is the difference between MCP and contract?
The Model Context Protocol is an open standard that defines how AI applications connect with external tools, data sources, and other contextual resources. A contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
What is MCP also called?
MCP is also called Model Context Protocol.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.




















