Nicolas Dabene

Posted on Jan 25 • Originally published at nicolas-dabene.fr

Understanding MCP Protocol: Complete Guide

#prestashop #ecommerce #ai

Unleashing AI's Full Potential: A Practical Look at the Model Context Protocol (MCP)

Ever imagined how an AI like ChatGPT or Claude could delve into your personal files, browse your emails, or query your database? The key lies in three letters: MCP (Model Context Protocol). Before we jump into implementation, let's unpack this game-changing architecture with an accessible analogy and a step-by-step discussion.

Introduction to AI Interaction

Having spent over 15 years in software development, I've witnessed countless protocols and architectures emerge and fade. MCP, however, truly stands out for its elegant simplicity. It transforms seemingly isolated AI models into robust assistants capable of engaging with the real world. Picture telling Claude, "Summarize the 'report.pdf' on my desktop," and watching the AI effortlessly access, read, and condense your document. This is precisely the power MCP unlocks.

But how does this marvel actually function under the hood? We'll explore this together, not through convoluted technical diagrams, but by tracing the natural progression of a user's request to an AI.

The Three Pillars of the MCP Ecosystem

Before dissecting the protocol itself, let’s identify the main players in this interaction. The MCP framework relies on three core actors, each with a distinct and vital role.

🤖 The AI Application: The Isolated Genius

Consider large language models such as Claude, ChatGPT, or any other sophisticated AI. These intelligences excel at comprehending and generating text; they can reason, innovate, and analyze with impressive prowess. Yet, they share a fundamental constraint: they are entirely cut off from external environments.

Think of it like a brilliant scholar confined to a library, brimming with knowledge but unable to open a door or fetch a book from outside its walls.

💻 The MCP Server: The Smart Gateway

This component is what we'll build and focus on. The MCP server acts as the crucial link between the AI and the tangible world. Its primary responsibilities include:

Announcing capabilities: ("I can read documents," "I can send emails.")
Translating requests: Converting AI's needs into actionable instructions.
Secure execution: Performing AI-initiated actions safely and reliably.

Envision an expert interpreter who not only translates language but also transforms intentions into concrete actions.

📄 The Resource: The Ultimate Destination

This represents the actual data source or utility we aim to interact with: a folder on your local machine, a PostgreSQL database, the Google Drive API, your Gmail inbox—essentially, anything that stores information or enables specific operations.

Tracing a Simple AI Query

With our actors introduced, let's now follow the path of a typical user request. Imagine you pose this question to Claude:

“Could you summarize the report.pdf file located on my desk?”

Step 1: Discovering Available Tools

The initial, critical question is: how does the AI know it can even interact with files?

It's much like stepping into a new restaurant. Before placing an order, you first peruse the menu to see what's on offer. The AI engages similarly with our MCP server.

Our server thus presents a "menu" of its functionalities. For a server configured to access local files, this menu might appear as follows:

Available Tool: readFile

Description: "Extracts the text content from a specified file."
Required Parameter: file_path (a string value)

Available Tool: listFiles

Description: "Provides a list of files within a designated folder."
Required Parameter: folder_path (a string value)

Do you see the rationale? Each tool is clearly outlined with its necessary parameters. This allows the AI to "understand" its capabilities and how to invoke them effectively.

Step 2: The Essential Security Check

Now that the AI is aware of the readFile capability, do you believe it can simply access any file on your computer without further ado?

Absolutely not! That would be a catastrophic security vulnerability. This is where a vital stage comes into play: the explicit permission request.

The AI application (whether ChatGPT, Claude, etc.) will directly prompt you:

“Do you grant this server permission to read the 'report.pdf' file?”

You, the human user, remain firmly in control. Only after your express consent will the AI proceed. This human validation step is a cornerstone of the MCP philosophy.

Step 3: Crafting the Structured Command

Once authorization is granted, the AI constructs its request for the server. However, it won't phrase it in a conversational sentence like we would. Computers prefer precise, unambiguous structures.

Here’s how the AI formats its command using JSON (a standard format for data exchange):

{
  "tool_name": "readFile",
  "parameters": {
    "file_path": "/Users/you/Desktop/report.pdf"
  }
}

