Chatbot in a Box: Building a MCP Server & Client from Scratch

Building a Simple MCP Server and Client for AI-Powered Programming

In this post, we'll delve into creating a basic in-memory database server using the Model Context Protocol (MCP), a lightweight framework that enables seamless interaction between AI agents and your code. By the end of this article, you'll have a working prototype and be equipped to extend it with additional functionalities.

What is MCP?

MCP is an open-source standard for connecting AI applications to external systems. It's designed to expose functions as "tools" to language models, making it easier to interact with your code using AI agents. Think of it as a bridge that turns your functions into callable endpoints for models.

Setting Up the Server

To start building our MCP server, we'll use Python as our programming language. We'll need to install the mcp-server library and its dependencies using pip:

pip install mcp-server

Next, let's create a basic in-memory database class that will serve as our data storage:

import json

class InMemoryDatabase:
    def __init__(self):
        self.data = {}

    def get(self, key):
        return self.data.get(key)

    def set(self, key, value):
        self.data[key] = value

    def delete(self, key):
        if key in self.data:
            del self.data[key]

This class will store data in memory and provide basic CRUD (Create, Read, Update, Delete) operations.

Implementing the MCP Server

Now that we have our in-memory database set up, let's create an MCP server using the mcp-server library:

from mcp_server import MCPServer

class DatabaseMCPServer(MCPServer):
    def __init__(self):
        super().__init__()
        self.database = InMemoryDatabase()

    def on_tool_call(self, tool_name, arguments):
        if tool_name == "get":
            return self.database.get(arguments["key"])
        elif tool_name == "set":
            self.database.set(arguments["key"], arguments["value"])

In this code snippet, we're creating an MCP server that uses our in-memory database. We've also defined two tools: get and set. The on_tool_call method checks the tool name and calls the corresponding method on the database object.

Starting the Server

To start our MCP server, we'll use the following code:

if __name__ == "__main__":
    server = DatabaseMCPServer()
    server.start()

With this code in place, you should now have a working MCP server that exposes two tools: get and set.

Building the Client

To interact with our MCP server using AI agents, we'll need to build a client. We'll use Python again for this example.

import requests

class MCPClient:
    def __init__(self, server_url):
        self.server_url = server_url

    def call_tool(self, tool_name, arguments):
        response = requests.post(
            f"{self.server_url}/tools/{tool_name}",
            json=arguments
        )
        return response.json()

This client class sends a POST request to the MCP server's /tools/<tool_name> endpoint with the specified tool name and arguments.

Real-World Applications

MCP has numerous real-world applications, including:

• AI-assisted programming: Use AI agents to interact with your code using MCP tools.
• Serverless functions: Expose functions as MCP tools for seamless interaction with language models.
• Data integration: Connect different data sources using MCP tools.

Conclusion and Next Steps

In this article, we've built a basic in-memory database server using the Model Context Protocol (MCP). We've also created an MCP client to interact with our server. By following these steps, you should now have a working prototype that exposes two tools: get and set.

To extend this example, try implementing update, delete, and drop functionalities on your in-memory database. You can also explore other MCP tools and features.

MCP Example Use Cases

Here are some ideas to get you started:

• Database migration: Use MCP to migrate data between different databases.
• Data aggregation: Expose functions as MCP tools to aggregate data from multiple sources.
• Machine learning model deployment: Use MCP to deploy machine learning models and interact with them using AI agents.

---

By Malik Abualzait