Keel Framework / Keel/MCP / Java

Keel Architecture

The Keel Architecture defines the technical structure on which the MCP Servers generated from the archetype are built. It is organized in layers and components, separating the functional capabilities from the cross-cutting technical capabilities provided by Keel.

Overview

The Keel architecture combines a Reference Architecture, reusable functional and cross-cutting capabilities, and build & scaffolding mechanisms to standardize the development of new MCP servers.

The following diagram shows the conceptual view of Keel, its relationship with Spring AI as the framework for implementing MCP and with MCP (Model Context Protocol) as the communication protocol, as well as the role of Maven in the build and scaffolding of projects.

Keel in the Spring AI MCP ecosystem

A Keel-based MCP Server is built on the Java / Spring Boot technology stack, using Spring AI as the framework for implementing the MCP capabilities.

Framework modules

The Keel framework is made up of a set of independent modules, organized by architectural responsibility. Each module encapsulates a specific technical capability and can evolve independently, keeping its contracts and dependencies clearly defined.

The modules are organized mainly in the following areas:

• Common — common technical capabilities and components.
• Adapters — integrations with external services and components.
• Transport — capabilities related to security, session/authentication, the transport protocol and client ↔ MCP Server communication.
• Observability — capabilities related to observability and logging.

This organization keeps a clear separation of responsibilities, reduces coupling between components and makes it easier to evolve, reuse and compose the capabilities provided by Keel.

The framework also relies on third-party dependencies, such as Spring AI, Spring Boot and Caffeine, whose version management and compatibility are centralized through the project's Maven BOM (Bill of Materials).

All modules share the Group ID io.keelframework.mcp and the version defined at project level, ensuring consistent dependency management across the stack.

Maven structure of the framework

The Maven structure of Keel organizes the framework components in independent modules, grouped by architectural responsibility. The project starts from a parent POM / BOM that centralizes the management of dependencies, versions, plugins and common properties, while the modules are grouped in four main areas: Common, Adapters, Transport and Observability.

keel-mcp-java/
│
├── keel-mcp-common/
│   ├── keel-common-jwt/
│   └── keel-common-exceptions/
│
├── keel-mcp-adapters/
│   ├── keel-adapter-auth-idp/
│   ├── keel-adapter-cache-caffeine/
│   └── keel-adapter-rest-client/
│
├── keel-mcp-archetype/
│
├── keel-mcp-archetype-installer/
│
├── keel-mcp-transport/
│   ├── keel-transport-auth/
│   ├── keel-transport-cors/
│   ├── keel-transport-session/
│   └── keel-transport-streamable-mvc/
│
└── keel-mcp-observability/
    └── keel-observability-logging/

Framework requirements

To use Keel, generate new MCP Servers and build the framework modules, the development environment must meet the following requirements and reference versions.

The requirements below correspond to the base technologies on which Keel is built. The framework-specific dependencies, including Spring Boot, Spring AI and their transitive dependencies, are managed and versioned centrally through the project's Maven BOM.

Technology stack

The Keel architecture is built on a modern technology stack based on Java 25, Spring Boot 4 and Spring AI, using MCP (Model Context Protocol) as the communication standard between MCP clients and servers.

Spring AI provides the abstractions needed to implement the MCP capabilities natively through annotations such as @Tool, @Resource and @Prompt, while Keel contributes the architecture, the reusable modules and the cross-cutting capabilities needed to standardize the construction of MCP Servers.

The following table summarizes the main technologies and components that make up the Keel stack: