Quick-Data MCP Server

The Model Context Protocol (MCP) server architecture relies on three primary building blocks to extend AI capabilities. Understanding when to use each is key to building effective agentic workflows:

• Tools: Use these when you want the AI to DO something. Tools are functions that the AI can call to perform atomic actions (e.g., creating a task, writing a file).
• Resources: Use these when you want the AI to READ information. Resources provide data access to the AI, such as user profiles, configuration files, or status updates.
• Prompts: Use these to create Reusable Agentic Workflows (ADWs). Prompts are pre-built conversation templates that provide structured starting points for repeatable, domain-specific workflows (e.g., a structured code review template).

By combining these—using a Prompt to initiate a workflow, Tools to execute actions within that workflow, and Resources to provide context—you can build powerful, scalable agentic systems.

The Quick-Data MCP server is designed as a universal data analysis platform rather than a tool for a specific dataset. Its architecture provides several key benefits:

• True Reusability: The server is dataset agnostic. It works with any structured data (customer data, sales, surveys, inventory, etc.) without hardcoding dataset-specific assumptions.
• Modular Excellence: It uses a data layer abstraction where Pandas operations are applied identically across any structured data. Analysis tools (correlation, segmentation) and visualization tools adapt automatically to the columns and data types provided.
• AI-Guided Discovery: The server enables interactive exploration. The AI can suggest analyses based on actual data characteristics and use context-aware prompts that reference real column names and patterns.
• Scalability: The system is designed to scale from small CSV files (e.g., 100 rows) to larger enterprise datasets (e.g., 100K rows).

The Model Context Protocol (MCP) provides three primary primitives for interacting with LLMs via a server:

1. Tools: Functions that an LLM can actively call to perform actions (e.g., math, fetching weather, or running tasks). Use the @mcp.tool() decorator.
2. Resources: Data that an LLM can read to gain context (e.g., configuration files, user profiles, or database schemas). Use the @mcp.resource(uri) decorator. Resources can use URI templates like users://{user_id}/profile.
3. Prompts: Reusable conversation templates that provide structured instructions or context to the LLM. Use the @mcp.prompt() decorator.

Use FastMCP to manage these primitives easily.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Demo Server")

@mcp.tool()
def add(a: int, b: int) -> int:
    return a + b

@mcp.resource("config://app-settings")
def get_config() -> dict:
    return {"version": "1.0.0"}

@mcp.prompt()
def review_code(code: str) -> str:
    return f"Review this: {code}"

To ensure compatibility with MCP clients that do not support the Resource protocol, the server implements a Dual Access Pattern. This pattern provides two ways to access the same data:

1. Resource-Enabled Clients: Use standard MCP resources via URIs (e.g., @mcp.resource()).
2. Tool-Only Clients: Use a parallel set of tools prefixed with resource_* (e.g., @mcp.tool()).

This ensures that even if a client cannot read dynamic resources like datasets://loaded, it can still call the tool resource_datasets_loaded() to retrieve the exact same information.

Resource-Enabled Clients:           Tool-Only Clients:
├── @mcp.resource()                ├── @mcp.tool() 
├── datasets://loaded              ├── resource_datasets_loaded()
├── analytics://memory_usage        ├── resource_analytics_memory_usage()
└── datasets://{name}/schema       └── resource_datasets_schema(name)

Use the lifespan parameter in FastMCP to manage application startup and shutdown logic. By passing an @asynccontextmanager function, you can initialize resources like database connections or caches before the server starts and ensure they are gracefully closed when the server shuts down.

from contextlib import asynccontextmanager
from typing import AsyncIterator

@asynccontextmanager
async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
    """Manage application lifecycle with startup/shutdown logic."""
    # Startup
    print("Starting MCP server...")
    db_connection = await create_db_connection()
    cache = {}
    
    context = AppContext(db_connection=db_connection, cache=cache)
    
    try:
        yield context
    finally:
        # Cleanup
        print("Shutting down MCP server...")
        await db_connection.close()

mcp = FastMCP("Demo Server", lifespan=app_lifespan)

The generic architecture allows for several advanced extension paths to increase the server's capabilities:

Advanced Analytics Integration

• ML Pipeline: Implement automatic feature engineering and model suggestions based on the loaded data.
• Statistical Testing: Add support for A/B testing, significance testing, and hypothesis validation.
• Forecasting: Implement time series forecasting that triggers when temporal patterns are detected in the data.

Enterprise Features

• Multi-Dataset Workflows: Enable intelligent joining and comparison of multiple datasets.
• Automated Reporting: Generate business reports containing insights and recommendations.
• Real-Time Updates: Support streaming new data to update analyses automatically.

Collaboration Tools

• Insight Sharing: Export findings in business-friendly formats.
• Analysis Templates: Allow users to save and reuse specific analysis workflows across different datasets.
• Team Dashboards: Implement collaborative analytics with role-based access control.