Your Personal Analytics Toolbox | Towards Data Science

nearly as good because the context offered to them. Even probably the most superior mannequin gained’t be very useful if it doesn’t have entry to the information or instruments it must get extra data. That’s why instruments and assets are essential for any AI agent.

I’ve seen that I hold repeating the identical duties again and again: writing comparable prompts or creating the identical instruments repeatedly. There’s a basic precept in software program engineering referred to as DRY, which stands for “Don’t Repeat Your self”.

So, I began questioning if there’s a technique to keep away from duplicating all this work. Thankfully, the GenAI trade already has an answer in place. MCP (Mannequin Context Protocol) is an open-source protocol that allows the connection of AI functions to exterior instruments and knowledge sources. Its essential aim is to standardise such interactions, just like how REST APIs standardised communication between internet functions and backend servers.

With MCP, you may simply combine third-party instruments like GitHub, Stripe and even LinkedIn into your AI agent with out having to construct instruments your self. 

Yow will discover the listing of MCP servers in this curated repository. Nonetheless, it’s necessary to notice that you must solely use trusted MCP servers to keep away from potential points.

Equally, if you wish to expose your instruments to clients (i.e. permit them to entry your product by way of their LLM brokers), you may merely construct an MCP server. Then clients will have the ability to combine with it from their LLM brokers, AI assistants, desktop apps or IDEs. It’s actually handy.

MCP essentially solves the issue of repetitive work. Think about you’ve gotten M functions and N instruments. With out MCP, you would want to construct M * N integrations to attach all of them.

With MCP and standardisation, you may scale back this quantity to simply M + N. 

On this article, I’ll use MCP to develop a toolkit for analysts. After studying this text, you’ll 

• find out how MCP really works underneath the hood, 
• construct your first MCP server with helpful instruments, 
• leverage the capabilities of your personal MCP server and reference servers in your native AI IDE (like Cursor or Claude Desktop), 
• launch a distant MCP server that might be accessible by the neighborhood.

Within the following article, we’ll take it a step additional and learn to combine MCP servers into your AI brokers. 

That’s rather a lot to cowl, so let’s get began.

MCP structure

I feel it’s price understanding the essential rules earlier than leaping into apply, since that may assist us use the instruments extra successfully. So let’s focus on the basics of this protocol.

Parts
This protocol makes use of a client-server structure: 

• Server is an exterior program that exposes capabilities by way of the MCP protocol.

• Host is the client-facing utility (like Claude Desktop app, AI IDEs corresponding to Cursor or Lovable, or customized LLM brokers). The host is liable for storing MCP shoppers and sustaining connections to servers.

• Consumer is a element of the user-facing app that maintains a one-to-one reference to a single MCP server. They convey by way of messages outlined by the MCP protocol.

MCP permits LLM to entry completely different capabilities: instruments, assets and prompts.

• Instruments are capabilities that LLM can execute, corresponding to getting the present time in a metropolis or changing cash from one forex to a different. 
• Assets are read-only knowledge or context uncovered by the server, corresponding to a data base or a change log. 
• Prompts are pre-defined templates for AI interactions. 

MCP permits you to write servers and instruments in many different languages. On this article, we can be utilizing the Python SDK.

Lifecycle

Now that we all know the primary parts outlined in MCP, let’s see how the complete lifecycle of interplay between the MCP shopper and server works.

Step one is initialisation. The shopper connects to the server, they change protocol variations and capabilities, and, lastly, the shopper confirms through notification that initialisation has been accomplished. 

Then, we transfer to the message change part. 

• The shopper may begin the interplay with discovery. MCP permits dynamic characteristic discovery, when the shopper can ask the server for an inventory of supported instruments with requests like instruments/listing and can get the listing of uncovered instruments in response. This characteristic permits the shopper to adapt when working with completely different MCP servers. 
• Additionally, the shopper can invoke capabilities (name a software or entry a useful resource). On this case, it may possibly get again from the server not solely a response but in addition progress notifications.

Lastly, the shopper initiates the termination of the connection by sending a request to the server.

Transport

If we dive somewhat bit deeper into the MCP structure, it’s additionally price discussing transport. The transport defines how messages are despatched and obtained between the shopper and server.

At its core, MCP makes use of the JSON-RPC protocol. There are two transport choices: 

• stdio (customary enter and output) for instances when shopper and server are operating on the identical machine, 
• HTTP + SSE (Server-Despatched Occasions) or Streamable HTTP for instances when they should talk over a community. The first distinction between these two approaches lies in whether or not the connection is stateful (HTTP + SSE) or can be stateless (Streamable HTTP), which might be essential for sure functions.

