What Is MCP? A Practical Model Context Protocol Guide
MCP, or Model Context Protocol, is an open protocol that lets an AI application connect to external tools and context through a consistent client-server interface. An MCP server can expose actions, data, and reusable prompts; the host application decides what reaches the model and what the user may approve. This guide follows specification revision 2026-07-28.
What is MCP in one sentence?
Model Context Protocol (MCP) is an open client-server protocol that gives AI applications a standard way to discover and use external capabilities and context. Instead of building a different connector for every application-data pair, developers can implement one shared protocol boundary.[1]
Anthropic introduced and open-sourced MCP on November 25, 2024, describing it as a standard for connecting AI assistants to content repositories, business tools, and development environments.[1] The protocol is now documented as an open specification at modelcontextprotocol.io; this guide reads the current stable revision, 2026-07-28, rather than an unversioned recollection.
The useful mental model is a universal adapter for AI applications. A host such as a coding assistant does not need custom logic for every timer, database, or issue tracker. It can speak MCP to any compatible server, discover what that server offers, and make structured requests. MCP standardizes that exchange; it does not decide whether a particular tool is trustworthy or whether an action should be approved.
If your immediate goal is configuration rather than protocol theory, jump to the practical Claude Code MCP guide. For ntimer's own endpoint and setup details, see the MCP page.
What are the parts of Model Context Protocol?
MCP has three architectural roles: a host application, a client created by that host, and a server that exposes focused capabilities. Each client communicates with one server, while a host can manage multiple clients and keep security decisions and combined context under its control.[2]
- Host: the AI application that coordinates connections, applies permissions, handles user authorization, and decides what context reaches the model.[2]
- Client: the protocol component inside the host. The 2026-07-28 architecture gives each client a one-to-one relationship with a server and requires requests to carry protocol version and capability metadata.[2]
- Server: a local process or remote service that publishes a focused set of capabilities while remaining isolated from other servers and the host's full conversation.[2]
Servers organize what they offer into three familiar primitives. Tools are model-invoked actions with names and input schemas, such as creating an issue or starting a timer.[3] Resources are application-controlled context identified by URIs, such as file contents or database records.[4] Prompts are user-controlled reusable templates that a client can discover and retrieve.[5] A server may support one, two, or all three.
This separation matters in practice. A resource can supply read-only background without pretending to be an action. A tool can make its required inputs explicit. A prompt can package a repeatable workflow without hard-coding it into the host. The host still owns the model experience and can present or withhold each primitive according to its policy.
How does an MCP tool call work?
An MCP tool call moves from a user's request through the host and its client to a selected server, then returns result content or an error to the host. The server advertises tools before invocation, and the application should keep a human able to deny sensitive calls.[3]
- The host connects a client to one MCP server and discovers the protocol version and supported capabilities.[2]
- The client requests the available tools. Each advertised tool includes a name, description, and input schema that helps the model form valid arguments.[3]
- The user asks for an outcome, such as “start a timer for the billing refactor.” The host gives the model the relevant tool descriptions.
- The model selects a tool and proposes structured arguments. The host applies its permission rules and may show a confirmation before anything runs; the tool specification recommends a human-in-the-loop path.[3]
- The client sends a
tools/callrequest to the server. The server validates the arguments, performs the operation, and returns result content (text, images, resource links or optional structured data) or an error.[3] - The host shows the result to the model and user. The model can explain the outcome or decide whether another permitted call is needed.
Discovery is a key difference from pasting API documentation into a prompt. The client can ask the server for its current tool list, and a capable server can notify subscribed clients when that list changes.[3] The model still does not call the service directly: the host and client mediate the request, authorization, and result.
ntimer's remote MCP server exposes tools such as ntime_start, ntime_pause, ntime_resume, ntime_stop, ntime_status, and ntime_report. An agent can start work against a project, send ntime_heartbeat while it codes, and stop the session when the task ends. If heartbeats stop, the timer closes at the last heartbeat after the configured idle period, 30 minutes by default.
Is MCP the same as an API or function calling?
No. A REST API defines a service's HTTP endpoints, function calling gives a model a schema for requesting a function, and MCP defines a complete client-server exchange for discovering and using tools, resources, and prompts. MCP servers often wrap APIs, and MCP tools can be presented to a model through function calling.
| Question | MCP | Plain REST API | Function calling |
|---|---|---|---|
| What is standardized? | Discovery and exchange of AI-oriented tools, resources, and prompts.[2] | A service's HTTP endpoints and representations | A model's structured request to run a named function |
| Who connects? | An MCP host/client connects to an MCP server | Any HTTP client connects to an API service | An application offers schemas to a model and executes accepted calls |
| Is discovery built in? | Yes; clients can list server capabilities and tools.[3] | Not inherently; documentation or another description format supplies it | The application supplies the available schemas |
| Typical use | Reuse one integration pattern across AI hosts | Expose application or business operations | Let a model choose structured actions within one application |
These are complements, not competitors. A time-tracking MCP server might call an existing REST API behind the scenes, then expose a smaller set of model-friendly tools. The host may convert those MCP tool schemas into the model provider's function-calling format. MCP supplies the interoperability and lifecycle around that model interaction.
What is the difference between local and remote MCP servers?
A local MCP server usually runs as a subprocess launched by the client over stdio; a remote server runs as an independently hosted service reached over Streamable HTTP. The 2026-07-28 specification defines both as standard transports with the same protocol semantics.[6]
| Concern | Local server | Remote server |
|---|---|---|
| Location | Runs on your machine | Runs at an HTTPS service |
| Standard transport | stdio | Streamable HTTP |
| Lifecycle | Client launches and stops the process | Service operates independently |
| Good fit | Local files, developer tools, machine-only access | Shared SaaS data, centrally maintained services, multiple devices |
| Credentials | Usually supplied through the local environment | Often an OAuth access token |
With stdio, newline-delimited protocol messages travel through a client-launched process's standard input and output. With Streamable HTTP, messages are HTTP POST requests to one MCP endpoint, and a reply is either a JSON object or a request-scoped event stream.[6] The protocol meaning stays the same across both transports.
Remote does not automatically mean public. An HTTP MCP server can require authorization, restrict scopes, and expose different capabilities to different users. Local does not automatically mean safe: launching an untrusted package gives that process the operating-system access of the client user, so review the command and source before enabling it.[8]
How does OAuth work with a remote MCP server?
Authorization is optional in MCP, but protected HTTP servers should follow the specification's OAuth-based flow. The client discovers the authorization server, obtains user approval and an access token, then presents that token only to the intended MCP resource.[7]
The 2026-07-28 authorization specification is based on OAuth 2.1 and related discovery and protected-resource standards. It assigns the protected MCP server the resource-server role, the MCP client the client role, and a separate or co-hosted authorization server the job of authenticating the user and issuing access tokens.[7]
- The client requests the protected MCP endpoint and receives an authentication challenge.
- It reads protected-resource metadata to discover the appropriate authorization server.[7]
- The user signs in and approves the requested access in the authorization flow.
- The client exchanges the authorization code for an access token bound to the intended MCP resource.[7]
- Later MCP requests carry the token; clients should request only the scopes needed for the operation.[7]
ntimer serves MCP over HTTPS at https://api.ntimer.app/mcp. A compatible client opens OAuth sign-in on first use, so the user authorizes their own ntimer account. The same endpoint can then expose permitted timer, worklog, work-tree, mind-map, and mail-draft tools.
Is an MCP server safe to use?
MCP provides security boundaries and authorization patterns, but a server is not safe merely because it speaks MCP. You should verify its source, review requested access, keep a human approval path for consequential tools, use least privilege, and treat external content as potentially hostile.[3][8]
- Keep consent visible. The tool specification recommends showing which tools the model can use, indicating when a tool runs, and allowing a human to deny invocations.[3]
- Grant the minimum access. The authorization specification tells clients to request only the scopes necessary for their intended operations.[7]
- Verify local commands. An untrusted local server can execute with the client's operating-system privileges; prefer reviewed packages and narrowly scoped filesystem access.[8]
- Expect prompt injection. Malicious text in fetched pages, tickets, documents, or tool results can try to redirect the assistant's behavior. Anthropic advises reviewing suggested commands, not piping untrusted content directly to Claude, and using virtual machines for scripts and tool calls that touch external services.[9]
- Confirm consequential writes. Reading a status is different from deleting records or sending mail. Use permissions and explicit confirmation proportional to impact.
A useful review asks four questions: Who operates this server? What data can it read? Which actions can it take? Where do its credentials and results go? MCP makes capabilities discoverable, but you still need to inspect them. Authorization proves what a caller may access; it does not prove that every server response or model decision is benign.
Where can I find an MCP servers list?
Start with the official MCP Registry for published server metadata, then use the Model Context Protocol servers repository for a small set of reference implementations. A listing helps discovery, but you must still evaluate ownership, permissions, maintenance, and security before installing or authorizing a server.[10][11]
The official MCP Registry (currently in preview) is a centralized metadata repository for publicly accessible MCP servers. It records standardized metadata such as a unique name, package or remote URL, description, and capability information, and it offers a discovery API for clients and aggregators.[10] Browse it when you need a current catalog rather than relying on an old blog post.
The official modelcontextprotocol/servers repository serves a different purpose. Its maintainers say it contains a small collection of educational reference servers, not a comprehensive catalog or production-ready promise, and direct people seeking a list to the Registry.[11] That distinction prevents a common mistake: treating example code as a vetted hosted service.
- Prefer a server published by the service owner or a maintainer you can identify.
- Check whether it is local or remote and whether the requested deployment matches your needs.
- Read the tool list and requested OAuth scopes before approval.
- Look for maintained documentation, version history, and a clear security contact.
- Test read-only operations first, then enable write actions deliberately.
What does a real MCP server do for time tracking?
A time-tracking MCP server turns natural-language work events into structured timer and worklog actions. With ntimer, a coding agent can start, pause, resume, and stop sessions, maintain activity through heartbeats, inspect status, and produce reports without inventing its own time records.
Imagine asking an agent to fix a billing bug. It calls ntime_start against the relevant work, sends ntime_heartbeat every few minutes while it edits and tests, and calls ntime_stop when finished. The server, not the model's prose, becomes the source of the recorded session. If the agent disappears, the heartbeat rule prevents a forgotten timer from accumulating unlimited idle time.
The same server can expose ntime_log for a completed session, ntime_edit_session for a correction, ntime_report for totals, and ntime_list_works for project selection. Because these are explicit tools, the host can distinguish a read from a write and ask for confirmation where appropriate. This is the practical value of MCP: a reusable protocol boundary around real domain operations.
In Claude Code, add the remote server with claude mcp add --transport http -s user ntime https://api.ntimer.app/mcp, then run claude mcp login ntime. Once connected, ask Claude to start a timer for a named work and stop it when the task is complete. You can create an ntimer account to try the workflow.
Questions
What does MCP stand for in AI?
MCP stands for Model Context Protocol. It is an open protocol for connecting AI host applications to servers that expose tools, resources, and prompts through a consistent client-server exchange.[1][2]
Does MCP replace REST APIs?
No. An MCP server can call REST APIs behind the scenes and present selected operations as AI-oriented tools. REST remains the service interface; MCP adds standard discovery, capability exchange, and model-facing primitives around integrations.
Can one AI application use several MCP servers?
Yes. An MCP host can manage multiple client instances, while each client has a one-to-one relationship with a particular server.[2] The host combines the permitted context and keeps servers isolated from one another.
Do all MCP servers require OAuth?
No. Authorization is optional, and the specification's OAuth flow applies to HTTP-based transports. Stdio servers should obtain credentials from their environment instead of following that HTTP authorization flow.[7]
Is the official MCP servers repository a production-ready catalog?
No. Its maintainers describe those servers as reference implementations for learning and direct people who want a broader MCP servers list to the official Registry.[11] Evaluate every listing against your own security and reliability needs.
Sources
- Introducing the Model Context Protocol, Anthropic, 2024. accessed Nov 21, 2026. Back
- Architecture, Model Context Protocol, 2026. accessed Nov 21, 2026. Back
- Tools, Model Context Protocol, 2026. accessed Nov 21, 2026. Back
- Resources, Model Context Protocol, 2026. accessed Nov 21, 2026. Back
- Prompts, Model Context Protocol, 2026. accessed Nov 21, 2026. Back
- Transports: Overview, Model Context Protocol, 2026. accessed Nov 21, 2026. Back
- Authorization, Model Context Protocol, 2026. accessed Nov 21, 2026. Back
- Security Best Practices, Model Context Protocol, 2026. accessed Nov 21, 2026. Back
- Security, Anthropic. accessed Nov 21, 2026. Back
- The MCP Registry, Model Context Protocol. accessed Nov 21, 2026. Back
- Model Context Protocol servers, Model Context Protocol. accessed Nov 21, 2026. Back