Overview

Working with AI often boosts productivity, but it can quickly become tedious. You might find yourself constantly copying and pasting code snippets or images into prompts. While this is manageable for analyzing single source files, it becomes cumbersome when dealing with entire projects. Manually feeding source code to a Large Language Model (LLM) is inefficient, and the LLM itself struggles to grasp the overall context and flow of the project.

To address this, researchers and developers are exploring ways for LLMs to directly interact with tools like note-taking apps (e.g., Obsidian) or reverse engineering software (e.g., IDA Pro). This approach promises a smoother and more productive workflow.

Existing solutions like OpenAI’s API, orchestration frameworks like LangChain, and Retrieval-Augmented Generation (RAG) offer some capabilities. However, these methods often suffer from limitations in extensibility, flexibility, and can be quite closed-off, requiring significant customization for specific needs. It’s reminiscent of the past when every electronic device needed its own proprietary charger. This analogy, used by Anthropic when introducing MCP, aptly highlights the need for standardization.

The Model Context Protocol (MCP) aims to solve these problems by standardizing the communication protocol between models and the tools that provide them with external data. Think of it as creating a universal standard for how AI models access and use information from various sources.

Features

Key features of MCP include:

• Open Source and Customizable: MCP is open source, allowing for modification and adaptation.
• Model Agnostic: While developed by Anthropic (creators of Claude), MCP supports various LLMs.
• Persistent, Bidirectional Communication: Enables ongoing, two-way interaction between the model and tools.
• Context Preservation: Maintains the context of the interaction across multiple turns.
• Extensibility: Designed to easily integrate new tools and capabilities.
• Ease of Use: Relatively simple to implement, even without deep development expertise.
• Security: Communication occurs at the transport layer, offering inherent security benefits.

The MCP architecture involves three main components: Hosts, MCP Clients, and MCP Servers. While understanding the specifics isn’t essential for end-users, a basic grasp is helpful.

Host

• The user-facing application (e.g., Claude Desktop, VS Code, Cursor, other AI tools).
• Manages multiple MCP Client instances.
• Determines what information to provide to the LLM.

MCP Clients

• Connect to MCP Servers.
• Represent a single interaction session.
• Route messages between the Host and Servers.
• Act as intermediaries.

MCP Servers

• Provide “tools” (capabilities) to MCP Clients.
• Can run locally or remotely.
• Deliver capabilities independently.

The term “tools” here refers to the functionalities exposed by the Servers. MCP also supports “Resources” and “Prompts,” though these are less commonly used currently. If their usage increases, dedicated documentation will likely follow.

Open-Source MCP Server with Cursor

Let’s look at using an open-source MCP server with Cursor, a popular AI-powered code editor. Smithery offers various Global MCP servers like Sequential Thinking and Github. We’ll connect Cursor to the Sequential Thinking server.

Popular open-source MCP server hubs include Cursor Directory, Glama, and Smithery.

Installation

1. Visit the Sequential Thinking server page on Smithery.

   

2. Install the MCP Server. Initially, I tried installing by manually adding the JSON configuration, but encountered issues.

   

   The recommended method is direct installation using npx.

   2-1. Check the latest version on the Smithery page.

   

   2-2. Copy the installation command.

   

   2-3. Run the command in your terminal. Note: Node.js must be installed beforehand.

   $chjw1: ~ > npx -y @smithery/cli@latest install @smithery-ai/server-sequential-thinking --client cursor --key [redacted]
   ✔ Successfully resolved @smithery-ai/server-sequential-thinking
   Installing remote server. Please ensure you trust the server author, especially when sharing sensitive data.
   For information on Smithery's data policy, please visit: https://smithery.ai/docs/data-policy
   @smithery-ai/server-sequential-thinking successfully installed for cursor
   

3. Verify recognition in the Host (Cursor). The server should now be recognized by Cursor.

   

   

   Important: Remember to restart the Host application (Cursor, Claude Desktop, etc.) whenever you modify MCP settings.

Config File

In Cursor, go to Settings (gear icon) -> MCP -> Click the blue +Add new global MCP server button in the top right. This reveals how the Host recognizes MCP Servers. You can see which command establishes communication, available tools, and manage multiple servers easily.

On Windows, the configuration file is located at C:\Users\<YourUsername>\.cursor\mcp.json.

Here’s an example configuration (API keys redacted):

{
  "mcpServers": {
    "github": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "@smithery/cli@latest",
        "run",
        "@smithery-ai/github",
        "--config",
        "\"{\\\"githubPersonalAccessToken\\\":\\\"[redacted]\\\"}\""
      ]
    },
    "desktop-commander": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "@smithery/cli@latest",
        "run",
        "@wonderwhy-er/desktop-commander",
        "--key",
        "[redacted]"
      ]
    },
    "mcp-obsidian": {
      "command": "uvx",
      "args": [
        "mcp-obsidian"
      ],
      "env": {
        "OBSIDIAN_API_KEY": "[redacted]"
      }
    },
    "github.com/qw3rtyou/ida-pro-mcp": {
      "command": "C:\\Users\\chjw1\\AppData\\Local\\Programs\\Python\\Python312\\python.exe",
      "args": [
        "C:\\Users\\chjw1\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\ida_pro_mcp\\server.py"
      ],
      "timeout": 1800,
      "disabled": false,
      "autoApprove": [
        "check_connection",
        "get_metadata",
        // ... other auto-approved tools ...
        "get_struct_size"
      ],
      "alwaysAllow": [
        "check_connection",
        "get_metadata",
        // ... other always-allowed tools ...
        "get_struct_size"
      ]
    },
    "think-mcp-server": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "@smithery/cli@latest",
        "run",
        "@PhillipRt/think-mcp-server",
        "--key",
        "[redacted]"
      ]
    },
    "server-sequential-thinking": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "@smithery/cli@latest",
        "run",
        "@smithery-ai/server-sequential-thinking",
        "--key",
        "[redacted]"
      ]
    }
  }
}

This configuration allows the AI to perform tasks like pushing projects to GitHub or documenting findings in Obsidian, creating a powerful, extensible environment.

Make my own MCP Server

While using public servers is convenient, you can also create and run your own local MCP server. The Python SDK makes this straightforward.

Development

Before starting server development, consider using UV, a Python package and version management tool. While not mandatory, it’s fast, stable, and significantly improves the development experience once learned. Many modern Python tools are adopting UV for package management, making it a worthwhile investment.

1. Create Project and Install SDK

   $chjw1: ~/mcp > uv init MCP05
   Initialized project `mcp05` at `C:\Users\chjw1\mcp\MCP05`
   $chjw1: ~/mcp > cd .\MCP05\
   $chjw1: ~/mcp/MCP05 on master ?7 > uv add "mcp[cli]"
   Using CPython 3.12.6 interpreter at: C:\Users\chjw1\AppData\Local\Programs\Python\Python312\python.exe
   Creating virtual environment at: .venv
   Resolved 28 packages in 291ms
   Prepared 27 packages in 783ms
   Installed 27 packages in 129ms
    + annotated-types==0.7.0
    + anyio==4.9.0
    # ... other installed packages ...
   

   Test the installation:

   $chjw1: ~/mcp/MCP05 on master ?8 > uv run mcp
    Usage: mcp [OPTIONS] COMMAND [ARGS]...
   
    MCP development tools
   # ... (mcp help output) ...
   

   View the dependency tree:

   $chjw1: ~/mcp/MCP05 on master ?8 > uv tree
   Resolved 28 packages in 2ms
   mcp05 v0.1.0
   └── mcp[cli] v1.6.0
       ├── anyio v4.9.0
       │   ├── idna v3.10
       │   ├── sniffio v1.3.1
       │   └── typing-extensions v4.13.0
      # ... (dependency tree output) ...
   

   Debugging is also possible (though not extensively tested by the author):

   $chjw1: ~/mcp/MCP05 on master ?8 > .\.venv\Scripts\activate.ps1
   (mcp05) $chjw1: ~/mcp/MCP05 on master ?8 > mcp dev server.py
   Starting MCP inspector...
   Proxy server listening on port 3000
   
   🔍 MCP Inspector is up and running at http://localhost:5173 🚀
   

2. Write Server Code Here’s the example from the official documentation:

   # server.py
   from mcp.server.fastmcp import FastMCP
   
   # Create an MCP server
   mcp = FastMCP("Demo")
   
   # Add an addition tool
   @mcp.tool()
   def add(a: int, b: int) -> int:
       """Add two numbers"""
       return a + b
   
   # Add a dynamic greeting resource
   @mcp.resource("greeting://{name}")
   def get_greeting(name: str) -> str:
       """Get a personalized greeting"""
       return f"Hello, {name}!"
   

   Consider using Docker for deployment:

   FROM python:3.11-slim
   
   WORKDIR /app
   
   RUN apt-get update && apt-get install -y curl
   
   COPY . .
   
   RUN curl -LsSf https://astral.sh/uv/install.sh | sh
   
   ENV PATH="/root/.local/bin:${PATH}"
   
   RUN uv venv .venv && uv pip install -r pyproject.toml
   
   EXPOSE 3000
   EXPOSE 5173
   
   ENTRYPOINT ["uv", "run", "mcp", "run", "src/calc_server.py:mcp"]
   

3. Configure Host App Below are configurations for connecting via Docker (top) and directly locally (bottom). Dockerizing can save hassle compared to configuring mcp.json for every environment.

   "simple-calc-docker": {
     "command": "docker",
     "args": [
       "run",
       "-i",
       "--rm",
       "-p",
       "3010:3000",
       "mcp/seminar"
     ]
   },
   "simple-calc": {
     "command": "uv",
     "args": [
       "--directory",
       "C:\\Users\\chjw1\\mcp\\MCP05",
       "run",
       "src\\calc_server.py"
     ]
   }
   

