Table of Content<\/h1>\n\nIntroduction<\/mdspan>: Why I Wrote This<\/a><\/li>\n- The Evolution of Tool Integration with LLMs<\/a><\/li>\n
- What Is Model Context Protocol (MCP), Really?<\/a><\/li>\n
- \nWait, MCP sounds like RAG\u2026 but is it?<\/a><\/p>\n
\n- In an MCP-based setup<\/a><\/li>\n
- In a traditional RAG system<\/a><\/li>\n
- Traditional RAG Implementation<\/a><\/li>\n
- MCP Implementation<\/a><\/li>\n<\/ol>\n<\/li>\n
- Quick recap!<\/a><\/li>\n
- Core Capabilities of an MCP Server<\/a><\/li>\n
- \nReal-World Example: Claude Desktop + MCP (Pre-built Servers<\/a>)<\/li>\n
- Build Your Own: Custom MCP Server from Scratch <\/a><\/li>\n
![\"\ud83c\udf89\"](\"https:\/\/i0.wp.com\/s.w.org\/images\/core\/emoji\/15.0.3\/72x72\/1f389.png?ssl=1\")
Congrats, You\u2019ve Mastered MCP!<\/a><\/li>\n- References<\/a><\/li>\n<\/ol>\n
\n\nIntroduction<\/mdspan>: Why I Wrote This<\/h2>\nI will be honest. When I first saw the term \u201cModel Context Protocol (mcp<\/a>),\u201d I did what most developers do when confronted with yet another new acronym: I skimmed a tutorial, saw some JSON, and quietly moved on. \u201cToo abstract,\u201d I thought. Fast-forward to when I actually tried to integrate some custom tools with Claude Desktop\u2014 something that needed memory or access to external tools \u2014 and suddenly, MCP wasn\u2019t just relevant. It was essential.<\/p>\nThe problem? None of the tutorials I came across felt beginner-friendly. Most jumped straight into building a custom MCP server without explaining in details why<\/em> you\u2019d need a server in the first place \u2014 let alone mentioning that prebuilt MCP servers already exist and work out of the box. So, I decided to learn it from the ground up.<\/p>\nI read everything I could, experimented with both prebuilt and custom servers, integrated it with Claude Desktop and tested whether I could explain it to my friends \u2014people with zero prior context. When I finally got the nod from them, I knew I could break it down for anyone, even if you\u2019ve never heard of MCP until five minutes ago.<\/p>\n
This article breaks down what MCP is, why it matters, and how it compares to other popular architectures like RAG. We\u2019ll go from \u201cwhat even is this?\u201d to spinning up your own working Claude integration \u2014 no prior MCP knowledge required. If you\u2019ve ever struggled to get your AI model to feel a little less like a goldfish, this is for you.<\/p>\n
The Evolution of Tool Integration with LLMs<\/h2>\n
Before diving into MCP, let\u2019s understand the progression of how we connect Large Language Models (LLMs) to external tools and data:<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/contributor.insightmediagroup.io\/wp-content\/uploads\/2025\/04\/image-78-1024x501.png?resize=1024%2C501&ssl=1\")
Image by author<\/figcaption><\/figure>\n\n- \nStandalone LLMs<\/strong>: Initially, models like GPT and Claude operated in isolation, relying solely on their training data. They couldn\u2019t access real-time information or interact with external systems.<\/li>\n
- \nTool Binding:<\/strong> As LLMs advanced, developers created methods to \u201cbind\u201d tools directly to models. For example, with LangChain or similar frameworks, you could do something like:<\/li>\n<\/ol>\n
llm = ChatAnthropic()\naugmented_llm = llm.bind_tools([search_tool, calculator_tool])<\/code><\/pre>\nThis works well for individual scripts but doesn\u2019t scale easily across applications. Why?<\/em><\/strong> Because tool binding in frameworks like LangChain is typically designed around single-session, stateless interactions<\/strong>, meaning every time you spin up a new agent or function call, you\u2019re often re-defining which tools it can access. There\u2019s no centralized way to manage tools across multiple interfaces or user contexts.<\/p>\n3. Application Integration Challenge<\/strong>: The real complexity arises when you want to integrate tools with AI-powered applications like IDEs (Cursor, VS Code), chat interfaces (Claude Desktop), or other productivity tools. Each application would need custom connectors for every possible tool or data source, creating a tangled web of integrations.<\/p>\nThis is where MCP enters the picture \u2014 providing a standardized layer of abstraction for connecting AI applications to external tools and data sources.<\/p>\n
What Is Model Context Protocol (MCP), Really?<\/h2>\n
Let\u2019s break it down:<\/p>\n
\n- \nModel<\/strong>: The LLM at the heart of your application \u2014 GPT, Claude, whatever. It\u2019s a powerful reasoning engine but limited by what it was trained on and how much context it can hold.<\/li>\n
- \nContext<\/strong>: The extra information your model needs to do its job \u2014 documents, search results, user preferences, recent history. Context extends the model\u2019s capabilities beyond its training set.<\/li>\n
- \nProtocol<\/strong>: A standardized way of communicating between components. Think of it as a common language that lets your model interact with tools and data sources in a predictable way.<\/li>\n<\/ul>\n
Put those three together, and MCP<\/strong> becomes a framework that connects models to contextual information and tools through a consistent, modular, and interoperable interface.<\/p>\nMuch like HTTP enabled the web by standardizing how browsers talk to servers, MCP standardizes how AI applications interact with external data and capabilities.<\/p>\n
\n\nPro tip! <\/strong>An easy way to visualize MCP is to think of it like tool binding for the entire AI stack<\/strong>, not just a single agent. That\u2019s why <\/strong>Anthropic describes MCP<\/strong><\/a> as \u201ca USB-C port for AI applications.\u201d<\/strong><\/p>\n<\/blockquote>\n![\"\"](\"https:\/\/i0.wp.com\/contributor.insightmediagroup.io\/wp-content\/uploads\/2025\/04\/image-79-1024x858.png?resize=1024%2C858&ssl=1\")
Image by author, inspired by Understanding MCP From Scratch<\/a> by LangChain<\/figcaption><\/figure>\n
\nWait, MCP sounds like RAG\u2026 but is it?<\/h2>\n
A lot of people ask, \u201cHow is this different from RAG?\u201d Great question.<\/p>\n
At a glance, both MCP and RAG aim to solve the same problem: give language models access to relevant, external information. But how they do it \u2014 and how maintainable they are \u2014 differs significantly.<\/p>\n
In an MCP-based setup<\/h3>\n\n- Your AI app (host\/client) connects to an MCP document server<\/li>\n
- You interact with context using a standardized protocol<\/li>\n
- You can add new documents or tools without modifying the app<\/li>\n
- Everything works via the same interface, consistently<\/li>\n<\/ul>\n
![\"\"](\"https:\/\/i0.wp.com\/contributor.insightmediagroup.io\/wp-content\/uploads\/2025\/04\/image-80-1024x1011.png?resize=1024%2C1011&ssl=1\")
Image by author, inspired by MCP Documentation<\/a>.<\/figcaption><\/figure>\nIn a traditional RAG system<\/h3>\n\n- Your app manually builds and queries a vector database<\/li>\n
- You often need custom embedding logic, retrievers, and loaders<\/li>\n
- Adding new sources means rewriting part of your app code<\/li>\n
- Every integration is bespoke, tightly coupled to your app logic<\/li>\n<\/ul>\n
The key distinction is abstraction: <\/strong>The Protocol<\/em> in Model Context Protocol<\/a> is nothing but a standardized abstraction layer<\/em> that defines bidirectional communication<\/strong> between MCP Client\/Host and MCP Servers.<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/contributor.insightmediagroup.io\/wp-content\/uploads\/2025\/04\/image-81-1024x725.png?resize=1024%2C725&ssl=1\")
Image by author, inspired by MCP Documentation<\/a>.<\/figcaption><\/figure>\nMCP gives your app the ability to ask, \u201cGive me information about X,\u201d without knowing how<\/em> that info is stored or retrieved. RAG systems require your app to manage all of that.<\/p>\nWith MCP, your application logic stays the same, even as your document sources evolve.<\/strong><\/p>\nLet\u2019s look at some high-level codes to see how these approaches differ:<\/p>\n
Traditional RAG Implementation<\/h3>\n
In a traditional RAG implementation, your application code directly manages connections to document sources:<\/p>\n
# Hardcoded vector store logic\nvectorstore = FAISS.load_local(\"store\/embeddings\")\nretriever = vectorstore.as_retriever()\nresponse = retriever.invoke(\"query about LangGraph\")<\/code><\/pre>\nWith tool binding, you define tools and bind them to an LLM, but still need to modify the tool implementation to incorporate new data sources. You still need to update the tool implementation when your backend changes.<\/p>\n
@tool\ndef search_docs(query: str):\n return search_vector_store(query)<\/code><\/pre>\nMCP Implementation<\/h3>\n
With MCP, your application connects to a standardized interface, and the server handles the specifics of document sources:<\/p>\n
# MCP Client\/Host: Client\/Host stays the same\n\n# MCP Server: Define your MCP server\n# Import necessary libraries\nfrom typing import Any\nfrom mcp.server.fastmcp import FastMCP\n\n# Initialize FastMCP server\nmcp = FastMCP(\"your-server\")\n\n# Implement your server's tools\n@mcp.tool()\nasync def example_tool(param1: str, param2: int) -> str:\n \"\"\"An example tool that demonstrates MCP functionality.\n \n Args:\n param1: First parameter description\n param2: Second parameter description\n \n Returns:\n A string result from the tool execution\n \"\"\"\n # Tool implementation\n result = f\"Processed {param1} with value {param2}\"\n return result\n\n# Example of adding a resource (optional)\n@mcp.resource()\nasync def get_example_resource() -> bytes:\n \"\"\"Provides example data as a resource.\n \n Returns:\n Binary data that can be read by clients\n \"\"\"\n return b\"Example resource data\"\n\n# Example of adding a prompt template (optional)\nmcp.add_prompt(\n \"example-prompt\",\n \"This is a template for {{purpose}}. You can use it to {{action}}.\"\n)\n\n# Run the server\nif __name__ == \"__main__\":\n mcp.run(transport=\"stdio\")<\/code><\/pre>\nThen, you configure the host or client (like Claude Desktop) to use the server by updating its configuration file.<\/p>\n
{\n \"mcpServers\": {\n \"your-server\": {\n \"command\": \"uv\",\n \"args\": [\n \"--directory\",\n \"\/ABSOLUTE\/PATH\/TO\/PARENT\/FOLDER\/your-server\",\n \"run\",\n \"your-server.py\"\n ]\n }\n }\n}<\/code><\/pre>\n
\nIf you change where or how the resources\/documents are stored, you update the server \u2014 not the client.<\/strong><\/p>\nThat\u2019s the magic of abstraction.<\/em><\/strong><\/p>\nAnd for many use cases \u2014 especially in production environments like IDE extensions or commercial applications \u2014 you can\u2019t<\/em> touch the client code at all. MCP\u2019s decoupling is more than just a nice-to-have: it\u2019s a necessity. It isolates the application code so that only the server-side logic (tools, data sources, or embeddings) needs to evolve. The host application remains untouched. This enables rapid iteration and experimentation without risking regression or violating application constraints.<\/p>\n
\nQuick recap!<\/h2>\n
Hopefully, by now, it\u2019s clear why MCP actually matters.<\/p>\n
Imagine you\u2019re building an AI assistant that needs to:<\/p>\n
\n- Tap into a knowledge base<\/li>\n
- Execute code or scripts<\/li>\n
- Keep track of past user conversations<\/li>\n<\/ul>\n
Without MCP, you\u2019re stuck writing custom glue code for every single integration. Sure, it works \u2014 until it doesn\u2019t. It\u2019s fragile, messy, and a nightmare to maintain at scale.<\/p>\n
MCP fixes this<\/strong> by acting as a universal adapter between your model and the outside world. You can plug in new tools or data sources without rewriting your model logic. That means faster iteration, cleaner code, fewer bugs<\/strong>, and AI applications that are actually modular and maintainable.<\/p>\nAnd I hope you were paying attention when I said MCP enables bidirectional communication<\/strong> between the host (client) and the server \u2014 because this unlocks one of MCP\u2019s most powerful use cases: persistent memory<\/strong>.<\/p>\nOut of the box, LLMs are goldfish. They forget everything unless you manually stuff the entire history into the context window. But with MCP, you can:<\/p>\n
\n- Store and retrieve past interactions<\/li>\n
- Keep track of long-term user preferences<\/li>\n
- Build assistants that actually \u201cremember\u201d full projects or ongoing sessions<\/li>\n<\/ul>\n
No more clunky prompt-chaining hacks or fragile memory workarounds. MCP gives your model a brain that lasts longer than a single chat.<\/strong><\/p>\nCore Capabilities of an MCP Server<\/h2>\n
With all that in mind, it\u2019s pretty clear: the MCP server is the MVP of the whole protocol.<\/strong><\/p>\nIt\u2019s the central hub that defines the capabilities your model can actually use. There are three main types:<\/p>\n
\n- \nResources:<\/strong> Think of these as external data sources \u2014 PDFs, APIs, databases. The model can pull them in for context, but it can\u2019t change them. Read-only.<\/li>\n
- \nTools:<\/strong> These are the actual functions the model can call \u2014 run code, search the web, generate summaries, you name it.<\/li>\n
- \nPrompts:<\/strong> Predefined templates that guide the model\u2019s behavior or structure its responses. Like giving it a playbook.<\/li>\n<\/ul>\n
What makes MCP powerful is that all of these are exposed through a single, consistent protocol<\/strong>. That means the model can request, invoke, and incorporate them without needing custom logic for each one. Just plug into the MCP server, and everything\u2019s ready to go.<\/p>\nReal-World Example: Claude Desktop + MCP (Pre-built Servers)<\/h2>\n
Out of the box, Anthropic offers a bunch of pre-built MCP servers<\/strong> you can plug into your AI apps \u2014 things like Claude Desktop, Cursor, and more. Setup is super quick and painless.<\/p>\nFor the full list of available servers, head over to the MCP Servers Repository.<\/a> It\u2019s your buffet of ready-to-use integrations.<\/p>\nIn this section, I\u2019ll walk you through a practical example: extending Claude Desktop<\/strong> so it can read from your computer\u2019s file system, write new files, move them around, and even search through them.<\/p>\nThis walkthrough is based on the Quickstart<\/a> guide from the official docs, but honestly, that guide skips a few key details \u2014 especially if you\u2019ve never touched these settings before. So I\u2019m filling in the gaps and sharing the extra tips I picked up along the way to save you the headache.<\/p>\n1. Download Claude Desktop<\/h3>\n
First things first \u2014 grab Claude Desktop<\/strong><\/a>. Choose the version for macOS<\/strong> or Windows<\/strong> (sorry Linux folks, no support just yet).<\/p>\nFollow the installation steps as prompted.<\/p>\n
Already have it installed? Make sure you\u2019re on the latest version by clicking the Claude menu<\/strong> on your computer and selecting \u201cCheck for Updates\u2026\u201d<\/strong><\/p>\n2. Check the Prerequisites<\/h3>\n
You\u2019ll need Node.js<\/strong> installed on your machine to get this running smoothly.<\/p>\nTo check if you already have Node installed:<\/p>\n
\n- \nOn macOS<\/strong>: Open the Terminal<\/strong> from your Applications folder.<\/li>\n
- \nOn Windows<\/strong>: Press
Windows + R<\/code>, type cmd<\/code>, and hit Enter.<\/li>\n- Then run the following command in your terminal:<\/li>\n<\/ul>\n
node --version<\/code><\/pre>\nIf you see a version number, you\u2019re good to go. If not, head over to nodejs.org<\/a> and install the latest LTS version<\/strong>.<\/p>\n3. Enable Developer Mode<\/h3>\n
Open Claude Desktop and click on the \u201cClaude\u201d menu in the top-left corner of your screen. From there, select Help<\/strong>.<\/p>\nOn macOS, it should look something like this:<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/contributor.insightmediagroup.io\/wp-content\/uploads\/2025\/04\/image-82-1024x478.png?resize=1024%2C478&ssl=1\")
Image by author<\/figcaption><\/figure>\nFrom the drop-down menu, select \u201cEnable Developer Mode.\u201d<\/strong><\/p>\nIf you\u2019ve already enabled it before, it won\u2019t show up again \u2014 but if this is your first time, it should be right there in the list.<\/p>\n
Once Developer Mode<\/strong> is turned on:<\/p>\n\n- Click on \u201cClaude\u201d<\/strong> in the top-left menu again.<\/li>\n
- Select \u201cSettings.\u201d<\/strong>\n<\/li>\n
- A new pop-up window will appear \u2014 look for the \u201cDeveloper\u201d<\/strong> tab in the left-hand navigation bar. That\u2019s where all the good stuff lives.<\/li>\n<\/ol>\n
![\"\"](\"https:\/\/i0.wp.com\/contributor.insightmediagroup.io\/wp-content\/uploads\/2025\/04\/image-83-1024x724.png?resize=1024%2C724&ssl=1\")
Image by author<\/figcaption><\/figure>\n4. Set Up the Configuration File<\/h3>\n
Still in the Developer<\/strong> settings, click on \u201cEdit Config.\u201d<\/strong><\/p>\nThis will create a configuration file if one doesn\u2019t already exist and open it directly in your file system.<\/p>\n
The file location depends on your OS:<\/p>\n
\n- \nmacOS:<\/strong>
~\/Library\/Application Support\/Claude\/claude_desktop_config.json<\/code>\n<\/li>\n- \nWindows:<\/strong>
%APPDATA%Claudeclaude_desktop_config.json<\/code>\n<\/li>\n<\/ul>\nThis is where you\u2019ll define the servers and capabilities you want Claude to use \u2014 so keep this file open, we\u2019ll be editing it next.<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/contributor.insightmediagroup.io\/wp-content\/uploads\/2025\/04\/image-84-1024x692.png?resize=1024%2C692&ssl=1\")
Image by author<\/figcaption><\/figure>\nOpen the config file (claude_desktop_config.json<\/code>) in any text editor. Replace its contents with the following, depending on your OS:<\/p>\nFor macOS:<\/h4>\n{\n \"mcpServers\": {\n \"filesystem\": {\n \"command\": \"npx\",\n \"args\": [\n \"-y\",\n \"@modelcontextprotocol\/server-filesystem\",\n \"\/Users\/username\/Desktop\",\n \"\/Users\/username\/Downloads\"\n ]\n }\n }\n}<\/code><\/pre>\nFor Windows:<\/h4>\n{\n \"mcpServers\": {\n \"filesystem\": {\n \"command\": \"npx\",\n \"args\": [\n \"-y\",\n \"@modelcontextprotocol\/server-filesystem\",\n \"C:\\Users\\username\\Desktop\",\n \"C:\\Users\\username\\Downloads\"\n ]\n }\n }\n}<\/code><\/pre>\nMake sure to replace <\/strong>\"username\"<\/code> with your actual system username.<\/strong> The paths listed here should point to valid folders on your machine\u2014this setup gives Claude access to your Desktop<\/strong> and Downloads<\/strong>, but you can add more paths if needed.<\/p>\nWhat This Does<\/h4>\n
This config tells Claude Desktop<\/strong> to automatically start an MCP server called \"filesystem\"<\/code> every time the app launches. That server runs using npx<\/code> and spins up @modelcontextprotocol\/server-filesystem<\/code>, which is what lets Claude interact with your file system\u2014read, write, move files, search directories, etc.<\/p>\n\n![\"\u26a0\"](\"https:\/\/i0.wp.com\/s.w.org\/images\/core\/emoji\/15.0.3\/72x72\/26a0.png?ssl=1\")
Command Privileges<\/h4>\n\nJust a heads-up: Claude will run these commands with your user account\u2019s permissions, meaning it can access and modify local files. Only add commands to the config file if you understand and trust the server you\u2019re hooking up \u2014 no random packages from the internet!<\/p>\n<\/blockquote>\n
5. Restart Claude<\/h3>\n
Once you\u2019ve updated and saved your configuration file, restart Claude Desktop<\/strong> to apply the changes.<\/p>\nAfter it boots up, you should see a hammer icon<\/strong> in the bottom-left corner of the input box. That\u2019s your signal that the developer tools \u2014 and your custom MCP server \u2014 are up and running.<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/contributor.insightmediagroup.io\/wp-content\/uploads\/2025\/04\/image-85-1024x369.png?resize=1024%2C369&ssl=1\")
Image by author<\/figcaption><\/figure>\nAfter clicking the hammer icon<\/strong>, you should see the list of tools exposed by the Filesystem MCP Server<\/strong> \u2014 things like reading files, writing files, searching directories, and so on.<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/contributor.insightmediagroup.io\/wp-content\/uploads\/2025\/04\/image-86-792x1024.png?resize=792%2C1024&ssl=1\")
Image by author<\/figcaption><\/figure>\nIf you don\u2019t see your server listed or nothing shows up, don\u2019t worry. Jump over to the Troubleshooting<\/strong><\/a> section in the official documentation for some quick debugging tips to get things back on track.<\/p>\n6. Try It Out!<\/h3>\n
Now that everything\u2019s set up, you can start chatting with Claude about your file system \u2014 and it should know when to call the right tools<\/strong>.<\/p>\nHere are a few things you can try asking:<\/p>\n
\n- \u201cCan you write a poem and save it to my Desktop?\u201d<\/em><\/li>\n
- \u201cWhat are some work-related files in my Downloads folder?\u201d<\/em><\/li>\n
- \u201cCan you take all the images on my Desktop and move them to a new folder called \u2018Images\u2019?\u201d<\/em><\/li>\n<\/ul>\n
When needed, Claude will automatically invoke the appropriate tools and ask for your approval<\/strong> before doing anything on your system. You stay in control, and Claude gets the job done.<\/p>\nBuild Your Own: Custom MCP Server from Scratch <\/h2>\n
Alright, ready to level up?<\/strong><\/p>\nIn this section, you\u2019ll go from user to builder. We\u2019re going to write a custom MCP server that Claude can talk to \u2014 specifically, a tool that lets it search the latest documentation from AI libraries like LangChain, OpenAI, MCP (yes, we\u2019re using MCP to learn MCP), and LlamaIndex.<\/p>\n
Because let\u2019s be honest \u2014 how many times have you watched Claude confidently spit out deprecated code or reference libraries that haven\u2019t been updated since 2021?<\/p>\n
This tool uses real-time search, scrapes live content, and gives your assistant fresh knowledge on demand. Yes, it\u2019s as cool as it sounds.<\/p>\n
The project is built using the official MCP SDK from Anthropic. If you\u2019re comfortable with Python and the command line, you\u2019ll be up and running in no time. And even if you\u2019re not \u2014 don\u2019t worry. We\u2019ll walk through everything step by step, including the parts most tutorials just assume you already know.<\/p>\n
Prerequisites<\/h3>\n
Before we dive in, here are the things you need installed on your system:<\/p>\n
\n- \nPython 3.10 or higher <\/strong>\u2014 this is the programming language we\u2019ll use<\/li>\n
- \nMCP SDK (v1.2.0 or higher)<\/strong> \u2014 this gives you all the tools to create a Claude-compatible server (which will be installed in upcoming parts)<\/li>\n
- \nuv<\/strong><\/a>
- \n
- In an MCP-based setup<\/a><\/li>\n
- In a traditional RAG system<\/a><\/li>\n
- Traditional RAG Implementation<\/a><\/li>\n
- MCP Implementation<\/a><\/li>\n<\/ol>\n<\/li>\n
- Quick recap!<\/a><\/li>\n
- Core Capabilities of an MCP Server<\/a><\/li>\n
- \nReal-World Example: Claude Desktop + MCP (Pre-built Servers<\/a>)<\/li>\n
- Build Your Own: Custom MCP Server from Scratch <\/a><\/li>\n
Congrats, You\u2019ve Mastered MCP!<\/a><\/li>\n- References<\/a><\/li>\n<\/ol>\n
\n\n
Introduction<\/mdspan>: Why I Wrote This<\/h2>\n I will be honest. When I first saw the term \u201cModel Context Protocol (mcp<\/a>),\u201d I did what most developers do when confronted with yet another new acronym: I skimmed a tutorial, saw some JSON, and quietly moved on. \u201cToo abstract,\u201d I thought. Fast-forward to when I actually tried to integrate some custom tools with Claude Desktop\u2014 something that needed memory or access to external tools \u2014 and suddenly, MCP wasn\u2019t just relevant. It was essential.<\/p>\n
The problem? None of the tutorials I came across felt beginner-friendly. Most jumped straight into building a custom MCP server without explaining in details why<\/em> you\u2019d need a server in the first place \u2014 let alone mentioning that prebuilt MCP servers already exist and work out of the box. So, I decided to learn it from the ground up.<\/p>\n
I read everything I could, experimented with both prebuilt and custom servers, integrated it with Claude Desktop and tested whether I could explain it to my friends \u2014people with zero prior context. When I finally got the nod from them, I knew I could break it down for anyone, even if you\u2019ve never heard of MCP until five minutes ago.<\/p>\n
This article breaks down what MCP is, why it matters, and how it compares to other popular architectures like RAG. We\u2019ll go from \u201cwhat even is this?\u201d to spinning up your own working Claude integration \u2014 no prior MCP knowledge required. If you\u2019ve ever struggled to get your AI model to feel a little less like a goldfish, this is for you.<\/p>\n
The Evolution of Tool Integration with LLMs<\/h2>\n
Before diving into MCP, let\u2019s understand the progression of how we connect Large Language Models (LLMs) to external tools and data:<\/p>\n
Image by author<\/figcaption><\/figure>\n - \n
- \nStandalone LLMs<\/strong>: Initially, models like GPT and Claude operated in isolation, relying solely on their training data. They couldn\u2019t access real-time information or interact with external systems.<\/li>\n
- \nTool Binding:<\/strong> As LLMs advanced, developers created methods to \u201cbind\u201d tools directly to models. For example, with LangChain or similar frameworks, you could do something like:<\/li>\n<\/ol>\n
llm = ChatAnthropic()\naugmented_llm = llm.bind_tools([search_tool, calculator_tool])<\/code><\/pre>\nThis works well for individual scripts but doesn\u2019t scale easily across applications. Why?<\/em><\/strong> Because tool binding in frameworks like LangChain is typically designed around single-session, stateless interactions<\/strong>, meaning every time you spin up a new agent or function call, you\u2019re often re-defining which tools it can access. There\u2019s no centralized way to manage tools across multiple interfaces or user contexts.<\/p>\n
3. Application Integration Challenge<\/strong>: The real complexity arises when you want to integrate tools with AI-powered applications like IDEs (Cursor, VS Code), chat interfaces (Claude Desktop), or other productivity tools. Each application would need custom connectors for every possible tool or data source, creating a tangled web of integrations.<\/p>\n
This is where MCP enters the picture \u2014 providing a standardized layer of abstraction for connecting AI applications to external tools and data sources.<\/p>\n
What Is Model Context Protocol (MCP), Really?<\/h2>\n
Let\u2019s break it down:<\/p>\n
- \n
- \nModel<\/strong>: The LLM at the heart of your application \u2014 GPT, Claude, whatever. It\u2019s a powerful reasoning engine but limited by what it was trained on and how much context it can hold.<\/li>\n
- \nContext<\/strong>: The extra information your model needs to do its job \u2014 documents, search results, user preferences, recent history. Context extends the model\u2019s capabilities beyond its training set.<\/li>\n
- \nProtocol<\/strong>: A standardized way of communicating between components. Think of it as a common language that lets your model interact with tools and data sources in a predictable way.<\/li>\n<\/ul>\n
Put those three together, and MCP<\/strong> becomes a framework that connects models to contextual information and tools through a consistent, modular, and interoperable interface.<\/p>\n
Much like HTTP enabled the web by standardizing how browsers talk to servers, MCP standardizes how AI applications interact with external data and capabilities.<\/p>\n
\n\n
Pro tip! <\/strong>An easy way to visualize MCP is to think of it like tool binding for the entire AI stack<\/strong>, not just a single agent. That\u2019s why <\/strong>Anthropic describes MCP<\/strong><\/a> as \u201ca USB-C port for AI applications.\u201d<\/strong><\/p>\n<\/blockquote>\n
Image by author, inspired by Understanding MCP From Scratch<\/a> by LangChain<\/figcaption><\/figure>\n
\nWait, MCP sounds like RAG\u2026 but is it?<\/h2>\n
A lot of people ask, \u201cHow is this different from RAG?\u201d Great question.<\/p>\n
At a glance, both MCP and RAG aim to solve the same problem: give language models access to relevant, external information. But how they do it \u2014 and how maintainable they are \u2014 differs significantly.<\/p>\n
In an MCP-based setup<\/h3>\n
- \n
- Your AI app (host\/client) connects to an MCP document server<\/li>\n
- You interact with context using a standardized protocol<\/li>\n
- You can add new documents or tools without modifying the app<\/li>\n
- Everything works via the same interface, consistently<\/li>\n<\/ul>\n
Image by author, inspired by MCP Documentation<\/a>.<\/figcaption><\/figure>\n In a traditional RAG system<\/h3>\n
- \n
- Your app manually builds and queries a vector database<\/li>\n
- You often need custom embedding logic, retrievers, and loaders<\/li>\n
- Adding new sources means rewriting part of your app code<\/li>\n
- Every integration is bespoke, tightly coupled to your app logic<\/li>\n<\/ul>\n
The key distinction is abstraction: <\/strong>The Protocol<\/em> in Model Context Protocol<\/a> is nothing but a standardized abstraction layer<\/em> that defines bidirectional communication<\/strong> between MCP Client\/Host and MCP Servers.<\/p>\n
Image by author, inspired by MCP Documentation<\/a>.<\/figcaption><\/figure>\n MCP gives your app the ability to ask, \u201cGive me information about X,\u201d without knowing how<\/em> that info is stored or retrieved. RAG systems require your app to manage all of that.<\/p>\n
With MCP, your application logic stays the same, even as your document sources evolve.<\/strong><\/p>\n
Let\u2019s look at some high-level codes to see how these approaches differ:<\/p>\n
Traditional RAG Implementation<\/h3>\n
In a traditional RAG implementation, your application code directly manages connections to document sources:<\/p>\n
# Hardcoded vector store logic\nvectorstore = FAISS.load_local(\"store\/embeddings\")\nretriever = vectorstore.as_retriever()\nresponse = retriever.invoke(\"query about LangGraph\")<\/code><\/pre>\nWith tool binding, you define tools and bind them to an LLM, but still need to modify the tool implementation to incorporate new data sources. You still need to update the tool implementation when your backend changes.<\/p>\n
@tool\ndef search_docs(query: str):\n return search_vector_store(query)<\/code><\/pre>\nMCP Implementation<\/h3>\n
With MCP, your application connects to a standardized interface, and the server handles the specifics of document sources:<\/p>\n
# MCP Client\/Host: Client\/Host stays the same\n\n# MCP Server: Define your MCP server\n# Import necessary libraries\nfrom typing import Any\nfrom mcp.server.fastmcp import FastMCP\n\n# Initialize FastMCP server\nmcp = FastMCP(\"your-server\")\n\n# Implement your server's tools\n@mcp.tool()\nasync def example_tool(param1: str, param2: int) -> str:\n \"\"\"An example tool that demonstrates MCP functionality.\n \n Args:\n param1: First parameter description\n param2: Second parameter description\n \n Returns:\n A string result from the tool execution\n \"\"\"\n # Tool implementation\n result = f\"Processed {param1} with value {param2}\"\n return result\n\n# Example of adding a resource (optional)\n@mcp.resource()\nasync def get_example_resource() -> bytes:\n \"\"\"Provides example data as a resource.\n \n Returns:\n Binary data that can be read by clients\n \"\"\"\n return b\"Example resource data\"\n\n# Example of adding a prompt template (optional)\nmcp.add_prompt(\n \"example-prompt\",\n \"This is a template for {{purpose}}. You can use it to {{action}}.\"\n)\n\n# Run the server\nif __name__ == \"__main__\":\n mcp.run(transport=\"stdio\")<\/code><\/pre>\nThen, you configure the host or client (like Claude Desktop) to use the server by updating its configuration file.<\/p>\n
{\n \"mcpServers\": {\n \"your-server\": {\n \"command\": \"uv\",\n \"args\": [\n \"--directory\",\n \"\/ABSOLUTE\/PATH\/TO\/PARENT\/FOLDER\/your-server\",\n \"run\",\n \"your-server.py\"\n ]\n }\n }\n}<\/code><\/pre>\n
\nIf you change where or how the resources\/documents are stored, you update the server \u2014 not the client.<\/strong><\/p>\n
That\u2019s the magic of abstraction.<\/em><\/strong><\/p>\n
And for many use cases \u2014 especially in production environments like IDE extensions or commercial applications \u2014 you can\u2019t<\/em> touch the client code at all. MCP\u2019s decoupling is more than just a nice-to-have: it\u2019s a necessity. It isolates the application code so that only the server-side logic (tools, data sources, or embeddings) needs to evolve. The host application remains untouched. This enables rapid iteration and experimentation without risking regression or violating application constraints.<\/p>\n
\nQuick recap!<\/h2>\n
Hopefully, by now, it\u2019s clear why MCP actually matters.<\/p>\n
Imagine you\u2019re building an AI assistant that needs to:<\/p>\n
- \n
- Tap into a knowledge base<\/li>\n
- Execute code or scripts<\/li>\n
- Keep track of past user conversations<\/li>\n<\/ul>\n
Without MCP, you\u2019re stuck writing custom glue code for every single integration. Sure, it works \u2014 until it doesn\u2019t. It\u2019s fragile, messy, and a nightmare to maintain at scale.<\/p>\n
MCP fixes this<\/strong> by acting as a universal adapter between your model and the outside world. You can plug in new tools or data sources without rewriting your model logic. That means faster iteration, cleaner code, fewer bugs<\/strong>, and AI applications that are actually modular and maintainable.<\/p>\n
And I hope you were paying attention when I said MCP enables bidirectional communication<\/strong> between the host (client) and the server \u2014 because this unlocks one of MCP\u2019s most powerful use cases: persistent memory<\/strong>.<\/p>\n
Out of the box, LLMs are goldfish. They forget everything unless you manually stuff the entire history into the context window. But with MCP, you can:<\/p>\n
- \n
- Store and retrieve past interactions<\/li>\n
- Keep track of long-term user preferences<\/li>\n
- Build assistants that actually \u201cremember\u201d full projects or ongoing sessions<\/li>\n<\/ul>\n
No more clunky prompt-chaining hacks or fragile memory workarounds. MCP gives your model a brain that lasts longer than a single chat.<\/strong><\/p>\n
Core Capabilities of an MCP Server<\/h2>\n
With all that in mind, it\u2019s pretty clear: the MCP server is the MVP of the whole protocol.<\/strong><\/p>\n
It\u2019s the central hub that defines the capabilities your model can actually use. There are three main types:<\/p>\n
- \n
- \nResources:<\/strong> Think of these as external data sources \u2014 PDFs, APIs, databases. The model can pull them in for context, but it can\u2019t change them. Read-only.<\/li>\n
- \nTools:<\/strong> These are the actual functions the model can call \u2014 run code, search the web, generate summaries, you name it.<\/li>\n
- \nPrompts:<\/strong> Predefined templates that guide the model\u2019s behavior or structure its responses. Like giving it a playbook.<\/li>\n<\/ul>\n
What makes MCP powerful is that all of these are exposed through a single, consistent protocol<\/strong>. That means the model can request, invoke, and incorporate them without needing custom logic for each one. Just plug into the MCP server, and everything\u2019s ready to go.<\/p>\n
Real-World Example: Claude Desktop + MCP (Pre-built Servers)<\/h2>\n
Out of the box, Anthropic offers a bunch of pre-built MCP servers<\/strong> you can plug into your AI apps \u2014 things like Claude Desktop, Cursor, and more. Setup is super quick and painless.<\/p>\n
For the full list of available servers, head over to the MCP Servers Repository.<\/a> It\u2019s your buffet of ready-to-use integrations.<\/p>\n
In this section, I\u2019ll walk you through a practical example: extending Claude Desktop<\/strong> so it can read from your computer\u2019s file system, write new files, move them around, and even search through them.<\/p>\n
This walkthrough is based on the Quickstart<\/a> guide from the official docs, but honestly, that guide skips a few key details \u2014 especially if you\u2019ve never touched these settings before. So I\u2019m filling in the gaps and sharing the extra tips I picked up along the way to save you the headache.<\/p>\n
1. Download Claude Desktop<\/h3>\n
First things first \u2014 grab Claude Desktop<\/strong><\/a>. Choose the version for macOS<\/strong> or Windows<\/strong> (sorry Linux folks, no support just yet).<\/p>\n
Follow the installation steps as prompted.<\/p>\n
Already have it installed? Make sure you\u2019re on the latest version by clicking the Claude menu<\/strong> on your computer and selecting \u201cCheck for Updates\u2026\u201d<\/strong><\/p>\n
2. Check the Prerequisites<\/h3>\n
You\u2019ll need Node.js<\/strong> installed on your machine to get this running smoothly.<\/p>\n
To check if you already have Node installed:<\/p>\n
- \n
- \nOn macOS<\/strong>: Open the Terminal<\/strong> from your Applications folder.<\/li>\n
- \nOn Windows<\/strong>: Press
Windows + R<\/code>, typecmd<\/code>, and hit Enter.<\/li>\n- Then run the following command in your terminal:<\/li>\n<\/ul>\n
node --version<\/code><\/pre>\nIf you see a version number, you\u2019re good to go. If not, head over to nodejs.org<\/a> and install the latest LTS version<\/strong>.<\/p>\n
3. Enable Developer Mode<\/h3>\n
Open Claude Desktop and click on the \u201cClaude\u201d menu in the top-left corner of your screen. From there, select Help<\/strong>.<\/p>\n
On macOS, it should look something like this:<\/p>\n
Image by author<\/figcaption><\/figure>\n From the drop-down menu, select \u201cEnable Developer Mode.\u201d<\/strong><\/p>\n
If you\u2019ve already enabled it before, it won\u2019t show up again \u2014 but if this is your first time, it should be right there in the list.<\/p>\n
Once Developer Mode<\/strong> is turned on:<\/p>\n
- \n
- Click on \u201cClaude\u201d<\/strong> in the top-left menu again.<\/li>\n
- Select \u201cSettings.\u201d<\/strong>\n<\/li>\n
- A new pop-up window will appear \u2014 look for the \u201cDeveloper\u201d<\/strong> tab in the left-hand navigation bar. That\u2019s where all the good stuff lives.<\/li>\n<\/ol>\n
Image by author<\/figcaption><\/figure>\n 4. Set Up the Configuration File<\/h3>\n
Still in the Developer<\/strong> settings, click on \u201cEdit Config.\u201d<\/strong><\/p>\n
This will create a configuration file if one doesn\u2019t already exist and open it directly in your file system.<\/p>\n
The file location depends on your OS:<\/p>\n
- \n
- \nmacOS:<\/strong>
~\/Library\/Application Support\/Claude\/claude_desktop_config.json<\/code>\n<\/li>\n- \nWindows:<\/strong>
%APPDATA%Claudeclaude_desktop_config.json<\/code>\n<\/li>\n<\/ul>\nThis is where you\u2019ll define the servers and capabilities you want Claude to use \u2014 so keep this file open, we\u2019ll be editing it next.<\/p>\n
Image by author<\/figcaption><\/figure>\n Open the config file (
claude_desktop_config.json<\/code>) in any text editor. Replace its contents with the following, depending on your OS:<\/p>\nFor macOS:<\/h4>\n
{\n \"mcpServers\": {\n \"filesystem\": {\n \"command\": \"npx\",\n \"args\": [\n \"-y\",\n \"@modelcontextprotocol\/server-filesystem\",\n \"\/Users\/username\/Desktop\",\n \"\/Users\/username\/Downloads\"\n ]\n }\n }\n}<\/code><\/pre>\nFor Windows:<\/h4>\n
{\n \"mcpServers\": {\n \"filesystem\": {\n \"command\": \"npx\",\n \"args\": [\n \"-y\",\n \"@modelcontextprotocol\/server-filesystem\",\n \"C:\\Users\\username\\Desktop\",\n \"C:\\Users\\username\\Downloads\"\n ]\n }\n }\n}<\/code><\/pre>\nMake sure to replace <\/strong>
\"username\"<\/code> with your actual system username.<\/strong> The paths listed here should point to valid folders on your machine\u2014this setup gives Claude access to your Desktop<\/strong> and Downloads<\/strong>, but you can add more paths if needed.<\/p>\nWhat This Does<\/h4>\n
This config tells Claude Desktop<\/strong> to automatically start an MCP server called
\"filesystem\"<\/code> every time the app launches. That server runs usingnpx<\/code> and spins up@modelcontextprotocol\/server-filesystem<\/code>, which is what lets Claude interact with your file system\u2014read, write, move files, search directories, etc.<\/p>\n\n
Command Privileges<\/h4>\n\n
Just a heads-up: Claude will run these commands with your user account\u2019s permissions, meaning it can access and modify local files. Only add commands to the config file if you understand and trust the server you\u2019re hooking up \u2014 no random packages from the internet!<\/p>\n<\/blockquote>\n
5. Restart Claude<\/h3>\n
Once you\u2019ve updated and saved your configuration file, restart Claude Desktop<\/strong> to apply the changes.<\/p>\n
After it boots up, you should see a hammer icon<\/strong> in the bottom-left corner of the input box. That\u2019s your signal that the developer tools \u2014 and your custom MCP server \u2014 are up and running.<\/p>\n
Image by author<\/figcaption><\/figure>\n After clicking the hammer icon<\/strong>, you should see the list of tools exposed by the Filesystem MCP Server<\/strong> \u2014 things like reading files, writing files, searching directories, and so on.<\/p>\n
Image by author<\/figcaption><\/figure>\n If you don\u2019t see your server listed or nothing shows up, don\u2019t worry. Jump over to the Troubleshooting<\/strong><\/a> section in the official documentation for some quick debugging tips to get things back on track.<\/p>\n
6. Try It Out!<\/h3>\n
Now that everything\u2019s set up, you can start chatting with Claude about your file system \u2014 and it should know when to call the right tools<\/strong>.<\/p>\n
Here are a few things you can try asking:<\/p>\n
- \n
- \u201cCan you write a poem and save it to my Desktop?\u201d<\/em><\/li>\n
- \u201cWhat are some work-related files in my Downloads folder?\u201d<\/em><\/li>\n
- \u201cCan you take all the images on my Desktop and move them to a new folder called \u2018Images\u2019?\u201d<\/em><\/li>\n<\/ul>\n
When needed, Claude will automatically invoke the appropriate tools and ask for your approval<\/strong> before doing anything on your system. You stay in control, and Claude gets the job done.<\/p>\n
Build Your Own: Custom MCP Server from Scratch <\/h2>\n
Alright, ready to level up?<\/strong><\/p>\n
In this section, you\u2019ll go from user to builder. We\u2019re going to write a custom MCP server that Claude can talk to \u2014 specifically, a tool that lets it search the latest documentation from AI libraries like LangChain, OpenAI, MCP (yes, we\u2019re using MCP to learn MCP), and LlamaIndex.<\/p>\n
Because let\u2019s be honest \u2014 how many times have you watched Claude confidently spit out deprecated code or reference libraries that haven\u2019t been updated since 2021?<\/p>\n
This tool uses real-time search, scrapes live content, and gives your assistant fresh knowledge on demand. Yes, it\u2019s as cool as it sounds.<\/p>\n
The project is built using the official MCP SDK from Anthropic. If you\u2019re comfortable with Python and the command line, you\u2019ll be up and running in no time. And even if you\u2019re not \u2014 don\u2019t worry. We\u2019ll walk through everything step by step, including the parts most tutorials just assume you already know.<\/p>\n
Prerequisites<\/h3>\n
Before we dive in, here are the things you need installed on your system:<\/p>\n
- \n
- \nPython 3.10 or higher <\/strong>\u2014 this is the programming language we\u2019ll use<\/li>\n
- \nMCP SDK (v1.2.0 or higher)<\/strong> \u2014 this gives you all the tools to create a Claude-compatible server (which will be installed in upcoming parts)<\/li>\n
- \nuv<\/strong><\/a>
- \nMCP SDK (v1.2.0 or higher)<\/strong> \u2014 this gives you all the tools to create a Claude-compatible server (which will be installed in upcoming parts)<\/li>\n
- \u201cWhat are some work-related files in my Downloads folder?\u201d<\/em><\/li>\n
- \nWindows:<\/strong>
- Select \u201cSettings.\u201d<\/strong>\n<\/li>\n
- \nOn Windows<\/strong>: Press
- \nTools:<\/strong> These are the actual functions the model can call \u2014 run code, search the web, generate summaries, you name it.<\/li>\n
- \nResources:<\/strong> Think of these as external data sources \u2014 PDFs, APIs, databases. The model can pull them in for context, but it can\u2019t change them. Read-only.<\/li>\n
- \nContext<\/strong>: The extra information your model needs to do its job \u2014 documents, search results, user preferences, recent history. Context extends the model\u2019s capabilities beyond its training set.<\/li>\n
- \nTool Binding:<\/strong> As LLMs advanced, developers created methods to \u201cbind\u201d tools directly to models. For example, with LangChain or similar frameworks, you could do something like:<\/li>\n<\/ol>\n
- In a traditional RAG system<\/a><\/li>\n