MCP for PMs: plug AI into your tools and scope an MCP server
What MCP is (host, client, server), what a PM can connect with it, and how to scope your product’s own MCP server safely, plus a free spec template.
Guide written by Alex Dionisio, Senior Product Manager. Updated November 13, 2026.
In short
MCP (Model Context Protocol) is an open protocol that lets an AI application such as Claude connect in a standard way to external tools and data: Notion, Jira, a database or your own product. For a product manager, MCP matters twice: it lets you plug useful sources into your assistant, and it forces you to decide which tools and data your product exposes to agents, and with what permissions.
What is MCP, exactly?
MCP, the Model Context Protocol, is an open standard for the way AI applications exchange with external services. A service describes its capabilities once as an MCP server, and any compatible AI application can then use it without a custom integration.
Before MCP, every assistant had to build its own integration for every tool: one Notion connector here, another one there, each with its own rules. The protocol replaces that duplicated work with a shared contract. The official specification defines the messages exchanged (in JSON-RPC), the role of each party and the security rules implementers are expected to follow.
In practice, MCP does not make a model smarter. It gives it hands and eyes: read a ticket, search a knowledge base, create a task. The model decides when to call a tool, which relies on tool calling; MCP standardizes how those tools are discovered and invoked.
For a one-line definition, see the MCP glossary entry. If you are weighing MCP against a classic integration, the MCP vs API guide compares both approaches.
Host, client, server: who does what in MCP?
In MCP, the host is the app in front of the user, the client is the part of the host that manages the connection to one specific server, and the MCP server is the program that exposes a service’s capabilities. One host can run several clients, one per server.
The split matters because each role carries different responsibilities:
- The host (Claude Desktop, an IDE, your own assistant) runs the show: it creates clients, enforces security policy and collects the user’s consent.
- The client keeps a dedicated connection to a single server. It is an implementation detail for you, but it explains why two servers do not see each other’s data.
- The server exposes what a service can do. It can run on your machine (launched by the host) or remotely over HTTP.
The specification defines two standard transports: stdio for a local server launched by the application, and Streamable HTTP for a remote one. For a remote server that restricts access, the spec’s authorization is built on OAuth 2.1: the user signs in to the service and grants access, without pasting a password into the assistant.
The useful question for a PM is simple: who controls the host, who controls the server, and where does data flow between them.
Tools, resources and prompts: what can an MCP server expose?
An MCP server exposes three kinds of capabilities: tools, which the model decides to call to act or fetch information; resources, data the application attaches to the context; and prompts, instruction templates the user triggers on purpose.
The specification ties each kind to whoever is in control of it, and that is the most useful idea when scoping a product:
- Tools: model-controlled. Examples:
search_tickets,create_task. They are the most powerful and the riskiest, because the agent calls them on its own. - Resources: application-controlled. Examples: a page’s content, a database schema, a file. They add context without triggering any action.
- Prompts: user-controlled. Example: a “summarize this sprint” command offered in a menu. They package a frequent request.
On the client side, the specification also describes capabilities the host can offer the server, such as asking the user for input mid-task (elicitation). These parts change between versions: check the current specification before turning one into a product requirement.
A practical rule of thumb: what reads tends to be a resource, what acts is a tool, and what users repeat on demand is a prompt.
What can a product manager connect with MCP?
A product manager can use MCP to connect everyday work tools to an AI assistant: ticket tracking such as Jira, documentation such as Notion, analytics, a read-only database or a code repository. The assistant can then combine these sources to draft a summary, a spec or an analysis.
The use cases that pay off are the ones that remove copy-paste between tools:
- Prepare a sprint review: read closed and open tickets, summarize progress and flag blockers.
- Write a spec with real context: pull discovery pages, customer feedback and linked tickets before drafting.
- Query data: ask a plain-language question of a database or analytics tool in read-only mode, then check the query it produced.
- Triage feedback: group support tickets by theme and suggest priorities that you approve.
To connect Claude to Notion or Jira, look first for a server published by the tool’s own vendor, then add it to your AI application by following that vendor’s instructions. Start read-only: you will see what the agent does with the data before you let it write anything.
When the same know-how comes back every time (a writing style, a checklist), it usually belongs in a skill rather than an MCP server: the Skills vs MCP guide helps you decide, and the Claude Skills guide shows how to write one.
How do you scope your product’s MCP server?
Scoping your product’s MCP server means answering five questions before any code is written: which users and which jobs, which tools to expose and which to leave out, what data each tool reads or changes, which permissions and authentication, and how you will measure usage.
An MCP server is a product surface, not a raw technical dump of your API. Agents will read it the way a person reads a screen. The method fits in a few steps:
- Start from jobs: list three to five real jobs your customers will want to hand to an agent. Every tool must serve at least one of them.
- Pick few, well-named tools: an explicit name, a description that says which situations call for it and which do not, typed parameters. An agent picks badly among thirty similar tools.
- Split read from write: tools that change or delete data are separate, labeled as such and gated behind confirmation.
- Bound the data: state what each tool returns and what it never returns (personal data, internal fields).
- Set permissions and auth: each call runs under the identity and permissions of the person who is logged in, never through an all-powerful service account.
- Plan measurement: which calls to log, which metrics to track, which threshold triggers a review.
The MCP-SERVER-SPEC.md template below follows this outline. To design tool definitions that models call correctly, the course on agents and tool calling goes deeper, and the API integration course helps you frame what your API already does.
What security risks does MCP bring, and how do you reduce them?
The main MCP risks are prompt injection hidden in data or tool descriptions, overly broad permissions granted to the agent, actions taken without clear consent and unvetted third-party servers. You reduce them with least privilege, confirmation of actions and a review of every server you connect.
The MCP specification sets out three principles: users explicitly consent to access and actions, their data is not shared without their agreement, and tools are treated as arbitrary code execution. It also says descriptions of tool behavior, such as annotations, should be considered untrusted unless they come from a trusted server, and that the protocol cannot enforce these rules on its own: hosts and servers have to.
Turned into product requirements:
- Consent: any action that writes, sends or deletes asks for a readable confirmation that says what will happen.
- Prompt injection: a ticket or a page can carry malicious instructions that the agent reads as orders. See prompt injection; never let external content trigger a sensitive action on its own.
- Least privilege: narrowly scoped, per-user, revocable tokens, with read-only as the default.
- Supply chain: a third-party server can change behavior after you install it. Prefer official servers, pin versions and review the exposed tools after each update.
The lesson Risks specific to MCP walks through these scenarios, and the AI product security course covers the wider set of AI features.
How do you evaluate an MCP server, third-party or your own?
To evaluate an MCP server, check who publishes and maintains it, the exact list of tools and permissions it requests, how it behaves on real tasks in read-only mode, and how the agent copes with edge cases or booby-trapped data.
Whether you are plugging in a third-party server or testing your product’s own, the checklist is the same:
- Provenance: official vendor or community project, recent activity, a published security policy.
- Surface: number of tools, share of tools that write, OAuth scopes requested compared with the need.
- Description quality: does an agent pick the right tool on the first try for your typical jobs?
- Results: are responses complete, paginated and free of needless sensitive fields?
- Edge cases: an ambiguous request, missing data, content that carries a fake instruction.
For your own server, turn the jobs from the spec into a test set: a list of requests, the expected tool and the result you consider correct. Rerun it whenever a description or the model changes, because a single rewording can shift which tool an AI agent chooses.
Which MCP mistakes should PMs avoid?
Common PM mistakes with MCP are exposing the whole API without curation, granting write access from day one, assuming an MCP server makes the product work with every assistant at no cost, and forgetting to measure how the tools are actually used.
- Exposing everything: turning each endpoint into a tool drowns the agent. A few job-oriented tools work better.
- Writing too early: start read-only, watch, then open write access one tool at a time.
- Mixing up protocol and product: MCP solves the plumbing, not the value. If nobody wants to hand the job to an agent, the server will sit unused.
- Installing without reading: adding a community server found in a list without checking its tools or code.
- Forgetting what comes after: no call log, no owner, no review when the specification or the clients change.
MCP is worth the effort when your users already work inside AI assistants and want your product there too. To decide between using existing servers and exposing your own, without opening a security hole, the course on connecting AI to your tools with MCP takes you to a reasoned decision plus a connected server, restricted and checked.
Free template: MCP-SERVER-SPEC.md
Fill in this file before asking your engineering team for an MCP server, then review it with them. Delete the sections you do not need and keep one line per tool.
Download MCP-SERVER-SPEC.md# MCP server spec: [product name]
## Why
- Problem: [what users want to do from their AI assistant]
- Target users: [who, with which assistant]
- Out of scope: [what the server will not do]
## Target jobs (3 to 5)
1. [Job]: [expected result]
2. [Job]: [expected result]
3. [Job]: [expected result]
## Exposed tools
| Tool | Serves job | Read or write | Confirmation required |
|------|------------|---------------|-----------------------|
| [explicit_name] | [#] | Read | No |
| [explicit_name] | [#] | Write | Yes |
Each tool description states:
- the situations it fits and the ones it does not;
- its parameters and their allowed values;
- what it returns.
## Resources and prompts (optional)
- Resources: [read-only data attached to context]
- Prompts: [commands offered to the user]
## Data
- Returned: [fields]
- Never returned: [personal data, internal fields, secrets]
## Permissions and authentication
- Transport: [local / remote]
- Authentication: [OAuth with the user's account]
- Granted scopes: [read-only by default, write listed tool by tool]
- Revocation: [how the user cuts access]
## Security
- Actions that require confirmation: [list]
- External content treated as untrusted: [tickets, comments, pages]
- Usage limits: [number of calls, returned volume]
## Evaluation
- Test set: [10 requests, expected tool, correct result]
- Launch criterion: [threshold to reach]
## Measurement after launch
- Metrics: [calls per tool, errors, successful jobs]
- Owner: [who reviews the server and how often]
Put it into practice
The “Connect AI to your tools and data with MCP” course walks you through it step by step, on your own product, all the way to the deliverable.
See the courseFrequently asked questions
Do I need to code to use MCP?
Not to plug in an existing server: many AI applications let you add a server or connector without code, through a screen or a command. Building your product’s own server takes an engineering team; your job is to write the spec and approve the exposed tools.
What is the difference between MCP and an API?
An API is built for developers who write an integration. An MCP server targets AI applications that discover and call tools on their own. An MCP server often sits on top of an existing API; the MCP vs API guide covers the choice in detail.
Does MCP only work with Claude?
No. Anthropic introduced MCP, but it is an open protocol with a public specification, adopted by other AI applications and developer tools. Check each application’s support before you commit.
Is an MCP server safe by default?
No. The specification describes consent and security principles, but applying them is up to the host and the server. Check provenance, limit permissions and confirm sensitive actions.
When should a product expose its own MCP server?
When your customers already use AI assistants and want to complete specific jobs with your product from there. Without identified jobs and real demand, an MCP server is just one more feature to maintain.