4. Run the Server (Example using Docker)

   $chjw1: ~/mcp/MCP05 on master ?7 > docker image build -t mcp/seminar .
   [+] Building 1.3s (11/11) FINISHED                                      docker:default
    => [internal] load build definition from Dockerfile                              0.0s
    => => transferring dockerfile: 619B                                              0.0s
    # ... (docker build output) ...
    => => naming to docker.io/mcp/seminar                                            0.0s
   

5. Verify Connection

   

   The Host should now list the tools provided by your custom server.

   

   However, note that Cursor currently seems unable to fetch Resources defined in the server code.

   

   As Cursor only supports Tools at the moment, using Claude Desktop might be necessary to use Resources or Prompts.

   You can install the server for Claude Desktop using the following command in your virtual environment:

   mcp install .\src\calc_server.py
   

   This adds an entry to claude_desktop_config.json:

   "mcpServers": {
       "CalcMCPServer": {
         "command": "uv",
         "args": [
           "run",
           "--with",
           "mcp[cli]",
           "mcp",
           "run",
           "C:\\Users\\chjw1\\mcp\\MCP05\\src\\calc_server.py"
         ]
       }
   }
   

   Now, Claude Desktop can access the defined Resources.

   

   

IDA-pro-mcp Customizing

From a security perspective, exploring MCP’s capabilities through customization is particularly interesting. A colleague recommended the IDA MCP server, which proved to be the most useful and engaging MCP application I’ve encountered.

It allows real-time symbol renaming, adding relevant comments, and performing analysis within IDA Pro via the AI assistant.

However, I encountered situations where analysis stalled because the AI didn’t know the data residing at a specific memory address. To overcome this, I implemented a memory dump function.

Available tools (before customization):

check_connection: Check if the IDA plugin is running.
get_metadata(): Get metadata about the current IDB.
get_function_by_name(name): Get a function by its name.
# ... (list of original tools) ...
set_local_variable_type(function_address, variable_name, new_type): Set a local variable's type.

Development process:

1. Locate the local Python package directory.

   $chjw1: ~/workspace/ida-pro-mcp on main > pip show ida-pro-mcp
   Name: ida-pro-mcp
   Version: 1.2.0
   Summary: Vibe reversing with IDA Pro
   Home-page:
   Author: mrexodia
   Author-email:
   License:
   Location: C:\Users\chjw1\AppData\Local\Programs\Python\Python312\Lib\site-packages
   Requires: mcp
   Required-by:
   

2. Replace existing files with modified ones (e.g., copy your customized server.py).

   $chjw1: ~/workspace/ida-pro-mcp on main > explorer.exe C:\Users\chjw1\AppData\Local\Programs\Python\Python312\Lib\site-packages\ida_pro_mcp\
   

3. Reinstall the package to apply changes. This updates server_generated.py and applies the modifications to the IDA Python plugin.

   $chjw1: ~/workspace/ida-pro-mcp on main > ida-pro-mcp --install
   Skipping Cline installation
     Config: C:\Users\chjw1\AppData\Roaming\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json (not found)
   Skipping Roo Code installation
     Config: C:\Users\chjw1\AppData\Roaming\Code\User\globalStorage\rooveterinaryinc.roo-cline\settings\mcp_settings.json (not found)
   Installed Claude MCP server (restart required)
     Config: C:\Users\chjw1\AppData\Roaming\Claude\claude_desktop_config.json
   Installed IDA Pro plugin (IDA restart required)
     Plugin: C:\Users\chjw1\AppData\Roaming\Hex-Rays\IDA Pro\plugins\mcp-plugin.py
   

I forked the original repository and added the memory dump functionality to my personal GitHub.

Another inconvenience arose during development: the installation command updated claude_desktop_config.json but not Cursor’s mcp.json.

I modified the installation script to automatically update Cursor’s configuration as well:

 def install_mcp_servers(*, uninstall=False, quiet=False, env={}):
     if sys.platform == "win32":
         configs = {
             "Cline": (os.path.join(os.getenv("APPDATA"), "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings"), "cline_mcp_settings.json"),
             "Roo Code": (os.path.join(os.getenv("APPDATA"), "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings"), "mcp_settings.json"),
             "Claude": (os.path.join(os.getenv("APPDATA"), "Claude"), "claude_desktop_config.json"),
+            "Cursor": (os.path.join(os.getenv("USERPROFILE"), ".cursor"), "mcp.json"),
         }

References

• python-sdk github
• fastmcp github
• https://tiaz.dev/ai/3
• https://apidog.com/kr/blog/build-a-custom-mcp-server/
• https://tiaz.dev/ai/1