Skip to main content
Glama
maocatooo

Flask-MCP-Plus

by maocatooo

Flask-MCP-Plus

Flask integration for Model Context Protocol (MCP) - a framework for building MCP servers with Flask.

License: apache-2-0 Python Version Flask

Overview

Flask-MCP-Plus provides a simple and intuitive way to create Model Context Protocol (MCP) servers using Flask. It allows developers to easily expose tools, resources, and prompts that can be consumed by MCP clients, facilitating rich interactions between language models and external systems.

Related MCP server: Awesome MCP FastAPI

Features

  • Easy Integration: Seamless integration with Flask applications

  • Type Safety: Built-in support for type hints and Pydantic validation

  • Tool Support: Define MCP tools with automatic schema generation

  • Resource Management: Handle static and dynamic resources with URI templates

  • Prompt Generation: Create dynamic prompts for AI models

  • JSON Schema Generation: Automatic generation of JSON schemas from Python functions

  • Streaming Support: Streamable HTTP responses for large data

Installation

pip install flask-mcp-plus

Quick Start

Here's a basic example to get you started:

from flask import Flask
from flask_mcp_plus import MCP

app = Flask(__name__)
mcp = MCP()
mcp.init_app(app, "my_mcp_server", __name__)


# Define a simple tool
@mcp.tool
def add(a: int, b: int) -> int:
    """Add two numbers together."""
    return a + b


# Define a resource
@mcp.resource("http://example.com/data.json")
def get_data():
    """Return some static data."""
    return {"message": "Hello, MCP!"}


# Define a prompt
@mcp.prompt
def greeting(name: str) -> str:
    """Create a personalized greeting."""
    return f"Hello, {name}!"


if __name__ == "__main__":
    app.run(debug=True)

Use in Client

To use your Flask-MCP-Plus server with an MCP client, you need to configure the client to connect to your server's endpoint.
The configuration format varies depending on the specific MCP client you're using, but generally follows this structure:

{
  "mcpServers": {
    "my_mcp_server": {
      "autoApprove": [],
      "disabled": false,
      "timeout": 60,
      "type": "streamableHttp",
      "url": "http://127.0.0.1:5000/mcp"
    }
  }
}

Core Concepts

Tools

Tools are functions that can be called by MCP clients. They can accept parameters and return structured results.

from flask_mcp_plus import Text, Field
from typing import Annotated


@mcp.tool(
    name="calculate_sum",
    title="Calculate Sum",
    description="Add two floating point numbers",
    icons=[
        {
            "src": "https://example.com/calculator-icon.png",
            "mimeType": "image/png",
            "sizes": ["48x48"]
        }
    ]
)
def add_float(a: Annotated[float, Field(description="The first number")],
              b: Annotated[float, Field(description="The second number")]) -> Text:
    return Text(text=str(a + b))

Resources

Resources provide data that can be fetched by URI. Flask-MCP-Plus supports both static URIs and dynamic URI templates with parameters.

@mcp.resource("file://data/config.json")
def get_config():
    """Return static configuration data."""
    return {"setting1": "value1", "setting2": "value2"}


# Dynamic resource with path parameters
@mcp.resource("file://data/users/{user_id}.json")
def get_user(user_id: str):
    """Return user data by ID."""
    return {"id": user_id, "name": f"User {user_id}"}

Prompts

Prompts are specialized functions that return structured content to guide AI models.

from flask_mcp_plus import Message, Text


@mcp.prompt
def daily_fact() -> Message:
    """Return a daily fact as a message."""
    return Message(
        content=Text(text="The capital of France is Paris.")
    )

Advanced Usage

Custom Output Schema

For tools that return structured data, you can specify a custom JSON schema:

@mcp.tool(
    output_schema={
        "type": "object",
        "properties": {
            "result": {"type": "string"},
            "success": {"type": "boolean"}
        },
        "required": ["result", "success"]
    }
)
def api_call():
    return {
        "result": "Operation completed successfully",
        "success": True
    }

Multiple Content Types

Tools can return multiple content types in a single response:

from flask_mcp_plus import Image, Text


@mcp.tool
def multi_data():
    return [
        Image(data=base64_image_data),
        Text(text="Here's an image and some text")
    ]

Running the Examples

The repository includes comprehensive examples in the src/example/ directory:

  • tools.py - Examples of various tool definitions

  • resources.py - Examples of resource handling

  • prompt.py - Examples of prompt creation

To run an example:

cd src/example
python tools.py

Configuration

The MCP server can be configured with various options:

mcp = MCP()
mcp.init_app(
    app,
    name="my-awesome-server",
    import_name=__name__,
    url_prefix="/mcp",  # Endpoint prefix for MCP routes
    version="1.0.0"
)

Development

Prerequisites

  • Python 3.9+

  • Flask 3+

  • Pydantic 2+

Setup

# Clone the repository
https://github.com/maocatooo/flask-mcp-plus
cd flask-mcp-plus

# Install dependencies
uv sync

License

This project is licensed under the Apache 2.0 License - see the LICENSE file for details.

Support

If you encounter any issues or have questions, please file an issue on the GitHub repository.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

No tool schema history has been recorded yet.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • F
    license
    C
    quality
    D
    maintenance
    This is an MCP server that facilitates building tools for interacting with various APIs and workflows, supporting Python-based development with potential for customizable prompts and user configurations.
    1
    -
  • A
    license
    Not graded
    quality
    D
    maintenance
    Flask-based Model Context Protocol (MCP) server for Python. Drop it into any Flask app or run it standalone.
    8
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Easiest framework for building MCP servers with automatic discovery of tools, prompts, and resources, plus enterprise-grade authentication and telemetry.
    839
    Apache 2.0

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/maocatooo/flask-mcp-plus'

If you have feedback or need assistance with the MCP directory API, please join our Discord server