When operating our server domestically, we’ll use customary I/O as transport. The shopper will launch the server as a subprocess, and they’re going to use customary enter and output to speak.

With that, we’ve lined all the speculation and are prepared to maneuver on to constructing our first MCP server.

Creating your toolkit as a neighborhood MCP server

I want to construct a server with some customary instruments I exploit incessantly, and likewise leverage all of the MCP capabilities we mentioned above: 

• immediate template to question our ClickHouse database that outlines each the information schema and nuances of SQL syntax (it’s tedious to repeat it each time),
• instruments to question the database and get some details about latest GitHub PRs,
• our changelog as assets.

Yow will discover the complete code in repository, I’ll present solely the primary server code within the snapshot under omitting all of the enterprise logic.

We are going to use the Python SDK for MCP. Creating an MCP server is fairly easy. Let’s begin with a skeleton. We imported the MCP package deal, initialised the server object and ran the server when this system is executed instantly (not imported).

from mcp.server.fastmcp import FastMCP
from mcp_server.prompts import CLICKHOUSE_PROMPT_TEMPLATE
from mcp_server.instruments import execute_query, get_databases, get_table_schema, get_recent_prs, get_pr_details
from mcp_server.assets.change_log import get_available_periods, get_period_changelog
import os

# Create an MCP server
mcp = FastMCP("Analyst Toolkit")

# Run the server
if __name__ == "__main__":
    mcp.run()

Now, we have to add the capabilities. We are going to do that by annotating capabilities. We will even write detailed docstrings and embrace sort annotations to make sure that the LLM has all the required data to make use of them correctly.

@mcp.immediate()
def sql_query_prompt(query: str) -> str:
    """Create a SQL question immediate"""
    return CLICKHOUSE_PROMPT_TEMPLATE.format(query=query)

Subsequent, we’ll outline instruments equally.

# ClickHouse instruments

@mcp.software()
def execute_sql_query(question: str) -> str:
    """
    Execute a SQL question on the ClickHouse database.
    
    Args:
        question: SQL question string to execute towards ClickHouse
        
    Returns:
        Question outcomes as tab-separated textual content if profitable, or error message if question fails
    """
    return execute_query(question)

@mcp.software()
def list_databases() -> str:
    """
    Listing all databases within the ClickHouse server.
    
    Returns:
        Tab-separated textual content containing the listing of databases
    """
    return get_databases()

@mcp.software()
def describe_table(table_name: str) -> str:
    """
    Get the schema of a selected desk within the ClickHouse database.
    
    Args:
        table_name: Identify of the desk to explain
        
    Returns:
        Tab-separated textual content containing the desk schema data
    """
    return get_table_schema(table_name)

# GitHub instruments
@mcp.software()
def get_github_prs(repo_url: str, days: int = 7) -> str:
    """
    Get an inventory of PRs from the final N days.
    
    Args:
        repo_url: GitHub repository URL or proprietor/repo format
        days: Variety of days to look again (default: 7)
        
    Returns:
        JSON string containing listing of PR data, or error message
    """
    import json
    token = os.getenv('GITHUB_TOKEN')
    outcome = get_recent_prs(repo_url, days, token)
    return json.dumps(outcome, indent=2)

@mcp.software()
def get_github_pr_details(repo_url: str, pr_identifier: str) -> str:
    """
    Get detailed details about a selected PR.
    
    Args:
        repo_url: GitHub repository URL or proprietor/repo format
        pr_identifier: Both PR quantity or PR URL
        
    Returns:
        JSON string containing detailed PR data, or error message
    """
    import json
    token = os.getenv('GITHUB_TOKEN')
    outcome = get_pr_details(repo_url, pr_identifier, token)
    return json.dumps(outcome, indent=2)

Now, it’s time so as to add assets. I’ve added two strategies: one to see what changelog durations we’ve accessible, and one other to extract data for a selected interval. Additionally, as you might need seen, we used URIs to entry assets.

@mcp.useful resource("changelog://durations")
def changelog_periods() -> str:
    """
    Listing all accessible change log durations.
    
    Returns:
        Markdown formatted listing of accessible time durations
    """
    return get_available_periods()

@mcp.useful resource("changelog://{interval}")
def changelog_for_period(interval: str) -> str:
    """
    Get change log for a selected time interval.
    
    Args:
        interval: The time interval identifier (e.g., "2025_q1" or "2025 Q2")
        
    Returns:
        Markdown formatted change log for the required interval
    """
    return get_period_changelog(interval)

That’s it for the code. The final step is organising the setting. I’ll use the uv package manager, which is beneficial within the MCP documentation. 

In case you don’t have it put in, you will get it from PyPI.

pip set up uv

Then, we will initialise a uv mission, create and activate the digital setting and, lastly, set up all of the required packages.

