1. Content from code.visualstudio.com is not included.Visual Studio Code - The code editor

2. Content from www.jbang.dev is not included.JBang - Required for running Camel integrations locally

   1. macOS/Linux:

      curl -Ls https://sh.jbang.dev | bash -s - trust add https://github.com/apache/camel

      Copy code to clipboard

   2. Windows:

      curl -Ls https://sh.jbang.dev | bash -s - app setup add https://github.com/apache/camel

      Copy code to clipboard

3. Verify the installation

   jbang version

   Copy code to clipboard

1. Open Visual Studio Code
2. Open the Extensions view on the left side panel (or press Ctrl+Shift+X / Cmd+Shift+X)
3. Type Kaoto in the search field

4. Click the Install button on the Kaoto extension

   

1. Visual designer for Apache Camel routes
2. Integrated catalog of Camel components and patterns
3. YAML and XML DSL support
4. Real-time validation and error checking

1. Content from podman.io is not included.Podman installed and running.

1. Pull the Kaoto image:

   podman pull quay.io/kaotoio/kaoto-app:main

   Copy code to clipboard

2. Run the container:

   podman run -p 8080:8080 quay.io/kaotoio/kaoto-app:main

   Copy code to clipboard

3. Access Kaoto:

   1. Open your browser and navigate to Content from localhost is not included.http://localhost:8080
   2. If you used a different port in the -p parameter, adjust the URL accordingly

1. Open VS Code
2. Click the Kaoto icon in the left sidebar
3. Create a new Camel route file
4. You should see the visual designer interface

1. Access Content from localhost is not included.http://localhost:8080
2. You should see the Kaoto web interface
3. Try creating a simple route to test functionality

1. Visit Content from red.ht is not included.https://red.ht/kaoto
2. The Kaoto interface should load in your browser
3. Try exploring the catalog and creating a test route

1. Check the Content from kaoto.io is not included.Kaoto documentation
2. Visit the Content from github.com is not included.GitHub Issues page
3. Join the Content from camel.zulipchat.com is not included.Zulip Chat
4. Ask in the Content from github.com is not included.Discussion Forums

1. Content from marketplace.visualstudio.com is not included.VS Code Kaoto Extension on Marketplace - Download and reviews
2. Content from github.com is not included.Kaoto GitHub - Main project source code
3. Content from github.com is not included.VS Code Kaoto GitHub Repository - Extension source code
4. Content from github.com is not included.Kaoto Examples - Sample integrations and use cases

1. Content from camel.apache.org is not included.Apache Camel Documentation - Learn about Apache Camel
2. Content from camel.apache.org is not included.Camel JBang Documentation - JBang integration guide

1. This content is not included.Community Resources - Get involved with the Kaoto community
2. Content from camel.zulipchat.com is not included.Zulip Chat - Real-time chat support
3. Content from github.com is not included.Discussion Forums - Community discussions

1. Open VS Code.
2. Click on the Kaoto icon in the Activity Bar (left sidebar).

3. The Kaoto perspective will open, showing the route designer.

   

1. In the Kaoto perspective, click Camel File in the Integrations section.

   

2. Choose Camel Route as the route type.

   

3. Choose between YAML DSL or XML DSL as the route type.

   

4. Provide a name for the new route.

   

5. A basic timer-based route will be created automatically.

   

1. Click the Run: Workspace button in the Integrations panel.

   

2. The route will start executing, check the terminal output - you should see Hello Camel from route1 printed every second.

   

3. To stop the route, you can click on the Terminate button.

   

1. Hover over the timer node and click the replace button.

   

2. In the component selection dialog, search for file and select the File component.

   

3. You’ll end up having something like this, notice how hovering over the exclamation mark tells you that the directoryName configuration is missing!

   

4. Click on the file component, and fill the directoryName field with ./input.

   

5. Click on the All toggle, and search for the noop property and enable it.

   

6. Search for the idempotent property and enable it.

   

7. Hover over the setBody node and click the delete button.

   

8. Switch to the File explorer.

   

