Camel Catalog

Each release includes a catalog with all sorts of information about what’s included in the release.

About Camel Catalog

The catalog is shipped in an independent standalone camel-catalog JAR containing the following information:

  • List of all components, data formats, languages, EIPs, and everything else in the release

  • Curated lists for Camel Quarkus, Camel Spring Boot, and Camel Main runtimes

  • JSON schema with extensive details for every option

  • Human-readable documentation for every option

  • AsciiDoc documentation pages for components, EIPs, data formats, languages, and more

  • Categorization of options (for example, find all database components)

  • XML schema for the XML DSLs

There is also a Java API for tooling:

  • validating Camel endpoints and the Simple language

  • creating Camel endpoint URLs

The catalog provides a wealth of information that tooling can tap into and use.

Tooling using Camel Catalog

The following tools uses the catalog in their editor:

The Camel Maven validation plugin uses the catalog during validation of all the Camel endpoints found while scanning the source code.

The Camel CLI uses the catalog in some of the commands and actions.

Layout of camel-catalog

JAR includes the information using the following directory layout:

org
└── apache
  └── camel
    └── catalog
      ├── beans (JSON schema)
      ├── components (JSON schema)
      ├── dataformats (JSON schema)
      ├── dev-consoles (JSON schema)
      ├── dev-consoles-openapi.json (OpenAPI 3.0 specification)
      ├── docs (AsciiDoc documentation)
      ├── jbang (JSON schema)
      ├── languages (JSON schema)
      ├── main (JSON schema)
      ├── models (JSON schema)
      ├── models-app (JSON schema)
      ├── others (JSON schema)
      ├── releases (JSON schema)
      ├── schemas (XML and JSON schemas)
      ├── test-infra (JSON schema)
      └── transformers (JSON schema)

Each directory contains files with the information. Every Camel component is included as JSON schema files in the components directory. For example, the Timer component is included in the file timer.json.

The dev-consoles directory contains JSON schema files describing every Dev Console's query options and, since Camel 4.23, an authoritative response schema generated directly from the console’s typed Java Response record. The top-level dev-consoles-openapi.json file aggregates all of this into a single OpenAPI 3.0 specification covering every dev console endpoint, so the same contract used internally to serve the live api dev console is also available standalone for tooling. A dev-consoles.properties index file lists all available dev console names.

The docs directory contains the AsciiDoc documentation pages for all components, EIPs, data formats, languages, and other artifacts. A docs.properties index file lists all available documentation names.

The schemas directory contains the XML schemas for the XML DSLs (camel-spring.xsd, camel-xml-io.xsd) and the YAML DSL model (camelYamlDsl-model.json). The YAML DSL model is a generated data structure describing every valid key at every nesting level in the YAML DSL, with types, descriptions, required flags, default values, and enum choices. It can be used by third-party tooling (editors, IDE plugins, visual designers) to provide context-aware code completion and validation for YAML DSL routes.

Documentation in the Catalog

The catalog includes the AsciiDoc documentation pages from all modules. This makes the full documentation available to tooling such as AI agents (via MCP tools), the Camel CLI/TUI, and IDE plugins — for every Camel version, including SNAPSHOT and non-LTS releases.

The documentation filenames follow the naming convention used in each module’s src/main/docs/ directory:

  • Components: <name>-component.adoc (e.g., kafka-component.adoc)

  • Data formats: <name>-dataformat.adoc (e.g., jackson2-dataformat.adoc)

  • Languages: <name>-language.adoc (e.g., simple-language.adoc)

  • EIPs: <name>-eip.adoc (e.g., split-eip.adoc)

  • Others: <name>.adoc (e.g., yaml-dsl.adoc)

The Java API provides the following methods for accessing documentation:

CamelCatalog catalog = new DefaultCamelCatalog();

// list all available documentation names
List<String> docNames = catalog.findDocNames();

// load documentation by exact name (without .adoc extension)
String doc = catalog.asciiDoc("kafka-component");

// convenience methods that append the type suffix automatically
String componentDoc = catalog.componentAsciiDoc("kafka");        // loads kafka-component.adoc
String dataFormatDoc = catalog.dataFormatAsciiDoc("jackson2");   // loads jackson2-dataformat.adoc
String languageDoc = catalog.languageAsciiDoc("simple");         // loads simple-language.adoc
String modelDoc = catalog.modelAsciiDoc("split-eip");            // loads split-eip.adoc
String otherDoc = catalog.otherAsciiDoc("yaml-dsl");             // loads yaml-dsl.adoc

Dev Console information in the Catalog

The catalog also includes the query options and response schema for every Dev Console, so tooling can discover what a console accepts and what it returns without having to start a running Camel application first.

The Java API provides the following methods for accessing dev console information:

CamelCatalog catalog = new DefaultCamelCatalog();

// list all available dev console names
List<String> consoleNames = catalog.findDevConsoleNames();

// look up a single dev console's model, including its query options and response schema
DevConsoleModel model = catalog.devConsoleModel("circuit-breaker");

// summary of every dev console in JSon
String summary = catalog.listDevConsolesAsJson();

// the OpenAPI 3.0 specification aggregated across every dev console endpoint
String openApiSpec = catalog.devConsolesOpenApiSpec();
Back to top