uv init --name mcp-analyst-toolkit # initialise an uv mission
uv venv # create digital env 
supply .venv/bin/activate # activate setting
uv add "mcp[cli]" requests pandas typing requests datetime 
# including dependencies
uv pip set up -e . # putting in package deal mcp_server

Now, we will run the MCP server domestically. I’ll use the developer mannequin because it additionally launches MCP Inspector, which is actually helpful for debugging.

mcp dev server.py

# Beginning MCP inspector...
# ⚙️ Proxy server listening on 127.0.0.1:6277
# 🔑 Session token: <...>
# Use this token to authenticate requests or set DANGEROUSLY_OMIT_AUTH=true to disable auth

# 🔗 Open inspector with token pre-filled:
#   http://localhost:6274/?MCP_PROXY_AUTH_TOKEN=<...>

# 🔍 MCP Inspector is up and operating at http://127.0.0.1:6274 🚀

Now, we’ve our server and MCP Inspector operating domestically. Basically, MCP Inspector is a helpful implementation of the MCP shopper designed for debugging. Let’s use the Inspector to check how our server works. The inspector lets us see all of the capabilities the server exposes and name its instruments. I began with characteristic discovery, requesting the server to share the listing of instruments. The shopper despatched the instruments/listing request we mentioned earlier, as you may see within the historical past log on the backside of the display screen. Then, I executed a easy SQL question choose 1 and obtained the software name outcome again.

Nice! Our first MCP server is up and operating domestically. So, it’s time to start out utilizing it in apply.

Utilizing MCP servers in AI instruments 

As we mentioned, the facility of MCP servers lies in standardisation, which permits them to work with completely different AI instruments. I’ll combine my instruments into Claude Desktop. Since Anthropic developed MCP, I anticipate their desktop shopper to have the most effective assist for this protocol. Nonetheless, you need to use different shoppers like Cursor or Windsurf (other example clients).

I would love not solely to utilise my instruments, but in addition to leverage the work of others. There are a lot of MCP servers developed by the neighborhood that we will use as a substitute of reinventing the wheel after we want frequent capabilities. Nonetheless, understand that MCP servers can entry your system, so use solely trusted implementations. I’ll use two reference servers (carried out to exhibit the capabilities of the MCP protocol and official SDKs): 

• Filesystem — permits working with native information, 
• Fetch — helps LLMs retrieve the content material of webpages and convert it from HTML to markdown for higher readability.

Now, let’s transfer on to the setup. You’ll be able to observe the detailed directions on how one can arrange Claude Desktop here. All these instruments have configuration information the place you may specify the MCP servers. For the Claude Desktop, this file can be situated at: 

• macOS: ~/Library/Software Help/Claude/claude_desktop_config.json,
• Home windows: %APPDATApercentClaudeclaude_desktop_config.json.

Let’s replace the config to incorporate three servers: 

• For analyst_toolkit (our MCP server implementation), I’ve specified the uv command, path to the repository and command to run the server. Additionally, I’ve added a GITHUB_TOKEN setting variable to make use of for GitHub authentication.
• For the reference servers, I’ve simply copied the configs from the documentation. Since they’re carried out in several languages (TypeScript and Python), completely different instructions (npx and uvx) are wanted.

{
  "mcpServers": {
    "analyst_toolkit": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/github/mcp-analyst-toolkit/src/mcp_server",
        "run",
        "server.py"
      ],
      "env": {
          "GITHUB_TOKEN": "your_github_token"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/marie/Desktop",
        "/Users/marie/Documents/github"
      ]
    },
    "fetch": {
        "command": "uvx",
        "args": ["mcp-server-fetch"]
      }
  }
}

That’s it. Now, we simply must restart the Claude Desktop shopper, and we can have entry to all instruments and immediate templates.

Let’s strive utilizing the immediate template and ask the LLM to visualise high-level KPIs. 

Query: May you please present the variety of energetic clients and income by month for the reason that starting of 2024? Please, create a visualisation to have a look at dynamics and save the picture in Desktop folder.

We described the duty at a reasonably excessive degree with out offering a lot element concerning the knowledge schema or ClickHouse dialect. Nonetheless, since all this data is captured in our immediate template, the LLM managed to compose an accurate SQL question. 

choose 
    toStartOfMonth(s.action_date) as month,
    uniqExact(s.user_id) as active_customers,
    sum(s.income) as total_revenue
from ecommerce.periods as s 
inside be a part of ecommerce.customers as u on s.user_id = u.user_id
the place s.action_date >= '2024-01-01' 
    and u.is_active = 1
group by toStartOfMonth(s.action_date)
order by month
format TabSeparatedWithNames