9. Create a new folder called input with a story.txt file inside where you’ll be writing the text to summarize.

   
   Note

   For a text example, visit the wonderful Content from www.gutenberg.org is not included.Project Gutenberg and use a paragraph from the Content from www.gutenberg.org is not included.Alice’s Adventures in Wonderland, book by Lewis Carroll.

   You can also use the following text:

   First, she dreamed of little Alice herself, and once again the tiny hands were clasped upon her knee, and the bright eager eyes were looking up into hers—she could hear the very tones of her voice, and see that queer little toss of her head to keep back the wandering hair that would always get into her eyes—and still as she listened, or seemed to listen, the whole place around her became alive with the strange creatures of her little sister’s dream.

   The long grass rustled at her feet as the White Rabbit hurried by—the frightened Mouse splashed his way through the neighbouring pool—she could hear the rattle of the teacups as the March Hare and his friends shared their never-ending meal, and the shrill voice of the Queen ordering off her unfortunate guests to execution—once more the pig-baby was sneezing on the Duchess’s knee, while plates and dishes crashed around it—once more the shriek of the Gryphon, the squeaking of the Lizard’s slate-pencil, and the choking of the suppressed guinea-pigs, filled the air, mixed up with the distant sobs of the miserable Mock Turtle.

10. Navigate back to the Kaoto perspective and run the route, you should get a similar output like this. Notice how you see the text as the route output.

    

11. Stop the route now. In the next step, add the OpenAI component to perform the summary.

    

1. Hover in the edge between the file and log components, and click on the Add step button.

   

2. In the component catalog, search for openai and select the OpenAI component.

   

3. Click on the newly added OpenAI component and select the All view to configure the following options:

   

   Property	Value
   Operation	chat-completion
   API Key	OLLAMA-LOCAL-KEY
   Base URL	Content from localhost is not included.http://localhost:11434/v1
   Model	granite4:tiny-h
   System Message	Summarize this text into a couple of short sentences and give it a funny twist

   Note

   To run Ollama locally, an API Key is not really needed. You can fill this field with any string, or the actual OLLAMA-LOCAL-KEY string.

   After editing the option, click on the Modified toggle to see what has changed in the route configuration.

   Note

   For the next step, make sure to run ollama run granite4:tiny-h in your terminal beforehand.

