MCP Server Architecture Explained: Clients, Servers, Tools, Resources, and AI Agents
Sponsored Advertising Content |
You've probably heard people talk about MCP a lot lately, and maybe your team wants to build with it. But when someone draws the diagram, the boxes and arrows get confusing fast. What is a host? Why is there both a client and a server? Where does the AI agent sit? Those are fair questions, and good MCP server development starts with knowing how the parts fit together. The design is simpler than it looks: a few components, each with a clear job, exchanging structured messages. This guide walks through each one, follows a single request from start to finish, and flags where the current specification differs from older tutorials.
TL;DR
MCP (Model Context Protocol) is an open standard that gives AI applications one consistent way to reach outside tools and data.
Three roles do the work: the host is the AI application, a client inside it holds the link to exactly one server, and the server exposes tools, resources, and prompts.
Agent reasoning lives on the host side, while servers execute requests within the permissions you set. That split is the foundation of any sound AI agent architecture built on MCP.
Version matters: the 2026-07-28 specification replaced the old initialize handshake and protocol-level sessions with self-contained requests, though older implementations remain in use.
Security belongs on the server. Validate inputs, check authorization on every request, and keep a human in the loop for risky actions.
MCP server architecture is the structure the Model Context Protocol uses to connect AI applications to external systems. A host application runs the AI model and manages clients, each client maintains a connection to one server, and each server exposes tools, resources, and prompts over JSON-RPC, using either local stdio or remote Streamable HTTP.
Table of Contents
The Big Picture: What Is MCP Server Architecture?
MCP stands for Model Context Protocol. It is an open standard that gives AI applications one common way to connect with outside tools and data. Before a shared protocol existed, every assistant needed its own custom integration for every system it touched. MCP replaces that pattern with a single contract: build a server once, and any compatible host can use it.
Three Main Parts
MCP has three main parts. The host is the AI application your users work with. The client lives inside the host and manages the link to one server. The server sits outside and shares tools and data. That is the core of MCP server architecture, and everything else builds on these three pieces.
Part | What it is | Typical examples | Main responsibility |
|---|---|---|---|
Host | The AI application the user works in | Chat app, coding assistant, internal AI tool | Runs the model, creates clients, and handles user approvals |
Client | A connector inside the host | One instance for each connected server | Speaks the protocol to a single server |
Server | A program that exposes capabilities | Order lookup service, CRM connector, file server | Offers tools, resources, and prompts and enforces its own access rules |

