Model Context Protocol: A comprehensive overview

The abbreviation MCP stands for the open specification for the Model Context Protocol. This specification defines how large language models can interact with tools and functions. The highlight here is that tools and language models can be exchanged flexibly and used universally as they speak the same "language".

MCP is to tools and agents what REST APIs are to applications - a standardized link for seamless integration and communication.

What is the Model Context Protocol (MCP)?

The Model Context Protocol is an open technical standard published by Anthropic. It defines how large language models obtain specific context and access to tools and how communication between the language model and the tool takes place. This allows the language model to retrieve exactly the information, tools and functionalities that the model needs to provide meaningful answers or complete tasks.

MCP therefore creates a standardized interface that reduces complexity. Instead of building new special solutions every time, MCP creates order and reusability. Whether file access, web service or automation - with MCP, many things can be linked more easily and made usable for LLMs.

Why MCP is useful

Language models can capture the content of text and images and act on the basis of language model knowledge (trained knowledge). This knowledge is a limitation that is quickly reached. For example, an LLM knows nothing about current events, as the training of the language model was usually completed months before and no current events have been trained, so the LLM knows nothing about the news or the weather today.  

MCP has the potential to close this gap. It combines a language model with the appropriate toolbox and thus the limitation of static knowledge can be resolved.

For example, a language model can be given access to a search engine and a weather service so that the LLM can actively use these tools to retrieve the latest news or today's weather and use this information. This combination of LLM and tool can be used, for example, for a daily morning update in which the LLM summarizes the most important news and a weather report for today.

Another, somewhat special but useful, use case is the Use of an MCP server for the optimization of archive processes.

Also in the NLWeb (Natural Language Web) the MCP protocol is an integral part and plays to its strengths.

The architecture behind MCP

The Model Context Protocol (MCP) follows a typical client-server model. At its heart is the MCP host, a language model that executes commands. The MCP client acts as an interface and forwards requests between the model and the MCP server. An MCP server can provide a variety of tools, such as functions, files or APIs. These tools enable the model to access external resources such as databases or services. Prompts define specific tasks for the model, and tools are executable functions that the model can use to perform these tasks.

• MCP host - the model that performs tasks
• MCP client - mediates between model and server
• MCP server - provides tools in the form of functions, files or APIs
• Resources - Databases, files or services
• prompts - ready-made tasks
• Tools - Executable functions

The Model Context Protocol uses a client-server structure in which a central application can communicate with several servers simultaneously.

Just as USB-C bundles various functions via a single connection, such as charging, data and image signal, MCP connects models with data, tools and services via a standardized interface.

Advantages of the MCP standard

The MCP standard offers a number of practical advantages that will make the future of LLM-based software development more efficient and modular. This standardization makes it possible to do away with complex special solutions and rigid software implementations, which leads to more agile development and use of the software.
The main advantages of the MCP standard are listed below:

• Standardization - The principle of "set up once, use multiple times" takes center stage. Similar to USB-C, all components fit together seamlessly, regardless of manufacturer or provider. This standardization significantly reduces the integration effort and promotes the reusability of modules and services.
• Flexibility - Models, tools or providers can be partially or completely replaced, as they all speak the same "language" (MCP). This flexibility makes it possible to quickly adapt to new requirements or technologies without having to rework the entire system.
• Security - Access to tools and data can be precisely controlled and encapsulated. Defined interfaces and authorizations ensure that only authorized components can access sensitive information and functions.
• Modularity - MCP servers are small, self-contained building blocks that can be easily combined, exchanged and expanded. This modular architecture promotes the development of scalable and easy-to-maintain systems, as individual components can be updated or replaced independently of each other.

Thanks to these advantages, the MCP standard enables a more efficient, secure and flexible use of LLM-based applications and services.

What MCP servers can do

At its core, an MCP server extends the language model with specific capabilities.
Simply put, MCP servers are tools that the language model can use when it is useful to it.

Typical use cases that an MCP server can cover:

• Access to defined folders, files or directly to a database
• Connection with web services such as the Google search engine
• Use of applications such as Outlook or Teams
• Application of predefined prompts and workflows

Examples of popular MCP servers

The Github page punkpeye/awesome-mcp-servers lists many useful servers that can be used immediately. 

Here are some examples:

These servers work on the same principle as adapters - plug in and go.

This variety of MCP servers shows how flexible and expandable the Model Context Protocol is. The community is constantly developing new servers that are tailored to specific needs and expand the possibilities of LLMs.