4. Time of truth, run the route and see the summary. If everything went well, you should get a similar output like this:

   2026-03-26 13:09:37.293 INFO 592754 --- [ Content from . is not included.file://./input] demo.camel.yaml:19 : Once upon a time in Wonderland, Alice dreamt that her childhood fascination turned into a reality where she met her favorite characters from "Alice in Wonderland," but this time it’s all around her, filling her ears and eyes! Oh, and let’s not forget about the sneezing pig-baby and execution-ordered rabbit. Truly an unforgettable experience!

1. Locate the integration in the flows list

2. Click on the pencil button

   

3. Type the new name

   
4. Press Enter or click in the accept button
5. Save the file

1. Locate the integration in the flows list

2. Click the eye icon next to the integration name

   

3. The integration toggles between visible and hidden on the canvas

   

1. Locate the integration in the flows list

2. Click the delete icon next to the integration name

   

3. Confirm deletion in the dialog that appears

   
4. The integration content is removed from the file

1. You can either Right-Click on the step you want to insert before or after. This will bring up a context menu with the available actions to choose from.
2. An easier alternative would be to hover over the connection between the two steps you want to insert between and then click on the + button that appears.

3. Hover over the connection between the Timer and the Log steps now and click the + button to execute the Add step action.

   
   Note

   When using the right-click context menu, the set of available actions depend on the selected step and can vary. There are actions for appending, prepending, replacing and deleting steps as well as some more specialized actions.

4. This will open up the Camel Catalog where you can search the step you want to add.

   

5. As already mentioned we would like to modify the message body before sending it along to the Log component. To achieve that we need to add a Processor called setBody. Let’s enter this name into the filter text field on top of the Catalog.

   

6. You can now select the setBody tile to add it to your route. Select the new added step now on the canvas to open the configuration form to the right.

   
7. Let’s change the Expression text field to <code>Hello from Kaoto!</code>.

8. Now the Log component will receive a <code>Hello from Kaoto!</code> message every second and logs it to the console.

   Note

   When using the right click context menu of a step, adding new steps is usually done with two actions.

   • Prepend can be used to add a step before the selected step
   • Append will add the new step after the selected step.

   However, on the first step of a flow and on steps that can have children, the Add Step action is used.

1. You can replace any step on the canvas by hovering over or by selecting the step. This will spawn a toolbar which contains a button for the Replace action.

   
2. Alternatively you can do that also by invoking the context menu on a step and selecting the item Replace. Both ways it will open up the Camel Catalog and you can choose the replacement from there.

1. You can delete any step on the canvas by hovering over or by selecting the step. This will spawn a toolbar which contains a button for the Delete action.

   
2. Alternatively you can do that also by invoking the context menu on a step and selecting the item Delete. This will remove the step from your integration.

1. You can enable or disable any step on the canvas by hovering over or by selecting the step. This will spawn a toolbar which contains a button for the Enable / Disable action.

   Note

   Disabling a step will instruct the Content from camel.apache.org is not included.Apache Camel runtime to ignore the step when executing the flow. This can be convenient when prototyping a new route.

   

2. Alternatively you can enable / disable any step in your route by invoking the context menu on a step and selecting the item Enable / Disable.

   
3. In the picture above the Log component has been disabled. The icon is grayed out and there is a marker icon at the top right of the step to indicate it is disabled.

1. You can use the built-in documentation generating feature to create a Markdown file containing all the steps in your integration and all the changed parameters for these steps together with an image of your integration.

   

2. When you click the button it will open up a dialog with a preview of your integration documentation.

   
3. You can use the Visible Entities control in the top left of the dialog to control which routes are part of the documentation. You can either select all, just a subset or even just a single route.
4. Once you have made your choice you can specify a file name in the top right and then hit the Download button to retrieve the file in ZIP format.

1. Choose the right method: Use drag-and-drop for visual reorganization, copy/paste for duplication, and move-before/after for precise positioning
2. Plan before you reorganize: Think about the logical flow before moving or copying steps
3. Use visual feedback: When dragging, pay attention to the visual indicators showing valid drop zones and compatible targets
4. Test after reorganizing: Validate your routes after significant changes
5. Leverage undo/redo: Don’t hesitate to experiment - you can always undo
6. Combine methods: Use drag-and-drop, copy/paste, and move operations together for efficient workflow design
7. Save frequently: While undo/redo is available, regular saves ensure you don’t lose your work

How to use?

1. Clone Content from github.com is not included.Kaoto Camel catalog project
2. Navigate to the camel-catalog directory

3. Install the project dependencies

   yarn install

   Copy code to clipboard

4. Build the default catalogs

   yarn build

   Copy code to clipboard

5. This will generate a Catalog library containing:

   • Camel Main versions
   • Camel extensions for Quarkus
   • Camel Spring boot

   • Camel Kamelets

     Note

     To check what specific versions are included, please visit the Content from github.com is not included.index file

6. The resulting files will be in the catalog folder

   Note

   The latest catalog is version is available in the Content from github.com is not included.GitHub repository

7. Providing that folder through a http server will make it available for using it in Kaoto

1. In order to add multiple runtimes to the Catalog library, we can provide each runtime with its version using the following flags:

    -m,--main <version>               Camel Main version. If not specified,
                                      it will use the generator installed
                                      version
    -q,--quarkus <version>            Camel Extensions for Quarkus version
    -s,--springboot <version>         Camel SpringBoot version

   Copy code to clipboard

2. For instance, running the following command will create a Catalog library with Camel Main 4.15.0 and Camel extensions for Quarkus 3.27.0:

   ./mvnw package; java -jar ./target/catalog-generator-0.0.1-SNAPSHOT.jar -o ./dist/camel-catalog -k 4.15.0 -m 4.15.0 -q 3.27.0 -n "My Catalog"

   Copy code to clipboard

3. For a different Kamelets catalog version, the --kamelets or -k flag can be specified

   ./mvnw package; java -jar ./target/catalog-generator-0.0.1-SNAPSHOT.jar -o ./dist/camel-catalog -k 4.15.0 -m 4.15.0  -n "My Catalog"

   Copy code to clipboard

1. In VSCode, go to the settings page and look for "Kaoto"

   

2. In the TextField, provide the URL of the index.json file that specifies the location of the subsequent catalogs, for instance, the public Kaoto catalog can be used:

   

3. Restart Kaoto for the changes to have effect

   

1. Navigate to the Deployments panel and click the Stop button (⏹️) next to your running integration:

   

1. Go to the terminal where Camel is running
2. Press Ctrl + C (or Cmd + C on macOS)

1. Create an integration in Kaoto’s visual designer
2. Run** the single integration to test basic functionality
3. Modify the integration based on test results
4. Run the folder to test with related integrations
5. Run the workspace to verify complete integration

1. Unit testing: Run single integrations in isolation
2. Integration testing: Run folders with related integrations
3. System testing: Run the entire workspace

1. Start with single integration execution to isolate issues
2. Add log processors to track message flow
3. Use the terminal output to identify problems
4. Make incremental changes and re-run

1. Group related integrations: Keep related integrations in the same folder for easier management
2. Use meaningful names: Name files descriptively (e.g., order-processing.camel.yaml, customer-sync.camel.yaml)
3. One integration per file: Recommended approach for better organization, testing, and version control
4. Separate concerns: Use different folders for different modules, features, or business domains
5. Consistent naming: Follow a naming convention across your project (e.g., domain-action.camel.yaml)

1. Test incrementally: Start with single integrations, then folders, then workspace
2. Use workspace settings: Configure Kaoto settings at workspace level (.vscode/settings.json), not globally
3. Monitor output: Keep the terminal visible during development to catch errors early
4. Stop when done: Always stop integrations when finished testing to free up resources
5. Clean restarts: Stop all integrations before making significant changes
6. Use logs effectively: Add log processors at key points for debugging

1. Body - The incoming Camel Message Body (the main data payload)
2. Parameters - Additional data from Camel Variables and Message Headers

1. Body - The outgoing Camel Message Body (the transformed result)

1. Click the plus + button on the right side of the Parameters title.

   

2. Now type the parameter name and click the check button on the right.

   

1. To remove a parameter, click the trash icon next to it and confirm the deletion.

   

2. You then have to confirm the deletion by clicking the Confirm button.

   

3. The parameter is deleted.

   

1. Click the 3 dots context menu on the target field and select Add selector expression.

   

2. Then enter the XPath expression to define the mapping.

   

1. Click the 3 dots context menu on the target section’s field. Then select wrap with "if" to create a mapping.

   

2. Configure the if condition. You can drag the source field and drop it into the input field to build a condition, or alternatively type everything manually.

   

3. Create the mapping for when the condition is true.

   

1. Click the 3 dots context menu on the target section’s field. Then select wrap with "choose-when-otherwise" to create a mapping.

   

2. Configure when and otherwise conditions - Similar to if mapping, configure the condition and create mappings for both when and otherwise branches

   

3. Add more when branches (optional) - If you need multiple conditions, click the 3-dot menu on the choose field and select “Add when” to create additional when branches. Each branch can have its own condition and mappings.

   

1. Identify the target collection field - Look for fields marked with the layer icon Layer icon, indicating they contain multiple items.

   

2. Create the for-each mapping - Click the 3 dots context menu on the target section’s collection field. Then select Wrap with "for-each" to create a mapping.

   

3. Specify the source collection - Choose which source collection to iterate over. This determines what data will be processed for each target item.

   

4. Map the collection item fields - Create mappings for individual fields within each collection item. These mappings will be applied to every item in the collection.

   

1. After creating a first for-each mapping by following previous section, click Add Conditional Mapping in the placeholder below the added for-each mapping

   

2. Click Wrap with "for-each"

   

3. Configure the second collection mappings - Select the second source collection to iterate over, then create field mappings for each item. This allows you to merge data from multiple collections into a single target array, combining items from different sources.

   

4. Here is a demo screencast for merging 2 source collection fields with multiple for-each mappings.

   

String Functions:

1. concat() - Combine multiple strings
2. substring() - Extract part of a string
3. upper-case(), lower-case() - Change text case
4. normalize-space() - Remove extra whitespace

Numeric Functions:

1. sum(), avg(), min(), max() - Aggregate calculations
2. round(), floor(), ceiling() - Number rounding
3. format-number() - Number formatting

Date/Time Functions:

1. current-date(), current-time() - Get current date/time
2. format-date(), format-time() - Format date/time values

Conditional Functions:

1. if() - Inline conditional logic
2. choose() - Multi-branch conditionals

1. Switch to the Functions tab in the left palette.

   

2. Drag the function you need and drop it into the editor.

   
3. Fill in the function parameters with field references or literal values

1. Once you’ve built your XPath expression, click the Close button to apply it to the mapping.

   

2. The mapping will now appear in the tree view with your custom XPath expression.

   

1. Content from kaoto.io is not included.Download book-summary-api.openapi.yaml
2. Save this file to your workspace folder before starting the API-first or code-first examples. The REST Editor approach creates endpoints from scratch without OpenAPI.

1. Data sources — database connection pools (e.g., PGSimpleDataSource, HikariDataSource)
2. HTTP clients — pre-configured REST or HTTP clients with base URLs and authentication
3. Custom processors — Java classes implementing Camel’s Processor interface for custom logic
4. Caches — in-memory or distributed cache instances (e.g., Caffeine, Redis)
5. Serializers / Marshallers — Jackson ObjectMapper or JAXB context beans
6. Business logic beans — Custom Java classes containing business logic invoked via the Bean component or Bean EIP

1. Bean EIP — The standard way to invoke bean methods as processing steps within a route. Use this for most scenarios where you need to execute business logic mid-route.
2. Bean Component — Invokes beans using URI syntax (uri: bean:beanName?method=methodName). Use this when you need to dynamically construct the URI from runtime values such as headers or variables.

1. Open a Camel integration file in Kaoto (or create a new one named book-database.camel.yaml).

2. Click the Beans tab at the top of the Kaoto editor to open the Beans Editor.

   

3. Click Add new Beans at the top of the bean list.

   

4. In the Details form at the right, fill bean name and Java type:

   • name → bookDataSource

   • type → org.postgresql.ds.PGSimpleDataSource

     

5. Lower in the Details form, add the connection details under properties. Click Add a new property button:

   

6. Fill properties name and value as following:

   Key	Value
   serverName	localhost
   databaseName	bookstore
   user	postgres
   password	{{db.password}}
   portNumber	5432

   

7. This adds beans block

   - beans:
       - name: bookDataSource
         type: org.postgresql.ds.PGSimpleDataSource
         properties:
           serverName: localhost
           databaseName: bookstore
           user: postgres
           password: '{{db.password}}'
           portNumber: 5432

   Copy code to clipboard

1. Click the Design tab to return to the canvas

2. Kaoto creates a default timer-to-log route. Configure the Timer component:

   • Timer Name → bookInsertTimer
   • Period → 10000 (runs every 10 seconds)

3. Insert an SQL component between Timer and Log:

   • Query → INSERT INTO books (title, author, isbn, published_year) VALUES ('Camel Integration Patterns', 'John Smith', '978-0321200686', 2003)
   • Data Source → Select #bookDataSource from the dropdown

4. Update the Log step message:

   • Message → Book inserted successfully: ${body}

5. The generated structure looks like this:

   

1. Ensure PostgreSQL is running and the bookstore database exists

2. Click the Run button in the toolbar of the Kaoto editor to start the integration.

   

3. The integration will start and begin inserting book records every 10 seconds.

   

1. Open a Camel integration file in Kaoto and click the Design tab at the top of the Kaoto editor.
2. Kaoto creates a default timer-to-log route. Insert an SQL component between Timer and Log.

3. In the SQL step configuration, you’ll need to specify:

   • Query — INSERT INTO books (title, author, isbn, published_year) VALUES ('Camel Integration Patterns', 'John Smith', '978-0321200686', 2003).
   • Data Source — Reference to a datasource bean.

4. Locate the Data Source field and click it.

   

1. In the dropdown, click Create new bean image::13-create-new-bean-option.png[]

2. A modal dialog opens — fill in:

   • name → bookstoreDataSource

   • type → org.postgresql.ds.PGSimpleDataSource

     

3. Add the connection details under properties:

   Key	Value
   serverName	localhost
   databaseName	bookstore
   user	postgres
   password	{{db.password}}
   portNumber	5432

   

4. Click Create

   

5. The bean is added to the beans list and the Data Source field is automatically set to reference it — in a single action.

   
6. This adds beans block