How They Talk
The parts exchange short messages encoded as JSON-RPC 2.0. You do not need to learn it to follow along: each message either asks for something, returns an answer, or announces an update. Because every component uses the same format, MCP clients and servers from different teams can usually work together without custom glue. Messages travel over a transport, and the two standard ones are stdio for local servers and Streamable HTTP for remote ones. Both are covered below.
Where the AI Agent Fits
So where is the agent? On the host side of the picture. The host orchestrates an AI model, which may itself be served remotely. That model reads the user's request, looks at the tools the connected servers offer, and decides what to do next. Servers do not think. They do what they are asked, within the rules you set. Keeping that split in mind from day one separates a tidy design from a tangled one. Not every host is a fully autonomous agent, either: some simply put a person in charge of each step.
One caution about the diagram above: it is a conceptual illustration. Drawing agents and applications beside the server compresses the real path, where every request passes through a host and one of its clients.
Plan Your MCP Integration With Confidence Deciding which systems your host should reach, which tools each server should expose, and who may call them is easier with a second pair of eyes. Mobisoft Infotech describes architecture consulting and custom MCP server work for enterprise integrations. |
The Host: Where the AI Application Coordinates Work
The host is the starting point: the application your user actually sees and works with.
What the Host Does
A host could be a chat app, a coding assistant, or an internal tool your company built. It orchestrates the AI model, which may run locally or be served by a remote provider, and it creates and manages the MCP clients. When the user types a question, the host passes it to the model together with the list of tools the model may use. Saying the host "runs the AI model" is shorthand: the host coordinates the model rather than necessarily hosting it.
Context, Consent, and Multiple Clients
A host usually connects to several servers at once and runs one client for each. It decides which servers are connected, merges their tool lists into what the model sees, and keeps each server's data separate from the others. Because the host sits between the model and every server, it is also the natural place to apply user consent.
Why the Host Matters for Safety
The host decides a lot about safety. The specification says there should always be a human in the loop with the ability to deny tool invocations, and it advises applications to make exposed tools visible, signal when a tool runs, and ask for confirmation on sensitive operations. Many hosts ask the user to approve a tool call before it runs, and some show what data a tool will send. These checks matter because the model chooses tools on its own, and sometimes it chooses wrong. A good host gives people a chance to catch that.
Host Versus Server Responsibility
A useful rule of thumb: the host owns the experience and the consent, while the server owns the data and the enforcement. A host prompt can reduce mistakes, but it cannot replace a server that checks permissions itself. Careful MCP server development adds checks on both sides, because either side can fail.
The Client: The Link to One MCP Server
The client is easy to overlook, but it does important work. It is the link between the host and a single server, and it handles the protocol so the rest of the host does not have to.
One Client per Server
Each client connects to one server. If the host talks to three servers, it runs three clients. That keeps connections separate: one server cannot see what another server is doing, and each link carries its own capability information. The architecture documentation describes this as one logical client per server, and it is the key idea that keeps MCP clients and servers clean and isolated.
How Connections Work: Then and Now
Older tutorials, including many written before mid-2026, describe a connection that begins with an initialize handshake. The client and server swap protocol versions and supported features, the client sends an initialized notification, and the connection then behaves like a session. That is how earlier specification revisions work, and plenty of deployed software still works that way. The 2026-07-28 revision changes the model. It removes the initialize exchange and the protocol-level session header, and it moves to a stateless core in which every request is self-contained.
Aspect | Earlier revisions (handshake era) | 2026-07-28 revision |
|---|---|---|
Opening a connection | An initialize request, then an initialized notification | No handshake; the first message can be an ordinary request |
Version and capabilities | Negotiated once during the handshake | Carried in every request's _meta fields |
Session state | A connection-scoped session, with a session ID header on HTTP | No protocol-level session |
Discovery | Learned from the initialize response | Optional server/discover call, plus the list requests |
In the current revision, every request carries the protocol version, client information, and client capabilities in _meta fields under the io.modelcontextprotocol prefix. A client may call server/discover to learn what a server supports. Clients are not required to, but servers must implement it. If a server does not support the requested version, it answers with an UnsupportedProtocolVersionError (code -32022).
Compatibility in Practice
Do not assume everything moved at once. The specification includes a compatibility matrix for implementers who must interoperate with initialization-based versions, and the Tier 1 SDKs for TypeScript, Python, Go, and C# support the 2026-07-28 revision. Check which revision your host, SDK, and server actually speak before you debug a missing handshake.
What the Client Can Offer Back
Older write-ups say a client can offer sampling, roots, and logging to servers. In the current revision those three are deprecated, though they remain functional for at least twelve months, so avoid building new designs around them. When a server needs more input from the user mid-task, it now uses a multi round-trip request: the server returns an input_required result that describes what it needs, and the client retries the request with the user's answers attached. The host stays in control and can decline or ask the user first.
The Server: Exposing Functionality Safely
The server is where most MCP server development work happens. It connects the AI to a real system, such as a database, a CRM, or an internal API, and decides what the AI is allowed to do there.
What a Server Shares
A server can share three kinds of features: tools, resources, and prompts, covered in the next section. It declares the ones it supports as capabilities. One point deserves emphasis. The protocol does not check who is asking on its own, and authorization is optional in the specification. Your team has to add sign-in and access rules that fit your data, and for most business systems that is where real security lives.
Local and Remote Servers
Servers run in two main ways. A local server runs on the same computer as the host. The host launches it as a subprocess, and the two exchange newline-delimited JSON-RPC over standard input and output (stdio). A remote server runs elsewhere and exposes a single MCP endpoint over Streamable HTTP, where each message is an HTTP POST and the reply arrives as either a JSON object or a streamed response. Local servers suit personal tools and development. Remote servers suit cases where many users need the same connection, and they bring the usual web concerns of authentication, tenancy, and monitoring.

