MinIO Model-Context Protocol (MCP) Server

by ucesys
MIT License
  • Apple

Integrations

  • Provides access to MinIO object storage through standardized tools for listing buckets, listing objects, retrieving objects, and uploading files to MinIO buckets.

MinIO Model-Context Protocol (MCP)

This project implements a Model-Context Protocol (MCP) server and client for MinIO object storage. It provides a standardized way to interact with MinIO.

Features

Server

Resources

Exposes MinIO data through Resources. The server can access and provide:

  • Text files (automatically detected based on file extension)
  • Binary files (handled as application/octet-stream)
  • Bucket contents (up to 1000 objects per bucket)
Tools
  • ListBuckets
    • Returns a list of all buckets owned by the authenticated sender of the request
    • Optional parameters: start_after (pagination), max_buckets (limit results)
  • ListObjects
    • Returns some or all (up to 1,000) of the objects in a bucket with each request
    • Required parameter: bucket_name
    • Optional parameters: prefix (filter by prefix), max_keys (limit results)
  • GetObject
    • Retrieves an object from MinIO
    • Required parameters: bucket_name, object_name
  • PutObject
    • Uploads a file to MinIO bucket using fput method
    • Required parameters: bucket_name, object_name, file_path

Client

The project includes multiple client implementations:

  1. Basic Client - Simple client for direct interaction with the MinIO MCP server
  2. Anthropic Client - Integration with Anthropic's Claude models for AI-powered interactions with MinIO

Installation

  1. Clone the repository:
git clone https://github.com/yourusername/minio-mcp.git cd minio-mcp
  1. Install dependencies using pip:
pip install -r requirements.txt

Or using uv:

uv pip install -r requirements.txt

Environment Configuration

Create a .env file in the root directory with the following configuration:

# MinIO Configuration MINIO_ENDPOINT=play.min.io MINIO_ACCESS_KEY=your_access_key MINIO_SECRET_KEY=your_secret_key MINIO_SECURE=true MINIO_MAX_BUCKETS=5 # Server Configuration SERVER_HOST=0.0.0.0 SERVER_PORT=8000 # For Anthropic Client (if using) ANTHROPIC_API_KEY=your_anthropic_api_key

Usage

Running the Server

The server can be run directly:

python src/minio_mcp_server/server.py

Using the Basic Client

from src.client import main import asyncio asyncio.run(main())

Using the Anthropic Client

  1. Configure the servers in src/client/servers_config.json:
{ "mcpServers": { "minio_service": { "command": "python", "args": ["path/to/minio_mcp_server/server.py"] } } }
  1. Run the client:
python src/client/mcp_anthropic_client.py
  1. Interact with the assistant:
    • The assistant will automatically detect available tools
    • You can ask questions about your MinIO data
    • The assistant will use the appropriate tools to retrieve information
  2. Exit the session:
    • Type quit or exit to end the session

Integration with Claude Desktop

You can integrate this MCP server with Claude Desktop:

Configuration

On MacOS: ~/Library/Application\ Support/Claude/claude_desktop_config.json
On Windows: %APPDATA%/Claude/claude_desktop_config.json

{ "mcpServers": { "minio-mcp": { "command": "python", "args": [ "path/to/minio-mcp/src/minio_mcp_server/server.py" ] } } }

Development

Project Structure

minio-mcp/ ├── src/ │ ├── client/ # Client implementations │ │ ├── mcp_anthropic_client.py # Anthropic integration │ │ └── servers_config.json # Server configuration │ ├── minio_mcp_server/ # MCP server implementation │ │ ├── resources/ # Resource implementations │ │ │ └── minio_resource.py # MinIO resource │ │ └── server.py # Main server implementation │ ├── __init__.py │ └── client.py # Basic client implementation ├── LICENSE ├── pyproject.toml ├── README.md └── requirements.txt

Running Tests

pytest

Code Formatting

black src/ isort src/ flake8 src/

Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging experience, we recommend using the MCP Inspector:

npx @modelcontextprotocol/inspector python path/to/minio-mcp/src/minio_mcp_server/server.py

Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.

License

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

-
security - not tested
A
license - permissive license
-
quality - not tested

Provides a standardized way to interact with MinIO object storage, allowing access to text files, binary files, and bucket contents while supporting operations like listing buckets/objects, retrieving objects, and uploading files.

  1. Features
    1. Server
    2. Client
  2. Installation
    1. Environment Configuration
      1. Usage
        1. Running the Server
        2. Using the Basic Client
        3. Using the Anthropic Client
      2. Integration with Claude Desktop
        1. Configuration
      3. Development
        1. Project Structure
        2. Running Tests
        3. Code Formatting
      4. Debugging
        1. License

          Related MCP Servers

          • A
            security
            A
            license
            A
            quality
            This server facilitates interaction with Keboola's Storage API, enabling users to browse and manage project buckets, tables, and components efficiently through Claude Desktop.
            Last updated -
            7
            13
            Python
            MIT License
            • Apple
          • -
            security
            F
            license
            -
            quality
            This server provides an interface for performing basic file system operations such as navigation, reading, writing, and file analysis, allowing users to manage directories and files efficiently.
            Last updated -
            3
            Python
          • A
            security
            F
            license
            A
            quality
            Enables AI models to perform file system operations (reading, creating, and listing files) on a local file system through a standardized Model Context Protocol interface.
            Last updated -
            3
            JavaScript
          • -
            security
            -
            license
            -
            quality
            A Model Context Protocol server that enables large language models to upload files directly to Alibaba Cloud Object Storage Service (OSS), supporting multiple OSS configurations and specified upload directories.
            Last updated -
            1
            TypeScript

          View all related MCP servers

          ID: q82dn5hswd