Should MCP Replace REST for AI-Ready Applications?

An architectural experiment with the Galaxium Travels Infrastructure example

1. Introduction

When building applications that use AI agents, the Model Context Protocol (MCP) is becoming more important because it exposes backend functions as structured tools. REST APIs often return a lot of data, and this can make it harder for AI agents to find the right information, while normal applications usually take only the exact data they need.

MCP was designed primarily so that AI models and agents can call external capabilities in a standardized way.

But during an experiment with my Galaxium Travels example environment, a different architectural question appeared:

If MCP already exposes structured callable tools, could it also serve as the backend interface for applications?

In other words:

Do we still need a separate REST API when MCP already provides a service interface?

This article describes a small architecture experiment exploring this idea.

Table of contents

1. Introduction
2. The Problem: Two Backend Interfaces
3. The Experiment
4. Architecture Overview
5. Architecture Comparison
6. Hands-on: Run the Example in 10 Minutes
7. Potential Advantages
8. Potential Downsides
9. When MCP-First Architectures May Make Sense
10. When REST Still Makes Sense
11. Summary
12. References

2. The Problem: Two Backend Interfaces

Many modern AI-enabled systems end up maintaining two backend interfaces.

This often leads to several issues:

• duplicated backend logic
• additional maintenance overhead
• inconsistent interfaces
• increased operational complexity

The same functionality might be implemented twice:

• once as a REST endpoint
• once as an MCP tool

3. The Experiment

In the Galaxium Travels example repository, I explored a different approach.

Repository:

https://github.com/thomassuedbroecker/galaxium-travels-infrastructure-tsuedbro

Instead of exposing both REST and MCP interfaces, the example exposes only MCP tools. The web frontend calls MCP tools directly, without an AI agent involved.

This means the architecture looks like this:

+----------------------+
|   Web Application    |
|  (Frontend / UI)    |
+----------+-----------+
           |
           | MCP Tool Calls
           v
+----------------------+
|      MCP Server      |
|  (Tool Interface)    |
+----------+-----------+
           |
           | Internal Service Calls
           v
+----------------------+
|    Backend Logic     |
| (Business Services)  |
+----------+-----------+
           |
           | Data Access
           v
+----------------------+
|       Database       |
|  (Persistence Layer) |
+----------------------+

Layer Explanation

Flow

1. The Web Application invokes an MCP tool.
2. The MCP Server receives the request.
3. The MCP tool executes backend business logic.
4. The backend logic interacts with the database.
5. The response flows back through the MCP server to the frontend.

4. Architecture Overview

The example environment contains several components working together in a container-based setup:

• MCP server infrastructure
• container-based deployment
• OAuth authentication
• Keycloak identity provider
• simple web frontend
• travel booking example scenario

For simplicity, the database currently runs inside the container environment.

In a production architecture the database would likely be externalized, while the MCP server remains the service layer.

5. Architecture Comparison

To better understand the idea, it helps to compare three architectural approaches.

The third option is what the Galaxium Travels experiment demonstrates.

Applications and AI agents could use the same backend interface.

6. Hands-on: Run the Example in 10 Minutes

Follow the QuickStart in the repository to run one of the available setup options. You can explore the example environment locally.

Repository:

https://github.com/thomassuedbroecker/galaxium-travels-infrastructure-tsuedbro

Clone the repository and start:

git clone https://github.com/thomassuedbroecker/galaxium-travels-infrastructure-tsuedbro
cd galaxium-travels-infrastructure-tsuedbro

7. Potential Advantages

Using MCP as the primary backend interface could provide several benefits:

a. Single service interface

Backend functionality is implemented once.

b. AI-ready architecture

Agents can use the same tools as applications.

c. Reduced duplication

No need to maintain REST endpoints and MCP tools separately.

d. Security integration

Authentication can be centralized.
In the example, OAuth with Keycloak is used.

8. Potential Downsides

However, there are also limitations to consider.

a. REST ecosystem maturity

REST has decades of tooling, documentation standards, and infrastructure.

b. Frontend expectations

Most frontend frameworks expect REST or GraphQL APIs.

c. API management

Existing API gateways and monitoring solutions are heavily REST-oriented.

d. Developer familiarity

Many development teams are deeply experienced with REST-based architectures.

9. When MCP-First Architectures May Make Sense

Using MCP as the primary interface may be useful for:

• AI-native applications
• internal developer platforms
• tool-based service architectures
• systems designed to integrate agents later

10. When REST Still Makes Sense

REST remains a strong choice for:

• public APIs
• large frontend ecosystems
• third-party integrations
• legacy architectures

11. Summary

MCP will likely not replace REST everywhere.

However, for AI-enabled systems, MCP could evolve into a Applications and AI agents can use the same backend interface.

The Galaxium Travels example simply explores this idea in a small experimental environment.

12. References

1. Model Context Protocol documentation
   https://modelcontextprotocol.io
2. Anthropic introduction of MCP
   https://www.anthropic.com/news/model-context-protocol
3. Roy Fielding – REST architecture
   Fielding, R. (2000). Architectural Styles and the Design of Network-based Software Architectures
4. Galaxium Travels example repository
   https://github.com/thomassuedbroecker/galaxium-travels-infrastructure-tsuedbro

I hope this was useful to you and let’s see what’s next?

Greetings,

Thomas

Note: This post reflects my own ideas and experience; AI was used only as a writing and thinking aid to help structure and clarify the arguments, not to define them.

#AI, #MCP, #ModelContextProtocol, #RESTAPI, #SoftwareArchitecture, #AIArchitecture, #AIAgents, #GenerativeAI, #DeveloperTools, #OpenSource, #Keycloak, #OAuth, #Containerized, #CloudNative, #GalaxiumTravels