Production-Ready Spring Boot & Quarkus Microservices in Seconds
Powered by Apache Camel. Visually in your browser — or straight from any MCP-capable AI tool.

See CamelBee in Action

A short walkthrough: generate a microservice, then watch messages flow through your Camel routes in real time with the embedded debugger — review what AI-generated code actually does, instead of reading it line by line.

How It Works

Two phases: Generate your starting point, then Evolve it safely with AI as your needs grow.

Phase 1 — Generate Your Microservice

Two ways to generate: the visual Initializer in your browser, or directly from your AI tool via MCP.

1

Configure & Generate

Pick interfaces (REST, Kafka, gRPC, MCP, etc.), backends, and CRUD operations — in the Initializer UI, or by describing what you need to your AI tool (which calls the CamelBee MCP Server). Choose Spring Boot or Quarkus (JVM + native). You get a complete Maven project: Camel routes, MapStruct mappers, 3-level tests, Docker Compose, k6 load tests, and AI-tool context files.

Launch Initializer

2

AI Builds Your Logic

Open the project in Claude Code, Cursor, Codex, OpenCode, or Copilot and just ask: "Replace the Order domain with Payment", "Add credit-limit validation before the payment backend", "Run the tests". The AI follows the 3-layer architecture, Camel DSL patterns, and test patterns shipped with the project — routes, mappers, models, and unit + integration + black-box tests, all consistent with the existing code.

3

Debug Visually

The embedded React UI runs directly inside your microservice. Watch messages flow through your Camel routes in real-time, inspect payloads, and trace transformations — no external tooling needed. Run /cb-run-tests to verify everything passes, then /cb-debug to launch the debugger.

Phase 2 — Evolve with AI

Generate Microservices from Your AI Tool via MCP

Claude Code, Cursor, Codex, OpenCode, or Copilot — any AI tool that supports the Model Context Protocol can call the CamelBee MCP Server directly. Just ask: "Generate a Spring Boot or Quarkus microservice with Apache Camel routing — REST interface, Kafka backend, called orders-api" — you get a complete Maven project (routes, tests, Docker, embedded debugger UI) delivered straight into your workspace.

{
  "mcpServers": {
    "camelbee": {
      "type": "http",
      "url": "https://www.camelbee.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_CAMELBEE_API_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "camelbee": {
      "command": "npx",
      "args": ["mcp-remote", "https://www.camelbee.io/mcp",
               "--header", "Authorization: Bearer YOUR_CAMELBEE_API_KEY"]
    }
  }
}

Plus: Every Generated Project Ships AI-Tuned Context Files

Rules, slash commands, and architecture context tuned to CamelBee — so once the project is open in your AI tool, it doesn't just read your code, it knows how to build on it. Pick which tools via the aiTools setting, or take them all.

Key Features

Every Technology Comes with Full Test Infrastructure

All 19 interfaces and 19 backends ship with pre-built TestContainers configurations, WireMock stubs, Docker Compose services, test data producers, and backend verification utilities — verified on JVM and native executables. AI doesn't need to invent how to test Kafka, Cassandra, gRPC, or DynamoDB — it's all there, proven, and passing.

• Unit tests — AdviceWith mocks for every backend endpoint, success + error scenarios
• Integration tests — TestContainers for databases (PostgreSQL, MySQL, MariaDB, Oracle, MSSQL, DB2, Cassandra, MongoDB, DynamoDB), WireMock for REST/SOAP/gRPC backends, real brokers for Kafka/AMQP/JMS/MQTT/RabbitMQ, LocalStack for AWS services
• Black-box tests — Fully dockerized end-to-end: app + all backends in Docker Compose, tested via HTTP/MCP/gRPC clients with backend data verification
• k6 load tests — Ready-to-run scripts for REST, gRPC, GraphQL, SOAP, WebSocket, and MCP
• Test data producers — Pre-built utilities that create test requests, seed database records, publish queue messages, and set up WireMock stubs for each operation
• Backend verifiers — Utilities that check the backend actually received the correct data (DB queries, queue reads, file checks) — not just "no error", but real data verification
• Flyway migrations — Schema creation and test data seeding per database vendor, per test level
• Code quality — Checkstyle, PMD, and SpotBugs pre-configured
• Docker Compose — Production-grade Dockerfiles and Compose files for app + all backend services

Spring Boot or Quarkus — With Native Executable Support

Choose your framework in the Initializer. Quarkus supports both JVM and native mode — same generated code, two deployment targets.

CamelBee handles native compilation requirements automatically — reflection registration, serialization configs, and native-compatible Camel DSL patterns are all included in the generated code. No extra configuration needed to go native.

Interfaces & Backends

Articles & Real-World Examples

Example projects built from the CamelBee Initializer — full source on GitHub, with walkthrough posts on Medium.

Already Have Camel Microservices?

You don't need to start from scratch! Add CamelBee's core libraries to your existing Apache Camel microservices and instantly unlock the Debugger, Metrics, and Health UI — all as a React embedded UI running directly inside your microservice.

Simply add the dependency and your existing microservices will have the full CamelBee React embedded UI — Debugger, Metrics, and Health UI — for live debugging and monitoring