A Gentle Introduction to MCP

Or: What It Is, Why It Matters, and How You Can Actually Use It

As we move into 2026, something significant has been reshaping how we work with AI tools. Not through dramatic model upgrades or shiny new apps — but through something more subtle and powerful: MCP, the Model Context Protocol. What started as an emerging standard in 2025 has now become mainstream, with major development tools and AI platforms adopting it at an accelerating pace.

If the term sounds technical or mysterious, you’re not alone. Many readers of this blog have written to me saying the same thing:

“Elena, I hear people talk about MCP in Cursor or Antigravity, but… what is it actually? And do I need it?”

So today, we’ll take it slowly. This post explains:

• what MCP really is (in human terms),
• why it’s becoming important,
• how popular AI tools use it,
• and how you can bring MCP into your writing or coding workflow — even if you’re not a backend engineer.

My goal is to help you feel comfortable with the idea that MCP is not a scary protocol. It’s more like a polite assistant who knows how to knock.

🌿 MCP Ecosystem Updates in 2026

MCP got a formal specification revision this year (dated 2026-07-28), and the ecosystem has grown alongside it. That revision is a genuinely big one — it moves MCP from a stateful, bidirectional protocol to a stateless request/response core, which is what lets MCP servers now run on serverless and edge infrastructure instead of needing a long-lived process.

• Wider adoption: major IDEs and AI tools now ship with built-in MCP support
• A growing ecosystem: hundreds of MCP servers exist for common tasks — databases, APIs, file systems
• A settled protocol: the July 2026 spec revision cleaned up a lot of the rough edges from the early days
• Production use: MCP is no longer experimental — it runs in real workflows, including mine

If you’ve been waiting to try MCP, this is a good time to start.

🌿 MCP Definition: What Is the Model Context Protocol?

Imagine an AI agent as a very clever helper sitting at your desk. It can read, write, summarise, answer questions — but it has one big limitation: it cannot touch anything.

It can’t open files. It can’t run programs. It can’t fetch data from your laptop. It can’t trigger your scripts or tools. Without special permission, the AI is trapped inside a conversation window.

MCP changes that. It’s a standardised way for AI assistants to:

• call tools,
• run scripts,
• read files,
• update documents,
• and interact with your apps

— with your consent and full visibility.

In practice:

MCP gives AI the ability to use tools safely, the same way humans use apps on their computer.

This standardised tool-calling model is why so many systems adopted MCP: Cursor, Antigravity, Claude Desktop, and several emerging agent frameworks.

🌿 When You Need MCP: Use Cases for Developers and Writers

You might be thinking:

“I’m just writing blog posts and some Python… Do I really need a protocol?”

Maybe not immediately, but the moment you want your AI to:

• edit Markdown files directly,
• test code inside those files,
• organise your notes,
• generate summaries from your drafts,
• or run small automations on your machine,

MCP becomes the easiest, safest way to do it.

MCP creates a small doorway between:

• your tools,
• your AI,
• and your local environment.

Nothing sneaky. Nothing hidden. You see exactly what tools are available, and the AI can use them only with your permission.

🌿 MCP Definition Summary

For your notes or your first workshop:

MCP = A safe way for AI tools to call functions, run programs, or read/write files on your machine — with clear rules and full user control.

That’s it. Once you understand this, everything else becomes just implementation detail.

🍃 MCP Workflow Integration: Tools I Connect With It

Since many of you asked how I use MCP in my daily writing and coding setup, here’s the picture:

My current tools:

• Obsidian → drafting space
• PyCharm → final blog editing & code
• GitHub Pages → site hosting
• Ollama → local AI model for drafts and rewrites
• A small FastMCP tool server → lets AI read/write Markdown files
• Cursor / Antigravity → coding with AI in the IDE

What makes this work smoothly is that MCP sits quietly in the background, connecting these pieces without forcing me into a new platform.

For example:

• I can ask an AI assistant to summarise a long research note from my Obsidian vault.
• Or improve a draft in drafts/my_post.md.
• Or test all Python code blocks in a blog post.
• Or generate an outline for a new post.
• Or run a PDF export script for book chapters.

