Today, AI systems often face a silent limitation: access. While models have become smarter, faster, and more capable, their ability to interact with real-world data and systems remains constrained by fragmented, bespoke integrations. Anthropic’s Model Context Protocol (MCP) introduces a bold new vision: a universal standard for connecting AI models to the world’s data and tools—seamlessly, securely, and at scale. In this blog, we’ll explore MCP at both a conceptual and technical level, examine its relevance to analytics and semantic layers, and share a practical code example for building an MCP server.

What is MCP?

Imagine a world where AI assistants can seamlessly connect to any data source or tool you use, without needing custom integrations for each one. MCP aims to make this a reality by providing a universal, open standard for connecting AI systems with the vast amounts of data and capabilities that exist across different platforms. Think of it like a "USB for AI integrations", where a common interface allows various AI applications to plug into a multitude of tools and data sources. This eliminates the time-consuming and error-prone process of building custom code for each data connection.

Inside MCP: A Detailed Explanation

MCP operates on a client-server architecture:

  • Hosts: These are the AI applications that you interact with, such as the Claude Desktop app, an IDE with AI assistance (like Cursor), or a custom AI agent. Hosts contain MCP clients.
  • Clients: These reside within the Host application and manage the connection to specific MCP servers. Each client typically connects to one MCP server.
  • Servers: These are external programs that expose Tools, Resources, and Prompts via a standard API to the AI model through the client. They act as bridges between the MCP world and the underlying systems.

Key Components of MCP Servers

  1. Tools (Model-controlled): These are functions that the LLM can call to perform specific actions, similar to function calling in other AI models. Examples include fetching weather data from an API or querying a database.
  2. Resources (Application-controlled): These are data sources that the LLM can access, akin to GET endpoints in a REST API. Resources provide data without significant computation or side effects. They serve as context for the AI.
  3. Prompts (User-controlled): These are pre-defined templates designed to optimally use tools or resources. Users can select from available prompts to guide the AI's interaction. However, the sources suggest that uptake of prompts and resources has been less significant so far, with tools being the primary focus.

How MCP Works (Simplified Flow)

  1. When a Host application starts, it initializes MCP Clients.
  2. Clients discover the capabilities (Tools, Resources, Prompts) offered by the connected MCP Servers.
  3. Based on the user's request, the LLM within the Host decides if it needs to use a Tool.
  4. The Host directs the Client to send an invocation request to the appropriate Server.
  5. The Server executes the requested action (e.g., calls an external API) and retrieves the result.
  6. The Server sends the result back to the Client.
  7. The Client relays the result to the Host, which incorporates it into the LLM's context to generate a final response.

Communication between Clients and Servers

MCP servers can be built in various languages. Communication primarily occurs through:

  • stdio (Standard Input/Output): Used when the Client and Server run on the same machine, suitable for local integrations.
  • HTTP via SSE (Server-Sent Events) / Streamable HTTP: For remote connections, the Client connects to the Server via HTTP, and the Server can push messages to the Client over a persistent connection. The protocol is evolving to use a more flexible Streamable HTTP transport.
  • JSON-RPC 2.0: MCP uses JSON-RPC as the underlying message format for communication.

Security and Trust

Given the potential for data access and code execution, MCP emphasizes user consent and control. Users must explicitly authorize data access and tool usage. The protocol also recommends robust consent flows, clear documentation of security implications, and appropriate access controls. Authentication for remote HTTP servers is mandated using OAuth 2.1.

Short Code Example: Setting up an MCP Server for an API Tool (Python)

This example demonstrates a simple MCP server using the fastmcp library (mentioned in the sources) to interact with a hypothetical weather API.

from mcp.server.fastmcp import FastMCP
import requests
import json


# Create an MCP server named "WeatherService"
mcp = FastMCP("WeatherService")


@mcp.tool()
def get_weather(city: str) -> str:
    """
    Retrieves the current weather for a given city using the weatherapi.com API.
    """
    api_key = "YOUR_WEATHERAPI_COM_API_KEY"  # Replace with your actual API key
    url = f"http://api.weatherapi.com/v1/current.json?key={api_key}&q={city}"
    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise an exception for bad status codes
        weather_data = response.json()
        temperature = weather_data["current"]["temp_c"]
        condition = weather_data["current"]["condition"]["text"]
        return f"The current weather in {city} is {temperature}°C with {condition}."
    except requests.exceptions.RequestException as e:
        return f"Error fetching weather data: {e}"


if __name__ == "__main__":
    mcp.run()

Explanation

  1. We import the necessary libraries, including FastMCP.
  2. We create an MCP server instance named "WeatherService".
  3. We define a tool called get_weather using the @mcp.tool() decorator.
  4. The tool function takes a city as input and makes a request to a hypothetical weather API.
  5. The function processes the API response and returns a formatted string with the weather information.

