A few months ago, we started experimenting with a new idea through a project called Micepe. The idea was simple but powerful: What if existing APIs could instantly become MCP tools usable by AI agents without writing glue code?

Collect feedback and validate our ideas​

We launched a private beta program with a handful of enterprises, and the response was beyond what we expected.

The teams involved consistently told us the same thing:

This solves a real problem for AI-native architectures.

The feedback we received​

The discussions with platform teams and developers, and the concrete use cases we saw convinced us of one thing:

• This should not remain a proprietary experiment.

It deserves to become an open project that the community can shape and build together.

Micepe is evolving into → reShapr​

So today, we are taking the next step, reShapr is a new open source project created by the co-founders and maintainers of Microcks, the CNCF open source project used by organizations such as BNP Paribas, J.B. Hunt, Amadeus, Michelin, GSMA and many more to improve API and cloud native application development.

With reShapr, our goal is to help organizations:

• Turn existing APIs into AI-native tools instantly
• Expose services as MCP servers for AI agents
• Accelerate the adoption of AI + cloud native architectures

The success of our private beta and the amazing feedback from the enterprises involved reinforced our conviction that the project should grow within an open ecosystem.

We intend to donate the project to the AAIF open source foundation, so it can evolve with community open governance, transparency, and long-term sustainability.

This is just the beginning of the journey.​

If you followed Micepe, the story continues with reShapr. And if you are interested in AI-native APIs, MCP tools, and developer platforms for AI agents, we would love to have you involved in the project, the open source way.

reShapr is now live and open for the community.

Join the AI-Agent Revolution. We are building the future of developer platforms for AI agents, the open source way.

Whether it’s a GitHub ⭐️, a bug report, or a pull request, we’d love to have you involved.

Here’s how you can get involved:​

🚀 Check it out: Try reShapr online

🤝 Join the project: On Discord. Help us shape the future of AI-native APIs on GitHub

📱 Follow us: Stay connected on LinkedIn, Bluesky, X and YouTube for the latest updates.

How reShapr Makes the Model Context Protocol Production-Ready?​

When Anthropic introduced the Model Context Protocol (MCP), it provided developers with something they had been missing: a common language for connecting Large Language Model (LLM) and AI agents to existing systems and services.

But as the MCP ecosystem exploded, so did the context windows!

Anthropic’s own engineers recently wrote in “Code execution with MCP: Building more efficient agents” that agents now juggle hundreds or thousands of tools, and that every tool definition and intermediate result consumes tokens, slowing agents, inflating costs, and sometimes even breaking workflows.

At reShapr, we took that exact problem, token consumption and context-window explosion as the starting point of our product design. Before Anthropic formalized the MCP “code-execution” pattern, we asked a more straightforward question:

What if the protocol wasn’t the issue? What if the problem was how we expose APIs to it?

We built reShapr on “tokens first” thinking​

Anthropic’s post illustrates two pain points:

1. Loading all MCP tool definitions upfront floods the model’s context.
2. Intermediate results, even megabytes of JSON or text, must pass back through the model.

Both are symptoms of what we call context coupling: treating the model’s memory as a data bus instead of an intent space. When we designed the reShapr’s No-Code MCP Server, we flipped that pattern. Instead of dumping every API operation and description into the model, reShapr acts as a programmable filter between your existing API services and the MCP interface.

That design allows you to:

• Selectively translate only the operations you need into MCP tools.
• Restrict which tools are visible to which clients, agents, or LLM personas.
• Partition your exposure by business domain, use case, or security zone.

In other words, while the Anthropic team optimized the client-side execution loop, reShapr optimized the server-side surface area.

We shrink the tool universe before the model ever sees it.

One backend, many MCP faces​

Here’s where reShapr becomes powerful. From a single backend API service, your CRM, payment gateway, or internal microservice, you can create multiple MCP servers, each with:

• Its own name, tool set, and access policy.
• Its own domain focus (e.g., “finance”, “support”, “analytics”).
• Optional context filtering rules for sensitive data or operations.

Need to give a marketing AI access to campaign metrics but not customer PII? Spin up an mcp-marketing server exposing only /metrics and /reports.

Need a developer agent to deploy builds? Create mcp-devops with deploy, rollback, and status tools.

Same backend, different MCP surface, but zero code.