Then, the agent used our execute_sql_query software to get outcomes, composed the HTML web page with visualisations, and leveraged the write_file software from the Filesystem MCP server to save lots of the outcomes as an HTML file. 

The ultimate report seems actually good.

One limitation of the present immediate template implementation is that you need to choose it manually. The LLM can’t routinely select to make use of the template even when it’s acceptable for the duty. We’ll attempt to handle this in our AI agent implementation within the upcoming article.

One other use case is making an attempt out GitHub instruments by asking about latest updates within the llama-cookbook repository from the previous month. The agent accomplished this process efficiently and offered us with an in depth abstract. 

So, we’ve discovered how one can work with the native MCP servers. Let’s focus on what to do if we need to share our instruments extra broadly.

Working with a distant MCP server

We are going to use Gradio and HuggingFace Areas for internet hosting a public MCP server. Gradio has a built-in integration with MCP, making server creation actually easy. That is all of the code wanted to construct the UI and launch the MCP server. 

import gradio as gr
from statsmodels.stats.proportion import confint_proportions_2indep

def calculate_ci(count1: int, n1: int, count2: int, n2: int):
    """
    Calculate 95% confidence interval for the distinction of two impartial proportions.
    
    Args:
        count1 (int): Variety of successes in group 1
        n1 (int): Complete pattern dimension in group 1
        count2 (int): Variety of successes in group 2
        n2 (int): Complete pattern dimension in group 2
    
    Returns:
        str: Formatted string containing group proportions, distinction, and 95% confidence interval
    """
    strive:
        p1 = count1 / n1
        p2 = count2 / n2
        diff = p1 - p2
        
        ci_low, ci_high = confint_proportions_2indep(count1, n1, count2, n2)
        
        return f"""Group 1: {p1:.3f} | Group 2: {p2:.3f} | Distinction: {diff:.3f}
95% CI: [{ci_low:.3f}, {ci_high:.3f}]"""
        
    besides Exception as e:
        return f"Error: {str(e)}"

# Easy interface
demo = gr.Interface(
    fn=calculate_ci,
    inputs=[
        gr.Number(label="Group 1 successes", value=85, precision=0),
        gr.Number(label="Group 1 total", value=100, precision=0),
        gr.Number(label="Group 2 successes", value=92, precision=0),
        gr.Number(label="Group 2 total", value=100, precision=0)
    ],
    outputs="textual content",
    title="A/B Take a look at Confidence Interval",
    description="Calculate 95% CI for distinction of two proportions"
)

# Launch the Gradio internet interface
if __name__ == "__main__":
    demo.launch(mcp_server = True)

I’ve created a single operate that calculates the boldness interval for the distinction of two impartial proportions. It is perhaps useful when analysing the A/B check outcomes. 

Subsequent, we will push this code to HuggingFace Areas to get a server operating. I’ve lined how one can do it step-by-step in one of my previous articles. For this instance, I created this Area — https://huggingface.co/spaces/miptgirl/ab_tests. It has a clear UI and exposes MCP instruments. 

Subsequent, we will add the server to our Claude Desktop configuration like this. We’re utilizing mcp-remote as a transport this time since we’re now connecting to a distant server.

{
  "mcpServers": {
    "gradio": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://miptgirl-ab-tests.hf.space/gradio_api/mcp/sse",
        "--transport",
        "sse-only"
      ]
    }
  }
}

Let’s check it with a easy A/B check evaluation query. It really works properly. The LLM can now make considerate judgments primarily based on statistical significance.

You can too use Gradio integration to construct an MCP Consumer — documentation

And that’s it! We now know how one can share our instruments with a wider viewers.

Abstract

On this article, we’ve explored the MCP protocol and its capabilities. Let’s briefly recap the details:

• MCP (Mannequin Context Protocol) is a protocol developed by Antropic that goals to standardise communication between AI brokers and instruments. This strategy reduces the variety of integrations wanted from M * N to M + N. The MCP protocol makes use of a client-server structure.
• MCP servers expose capabilities (corresponding to assets, instruments and immediate templates). You’ll be able to simply construct your personal MCP servers utilizing SDKs or use servers developed by the neighborhood.
• MCP shoppers are a part of user-facing apps (hosts) liable for establishing a one-to-one reference to a server. There are various accessible apps appropriate with MCP, corresponding to Claude Desktop, Cursor or Windsurf.

Thanks for studying. I hope this text was insightful. Keep in mind Einstein’s recommendation: “The necessary factor is to not cease questioning. Curiosity has its personal motive for current.” Might your curiosity lead you to your subsequent nice perception.

Reference

This text is impressed by the “MCP: Build Rich-Context AI Apps with Anthropic” quick course from DeepLearning.AI and the MCP course by Hugging Face.