Guides

Step-by-step guides for building, running and operating Cameleer routes.

• Getting started with Cameleer Install Cameleer (Docker image, cargo install or Rust crates), run a first route and a first REST API, and configure them with properties and environment variables, in about ten minutes.
• Cameleer concepts Cameleer uses Apache Camel's model: a CamelContext runs routes; each route takes exchanges from an endpoint, passes their messages (body and headers) through processors and EIPs, and sends them to other endpoints created by components.
• YAML DSL reference The YAML DSL describes Cameleer routes in *.camel.yaml files: one input (from), a list of steps (EIPs), endpoints written as URIs, and expressions in Simple or another language, with the same names as the Apache Camel YAML DSL.
• Enterprise Integration Patterns in Cameleer Cameleer implements Apache Camel's Enterprise Integration Patterns (EIPs) with the same names, options and semantics; this page lists every one and links to a tested YAML example and its Rust DSL equivalent.
• Error handling Cameleer handles failures the way Apache Camel does: an error handler retries failed steps with a redelivery policy and then gives up or moves the message to a dead letter channel, onException reacts to specific exception types, and doTry/doCatch/doFinally handle errors inline.
• AI agent tool calls: direct vs through Cameleer Direct tool calls leave retries, duplicates, half-done work and business rules to the model; routing them through Cameleer makes each tool a tested route that validates, runs once, rolls back, retries and audits, so the model only decides what to do.
• AI components Cameleer calls large language models from routes with four components: openai (OpenAI and any OpenAI-compatible server such as Ollama or vLLM), azure-openai, aws-bedrock and google-vertexai; they cover chat, embeddings and, depending on the provider, streaming, tool calls and images.
• Build features: choose what goes into your build Cameleer's default build, image and cargo install include every component. Cargo features let you build a smaller binary that contains only the component families your routes use, for a serverless function, an edge device or a smaller container image.
• Cameleer at the edge Cameleer runs integration routes on gateways and small devices: a single native binary of about 10 MB of memory that ingests MQTT, syslog and HL7 locally, filters and aggregates on site, buffers when the uplink is down, and forwards to Kafka or HTTP in the cloud.
• Cameleer FAQ Short, factual answers to the questions people ask about Cameleer: what it is, how it relates to Apache Camel, how fast it is, where it runs, and how to use it with Kafka, LLMs and edge devices.
• Cameleer for AI agents Cameleer is the action layer for AI agents: the model decides what, a tested route decides how. It feeds events to models, routes on their answers, and turns agent tool calls into reliable actions with validation, idempotency, retries, sagas, human approval, rate limits, fallbacks and an audit log.
• Cloud credentials, regions and endpoints How Cameleer's AWS and Azure components find credentials (keys, profiles, instance and container roles, web identity, managed identity, SAS tokens), choose a region, and talk to emulators such as LocalStack and Azurite.
• Flow control and resilience patterns Flow control and resilience patterns protect routes and the systems they call: drop duplicates (idempotent consumer), limit the rate (throttle, sample, delay), stop calling a failing service (circuit breaker), check messages (validate) and process in parallel (threads).
• Interceptors, completions, sagas and reusable routes These patterns act around routes rather than on one message: interceptors that see every send or every input, onCompletion callbacks, sagas with compensation, route templates and Kamelets for reuse, the poll and stop EIPs.
• Message transformation patterns Transformation patterns change what a message contains: its body and headers (message translator), its format (marshal and unmarshal), extra data fetched from elsewhere (content enricher), or a large payload parked aside (claim check).
• Migrating from Apache Camel Camel YAML and XML routes, endpoint URIs, EIPs, the Simple language, headers and error handling carry over to Cameleer unchanged; Java code (processors, beans, custom components) must be rewritten in Rust, and a few behaviours differ, listed on this page.
• Routing patterns Routing patterns decide where a message goes next: to one endpoint, to several, to a list computed at run time, or around a loop, using the same EIP names and options as Apache Camel.
• Splitting and aggregating messages The splitter breaks one message into many, the aggregator combines many messages into one, and the resequencer and sort EIPs put messages and lists back in order.
• Validate routes with cameleer validate cameleer validate checks YAML and XML route files for syntax, structure, endpoint options, expressions, placeholders and route ids without starting any route or connecting to anything, and reports each problem with its line, column and a hint.
• YAML routes for coding agents How an AI coding assistant should write Cameleer YAML routes: start from a tested skeleton, follow a short list of rules, look up component options instead of guessing, and run cameleer validate until the file is clean before running it.