This domain specialization not only mirrors real business boundaries; it also keeps the model’s working set lean. Why make Claude, ChatGPT, or any other LLM “see” thousands of endpoints if it only needs a few to do what is expected?

Filtering at both ends​

Docker’s recent post, “The Model Context Protocol: Simplifying Building AI apps with Anthropic Claude Desktop and Docker”, praised Anthropic’s idea of filtering tool exposure for efficiency and safety. We couldn’t agree more, and we’ve implemented that concept from day one.

Where Docker focuses on local developer control and discovery, a marketplace or container registry of MCP servers, reShapr operates as an AI integration layer in all environments (dev, QA, prod).

Our filters exist not just for discovery, but for policy enforcement.

Think of it as defense in depth for context:

• reShapr filters which APIs become MCP tools.
• It also filters which tools each client or agent may call.
• It even filters which API operations flow, preventing oversharing.

While Docker helps you run MCP servers locally, reShapr enables you to govern them globally by enabling existing API services for the AI Era. The two approaches are complementary, not competing, layers of the same emerging ecosystem.

The context window isn’t infinite, and that’s okay!​

Anthropic’s own metrics show that replacing direct tool calls with “code execution” reduced token usage by 98.7 % in their benchmark scenario. That’s impressive, but it’s also proof of the underlying issue: agents today overconsume context because they’re given too much surface to reason about.

At reShapr, we believe, that context discipline beats context expansion. Instead of asking “how can the model handle more?”, we ask “how can we give it less, but more meaningful input?”

Our filtering architecture, domain-specific MCP servers, and selective exposure make it possible to:

• Keep token budgets predictable.
• Maintain shorter prompt-response cycles.
• Scale agent ecosystems horizontally without blowing up latency or cost.

You can call it context-aware architecture or, simply, good software engineering.

Bringing legacy APIs into the AI era​

One of the most exciting side effects of reShapr’s design is how easily it modernizes existing APIs.

Take Stripe’s REST API as an example. Its OpenAPI spec is comprehensive and enormous. Exposing it directly to an LLM would create a vast array of endpoints, parameters, and schemas, none of which are optimized for conversational use.

With reShapr, you can wrap Stripe’s API once and expose tailored MCP views:

• mcp-payments exposing only create charge, refund, and list customers.
• mcp-finops exposing reconcile payoutsand generate statement.
• mcp-analytics exposing top-10 customerswith simplified schemas.

Each of these servers can live side-by-side, derived from the same Stripe backend, yet independently optimized for distinct AI personas or business functions.

That’s what we mean when we say “AI-native by translation, not reinvention.”

No-Code setup, enterprise-grade results​

reShapr’s configuration model is intentionally simple:

1. Connect to your existing Rest API, GraphQL, or gRPC service.
2. Use our interface to select the operations you want to expose.
3. Add optional field-level filters, renames, or descriptions.
4. Publish, and you instantly have a fully compliant MCP server or workflow of MCP servers.

Behind the scenes, reShapr automatically:

• Generates the MCP schema and metadata.
• Handles auth propagation and error mapping.
• Enforces your security and throttling policies.
• Provides live observability dashboards for every tool call.

What Anthropic’s engineers call “progressive disclosure”, which allows models to discover only the tools they need, occurs naturally in reShapr through configuration, rather than custom code.

Scaling AI with less friction, not more code​

Anthropic’s “code execution” pattern is brilliant for power users and developer-friendly agents that can write their own scripts.

But in enterprise environments, most teams don’t want every agent writing arbitrary code in a sandbox.

They want predictability, governance, and measurable efficiency.

reShapr delivers that by externalizing code execution into controlled MCP endpoints rather than letting each agent spin its custom code.

You receive all the benefits, including reduced token usage, efficient data handling, and composable workflows, without the operational risk associated with distributed sandboxes.

And when you do want to give agents controlled compute, reShapr integrates seamlessly with your existing infrastructure: Kubernetes jobs, serverless functions, or dedicated compute pools all behind the same No-Code MCP Server powered by reShapr.

Complementing, not competing, with the ecosystem​

Let’s be clear: the work from Anthropic, Docker, and MCP / API Gateway vendors is moving the entire industry forward. Each focuses on a different layer:

