How to create an MCP Server: Using Refact.ai Agent to build a MinIO Server

Here is how you can create your own open-source MCP server using the open-source Refact.ai Agent. Follow these steps to do it for your personal needs. My fully implemented version is available here.

Building your own AI workflow will always require some resilient and secure place to store:

• Input text data, images, documents, videos, etc.
• Output logs, full prompts, model responses in different formats, generated documents and other objects
• Transient data if you have a chain of AI processes involved and you need to keep it for observability purposes.

MinIO can be your way forward since it is an open-source, cloud and on-premise solution. You can easily deploy it on your machine, server or in the cloud.

Tools used

• Refact.ai — Open-source autonomous AI coding Agent
• MinIO — Open-source object storage compatible with AWS S3.
• Model Context Protocol (MCP) — An open standard and open-source library that enables developers to build secure, two-way connections between their data sources and AI-powered tools.

Goal

Usage of MinIO in AI pipelines often requires developing custom code interfaces and wrappers to properly integrate it with other components of your AI workflow.

Model Context Protocol (MCP) Server simplifies this by enabling AI agents to interact with data storage directly via prompts. With MCP, AI models can access your data storage without requiring complex custom integrations.

The goal was to implement a MinIO MCP server so I can use it for AI Agents implementation, providing a seamless connection between my AI tools and data storage.

Tips for working with AI coding agents

I went ahead with Refact.ai Agent since it can reduce the time not only for implementation, but also testing — you can integrate your new MCP directly in Refact.ai.

If you are new to AI coding agents and worry about quality, here are some tricks. Imagine you are working with a Junior/Middle Software engineer who can code, but needs supervision. Here are the tips you need to understand:

• You can’t delegate large-scale system implementation asking “implement another dog-dating app”. Nobody will understand you, neither AI Agent nor person.
• You must review the code (or delegate it to…another agent?).
• You must test that the result is compliant with functional requirements (or delegate it, you got the point).
• You must test that the result is compliant with non-functional requirements (this is something I’m not sure is yet possible with AI agents).

Having this in mind, as with any other software development task you need to:

• Split your ultimate goal into smaller parts.
• Provide requirements and expectations for each task.

Creating an MCP Server: Steps and results

Refact.ai created an MCP server in 3 attempts, meaning one attempt is a single chat request to describe what I need.

Attempt 1. One-shot. Failed.

In this attempt I described to use official MCP documentation, but it was too vague:

Attempt 2. Few-shots. Failed.

This was a little closer. I provided more references, but didn’t provide enough expectations. The code was created and probably working, but a brief review showed that it wasn’t implemented in the way I needed:

Attempt 3. Few-shots + constraints + clear expectations. Success.

This attempt produced working code with minimal changes needed:

My goal is to generate a model-context protocol (MCP) for minio.
Generate me all needed files for minio-mcp.

The key difference was providing specific file paths from the reference repository and clear, numbered steps for the AI to follow.

Code review, integration into the MCP client, and testing still took some time, but the implementation time was reduced by 90%. Code was generated within minutes, and it was functional.

Testing and results

I used 4 MCP clients to test that the MinIO MCP server was working:

• Refact.ai which provides capabilities to integrate any MCP server into your agent
• Claude Desktop as a main generic AI tool with native integration of MCP
• Python Client with Anthropic chatbot
• Stdio client that was implemented using Refact.ai Agent.

I will skip the MCP client configuration details. These are well described in:

• https://modelcontextprotocol.io/quickstart/user
• https://docs.refact.ai/features/autonomous-agent/integrations/mcp

Visual Proof: Working implementations

Claude Desktop with configured MCP server

Refact.ai with working MinIO MCP server:

Lessons learned and conclusion

• Coding with an AI Agent saves significant time, but you need to understand what you want and set clear expectations. Being specific with file paths, references, and exact requirements produces the best results.
• MCP Server is difficult to debug — it’s worth creating a separate guide for troubleshooting, but be prepared for minimal logs to understand root causes when issues arise.
• MCP integration offers tremendous potential — I definitely recommend trying it as the capabilities are extensive. You can create chains of MCP servers and control your agents’ work through prompts with minimal code.
• Open Source is powerful, but leveraging open-source AI agents to build new open-source projects takes collaboration to an entirely new level.

Next steps

If you’re interested in implementing your own MinIO MCP server:

• Set up Refact.ai and MinIO following the links in the ‘Tools used’ section
• Use the successful prompt from Attempt 3 as your starting point
• Review and test the generated code carefully
• Configure your preferred MCP client to interface with your new server

The combination of open-source storage and AI tools opens up powerful possibilities for creating secure, flexible AI workflows with complete data sovereignty.

Author: Nikita Makarov