First steps with MCP servers

For a quick start

If you just want to get started, use an application like Claude Desktop. This allows you to link your own files to the model. The instructions on modelcontextprotocol.io/quickstart/user helps with this.

Here is an example configuration of the claude_desktop_config.json file that integrates a Github and Brave Search MCP server and makes it directly usable.

{
  "mcpServers": {
    "brave-search": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "BRAVE_API_KEY",
        "mcp/brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "YOUR_ACTUAL_BRAVE_API_KEY"
      }
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_ACTUAL_GITHUB_TOKEN"
      }
    }
  }
}

For those interested in technology

The MCP Server Quickstart shows how to build a server yourself. All you need is Python or TypeScript experience, the official SDK and a little curiosity.

The following code represents a minimal MCP server that can be used by an LLM to correctly convert times for different time zones.

#!/usr/bin/env python3
"""Minimal MCP-Server - Timezone Converter"""
import json
import sys
from datetime import datetime
import pytz
def convert_timezone(time_str, from_tz, to_tz):
    """Convert time between timezones"""
    dt = datetime.strptime(time_str, "%Y-%m-%d %H:%M")
    dt_with_tz = pytz.timezone(from_tz).localize(dt)
    converted = dt_with_tz.astimezone(pytz.timezone(to_tz))
    return {
        "original": f"{time_str} {from_tz}",
        "converted": f"{converted.strftime('%Y-%m-%d %H:%M')} {to_tz}",
        "offset": converted.strftime('%z')
    }
def handle_request(request):
    """Route and handle MCP requests"""
    method = request["method"]
    params = request.get("params", {})
    
    if method == "initialize":
        return {
            "protocolVersion": "0.1.0",
            "capabilities": {"tools": {}},
            "serverInfo": {"name": "timezone-converter", "version": "1.0.0"}
        }
    
    elif method == "tools/list":
        return {
            "tools": [{
                "name": "convert_timezone",
                "description": "Convert time between timezones",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "time": {"type": "string", "description": "Time 'YYYY-MM-DD HH:MM'"},
                        "from_tz": {"type": "string", "description": "Source timezone"},
                        "to_tz": {"type": "string", "description": "Target timezone"}
                    },
                    "required": ["time", "from_tz", "to_tz"]
                }
            }]
        }
    
    elif method == "tools/call":
        if params.get("name") != "convert_timezone":
            raise Exception(f"Unknown tool: {params.get('name')}")
        
        args = params["arguments"]
        try:
            result = convert_timezone(args["time"], args["from_tz"], args["to_tz"])
            return {"content": [{"type": "text", "text": json.dumps(result, indent=2)}]}
        except Exception as e:
            raise Exception(f"Tool error: {str(e)}")
    
    else:
        raise Exception(f"Unknown method: {method}")
def main():
    """Main server loop"""
    while True:
        try:
            line = sys.stdin.readline()
            if not line:
                break
            
            request = json.loads(line.strip())
            
            try:
                response = handle_request(request)
                output = {
                    "jsonrpc": "2.0",
                    "id": request.get("id"),
                    "result": response
                }
            except Exception as e:
                output = {
                    "jsonrpc": "2.0",
                    "id": request.get("id"),
                    "error": {"code": -32000, "message": str(e)}
                }
            
            print(json.dumps(output))
            sys.stdout.flush()
            
        except json.JSONDecodeError:
            error = {
                "jsonrpc": "2.0",
                "id": None,
                "error": {"code": -32700, "message": "Parse error"}
            }
            print(json.dumps(error))
            sys.stdout.flush()
if __name__ == "__main__":
    main()

Deep Dive Tutorial

For a deeper insight, Mahesh Murag from Anthropic shows a detailed look at building agents with Model Context Protocol in the following video. 

By loading the video, you accept YouTube's privacy policy.
Read more

Load video

Always unlock YouTube

Conclusion

The Model Context Protocol brings order and modularity to the world of language models. Instead of constantly building new interfaces, MCP ensures a stable standard. MCP servers not only make LLMs smarter, but also more agile. With MCP, data, services and models can be cleanly connected, regardless of whether in the company, in the project or for everyday tasks. This standardization and the associated flexibility mean that LLM-based solutions can be scaled more easily and adapted to new requirements. MCP also promotes the development of a lively community in which developers and companies can share their own servers and tools and develop them further together. Ultimately, MCP paves the way for a future in which language models are even more deeply integrated into our everyday digital lives and can support us in a variety of tasks.