We stand on their shoulders and build the bridge between prototype and production. reShapr is what makes the MCP ecosystem deployable at scale.

Toward a governed, efficient AI integration fabric​

As MCP adoption accelerates, organizations face the same maturity curve APIs did a decade ago:

1. Experimentation — local prototypes and SDKs.
2. Expansion — hundreds of endpoints and tools.
3. Governance — access control, observability, cost management.
4. Optimization — token efficiency, domain specialization, and security.

reShapr sits squarely at stages 2, 3 and 4. We help teams operationalize MCP servers safely, efficiently, and at scale, without requiring them to rewrite their systems or manually code integrations.

In summary: Control the context, don’t expand it​

Anthropic’s Code Execution with MCP article is an important milestone. It demonstrates how agents can be more intelligent about tool usage by converting direct calls into code. reShapr builds on that same insight, but applies it to the entire lifecycle of MCP deployment.

• We anticipated the token and context explosion problem.
• We engineered a system that filters, segments, and secures MCP exposure.
• We deliver remote-first, production-ready servers, not non-realistic experiments.
• We complement Anthropic and others, including Docker, API, and MCP Gateway vendors, by bringing enterprise rigor to the protocol.

In AI integrations, as in good software design, less context is often more powerful.

Ultimately, the goal isn’t to make LLMs see more; it’s to make them see better.

1. 🛠️ Convert Internal APIs into MCPs — AI Enablement in Minutes​

Challenge: Developers want internal APIs to be AI‑accessible without rewriting backends.

How reShapr helps:

• With reShapr, you can instantly expose existing REST, gRPC, or GraphQL APIs as Model Context Protocol (MCP) endpoints, requiring no code.
• That means teams can prototype AI assistants or agents in minutes, rather than waiting for a backend redesign to occur.
• Built on a No‑Code MCP Server with broad protocol compatibility, reShapr supports OpenAPI and gRPC out of the box.

2. 🧪 Build Fast, Safe AI POCs — MVPs Using Live Data​

Challenge: How can you safely build an AI proof‑of‑concept using production data?

Solution with reShapr:

• Enables developers to connect AI prototypes directly to live APIs while enforcing policies and safeguards.
• Data access remains secure and auditable, reducing risk and accelerating feedback loops.
• Ideal for organizations testing use cases early before scaling to production.

3. 🔁 Sync API and MCP Lifecycles — Prevent Contract Drift​

Challenge: API changes cause agent behavior to break.

reShapr’s approach:

• Integrates into CI/CD pipelines to automatically regenerate MCP schemas when APIs evolve.
• Enforces version checks and alignment, minimizing manual maintenance and eliminating drift between endpoints and AI agents.

4. 🌍 Multi‑Protocol Support — REST, gRPC, GraphQL? All Covered​

Challenge: Modern stacks often span multiple API protocols.

reShapr’s capability:

• Natively supports REST, gRPC, and GraphQL, turning any service into MCP tools for LLM consumption.
• No extra translation layers or adapters required, ensuring performance and consistency across services.

5. 🧱 Secure Cloud, Hybrid, or On‑Prem​

Challenge: Sensitive systems must remain inside secure perimeters.

reShapr’s flexibility:

• Supports fully on‑premises deployments or hybrid models where compute can reside in your private cloud.
• Keeps data and logic inside firewalls while still enabling AI connectivity, making it a suitable fit for regulated sectors and enterprises.

6. 📡 Gate External AI Agents — Safely Expose APIs Without Re‑architecting​

Challenge: Expose internal services to AI agents without rebuilding everything.

reShapr’s solution:

• Acts as a controlled MCP Server, enabling selective exposure of internal APIs.
• Provides runtime controls, logging, and schema enforcement, so backends remain untouched but safely accessible.

🔍 Real World Example: Open Meteo REST → MCP with reShapr​

reShapr has been demonstrated to instantly translate the Open-Meteo REST weather API into an MCP endpoint without requiring any code. This highlights how quickly external data sources can become AI‑ready tools using reShapr’s solution.

First, authenticate with the reShapr online try:

❯ reshapr login -s https://try.reshapr.io
ℹ️  Opening browser: https://try.reshapr.io/cli/login?redirect_uri=http://localhost:5556
ℹ️  Listening for authentication callback on http://localhost:5556
✅ Login successful!
ℹ️  Welcome, yada!
ℹ️  Organization: yada
✅ Configuration saved to /Users/yacine/.reshapr/config