The AI calls a tool → the tool performs the action → the AI continues helping me.

Nothing magical. Just small, precise steps that remove friction.

🌿 How to Get Started with MCP: Installation Steps

1. Install an MCP host. Claude Desktop or Cursor both work out of the box.
2. Try a pre-built server. Visit the MCP servers repository and connect one of the reference servers — Filesystem and Fetch are good first ones to try.
3. Write your first tool. Use the Python example below to connect your own local folders.

The beauty of MCP is that you stay in control. Your writing stays in Markdown, your data stays local, and the AI simply lends a hand where you need it most.

🌿 MCP Security: Do You Need API Tokens?

One of the most common questions I get is: “If I use MCP, do I have to manage a dozen different API keys?”

The answer is: only if you are leaving your computer.

1. Local tools (no tokens): if you write an MCP tool to organise your blog files or run local Python tests, you don’t need any keys. The tool is just a Python script running on your machine.
2. Existing logins: you can build tools that use CLIs you’ve already logged into (like the GitHub gh CLI). The AI uses your existing session, so you don’t have to copy-paste secret tokens into config files.
3. External services: only when your tool needs to talk to something like a cloud image API or Slack will you need an API key, usually stored safely in an environment variable.

🍃 Python MCP Server Example: Building a Blog Manager Tool

If you’re a Python developer, you don’t need to be a backend engineer to build an MCP server. Using the fastmcp library (pip install fastmcp), you can create a “Blog Manager” in a few lines of code:

import re
from pathlib import Path

from fastmcp import FastMCP

POSTS_DIR = Path("_posts")

# Initialize MCP Server
mcp = FastMCP("BlogManager")


def _safe_slug(title: str) -> str:
    """Turn a title into a filesystem-safe slug — never trust raw input
    as a path, even when it's coming from your own AI assistant."""
    slug = title.strip().lower()
    slug = re.sub(r"[^a-z0-9]+", "-", slug).strip("-")
    return slug or "untitled"


@mcp.tool()
def create_draft(title: str, content: str) -> str:
    """Creates a new markdown draft in the _posts folder."""
    filename = POSTS_DIR / f"{_safe_slug(title)}.md"
    filename.write_text(f"---\ntitle: {title}\n---\n\n{content}", encoding="utf-8")
    return f"Draft saved to {filename}"


@mcp.tool()
def check_python_snippets(file_path: str) -> str:
    """Reads a blog post and verifies if the Python code inside actually runs."""
    # Extract fenced ```python blocks and py_compile each one — see the
    # edaehn-python-validation approach used elsewhere on this blog.
    return "All code snippets passed!"


if __name__ == "__main__":
    mcp.run()

Note the _safe_slug helper: a title is user-supplied text, and skipping sanitisation here opens a classic path traversal vulnerability — a title like ../../.ssh/authorized_keys would happily write outside your _posts folder and overwrite an arbitrary file on disk. Small detail, but it’s exactly the kind of thing “least-privilege tool scopes” (see the checklist below) means in practice, not just in theory.

By default mcp.run() starts the server over stdio — the transport Claude Desktop and Cursor use to launch it as a subprocess, so this is all you need for local use. Once this is running, you can simply tell your AI (in Cursor or Claude Desktop):

“Hey, use my Blog Manager to create a draft about Python decorators and make sure the code snippets I wrote actually work.”

As a technical blogger, you’re in the perfect position to leverage the Model Context Protocol (MCP). It effectively turns your AI assistant from a “chatbot” into a “technical co-author” that can manage your local file system, run validation tests on your code snippets, and even interact with your deployment pipeline.

MCP Safety Checklist

1. Define least-privilege tool scopes first.
2. Separate read tools from write tools.
3. Require explicit confirmations for side effects.
4. Capture tool call logs with timestamps.
5. Add fail-closed behavior for unavailable tools.

References

1. Model Context Protocol Specification, 2026-07-28
2. MCP servers repository (reference servers)
3. FastMCP installation docs