Failure Boundaries
Because each server is a separate process or service, a failing server should not take the host down with it. Design for that: return clear errors, set timeouts, and make sure a slow backend cannot stall every conversation. A server that fails loudly and narrowly is far easier to operate than one that fails quietly and broadly.
Credentials and Tenancy
Servers often hold credentials for the systems behind them. Keep those credentials out of tool outputs and logs, scope them to the minimum the server needs, and make sure one user's requests can never reach another user's data. Remote servers should also validate the Origin header on incoming requests, and local ones should bind to localhost rather than every network interface.
Tools, Resources, and Prompts
Servers offer three main features. Knowing the difference between MCP tools and resources will help you design better servers.
Tools
Tools let the AI do something. A tool might create a ticket or look up an order. Tools are designed to be model-controlled: the model can discover and invoke them based on the conversation. That is why each tool needs a clear name, a short description, and an input schema written in JSON Schema. If the description is vague, the model may pick the wrong tool. Tools can read or write depending on how you design them, so a read-only order lookup and a ticket-creating action are both tools, with very different risk.
Resources
Resources give the AI something to read, each identified by a URI: a file, a database record, a document. Resources share data rather than take actions, and they are application-driven, meaning the host decides which resources to include in context. A host might show a picker, let users search, or include some automatically. That gives you control over what the model sees. Servers can also expose resource templates, which describe parameterized URIs.
Prompts
Prompts are ready-made templates that help users start common tasks the right way. A prompt might set up a "summarize this report" task. Prompts are user-controlled: the user typically picks one on purpose, often from a menu or a slash command. The server still defines the prompt's content, and "user-controlled" only describes who decides when it runs. Not every server needs all three features.
Feature | What it does | Who usually controls it | Example |
|---|---|---|---|
Tools | Performs an action or computation | The AI model, with host approval | Create a support ticket |
Resources | Provides context to read | The host application | Read a customer record |
Prompts | Offers reusable task templates | The user | Start a report summary |