Let's break down this structure:

tool_name: The specific tool to be invoked (in this case, readFile).
parameters: An object containing all necessary arguments.
- file_path: The precise location of the file to be read.

It's straightforward, clear, and leaves no room for misinterpretation. The server knows exactly how to proceed.

Step 4: Execution and Delivery

Our MCP server receives this structured command. Its subsequent actions involve:

Validation: Confirming the command is well-formed (e.g., are all required parameters present?).
Execution: Performing the requested action (reading the specified file from the storage).
Response: Sending the result back to the AI.

The server's response might look something like this:

{
  "content": "Q4 2024 Quarterly Report\n\nRevenue: €2.5M\nGrowth: +15%\n...",
  "success": true
}

The AI processes this response, now equipped with the file's content, and can then provide you with a comprehensive summary.

A Complete Conversational Walkthrough

Let's revisit our scenario from start to finish, illustrating the entire conversation flow:

👤 You: "Claude, could you summarize the 'report.pdf' file on my desk?"

🤖 Claude: "I can't directly access files, but I see an MCP 'filesystem' server is available. Let me check its capabilities..."

💻 MCP Server: "Here's my menu: I can readFile and listFiles."

🤖 Claude: "Excellent! I'll request to read the file."

🖥️ Application: "User, do you authorize reading '/Users/you/Desktop/report.pdf'?"

👤 You: "Yes, granted."

🤖 Claude: Sends the structured JSON command to the server.

💻 MCP Server: Reads the file and returns its content.

🤖 Claude: "Here's your report summary: Q4 2024 revenue reached €2.5M, demonstrating 15% growth..."

Essential MCP Principles to Grasp

Before we transition to practical coding, let's solidify our understanding with MCP's foundational tenets:

1. Discovery Precedes Action

The AI cannot intuit a server's capabilities. It always initiates by querying the "menu" of available functions. It's like navigating an unfamiliar city: you consult a map before plotting your course.

2. Security at the Core

Every significant action demands human approval. MCP isn't a loophole for AIs to indiscriminately probe your data. It's a protocol where you retain sovereign control over what becomes accessible.

3. Standardized Communication

Commands and responses adhere to a consistent JSON format. This strictness eliminates ambiguity, enabling any MCP-compliant AI to seamlessly interact with any MCP server.

4. Clear Role Separation

Each participant has a defined role:

The AI comprehends natural language and performs reasoning.
The MCP server translates and executes commands.
The resource holds or processes the data.

The Transformative Impact of This Architecture

MCP marks a monumental leap in integrating AI into our everyday workflows. Prior to MCP, each AI model required proprietary integrations. If you wanted ChatGPT to access your Google Drive, OpenAI had to develop that specific integration. If Claude desired the same, Anthropic had to duplicate that effort.

With MCP, a single server can be utilized by all compatible AIs. It's akin to transitioning from proprietary electrical outlets to a universal standard. Develop one MCP server for Google Drive, and every AI can leverage it instantly.

This standardization opens a universe of possibilities:

Secured access to personal and sensitive data.
Seamless integration with diverse enterprise tools.
Automation of intricate, multi-step tasks.
The creation of truly helpful and practical AI assistants for daily life.

Conclusion

We've covered significant ground! From the initial query, "How can an AI read my files?", we've arrived at a comprehensive understanding of a sophisticated protocol, its key players, interaction flows, and its inherent security philosophy.

The most exciting part? What we've just explored was purely theoretical. The real enchantment begins when we translate this knowledge into code, bringing our own MCP server to life and enabling an AI to genuinely interact with our data.

In upcoming articles, we'll get hands-on: project initialization with TypeScript, building our first readFile tool, implementing permission management, and conducting tests with Claude. For now, you possess the essential conceptual foundation—the robust bedrock upon which we'll construct our MCP server.

Continue Your Journey:

Enjoyed this deep dive into MCP? If you're eager to see more practical guides, coding tutorials, and insights into cutting-edge tech, make sure to subscribe to my YouTube channel! For professional updates, discussions on software architecture, and networking opportunities, let's connect on LinkedIn! Your support helps me create more valuable content for the developer community.

DEV Community