MCP explained: the Model Context Protocol for AI workspaces.

Updated 2026-04-27 · 10 min read

If you've heard MCP referenced and wondered whether it matters or if it's just another acronym, this is the page. I'll cover what problem MCP actually solves, how it works mechanically, what you can do with it today, and how Projelli uses it.

The problem MCP solves

For most of 2023-2024, every AI tool that wanted to connect to external data had to build that connection itself. ChatGPT had its own plugins format. Cursor had its own context system. Claude Desktop had its own. If you wrote a connector for a private database, you wrote it three times to support three tools. If you wanted a new tool to access the same database, you wrote a fourth.

The pattern was very 1995-Web-protocols-era. Lots of duplication, no shared standard.

MCP standardizes the connector. You write one MCP server for your database. Every MCP-compliant client can use it. New clients become useful instantly without each having to ship its own data integrations.

Concretely:

• Before MCP. Your AI tool can read files in its own special way. To add it to a different tool, you start over.
• With MCP. Your filesystem MCP server works for any MCP client: Claude Desktop, Cursor, Projelli, the next tool that comes along.

That's it. The acronym is intimidating; the underlying idea is the kind of plumbing the web has been doing for decades.

The architecture

MCP defines three roles:

• Host. The desktop app the user actually interacts with (Claude Desktop, Projelli). The host runs the AI conversation and manages connections to MCP servers.
• Client. The bit of the host that speaks the MCP protocol to a specific server. A host can run many clients, one per connected server.
• Server. A small program that exposes a capability (read files, query a DB, fetch from an API). Servers can run as a local subprocess, an HTTP service, or any transport that supports JSON-RPC.

Each MCP server can offer:

• Resources. Read-only data the AI can pull in (a file's contents, a table row, a Slack message thread).
• Tools. Actions the AI can take (write a file, run a query, send a message). Tool calls go through the host's approval flow before execution.
• Prompts. Reusable templates the host can present (e.g., "summarize this document" with the document already attached).

When you talk to your AI workspace and it accesses your files or your calendar or your codebase, here's what's really happening: the host sees that the AI's response includes a tool call ("read this file"), the host routes that call to the relevant MCP client, the client sends a JSON-RPC request to the server, the server runs the action and returns the result, the result feeds back into the AI's context, the AI generates the next part of the response. All in a few hundred milliseconds.

A concrete example

Say you're working on a customer interview synthesis. You ask your AI:

"Look through the customer interviews in ~/projects/acme/interviews/ and pull out everyone who mentioned pricing concerns."

Without MCP, the AI has no way to read that folder. The conversation goes sideways: "I can't access your filesystem; please paste the contents."

With MCP and a filesystem server connected:

1. The AI plans the work and emits a tool call: fs.list("/Users/you/projects/acme/interviews/")
2. The host receives the tool call
3. If the server is configured to require approval (a sensible default for write operations; reads are often allowed without prompt), the host shows you the request
4. The filesystem server returns the list of files
5. The AI sees the list, plans the next action, and starts requesting individual file contents
6. For each interview, it pulls the contents, finds pricing-relevant sections, and starts assembling a synthesis
7. The final response includes a written synthesis with citations to specific interview files

You see this happen in real-time as a flowing conversation. The AI is "doing research" against your actual data, with you in the loop on any destructive action.

What kinds of MCP servers exist today

The community-built MCP server registry at github.com/modelcontextprotocol/servers lists hundreds. Highlights:

Server	What it exposes
Filesystem	Read, write, list files in a workspace folder
GitHub	Read repos, browse issues, search code, file PRs
Slack	Read channels, search messages, post replies
Google Drive	List documents, read content, edit Docs / Sheets
Postgres / SQLite	Query a database, inspect schema
Notion	Read pages, search a workspace, create new pages
Linear / Jira	Read issues, create tickets, update status
Brave Search / Tavily	Web search
Custom	Whatever you build for your own data

Most are 50-300 lines of TypeScript or Python and run locally as a subprocess of the host app. Setup is typically: install the server (npm install or pip install), add a snippet to the host's MCP config file, restart the host.

How Projelli uses MCP

Projelli is both an MCP client and exposes itself as an MCP-compatible workspace.

As a client: Projelli can connect to any MCP server you configure. That means you can wire your Projelli workspace to your GitHub account (via the GitHub server), your Slack (via the Slack server), your Postgres (via the database server), or any custom internal data source you build a server for. The AI conversations in Projelli can then read from and write to those external sources, with Projelli's standard "ask before destructive operations" approval flow.

As a workspace: every Projelli workspace is already a folder of Markdown files. Tools that can read files (any MCP filesystem server, any other text-aware tool) can access your Projelli workspace without any special integration. Your data in, data out.

For the technically-minded: Projelli uses the official Anthropic MCP SDK. Server config is exposed in Settings → AI → MCP Servers. Each server runs as a separate subprocess that Projelli manages.

Should you care about MCP?

If you're an indie founder using AI for general workspace work (writing, planning, drafting), the answer depends on what data sources you want the AI to access:

• If you want the AI to read your project files, every modern AI workspace tool already does this via its built-in filesystem awareness, with or without MCP. You probably don't notice the difference.
• If you want the AI to read your GitHub, Slack, Notion, or another SaaS service, MCP is the cleanest way. Pick a tool that supports MCP, install the relevant server, done.
• If you have a private data source you want the AI to access (your customer database, a legacy system, a homegrown CRM), MCP is the standard way to expose it. Build one server, every MCP-compliant tool can use it.

For founders specifically, the most common useful MCP integrations are GitHub (for code-adjacent work), Notion (for migrating away from cloud workspaces), Postgres or SQLite (for any database-backed product where you want the AI to do analysis), and a custom server for whatever your particular product touches.

Building your own MCP server (briefly)

If you have something specific to expose, the official SDKs make a basic server about 50 lines. Here's the shape, in TypeScript:

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server(
  { name: "my-server", version: "0.1.0" },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(/* schema */, async (request) => {
  // your tool logic here
  return { content: [{ type: "text", text: "result" }] };
});

const transport = new StdioServerTransport();
await server.connect(transport);

The full guide is at the MCP documentation site. Anthropic and the community maintain reference implementations for both Python and TypeScript SDKs.

Frequently asked questions