Your Personal Analytics Toolbox | Towards Data Science

pretty much as good because the context supplied to them. Even essentially the most superior mannequin received’t be very useful if it doesn’t have entry to the info or instruments it must get extra info. That’s why instruments and sources are essential for any AI agent.

I’ve observed that I maintain repeating the identical duties time and again: writing related prompts or growing 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 method 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 permits the connection of AI purposes to exterior instruments and knowledge sources. Its primary purpose is to standardise such interactions, just like how REST APIs standardised communication between net purposes and backend servers.

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

You will discover the checklist of MCP servers in this curated repository. Nevertheless, it’s essential to notice that it is best to solely use trusted MCP servers to keep away from potential points.

Equally, if you wish to expose your instruments to prospects (i.e. enable them to entry your product via their LLM brokers), you’ll be able to merely construct an MCP server. Then prospects will be capable of 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 will have M purposes and N instruments. With out MCP, you would wish to construct M * N integrations to attach all of them.

With MCP and standardisation, you’ll be able to 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 truly works underneath the hood, 
• construct your first MCP server with helpful instruments, 
• leverage the capabilities of your individual 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 group.

Within the following article, we’ll take it a step additional and discover ways 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 fundamental ideas earlier than leaping into apply, since that may assist us use the instruments extra successfully. So let’s talk about the basics of this protocol.

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

• Server is an exterior program that exposes capabilities via the MCP protocol.

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

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

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

• Instruments are features that LLM can execute, similar 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, similar 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 principle elements outlined in MCP, let’s see how the total lifecycle of interplay between the MCP consumer and server works.

Step one is initialisation. The consumer connects to the server, they alternate protocol variations and capabilities, and, lastly, the consumer confirms by way of notification that initialisation has been accomplished. 

Then, we transfer to the message alternate part. 

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

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

Transport

If we dive a bit of bit deeper into the MCP structure, it’s additionally price discussing transport. The transport defines how messages are despatched and acquired between the consumer and server.

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

• stdio (commonplace enter and output) for instances when consumer 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 will also be stateless (Streamable HTTP), which will be essential for sure purposes.

When operating our server regionally, we’ll use commonplace I/O as transport. The consumer will launch the server as a subprocess, and they’ll use commonplace 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 an area MCP server

I want to construct a server with some commonplace instruments I take advantage of regularly, and likewise leverage all of the MCP capabilities we mentioned above: 

• immediate template to question our ClickHouse database that outlines each the info 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 sources.

You will discover the total code in repository, I’ll present solely the principle 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 simple. Let’s begin with a skeleton. We imported the MCP bundle, initialised the server object and ran the server when this system is executed straight (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.sources.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 features. We may even write detailed docstrings and embody sort annotations to make sure that the LLM has all the required info 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.device()
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.device()
def list_databases() -> str:
    """
    Record all databases within the ClickHouse server.
    
    Returns:
        Tab-separated textual content containing the checklist of databases
    """
    return get_databases()

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

# GitHub instruments
@mcp.device()
def get_github_prs(repo_url: str, days: int = 7) -> str:
    """
    Get a listing 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 checklist of PR info, or error message
    """
    import json
    token = os.getenv('GITHUB_TOKEN')
    end result = get_recent_prs(repo_url, days, token)
    return json.dumps(end result, indent=2)

@mcp.device()
def get_github_pr_details(repo_url: str, pr_identifier: str) -> str:
    """
    Get detailed details about a particular 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 info, or error message
    """
    import json
    token = os.getenv('GITHUB_TOKEN')
    end result = get_pr_details(repo_url, pr_identifier, token)
    return json.dumps(end result, indent=2)

Now, it’s time so as to add sources. I’ve added two strategies: one to see what changelog intervals we’ve got accessible, and one other to extract info for a particular interval. Additionally, as you may need observed, we used URIs to entry sources.

@mcp.useful resource("changelog://intervals")
def changelog_periods() -> str:
    """
    Record all accessible change log intervals.
    
    Returns:
        Markdown formatted checklist of obtainable time intervals
    """
    return get_available_periods()

@mcp.useful resource("changelog://{interval}")
def changelog_for_period(interval: str) -> str:
    """
    Get change log for a particular 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 establishing the surroundings. I’ll use the uv package manager, which is really helpful within the MCP documentation. 

For those who don’t have it put in, you will get it from PyPI.

pip set up uv

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

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

Now, we will run the MCP server regionally. I’ll use the developer mannequin because it additionally launches MCP Inspector, which is basically 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 got our server and MCP Inspector operating regionally. Primarily, MCP Inspector is a helpful implementation of the MCP consumer 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 checklist of instruments. The consumer despatched the instruments/checklist request we mentioned earlier, as you’ll be able to 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 device name end result again.

Nice! Our first MCP server is up and operating regionally. So, it’s time to begin 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 consumer to have the most effective assist for this protocol. Nevertheless, you should use different shoppers like Cursor or Windsurf (other example clients).

I would love not solely to utilise my instruments, but additionally to leverage the work of others. There are a lot of MCP servers developed by the group that we will use as a substitute of reinventing the wheel once we want frequent features. Nevertheless, remember the fact that MCP servers can entry your system, so use solely trusted implementations. I’ll use two reference servers (applied to show 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 comply with the detailed directions on the way to arrange Claude Desktop here. All these instruments have configuration information the place you’ll be able to specify the MCP servers. For the Claude Desktop, this file can be positioned at: 

• macOS: ~/Library/Utility Assist/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 surroundings variable to make use of for GitHub authentication.
• For the reference servers, I’ve simply copied the configs from the documentation. Since they’re applied 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 consumer, and we could 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: Might you please present the variety of energetic prospects 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 info 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 
interior be 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 device to get outcomes, composed the HTML web page with visualisations, and leveraged the write_file device from the Filesystem MCP server to avoid wasting the outcomes as an HTML file. 

The ultimate report seems to be actually good.

One limitation of the present immediate template implementation is that it’s a must 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 deal with this in our AI agent implementation within the upcoming article.

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

So, we’ve realized the way to work with the native MCP servers. Let’s talk about 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 Check Confidence Interval",
    description="Calculate 95% CI for distinction of two proportions"
)

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

I’ve created a single perform that calculates the arrogance interval for the distinction of two impartial proportions. It is likely to be 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 the way to do it step-by-step in one of my previous articles. For this instance, I created this House — 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 effectively. The LLM can now make considerate judgments primarily based on statistical significance.

You can even use Gradio integration to construct an MCP Shopper — documentation

And that’s it! We now know the way to 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 (similar to sources, instruments and immediate templates). You’ll be able to simply construct your individual MCP servers utilizing SDKs or use servers developed by the group.
• MCP shoppers are a part of user-facing apps (hosts) liable for establishing a one-to-one reference to a server. There are numerous accessible apps appropriate with MCP, similar to Claude Desktop, Cursor or Windsurf.

Thanks for studying. I hope this text was insightful. Bear in mind Einstein’s recommendation: “The essential factor is to not cease questioning. Curiosity has its personal cause for present.” 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” brief course from DeepLearning.AI and the MCP course by Hugging Face.