Apache Camel Microservices, Generated With Your Exact Stack
21 interfaces and 23 backends, on Spring Boot or Quarkus — with unit, integration and black-box tests that run against real backends and pass on the first build.

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.

“Why not just ask my AI tool to build it?”

It can. An assistant will write Camel routes, and it will write unit, integration and black-box tests when you ask for them. The question is what that costs you, and what you are left holding afterwards.

The point is not that AI cannot build a Camel microservice. It is that it should not have to rediscover the same architecture, the same test infrastructure and the same mistakes at your expense, on every project.

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 your AI tool 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.

Every Technology Comes with Full Test Infrastructure

The test infrastructure is written once per technology rather than once per project, and it is verified on the JVM and on native executables. Whichever of the 21 interfaces and 23 backends you select, the containers, seed data, stubs and verifiers for it already exist — so neither you nor your AI tool has to work out how to test Kafka, Cassandra, gRPC or DynamoDB.

• Unit tests — AdviceWith mocks for every backend endpoint, success + error scenarios
• Integration tests — Real containers wherever a real one exists: databases (PostgreSQL, MySQL, MariaDB, Oracle, MSSQL, DB2, Cassandra, MongoDB, DynamoDB), brokers (Kafka, AMQP, JMS, MQTT, RabbitMQ), caches (Redis, Valkey, Infinispan), vector stores (Qdrant, Weaviate, PGVector), FTP and SFTP servers, and LocalStack for AWS services. Everything else is stubbed deterministically: WireMock for REST, SOAP and gRPC backends and for LLM providers, and a purpose-built MCP server double for agent tool-calling
• 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 behind a quality Maven profile, with optional SonarQube analysis when a token is supplied
• CI/CD — GitHub Actions and GitLab CI pipelines pre-configured out of the box: parallel build, unit test, quality gate, integration test and black-box test jobs, plus an opt-in native image job for Quarkus
• 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

Combine any of them. Each one arrives with its routes, mappers, configuration, container and test harness already written.

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