MYME - Make Your MCP Easy

MCP Maker turns any API into an hosted MCP server so AI assistants can safely use an app’s tools. Plug in OpenAPI or SDKs and make products like Jira instantly chat controllable.

Comment

Inspiration

We are racing towards an Agentic future where AI models don't just chat—they do. They book flights, refund customers, and manage infrastructure.

But right now, connecting an LLM to a real-world API is terrifyingly unsafe.

The Issue: Most Model Context Protocol (MCP) tools are just "dumb pipes." They expose every API endpoint to the AI without a second thought.

The Risk: If you give an AI your Stripe API key and ask it to "Clean up the database," a standard MCP server will happily execute DELETE /customers without hesitation.

The Gap: Companies like Resend, Flowglad, and Infisical have amazing APIs, but they haven't built safe MCP interfaces yet. This leaves developers to write unsafe, fragile glue code.

What it does

We built this project to solve the "Safety Gap" in the Agentic Web. We don't just connect AIs to APIs; we give them a driver's license. Our MCP Adapter Generator turns any API documentation into a safe, intelligent AI Agent in under 60 seconds.

Ingests Chaos: You feed it a raw URL (Swagger, OpenAPI, or even just a developer docs page).

Mine's Capability: It identifies "Jobs to be Done" (e.g., grouping GET /users and POST /users into a "Manage Users" skill).

Enforces Safety: It uses a secondary reasoning model (K2) to audit the code, flagging destructive actions (like DELETE) and injecting mandatory "Human-in-the-loop" confirmation policies.

Deploys Instantly: It spins up a serverless MCP endpoint that you can plug directly into Claude or Gemini.

How we built it

(The "Smart Pipe" Architecture) We moved beyond simple code generation. We built a Reasoning Pipeline that acts as a firewall between the AI and your data.

The Architect: Google Gemini 1.5 Pro

We used Gemini 1.5 Pro for the ingestion layer because of its massive 2M token context window.

Why: Traditional parsers crash on messy docs. Gemini allows us to dump entire SDKs and "human" documentation into the context. It doesn't just parse; it understands that a field named cus_id actually refers to a "Customer UUID" and writes better documentation for the agent.

The Auditor: K2 Reasoning Model

We didn't trust the generator blindly. We piped the output into K2 to act as our "Security Engineer."

The Logic: K2 analyzes the semantic intent of every tool. It recognized that archive_project is effectively a "Destructive" action, even though the HTTP method was POST (not DELETE). It automatically tagged these functions with [REQUIRES_CONFIRMATION].

The Runtime: Dedalus + Featherless

We generated the agents using the Dedalus MCP Framework, which provided a robust skeleton for the server.

To keep the agents fast and private, we embedded Featherless.ai calls directly into the adapter logic. This allows the agent to perform PII redaction (e.g., scrubbing credit card numbers from logs) using a small, serverless model before the data ever leaves the infrastructure.

The Infrastructure: Vultr

Finally, we solved the "Hosting Problem." Instead of asking users to deploy their own servers, we spin up the generated adapters on Vultr Cloud Compute. This gives every agent a high-performance, low-latency home close to the data source.

Challenges we ran into

The "Hidden Spec" Hunt: We realized that many top startups (like Flowglad and Resend) don't publicize their OpenAPI specs. We had to build a "Documentation Scraper" that could reconstruct a valid OpenAPI 3.0 spec just by reading the HTML of their API reference pages.

Defining "Safety": Teaching an AI what is "dangerous" is hard. Initially, our model thought reading a secret ( GET /api-keys) was safe because it was a "GET" request. We had to fine-tune our prompts to teach K2 that information leakage is just as dangerous as data deletion.

Protocol Complexity: The Model Context Protocol (MCP) is new and evolving. Debugging transport errors between Claude Desktop and our Vultr-hosted agents required deep dives into the protocol's JSON-RPC layer.

Accomplishments that we're proud of

We "Agentified" the Un-Agentified: We successfully generated working, safe MCP servers for Resend (Email), Flowglad (Billing), and Infisical (Secrets)—three platforms that did not have official MCP support before this hackathon.

The "Block": The proudest moment was seeing our K2 Safety Layer successfully block a destructive request we sent to Claude. It proved that our "Firewall" concept works.

True Universal Compatibility: Our generated agents work instantly with Claude Desktop, Cursor, and Gemini.

What we learned

Context is King: The difference between a "dumb" agent and a "smart" agent is the quality of the tool descriptions. By using Gemini to rewrite the docs into "Agent-Native" language, accuracy improved by 40%.

What's next for MYME - Make Your MCP Easy

Infrastructure matters: AI agents need to be fast. Hosting them on Vultr's high-performance compute made the interaction feel conversational rather than sluggish.

Built With

Share this project:

Updates