Tools for Your LLM: a Deep Dive into MCP

approach that may flip LLMs into precise brokers. It’s because MCP supplies instruments to your LLM which it might use to retrieve stay info or carry out actions in your behalf.

Like all different instruments within the toolbox, I imagine that to be able to apply MCP successfully, it’s a must to perceive it totally. So I approached it in my typical manner: get my fingers round it, poke it, take it aside, put it again collectively and get it working once more.

The objectives of this week:

• get a stable understanding of MCP; what’s it?
• construct an MCP server and join it to an LLM
• perceive when to make use of MCP
• discover concerns round MCP

1) What’s MCP?

MCP (Mannequin Context Protocol) is protocol designed to increase LLM shoppers. An LLM shopper is something that runs an LLM: consider Claude, ChatGPT or your personal LangGraph agentic chatbot. On this article we’ll use Claude desktop as a LLM shopper and construct a MCP server for it that extends its talents.

First let’s perceive what MCP actually is.

A useful analogy

Consider MCP the identical manner you consider browser extensions. A browser extension provides capabilities to your browser. An MCP server provides capabilities to your LLM. In each circumstances you present a small program that the shopper (browser or LLM) can load and talk with to make it do extra.

This program is known as an MCP server and LLM shoppers can use it to e.g. retrieve info or carry out actions.

When is a program an MCP server?

Any program can turn into an MCP server so long as it implements the Mannequin Context Protocol. The protocol defines:

1. which features the server should expose (capabilities)
2. how these features should be described (instrument metadata)
3. how the LLM can name them (with JSON request codecs)
4. how the server should reply (with JSON consequence codecs)

An MCP server is any program that follows the MCP message guidelines. Discover that language, runtime or location don’t matter.

Key capabilities:

• declaring instruments
• accepting a instrument name request
• executing the requested perform
• returning a consequence or error

Instance of a tool-call message:

{
  "methodology": "instruments/name",
  "params": {
    "identify": "get_weather",
    "arguments": {"metropolis": "Groningen"}
  }
}

Sending this JSON means: “name the perform get_weather with arguments metropolis=’Groningen’.”

2) Creating an MCP server

Since any program could be an MCP server, let’s create one.

Think about we work for a cinema and we wish to make it attainable for brokers to assist individuals purchase tickets. This manner a consumer can determine which film to choose by chatting with ChatGPT or instruct Claude to purchase tickets.

In fact these LLMs will not be conscious of what’s occurring in our cinema so we’ll want to show our cinema’s API by MCP in order that the LLMs can work together with it.

The best attainable MCP server

We’ll use fastmcp, a Python bundle that wraps Python features so that they conform to the MCP specs. We will can “current” this code to the LLM in order that they’re conscious of the features and might name them.

from fastmcp import FastMCP

mcp = FastMCP("example_server")

@mcp.instrument
def list_movies() -> str:
    """ Checklist the flicks which can be presently enjoying """
    # Simulate a GET request to our /motion pictures endpoint
    return ["Shrek", "Inception", "The Matrix", "Lord of the Rings"]

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

The code above defines a server and registers a instrument. The docstring and sort hints assist fastmcp describe the instrument to the LLM shopper (as required by the MCProtocol). The agent decides based mostly on this description whether or not the perform is appropriate in fulfilling the duty it’s got down to do.

Connecting Claude Desktop to the MCP server

To ensure that our LLM to be “conscious” of the MCP server, we now have to inform it the place to seek out this system. We register our new server in Claude Desktop by opening Settings -> Developer and replace claude_desktop_config.json in order that it seems to be like this:

{
  "mcpServers": {
    "cinema_server": {
      "command": "/Customers/mikehuls/explore_mcp/.venv/bin/python",
      "args": [
        "/Users/mikehuls/explore_mcp/cinema_mcp.py"
      ]
    }
  }
}

Now that our MCP server is registered, Claude can use it. It name list_movies() for instance. The features in registered MCP servers turn into first-class instruments that the LLM can determine to make use of.

As you see, Claude has executed the perform from our MCP server and has entry to the ensuing worth. Very straightforward in just some traces of code.