Then, import and expose the API as an MCP server using in a single command:

❯ reshapr import -u https://raw.githubusercontent.com/open-meteo/open-meteo/refs/heads/main/openapi.yml --backendEndpoint https://api.open-meteo.com
✅ Import successful!
ℹ️  Discovered Service Open-Meteo APIs with ID: 0PXEW1ZDWFCZS
✅ Exposition done!
✅ Exposition is now active!
Exposition ID  : 0PXEW2272H0PB
Organization   : yada
Created on     : 2026-03-28T19:06:26.743899
Service ID     : 0PXEW1ZDWFCZS
Service Name   : Open-Meteo APIs
Service Version: 1.0
Service Type   : REST -> https://api.open-meteo.com
Endpoints      : mcp.try.reshapr.io/mcp/yada/Open-Meteo+APIs/1.0

That's it. Your MCP server is live at https://mcp.try.reshapr.io/mcp/yada/Open-Meteo+APIs/1.0, use https for reShapr Try, or http depending on your deployment. Connect it to any MCP client, LLM conversational agent, or agentic workflow as a remote HTTP Streamable MCP server and enjoy 😎

More demos available on our YouTube channel 🙌

✅ Why reShapr Matters​

Whether you’re embedding AI assistants, building RAG workflows, or enabling LLM-driven agents, reShapr lets you move forward quickly without compromising control:

• Instant MCP Server for internal or external APIs, securely exposed.
• Safe AI experimentation on real data for faster iteration.
• Seamless version control and lifecycle sync.
• Protocol-agnostic support with no vendor lock-in.
• Flexible deployment to match enterprise security policies.

🎯 Business Benefits Summarized​

Speed​

• Prototype AI integrations in minutes using production APIs with no backend overhaul

Security & Compliance​

• Enforce governance, logging, and access controls even in sensitive environments

Flexibility​

• Works across REST/GraphQL/gRPC, deploys Cloud, hybrid, or on-prem

Cost Efficiency​

• Avoid rewriting backend services, minimize development overhead

🔗 Looking Ahead​

Integration into a modern AI ecosystem is as straightforward as flipping a switch, and your existing APIs become first-class AI-ready tools.

reShapr empowers businesses to accelerate AI use cases, reduce integration friction, and deliver secure production-ready experiences while effectively leveraging existing infrastructure.

To explore reShapr’s vision and strategic context, see "Why reShapr" for deeper insight into the MCP framework and its architecture.

Why Enterprises Shouldn’t Build MCP Servers from Scratch, and What to Do Instead​

The AI-native era is here. Whether you’re integrating copilots into internal workflows, building LLM-powered agents for customer service, or exposing organizational knowledge to a retrieval-augmented generation (RAG) stack, the foundation is the same: (your) APIs.

But there’s a major roadblock that nearly every enterprise hits.

The Problem: (Your) Services Weren’t Designed for LLMs​

Enterprises are under growing pressure to make internal and business services accessible to Large Language Models (LLMs). But those services were not built for generative agents that parse documentation, generate prompts, or request human-like reasoning.

Suddenly, platform teams are being asked:

• “How can we let our AI assistant fetch data from our CRM, ERP, or ticketing systems?”
• “Can we integrate our knowledge base into our chatbot by giving it access to our API?”
• “Is it safe to let external copilots interact with internal endpoints?”

The typical answer is to build a Model Context Protocol (MCP) server, a new service and development interface layer that AI models can use.

That’s where the real trouble begins.

Why Building Your Own MCP Server Is a Trap​

A Model Context Protocol (MCP) server acts as the bridge between Large Language Models (LLMs) and your services. At first glance, building one may seem straightforward. But very quickly, most teams realize:

• It’s more than OpenAPI: You need translation layers, prompt guards, retries, rate limiting, and grounding logic.
• Security gets messy fast: How do you avoid exposing credentials in LLM prompts? How do you enforce identity, scope, and input validation?
• Fragility creeps in: Most DIY solutions end up as brittle pipelines of JSON transforms, hardcoded logic, and embedded hacks that fall apart under load or worse, leak data.