Discovery and Schemas
Clients discover features with list requests: tools/list, resources/list, and prompts/list. Each tool in the list carries its name, description, and inputSchema, and may declare an outputSchema for structured results. List results can include caching hints (ttlMs and cacheScope) so clients do not re-fetch constantly. Treat tool annotations as hints rather than guarantees. The specification says clients must consider them untrusted unless they come from a trusted server.
Choosing the Right Primitive
If the AI needs to change something, use a tool. If it needs stable context to read, a resource is usually cleaner. If a person needs a repeatable starting point, a prompt fits. These are tendencies, not laws. A lookup tool can return the same data a resource would, and hosts are free to choose other interaction patterns.
How MCP Communication Works
Under the diagrams, MCP is a conversation of JSON-RPC messages. Requests ask for something and carry an ID, results answer a specific request, and notifications announce something without expecting a reply. The same message patterns apply on every transport.
A Version-Aware Exchange
In the 2026-07-28 revision, a client can open with an ordinary request. To call a tool, it sends a tools/call request whose params name the tool and its arguments, with the protocol version, client information, and client capabilities in _meta. The server replies with a result marked resultType complete, containing the content and an isError flag. In handshake-era revisions, the same call would come after an initialize exchange.
Local and Remote Transports
On stdio, the client launches the server as a subprocess and exchanges newline-delimited messages. Servers should write logs to stderr, never to stdout, because stdout is reserved for protocol messages. On Streamable HTTP, each message is an HTTP POST to one endpoint. The client sends headers such as MCP-Protocol-Version, Mcp-Method, and Mcp-Name that mirror fields in the body, so proxies and gateways can route traffic without parsing JSON. The body remains the source of truth, and mismatches are rejected. The older HTTP+SSE transport is deprecated.
Updates and Optional Extras
Servers do not start their own requests in the current revision. Change notifications, such as a tool list changing, reach clients that opened a subscriptions/listen stream. Optional extensions, such as Tasks for long-running work and MCP Apps, add capabilities without changing the core. Check that your host supports an extension before depending on it.
Errors You Will Actually See
Two kinds of failure matter in practice. Protocol errors, such as an unknown tool or a malformed request, come back as standard JSON-RPC errors. Tool execution errors, such as an API failure or a date in the wrong format, come back inside a normal result with isError set to true, so the model can read the message and retry with better arguments. Write those messages for a model to act on: say what was wrong and what a valid request looks like.
Following One Request: Where Is Order 4417?
Let's put it all together. Here's what happens when a user asks an agent a question.
Step by Step
Say a user asks, "Where is order 4417?" Here's what happens next.
The host passes the question to the AI model, along with the tools that connected servers offer.
The model checks which tools are available and chooses the order lookup tool from the store's server.
The host might ask the user to approve this step first, especially if a tool changes data.
The client for that server sends a tools/call request with the order number as an argument.
The server validates the input and makes sure this user is allowed to see this order.
The server queries the order system with its own credentials and finds the order details.
The server returns a result trimmed to what the task needs.
The details travel back to the host through the client.
The model reads them and writes a reply for the user.
What This Shows
Each part stays in its lane. The model makes choices, the server does the work, and the host keeps an eye on safety. This split is what makes the architecture easy to reason about. When something goes wrong, you know where to look. It also makes it easier to add new servers later, because you plug each one in the same way.
When Something Goes Wrong
A troubleshooting recap for the order 4417 scenario:
Symptom | Where to look | First check |
|---|---|---|
The model ignores the lookup tool | Tool definition | Name and description clarity |
The tool does not appear in the host | Client and connection | Connection status and the tool list |
A validation error comes back | Server input handling | Input schema and the arguments sent |
A valid order returns nothing | Server authorization | The per-user access check |
The reply is slow | Backend and timeouts | Order API latency and server timeout settings |
Where AI Agents Fit in MCP
The word agent gets used loosely, so it helps to pin it down. In an MCP system, the agent is the part that plans, chooses actions, and loops until a goal is met, and that reasoning lives on the host side of the architecture.
Planning and Orchestration
The host's model reads the user's goal, breaks it into steps, and decides which tool to call next. After each result, it decides whether to call another tool, ask the user a question, or answer. Orchestration, meaning the loop around the model, belongs to the host or the agent framework it embeds, not to the servers.
Tool Execution and Context Exchange
Servers execute. A tool call goes out through a client, the server does the work, and the result comes back as context for the model's next decision. Resources and prompts feed context in the same way. That is why clear tool descriptions and well-shaped results matter so much: they are all the model has to reason with.
Role Separation and Risk Boundaries
Keeping reasoning and execution apart gives you clean risk boundaries. The model may propose an action, but the server decides whether the caller is allowed to take it, and the host decides whether the user must approve it first. Read-only tools can often run freely, while tools that write, delete, send, or spend usually deserve explicit approval.
When Human Approval Matters
Add a human step when an action is hard to undo, touches money or customer data, or is triggered by content the model read from an untrusted source. Not every MCP host is an autonomous agent. Many are assistants that suggest and then wait, and that is a perfectly sound design.
Connect AI Agents to Real Workflows Turning an agent idea into a dependable workflow means deciding how it orchestrates tools, what it may touch, and where users stay in control. Mobisoft Infotech describes AI agent strategy and custom, workflow-oriented agent development. |
Security, Permissions, and Trust Boundaries
MCP connects models to real systems, so security has to be built in layers. No single layer is enough alone, whether it is a prompt, a host confirmation, or a server check. The specification sets requirements for servers and recommendations for clients, and the guidance below builds on both.
Least Privilege and Identity
Give each server access to only what its tools need, and distinguish the user's identity from the server's own service identity. When a server acts on a user's behalf, it should check what that user may see, not what the server's credentials could technically reach. Otherwise a model can be led into fetching data the user was never entitled to.
Authorization and OAuth
Authorization is optional in MCP, and it applies differently by transport. HTTP-based servers that use it act as OAuth 2.1 resource servers. They publish protected resource metadata (RFC 9728), and clients request tokens bound to the server with the resource parameter (RFC 8707). Servers must validate that tokens were issued for them and must not accept or pass through tokens meant for other services. Client ID Metadata Documents are the preferred registration method, and Dynamic Client Registration is deprecated. Local stdio servers should read credentials from the environment instead.
Input Validation, Rate Limits, and Output
The specification says servers must validate all tool inputs, implement access controls, rate limit tool invocations, and sanitize tool outputs. Add scope and tenant checks to every handler, and return only the fields the task needs.
Prompt Injection and Untrusted Output
Tool results and resource contents are data, but a model may treat text inside them as instructions. A web page, support ticket, or document can carry hidden commands aimed at the model. Treat tool output as untrusted, avoid letting one tool's output silently trigger high-impact actions, and require approval for writes.
Logging and Secure Deployment
Log every tool call with the caller, the arguments, and the outcome, while keeping secrets and sensitive fields out of those logs. For remote deployments, use TLS, validate Origin headers, and watch for unusual call patterns. For local servers, bind to localhost. None of this guarantees perfect security, but it removes the easy failures.
Tips for Building Your Own MCP Server
Now that you know the parts, here are a few simple tips for your own build.
Keep Tools Small
Give each tool one clear job. Small tools are easier to test, and they're easier for the model to pick correctly. You can always add more tools later. Use precise names, short descriptions, and tight input schemas with required fields marked, so the model has little room to guess.
Put Security on the Server
Prompts won't keep your data safe. They tell the model how to behave, but they don't protect anything. That's why security belongs on the server itself. Check permissions every time a request comes in. Only share the data a task really needs. Keep a log of every tool call so you can look back at it later.
Test With Real Clients
Connect your server to a real host early. Ask the kind of questions your users would ask, and watch which tools the model picks. If it picks wrong, improve the tool description first. Run the same set of tests again after every change. Include authorization tests: confirm that a user without access to an order cannot retrieve it, and that error messages do not leak data.
Get Help If You Need It
Some teams build servers on their own. Others want an experienced partner for server design, security, and testing. The decision guide later in this article covers how to weigh the two.
Monitoring and Compatibility
After launch, watch error rates, latency for each tool, and which tools the model actually calls. Track which protocol revision each client uses, because handshake-era and 2026-07-28 clients can both be in the field, and re-test whenever you upgrade an SDK.
Design MCP Servers for Production Permissions, testability, deployment, and monitoring separate a working demo from a server you can run in production. Mobisoft Infotech lists custom MCP servers, enterprise integrations, deployment, access controls, and monitoring among its services. No provider can promise perfect security, but careful design lowers the risk. |
Production Readiness Checklist
Before a server goes live, walk through this checklist.
Scope: one system, a short list of tools, and a named owner for each tool.
Capability inventory: a written list of the tools, resources, and prompts the server exposes, and why.
Version compatibility: a documented list of supported MCP revisions, tested against handshake-era and 2026-07-28 clients where both matter.
Transport: stdio for local use or Streamable HTTP for shared access, chosen deliberately.
Authentication and authorization: a clear answer to how users are identified and how each call is checked.
Security controls: input validation, rate limits, output sanitizing, and approval for write actions.
Monitoring: logs, metrics, and alerts for errors, latency, and unusual call patterns.
Tests: realistic prompts run against a real host, plus authorization and failure tests.
Ownership: a named team responsible for on-call, upgrades, and incident response.
Rollback: a fast way to disable one tool or the whole server.
Build Internally or Work With an MCP or AI Agent Partner?
There is no universal answer. The right call depends on the system you are exposing, the skills you have, and how much risk a mistake carries.
When Building In-House Makes Sense
Build internally when the scope is narrow, such as one read-only server over one system, your team already knows the backend, and the cost of an error is low. A small first server is also a good way to learn the pattern before deciding how far to go.
What to Weigh
People and skills: protocol knowledge, backend expertise, and security experience, all available when you need them.
System risk: write actions, customer data, and regulated information raise the bar for design and review.
Governance: who approves new tools, reviews access, and signs off on changes.
Long-term maintenance: SDK upgrades, specification changes, and on-call coverage after launch.
Architecture review: an outside review can catch trust-boundary and authorization gaps before they ship.
When a Partner Can Help
A partner can help when you are exposing several enterprise systems, need an architecture review, or lack in-house experience with agent workflows. Mobisoft Infotech describes MCP architecture consulting, custom MCP servers, API and enterprise integrations, deployment, access controls, and monitoring, along with AI agent strategy and custom, workflow-oriented agent development. Those are the provider's stated services. Confirm scope, references, and delivery terms for your own project before committing, and compare more than one option.
Take Your Agent Architecture Beyond a Prototype A prototype proves an idea. A production agent also needs feasible workflow design, planned integrations, and clear approval points. Mobisoft Infotech describes AI agent strategy and custom development for workflow-oriented agents. |
Wrapping Up
MCP can look complicated at first, but the idea behind it is simple. The host coordinates the AI and keeps an eye on things. The client connects the host to a server. The server shares tools and data, following the rules you set. Once you understand these three jobs, the diagrams start to make sense.
It also helps you plan your own agent design. You will know where the AI makes decisions and where your data needs protection. When something breaks, you will know where to look, and the setup becomes easier to explain to leadership.
So where do you start? Keep it small. Build one server for one system and give it a few clear tools. Connect it to a real host with permissions in place and test it with real questions. Fix what doesn't work, then add more. Each new server follows the same pattern, so the next one is easier. That's the best way to approach MCP, one step at a time.
FAQ
What is MCP server architecture?
MCP server architecture is how the Model Context Protocol organizes an AI application, its clients, and the servers that expose tools, resources, and prompts. A host coordinates the model, one client manages each server connection, and JSON-RPC messages carry requests and results over stdio or Streamable HTTP.
What is the difference between an MCP host, client, and server?
The host is the AI application the user works in. A client is a connector inside the host that manages the link to exactly one server. The server is the program that exposes tools, resources, and prompts and enforces its own access rules. A host usually runs several clients, one for each server it uses.
Does an MCP server run the AI model?
No. A server exposes capabilities and acts on requests within the permissions you configure. The host orchestrates the AI model, which may itself be served remotely by a model provider.
Where do AI agents fit in MCP?
Agent reasoning sits on the host side: the model plans steps, chooses tools, and decides when it is done. Servers execute tool calls and return results. Not every host is an autonomous agent, so approval steps are common, especially for actions that change data.
What is the difference between MCP tools, resources, and prompts?
Tools perform actions or computations and are usually chosen by the model. Resources provide readable context and are typically selected by the host application. Prompts are reusable templates, usually picked by the user. These are common patterns rather than strict rules.
Does MCP still use an initialize handshake?
Earlier specification revisions use an initialize request and an initialized notification. The 2026-07-28 revision removes that exchange and the protocol-level session header, and each request carries its own version and capability metadata. Older implementations remain in use, so check which revision each side supports.
What is server/discover?
It is an optional method that clients can call under the 2026-07-28 revision to learn what a server supports. Clients are not required to call it, but servers must implement it. It covers part of what the initialize response provided in earlier revisions.
What is the difference between stdio and Streamable HTTP?
Stdio runs a server as a local subprocess that exchanges newline-delimited JSON-RPC over standard input and output. Streamable HTTP exposes one endpoint that accepts HTTP POST requests and answers with JSON or a streamed response. Stdio suits local tools, while Streamable HTTP suits shared, remote servers.
Is authorization required in MCP?
No. The specification treats authorization as optional. HTTP-based servers that use it should follow the OAuth 2.1-based flow, including protected resource metadata and audience-bound tokens, while stdio servers typically read credentials from the environment. Either way, servers still need their own access checks.
How do I keep an AI agent from taking risky actions?
Combine layers. Keep a human in the loop for sensitive actions, require approval for writes, give each tool the least access it needs, validate inputs on the server, and treat tool output as untrusted. No single control is enough, and none can guarantee a model never makes a bad choice.
Do all MCP clients and servers support the latest specification?
Not necessarily. The Tier 1 SDKs support the 2026-07-28 revision, but hosts, servers, and transports in production may still speak earlier revisions. The specification includes a compatibility matrix, and you should test against the clients your users actually have.
How should I test an MCP server?
Connect it to a real host and run realistic questions. Check which tools the model chooses, review tool descriptions when it picks wrong, and rerun the same set after every change. Add authorization tests, failure tests, and checks that error messages do not leak data.
When should a team bring in outside help?
Consider it when you are exposing sensitive or regulated systems, connecting several enterprise platforms, or lacking protocol and security experience. Many teams build a small first server themselves and bring in specialists for architecture review and production hardening.
Key Takeaways
MCP gives AI applications one standard way to reach outside tools and data.
The host coordinates the model and user consent, each client links to exactly one server, and the server exposes capabilities and enforces access.
Agent reasoning lives on the host side, while execution lives on the server.
Tools act, resources inform, and prompts guide, though who controls each is a tendency rather than a rule.
The 2026-07-28 revision replaces the initialize handshake and protocol sessions with self-contained requests, while older implementations persist.
Authorization is optional in the protocol, so servers must add their own access checks.
Validate inputs, limit privileges, treat tool output as untrusted, and require approval for write actions.
Start with one system, a few small tools, and a real host, then test and expand.
Actionable Next Steps
Pick one system and one read-only use case, such as order lookup, and write down who may access which data.
Define two or three small tools with clear names, descriptions, and input schemas.
Choose a transport: stdio for local testing, Streamable HTTP for shared use.
Confirm which MCP revision your host and SDK support, and test against it.
Add server-side authorization and input validation, then write a test that proves an unauthorized user gets nothing.
Connect the server to a real host, run ten realistic questions, and record which tool the model picks each time.
Improve the descriptions of any tool that was chosen wrongly, then rerun the same ten questions.
Turn on logging and an alert for errors and unusual call volume, and name an owner for both.
Require approval for any tool that writes, deletes, sends, or spends.
Review the production readiness checklist, then decide whether to expand or to seek an outside review.
Glossary
MCP (Model Context Protocol): an open standard that connects AI applications to external tools and data.
Host: the AI application that coordinates the model, creates clients, and handles user approvals.
Client: the connector inside a host that manages the link to one server.
Server: a program that exposes tools, resources, and prompts to clients.
JSON-RPC: the message format MCP uses for requests, results, and notifications.
Tool: a server function the model can call to perform an action or computation.
Resource: readable data identified by a URI that supplies context to the model.
Prompt: a reusable, server-defined template a user can choose to start a task.
stdio: a transport where a local server exchanges messages over standard input and output.
Streamable HTTP: a transport where messages are HTTP POST requests to one MCP endpoint.
Capability: a feature a server or client declares that it supports.
Agent: the model-driven loop that plans steps and chooses tools to reach a goal.
Prompt injection: hidden instructions in content that try to steer a model's behavior.
Sources & References
Model Context Protocol Specification, version 2026-07-28. Model Context Protocol. Accessed November 15, 2026. https://modelcontextprotocol.io/specification/2026-07-28
Architecture, version 2026-07-28. Model Context Protocol. Accessed November 15, 2026. https://modelcontextprotocol.io/specification/2026-07-28/architecture
Model Context Protocol blog, 2026-07-28 specification release post. Model Context Protocol. Accessed November 15, 2026. https://blog.modelcontextprotocol.io/posts/2026-07-28/
Tools, version 2026-07-28. Model Context Protocol. Accessed November 15, 2026. https://modelcontextprotocol.io/specification/2026-07-28/server/tools
Resources, version 2026-07-28. Model Context Protocol. Accessed November 15, 2026. https://modelcontextprotocol.io/specification/2026-07-28/server/resources
Prompts, version 2026-07-28. Model Context Protocol. Accessed November 15, 2026. https://modelcontextprotocol.io/specification/2026-07-28/server/prompts
Transports, version 2026-07-28. Model Context Protocol. Accessed November 15, 2026. https://modelcontextprotocol.io/specification/2026-07-28/basic/transports
Authorization, version 2026-07-28. Model Context Protocol. Accessed November 15, 2026. https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization
RFC 9728: OAuth 2.0 Protected Resource Metadata. Internet Engineering Task Force. n.d. https://datatracker.ietf.org/doc/html/rfc9728
RFC 8707: Resource Indicators for OAuth 2.0. Internet Engineering Task Force. n.d. https://www.rfc-editor.org/rfc/rfc8707.html