With a number of extra traces we wrap much more API endpoints in our MCP server and permit the LLM to name features that present screening occasions and even permit the LLM to carry out actions on our behalf by making a reservation:

Notice that though the examples are intentionally simplified, the precept stays the identical: we permit our LLM to retrieve info and act on our behalf, by the cinema API

3) When to make use of MCP

MCP is good when:

• You need an LLM to entry stay knowledge
• You need an LLM to carry out actions (create duties, fetch recordsdata, write information)
• You wish to expose inside programs in a managed manner
• You wish to share your instruments with others as a bundle they will plug into their LLM

Customers profit as a result of MCP lets their LLM turn into a extra highly effective assistant.

Suppliers profit as a result of MCP lets them expose their programs safely and constantly.

A standard sample is a “instrument suite” that exposes backend APIs. As an alternative of clicking by UI screens, a consumer can ask an assistant to deal with the workflow for them.

4) Concerns

Since its launch in November 2024, MCP has been extensively adopted and rapidly turned the default solution to join AI brokers to exterior programs. Nevertheless it’s not with out trade-offs; MCP introduces structural overhead and actual safety dangers, in my view, engineers ought to pay attention to earlier than utilizing it in prodution.

a) Safety

When you obtain an unknown MCP server and join it to your LLM, you’re successfully granting that server file and community entry, entry to native credentials and command execution permissions. A malicious instrument might:

• learn or delete recordsdata
• exfiltrate non-public knowledge (.ssh keys e.g.)
• scan your community
• modify manufacturing programs
• steal tokens and keys

MCP is barely as save because the server you select to belief. With out guardrails you’re principally giving an LLM full management over your laptop. It makes it very straightforward to over-expose since you may simply add instruments.

The browser-extension analogy applies right here as properly: most are secure however malicious ones can do actual injury. Like browser extensions, use trusted sources like verified repositories, examine supply code if attainable and sandbox execution if you’re not sure. Implement strict permissions and leas-privilege insurance policies.

b) Inflated context window, token inefficiency and latency

MCP servers describe each instrument intimately: names, argument schema’s, descriptions and consequence codecs. The LLM shopper hundreds all this metadata up-front into the mannequin context in order that it is aware of which instruments exist and the way to use it.

Which means that in case your agent makes use of many instruments or complicated schemas, the immediate can develop considerably. Not solely does this use lots of token, it additionally makes use of up remaining house for dialog historical past and task-specific directions. Each instrument you expose completely eats a slice of the out there context.

Moreover, each instrument name introduces reasoning overhead, schema parsing, context reassignment and a full round-trip from mannequin -> MCP shopper -> MCP server -> again to the mannequin. That is far too heavy for latency-sensitive pipelines.

c) Complexity shifts into the mannequin

The LLM should make all of the powerful choices:

• whether or not to name a instrument in any respect
• which instrument to name
• which arguments to make use of

All of this occurs contained in the mannequin’s reasoning quite than by specific orchestration logic. Though initially this feels magically handy and environment friendly, at scale this will turn into unpredictable, more durable to debug and harder to ensure deterministically.

Conclusion

MCP is easy and highly effective on the identical time. It’s a standardized solution to let LLMs name actual packages. As soon as a program implements MCP, any compliant LLM shopper can use it as an extension. This opens the door to assistants that may question API’s, carry out duties and work together with actual programs in a structured manner.

However with nice energy comes nice accountability. Deal with MCP servers with the identical warning as software program that has full entry to your machine. Its design additionally introduces implications for token utilization, latency and pressure on the LLM. These trade-offs could undermine the core advantage of MCP is thought for: turning brokers into environment friendly, real-world instruments.

When used deliberately and securely, MCP gives a clear basis for constructing agentic assistants that may really do issues quite than simply discuss them.

I hope this text was as clear as I meant it to be but when this isn’t the case please let me know what I can do to make clear additional. Within the meantime, try my other articles on all types of programming-related subjects.

Joyful coding!

— Mike

P.s: like what I’m doing? Comply with me!