Your Personal Analytics Toolbox | Towards Data Science

pretty much as good because the context offered to them. Even essentially the most superior mannequin gained’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 seen that I maintain repeating the identical duties time and again: writing comparable prompts or creating the identical instruments repeatedly. There’s a elementary 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. Fortuitously, the GenAI trade already has an answer in place. MCP (Mannequin Context Protocol) is an open-source protocol that permits the connection of AI functions to exterior instruments and knowledge sources. Its most important aim is to standardise such interactions, much 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. 

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

Equally, if you wish to expose your instruments to clients (i.e. enable them to entry your product via 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 basically solves the issue of repetitive work. Think about you have got 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 cut back this quantity to only M + N. 

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

• learn the way MCP truly works below 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 discover ways to combine MCP servers into your AI brokers. 

That’s quite a bit to cowl, so let’s get began.

MCP structure

I believe it’s value understanding the essential rules 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.

Parts
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 resembling Cursor or Lovable, or customized LLM brokers). The host is accountable 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 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, resembling getting the present time in a metropolis or changing cash from one foreign money to a different. 
• Assets are read-only knowledge or context uncovered by the server, resembling a data base or a change log. 
• Prompts are pre-defined templates for AI interactions. 

MCP means that you can write servers and instruments in many different languages. On this article, we shall 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 through notification that initialisation has been accomplished. 

Then, we transfer to the message alternate section. 

• 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/listing and can get the listing 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 instrument or entry a useful resource). On this case, it could possibly get again from the server not solely a response but in addition progress notifications.

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

Transport

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

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

• stdio (normal 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 may also be stateless (Streamable HTTP), which may be essential for sure functions.

When operating our server regionally, we’ll use normal I/O as transport. The consumer will launch the server as a subprocess, and they’ll use normal enter and output to speak.

With that, we’ve lined all the idea 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 normal instruments I exploit ceaselessly, 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 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 immediately (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 will even write detailed docstrings and embody kind 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.instrument()
def execute_sql_query(question: str) -> str:
    """
    Execute a SQL question on the ClickHouse database.
    
    Args:
        question: SQL question string to execute in opposition to ClickHouse
        
    Returns:
        Question outcomes as tab-separated textual content if profitable, or error message if question fails
    """
    return execute_query(question)

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

@mcp.instrument()
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 info
    """
    return get_table_schema(table_name)

# GitHub instruments
@mcp.instrument()
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 listing of PR info, or error message
    """
    import json
    token = os.getenv('GITHUB_TOKEN')
    consequence = get_recent_prs(repo_url, days, token)
    return json.dumps(consequence, indent=2)

@mcp.instrument()
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 info, or error message
    """
    import json
    token = os.getenv('GITHUB_TOKEN')
    consequence = get_pr_details(repo_url, pr_identifier, token)
    return json.dumps(consequence, indent=2)

Now, it’s time so as to add sources. I’ve added two strategies: one to see what changelog intervals we now have out there, and one other to extract info for a selected interval. Additionally, as you might need seen, we used URIs to entry sources.

@mcp.useful resource("changelog://intervals")
def changelog_periods() -> str:
    """
    Record all out there change log intervals.
    
    Returns:
        Markdown formatted listing of accessible time intervals
    """
    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 desired 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 really useful within the MCP documentation. 

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

pip set up uv

Then, we are able to initialise a uv undertaking, create and activate the digital setting 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 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 are able to run the MCP server regionally. 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 now have our server and MCP Inspector operating regionally. Primarily, MCP Inspector is a useful 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 listing of instruments. The consumer 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 bought the instrument name consequence 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 ability 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 very best assist for this protocol. Nonetheless, you need to use different shoppers like Cursor or Windsurf (other example clients).

I would really like 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 are able to use as a substitute of reinventing the wheel once we want frequent features. Nonetheless, remember the fact that MCP servers can entry your system, so use solely trusted implementations. I’ll use two reference servers (carried out to display 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 shall be situated 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 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 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: May you please present the variety of lively clients and income by month because the 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 in regards to 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 
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 instrument to get outcomes, composed the HTML web page with visualisations, and leveraged the write_file instrument 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 you must 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 realized how one can work with the native MCP servers. Let’s talk about what to do if we wish 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): Whole pattern measurement in group 1
        count2 (int): Variety of successes in group 2
        n2 (int): Whole pattern measurement 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 internet interface
if __name__ == "__main__":
    demo.launch(mcp_server = True)

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

Subsequent, we are able to 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 House — https://huggingface.co/spaces/miptgirl/ab_tests. It has a clear UI and exposes MCP instruments. 

Subsequent, we are able to 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 based mostly 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 method 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 (resembling sources, 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) accountable for establishing a one-to-one reference to a server. There are numerous out there apps appropriate with MCP, resembling 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 cause for current.” Could 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.