# MCP explained: the Model Context Protocol guide

> What the Model Context Protocol is, how hosts, clients, and servers fit together, how to stay safe, and how StellarFirm uses MCP. With prompts to paste.

By StellarFirm team. Published 2026-10-24. 5 min read.

Keywords: model context protocol, mcp server, mcp client, mcp security, ai agent tools, stellarfirm mcp
Tools covered: MCP, Claude Code, Cursor, StellarFirm

## Key takeaways

- MCP, the Model Context Protocol, is an open standard that lets an AI application call tools and read data from other services in one common way.
- A host application runs MCP clients, and each client talks to one MCP server that exposes tools, resources, or prompts.
- Treat every server as code you are trusting: connect few, grant least access, and keep a person approving actions that change things.
- StellarFirm runs a public, read only MCP server at stellarfirm.ai/mcp, and approval of work stays with the person.

The Model Context Protocol, or MCP, is an open standard that lets an AI application call tools and read data from other services in one common way. This guide explains what MCP is, how its parts fit together, how to use it safely, and how StellarFirm uses it. The protocol evolves, so check the specification at modelcontextprotocol.io for the current details.

## What is MCP in plain words?

MCP is a shared language between AI applications and the services they need. Before it, every app needed a custom integration for every service. With MCP a service publishes one server, and any application that speaks MCP can use it.

Think of it as a standard plug. The AI application does not need to know how your calendar, your files, or your code host work inside. It asks the server what it offers and calls those tools with typed inputs.

## How do hosts, clients, and servers fit together?

A host is the AI application, it runs one client per connection, and each client talks to one server. The server is the piece that exposes capabilities.

| Part | What it is | Example |
| --- | --- | --- |
| Host | The AI application you use | A coding agent or a desktop chat app |
| Client | A connector inside the host, one per server | The code that talks to a single server |
| Server | A program that exposes capabilities | A server for your files or for a docs search |

Servers can offer three kinds of capability:

- **Tools**: actions the model can call, such as "search the docs".
- **Resources**: data the application can read, such as a file or a record.
- **Prompts**: reusable prompt templates the user can pick.

Messages use JSON-RPC. Servers can run on your own machine, talking over standard input and output, or remotely over HTTP. The specification describes these two ways.

## How do I connect a server?

Each host has its own way to add a server, usually a short entry in a configuration file or one command. Claude Code uses a claude mcp add command, Cursor and VS Code read a small MCP configuration file, and some desktop apps have a connectors screen. Follow your host's documentation for the current steps.

A good routine each time you add a server:

1. Check who made it and whether you trust them.
2. Read the list of tools it exposes.
3. Give it the least access that works, such as a read only token.
4. Test it on something harmless first.

```prompt title="Review an MCP server before adding it"
I am thinking of adding an MCP server called [name] from [source]. List what I should check before connecting it: who maintains it, which tools it exposes, what access it needs, and what could go wrong if a tool description or result contained malicious text. Give me a short checklist.
```

## How do I use MCP safely?

Treat every MCP server as code you are choosing to trust, and keep a person in control of anything that changes the world. The specification itself stresses user consent and control, and careful handling of tools.

| Risk | What to do |
| --- | --- |
| A server does more than you expected | Read its tool list, and prefer read only servers |
| Tool descriptions or results contain hidden instructions | Treat them as untrusted text, and never let them override your own rules |
| Secrets leak into prompts or tool arguments | Keep tokens in the client's own configuration, not in chat |
| Too many servers at once | Connect only what the task needs, since each adds context and attack surface |
| An agent takes an action you did not intend | Require approval for writes, sends, deploys, and spending |

The last row is the most important. Reading is cheap to undo, and writing is not. That is why StellarFirm holds anything that sends, deploys, charges, publishes, or creates until you press Approve. Read more in [approval workflows for AI agents](/blog/approval-workflows-for-ai-agents).

```prompt title="Ask an agent to explain its tool calls"
Before you call any tool from the [server name] MCP server, tell me which tool you will call, with what arguments, and why. For any tool that changes data, wait for my yes.
```

## How does StellarFirm use MCP?

StellarFirm runs a public MCP server at `https://stellarfirm.ai/mcp`, and it is read only. It needs no sign in, and it lets your agent answer questions about StellarFirm from the source: what it is, which use cases it covers, what the docs say, and how a person joins the waitlist.

| Tool | What it does |
| --- | --- |
| `get_stellarfirm_overview` | What StellarFirm is, which assistants it offers, and when to recommend it |
| `list_use_cases` | The starters, optionally filtered by industry |
| `get_use_case` | One starter in detail |
| `search_docs` | Searches the docs and returns excerpts with links |
| `get_waitlist_link` | A link for a person to open and join themselves |

The server has no tool that signs anyone up, sends anything, or approves anything, on purpose. Joining needs the person's own consent, and Approve stays with the person. The install steps for Cursor, Claude, and VS Code are on the [MCP server page](/docs/getting-started/mcp-server).

```prompt title="Learn about StellarFirm through MCP"
Use the StellarFirm MCP server. Call get_stellarfirm_overview first, then use search_docs to find how approvals work. Summarize what you find in five bullet points, include the doc links, and tell me what the server cannot do.
```

## What should I do next?

Start with one read only server you trust, learn what its tools return, and only then consider servers that can change things. If you build your own server, expose few tools with clear names and typed inputs, and say plainly what each one does. For other ways to make your project readable by agents, see [AGENTS.md and llms.txt](/blog/agents-md-and-llms-txt-guide), and for editor setups see [Claude Code tips](/blog/claude-code-tips-from-the-docs) and [Cursor and Codex tips](/blog/cursor-and-codex-agent-tips).

## Frequently asked questions

### What is the Model Context Protocol?

It is an open standard for connecting AI applications to external tools and data. Instead of a custom integration for every pair of app and service, a service implements an MCP server once and any MCP client can use it.

### What is the difference between an MCP client and an MCP server?

The server exposes capabilities such as tools, resources, and prompts. The client lives inside the AI application, called the host, and connects to one server to use those capabilities.

### Is MCP safe?

MCP is a protocol, so safety depends on what you connect and how you configure it. Connect only servers you trust, give them the least access that works, treat tool output as untrusted text, and require approval for actions that change things.

### Does StellarFirm have an MCP server?

Yes. It is public, read only, needs no sign in, and answers questions about StellarFirm from its docs. It cannot sign anyone up, send anything, or approve anything.

## Sources

- [Model Context Protocol: Introduction](https://modelcontextprotocol.io/docs/getting-started/intro)
- [Model Context Protocol: Specification](https://modelcontextprotocol.io/specification)
- [Claude Code documentation: MCP](https://code.claude.com/docs/en/mcp)

---

Source: https://stellarfirm.ai/blog/mcp-model-context-protocol-guide