MinIO 모델-컨텍스트 프로토콜(MCP) 서버

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:

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

Installation

Clone the repository:

git clone https://github.com/yourusername/minio-mcp.git
cd minio-mcp

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

Configure the servers in src/client/servers_config.json:

{
  "mcpServers": {
    "minio_service": {
      "command": "python",
      "args": ["path/to/minio_mcp_server/server.py"]
    }
  }
}

Run the client:

python src/client/mcp_anthropic_client.py

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
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.

This server cannot be installed

security - not tested

license - permissive license

quality - not tested

How are these scores calculated?

remote-capable server

The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.

MinIO 개체 저장소와 상호 작용하는 표준화된 방법을 제공하여 텍스트 파일, 바이너리 파일 및 버킷 콘텐츠에 액세스할 수 있도록 하며, 버킷/개체 나열, 개체 검색, 파일 업로드와 같은 작업을 지원합니다.

Related MCP Servers

MCP File System Server
kvas-it
-
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 -
4
MCP File Server
codyde
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
Storacha MCP Storage Serverofficial
storacha
-
security
A
license
-
quality
Enables AI applications to interact with decentralized storage through a standardized Model Context Protocol interface, allowing file uploads, retrievals, and identity management.
Last updated -
12
Apache 2.0
Qiniu Cloud Storage MCP Server
joeseesun
-
security
F
license
-
quality
A server that enables uploading files to Qiniu Cloud Storage through a standardized MCP interface, providing a simple way to store and serve files with public URLs.
Last updated -
27

View all related MCP servers

MinIO Model-Context Protocol (MCP) Server