I built an MCP server in 50 lines of Python. Now Claude reads our CMS directly.
Recently, I was writing a social post about a blog we published months ago. I needed to reference the key message and how we framed the value prop.
For something like this, I'll usually copy the post into Claude and ask for a summary. The annoying part is when I need that same content in a different context, or I need it again a couple months from now. Each time means finding the post again, copying it, pasting it into a new conversation, or I end up with one massive chat handling multiple projects until I hit context limits.
The context goblin loves using up all the context in a chat. Nom nom nom.
To get rid of the context goblin, I connected Claude directly to our CMS with FastMCP. Now I ask "give me an overview of that blog post" and Claude reads it from Sanity. I get the breakdown I need without pasting content into every conversation.
This works for anything we've published: case studies, blog posts, landing pages. I can pull from multiple pieces of content at once and compare how we've messaged things over time.
The protocol behind this is MCP (Model Context Protocol). I used FastMCP to build it. FastMCP is an open-source framework, built by Prefect, to make building MCP servers straightforwardFor developers, this means connecting AI to code repositories, databases, and development environments. But for marketers? It means Claude can become your institutional memory.
FastMCP to the rescue! Context goblin is angry!
MCP gives Claude access to external data sources such as your CMS, analytics tools, anything with an API.
For this to work, you build a program (an MCP server) that sits between Claude and your data source. Claude then asks a question, and the server fetches what's needed and returns it.
Normally, Claude can only work with information you explicitly share in a conversation. With MCP, Claude can pull data from your systems on demand. You ask a question, the MCP server grabs the relevant content and hands it back.
But MCP isn't just about reading data. The protocol was designed to handle identity (showing different capabilities based on who's logged in), maintain state between conversations, send notifications when things change, and coordinate across multiple AI clients. My use case is more straightforward, but the protocol supports much more sophisticated patterns when needed (see the “multiple systems, one conversation” section).
Think of it like this: instead of copying your entire content library into every conversation, Claude can just look it up when needed. The MCP server acts as a bridge, translating your requests into API calls and bringing back exactly what you asked for.
At Prefect, we publish a lot of content. Case studies, blog posts, landing pages, etc.
When I'm writing something new, I'm constantly going back to old work. Did we already write about this feature? How did we describe it? Which case studies mention similar use cases?
I usually have a ton of tabs open. The blog in one, Sanity in another, a few case studies and landing pages for reference. If I wanted Claude to help analyze something, I'd copy entire posts into the conversation. This process worked, but it was tedious and I'd have to do it all over again for the next project.
Here’s an almost real depiction of what my windows look like. Let me tell you, it’s extremely embarrassing when someone sees this in IRL. I am the ICP for MCP.
Adam Azzam, Prefect's VP of Product, said "If you look at someone who has 12 browser tabs open, that's ripe for an MCP workflow. They're going to lots of different discrete systems to do different things and feed one thing into the other. That's essentially your workflow." 12 is nothing. Times that by 6, at least.
FastMCP made this straightforward. You write Python functions and FastMCP handles the protocol stuff.
The entire MCP server connecting Claude to Sanity is about 50 lines of Python:
FastMCP turns those functions into tools Claude can call. In MCP, "tools" are an official part of the protocol specification. They're how the server tells Claude what operations are available and what parameters they accept. The @mcp.tool() decorator registers a Python function as an MCP tool that Claude can discover and use.
I could have auto-generated an MCP server from Sanity's API, but that would have exposed every endpoint, parameter, and option. As Jeremiah (Prefect Founder and FastMCP's creator) points out in his post "Stop Converting Your REST APIs to MCP," auto-generated servers can overwhelm LLMs with too many choices. A curated server with only the tools you actually need performs better and costs less in tokens.
Here's a snippet of what the mcp server looks like:
1from fastmcp import FastMCP
2import httpx
3
4mcp = FastMCP("Prefect Content")
5
6@mcp.tool()
7def get_case_study(slug: str):
8 """Fetch a specific case study from Sanity"""
9 query = f'*[_type == "caseStudy" && slug.current == "{slug}"]'
10 response = httpx.get(f"{SANITY_API_URL}?query={query}")
11 return response.json()
12
13@mcp.tool()
14def search_blog_posts(keyword: str):
15 """Search blog posts by keyword"""
16 query = f'*[_type == "blogPost" && title match "{keyword}*"]'
17 response = httpx.get(f"{SANITY_API_URL}?query={query}")
18 return response.json()For the notification system, I added a tool (check_for_updates) that compares current content against what the server last saw. The server tracks content IDs between calls, so when you check for updates, it reports what's new since the last check. Simple state management that shows when content has been published.
As I mentioned, I'm using Sanity, but this works with any system that has an API. Contentful, WordPress, Notion, Airtable: if it has an API, you can connect Claude to it.
Try this: Pick one internal system you reference constantly. Check if it has an API, and that's your first MCP server candidate.
Once you've built your MCP server, it needs to be accessible to Claude. The easiest way to do this is with FastMCP Cloud.
FastMCP Cloud hosts your MCP server and handles all the infrastructure. You connect your GitHub repository, and it automatically deploys when you push changes. No need to manage servers or deal with authentication complexity.
Here's how it works:
FastMCP Cloud is free. Once deployed, your MCP server is available from any device where you use Claude.
Why MCP for a simple read-only server?
This is a straightforward use case since I'm just reading from Sanity. I'm not using identity-aware capabilities, cross-system orchestration, or any of MCP's sophisticated features yet.
So why not build a REST API instead?
It's easier. Building a custom API means handling authentication, making it work with Claude's tool calling, documenting endpoints, maintaining it myself. MCP is the simpler path.
It works everywhere. I use Claude on web and desktop. Others at Prefect might use Cursor or other MCP clients later. One server works across all of them, instead of custom integrations for each client.
It grows without rebuilding. I built this to learn how MCP works. Turns out people at Prefect want to use it too. So now I get to explore the more complex features like identity controls by adding to the same server.
There's an ecosystem. You're building on patterns others are using. Examples, documentation, community. A custom API is maintained by you alone.
What's possible when you're ready:
Cross-system synthesis: Connect your CMS, Google Analytics, and CRM at once. Ask "Based on our top-performing blog posts from Q2 and recent customer conversations, what topics should we focus on for our next webinar?" Claude pulls from all three systems and synthesizes an answer.
Dynamic, contextual queries: Show different tools based on who's logged in. Content editors see drafts, sales sees only published materials, leadership gets analytics. As Adam Azzam describes in "The Apology of MCP," the protocol handles identity-aware, stateful interactions where capabilities shift based on who's asking and what state the system is in.
MCP makes simple things easy and complex things possible.
Note: Some CMSs have their own MCP servers (Sanity built one using Anthropic's official MCP SDK, which uses FastMCP under the hood). Those are great if they exist for your platform, but building your own with FastMCP is surprisingly easy, and you can customize it exactly for your workflow rather than adapting to generic tools. Plus, you learn how it all works, which is useful if you ever switch platforms or want to integrate multiple data sources.
If you use Claude for work and find yourself constantly referencing your own content, this changes how you work.
Instead of copy-pasting blog posts or searching through multiple systems, Claude reads directly from your CMS and other tools. It pulls what's needed when you ask.
Here's something most people miss: every time you paste content into Claude, you're using up your context window. As Adam points out in his response to critiques of MCP, this context efficiency is what separates it from just being another search tool. MCP keeps the data external. Claude loads only what it needs, leaving your context window for the actual conversation and analysis.
For marketing teams, this means your entire content library is available in every conversation. For anyone managing knowledge across different platforms, you get real access to information without manual work.