This approach often duplicates your API logic into a parallel, standalone MCP layer, creating unnecessary complexity, increased maintenance overhead, and misalignment between your API and its AI-facing interface.

A smarter approach is to extend your existing API infrastructure rather than reinventing it.

Introducing reShapr: Your Zero-Code AI Translation Layer​

reShapr exists to solve this exact problem. Rather than building an MCP server from scratch, you can use reShapr to instantly translate your existing APIs (REST, gRPC, GraphQL) into AI-native endpoints.

• Zero code
• No rewrites
• No custom Agents
• No vendor lock-in

Think of it as a plug-and-play interface between your infrastructure and the AI-native world.

Time-to-Market Matters: How reShapr Accelerates AI Deployment​

Let’s compare two paths to AI-native readiness​

With reShapr, your team can:

• Deploy an AI-native interface in minutes, not weeks/months.
• Avoid rewriting APIs or duplicating business logic.
• Launch pilots quickly and iterate without platform bottlenecks.
• Get to proof of value before your competitors even clear their architecture review.

Speed isn’t just convenience; it’s a competitive advantage.

Secure by Design: Leverage What You Already Trust​

When it comes to security, we don’t believe in reinventing the wheel. reShapr’s philosophy is simple: build on top of the infrastructure, controls, and credentials you already trust.

Here’s how:​

• Reuse Existing Policies: Identity, rate limiting, scopes, and audit logging are inherited from your infrastructure (API gateway). There is no need to rebuild backend authentication or create shadow permission systems.
• OAuth2 support: Optionally leverage the latest MCP protocol enhancements to enable secure additional authentication at the reShapr layer.
• Multi-Protocol Support: Whether your backend speaks REST, gRPC, or GraphQL, reShapr understands it, without flattening security models or introducing fragile transforms.
• Leverage trusted infrastructure: reShapr translates your existing API operations into MCP tools, making all your current security layers and validations automatically apply to LLM-generated requests transparently and without modification. You simply reuse the same production-hardened controls you already trust.

Security isn’t an afterthought; it’s a prerequisite for exposing APIs to any AI agent. reShapr gives you the controls without the complexity.
👉 Read "Security options & Secrets"

Developer Experience That Doesn’t Fight You​

We know what it’s like to be asked to ship an AI feature “by the end of the quarter.” That’s why reShapr was built with a developer-first mindset:

• One command to deploy: Configure your MCP interface with a simple Rest API, CLI or UI.
• Declarative Config: Specify how each API should be exposed, if at all and define which operations are permitted or excluded.
• Infrastructure Agnostic: Works with any cloud, on-premise deployment, or hybrid environment.
• Portable and Auditable: No hidden agents. No black boxes. You stay in control.

It’s not magic; it’s just good engineering, abstracted for real-world use.

Built by People Who’ve Been There​

The reShapr team has designed API gateways, built security systems, and operated large-scale cloud infrastructure. We’ve seen the fragile SDK generators, the spaghetti YAML, and the LLM prompt hell, and we knew there had to be a better way.

So we built one!

Why This Matters Now​

Enterprises are racing to make their data and systems usable with AI-native tools. But each delay in integration leads to lost market share, stalled innovation, and missed opportunities.

The organizations that win will not be the ones that spend months writing custom LLM plugins. They will be the ones that expose their APIs safely, scalably, and instantly.

reShapr makes that possible with zero code and full control.

TL;DR: Why Choose reShapr 🤔​

• ✅ Fastest path to AI-native APIs, from concept to production in a day.
• ✅ No rewrites, works with your existing REST, gRPC, or GraphQL APIs.
• ✅ Security-first, leverages your existing infrastructure and shields against prompt ingestion risks.
• ✅ Highly portable, no vendor lock-in: deploy anywhere.
• ✅ Enterprise-ready, built for scale, extensibility, and real-world complexity.

Ready to Try reShapr?​

If you’re exploring how to safely expose your APIs to LLMs, whether for internal copilots, customer-facing agents, or RAG backends, reShapr is the fastest and most secure way to do it.

1. Use the Try it Online option to explore the platform. Follow our detailed "Try reShapr online".
2. Or Run the platform locally using containers, check out the “Run using Docker Compose”.

Make your APIs usable by AI without rewriting a single line of code.