To use this tool with a Claude Desktop app configured for MCP, you would need to:

  1. Save this code as a Python file (e.g., weather_server.py).
  2. Update the Claude Desktop app's configuration file (claude_desktop_config.json) to include this server, specifying its name and the command to run it (e.g., python weather_server.py).
  3. Restart the Claude Desktop app.
  4. Now, when you ask Claude a question like "What's the weather in London?", it could potentially invoke this get_weather tool (after you grant permission) to fetch and provide the information.

Relevance of MCP to the Field of Analytics

MCP holds significant relevance for the field of analytics by:

  • Simplifying Data Access: Traditionally, connecting AI models to various analytical data sources (databases, data warehouses, SaaS platforms) required building custom connectors for each. MCP standardizes this process, allowing AI-powered analytics tools and agents to seamlessly access diverse datasets through a unified protocol.
  • Enhancing Performance and Efficiency: By streamlining data access, MCP can lead faster and more accurate responses from AI-driven analytics applicationsto . Direct connections to data sources, facilitated by MCP servers, can reduce latency compared to indirect methods.
  • Facilitating Agentic AI in Analytics: MCP supports the development of AI agents capable of performing complex analytical tasks autonomously on behalf of users. By maintaining context across different analytical tools and datasets, MCP enables these agents to execute multi-step workflows, such as querying data, performing calculations, and generating reports.
  • Broadening Applicability: Unlike solutions limited to specific applications, MCP is designed to work across all AI systems and data sources relevant to analytics. This universality makes it a versatile tool for various analytical use cases, from automated data exploration to AI-powered business intelligence.
  • Lowering Development Costs and Complexity: By providing a standardized framework for tool use and data access, MCP can reduce the development effort and complexity associated with building AI-powered analytics solutions. Developers can focus on the analytical logic rather than the intricacies of data integration.

The Power of MCP and a Universal Semantic Layer

A semantic layer, like Cube (or the general concept of a semantic layer), provides a business-friendly abstraction of underlying data. It defines metrics, dimensions, and relationships in terms that business users understand, shielding them from the complexity of the physical data model.

MCP and a semantic layer can work together synergistically to enhance AI-driven analytics:

  1. Semantic Layer as Information Source for MCP Tools: An MCP server could be built on top of a semantic layer. The tools exposed by this server could leverage the semantic layer's definitions to construct intelligent queries and access data in a business-aware manner. For example, an AI agent could ask, "What was the total revenue for the last quarter in the marketing channel 'Email'?", and the MCP tool, informed by the semantic layer, would know how to translate this business query into the appropriate data retrieval operations on the underlying data sources.
  2. MCP for Accessing Data Underlying the Semantic Layer: Conversely, AI agents using MCP could directly access the data sources that the semantic layer sits on top of. While the semantic layer provides a curated and consistent view, there might be scenarios where a more direct or granular access is needed for advanced analytical tasks. MCP could provide the standardized means to achieve this, with appropriate authorization and understanding of the underlying data structures.
  3. Orchestrating Analytical Workflows: An AI agent using MCP could interact with both a semantic layer (via an MCP server exposing its capabilities) and the underlying data sources (via other MCP servers). It could use the semantic layer to understand the available data and perform high-level analysis, and then use direct data access via MCP for more detailed investigations or specific data manipulations.
  4. Consistent Data Definitions: By using a semantic layer in conjunction with MCP, organizations can ensure that AI-powered analytics tools and agents are working with consistent and well-defined business metrics and dimensions, reducing the risk of misinterpretations and errors.
  5. Leveraging Semantic Layer APIs for Data Retrieval: MCP tools could be designed to interact directly with the Semantic Layer's APIs to request data, rather than generating code to query the underlying data sources. This approach relies on the deterministic compilation capabilities of the Semantic Layer, which translates business terms into database queries. This method reduces errors by utilizing the Semantic Layer's built-in error handling, query rewrite capabilities and increases transparency as the requests are made using known and defined business terms.

In essence, the semantic layer provides the "what" and "how" of business data, while MCP provides the standardized "access" mechanism for AI agents to interact with that data (either directly or through the abstraction of the semantic layer) and perform analytical tasks. This combination can lead to more powerful, efficient, and user-friendly AI-driven analytics solutions.

MCP’s Role in the Future of AI and Analytics

While still in early stages, MCP offers a compelling path toward a more interoperable, dynamic AI ecosystem. By abstracting the complexity of integrations, it allows AI models to focus on what they do best:reasoning, decision-making, and creating value.

For enterprises looking to supercharge AI-driven analytics, combining MCP with semantic layers may prove to be the ultimate force multiplier. As the ecosystem matures with more MCP servers, clients, and standards, expect MCP to become not just a tool for connecting AI to the world, but a foundational element in the architecture of the AI-native enterprise. Contact sales to learn more about how MCP and Cube can work together to deliver trusted agentic analytics.