Components Overview

Component code

You can edit components in the workspace and in code. When editing a flow, select a component, and then click  Code to see and edit the component’s underlying Python code.

All components have underlying code that determines how you configure them and what actions they can perform. In the context of creating and running flows, component code does the following:

1. Determines what configuration options to show in the visual editor.
2. Validates inputs based on the component’s defined input types.
3. Processes data using the configured parameters, methods, and functions.
4. Passes results to the next component in the flow.

All components inherit from a base Component class that defines the component’s interface and behavior.

Each component’s code includes definitions for inputs and outputs, which are represented in the workspace as component ports. For example, the RecursiveCharacterTextSplitter has four inputs. Each input definition specifies the input type, such as IntInput, as well as the encoded name, display name, description, and other parameters for that specific input. These values determine the component settings, such as display names and tooltips in the visual editor.

inputs = [

        IntInput(

            name=”chunk_size”,

            display_name=”Chunk Size”,

            info=”The maximum length of each chunk.”,

            value=1000,

        ),

        IntInput(

            name=”chunk_overlap”,

            display_name=”Chunk Overlap”,

            info=”The amount of overlap between chunks.”,

            value=200,

        ),

        DataInput(

            name=”data_input”,

            display_name=”Input”,

            info=”The texts to split.”,

            input_types=[“Document”, “Data”],

        ),

        MessageTextInput(

            name=”separators”,

            display_name=”Separators”,

            info=’The characters to split on.\nIf left empty defaults to [“\\n\\n”, “\\n”, ” “, “”].’,

            is_list=True,

        ),

    ]

Additionally, components have methods or functions that handle their functionality. For example, the RecursiveCharacterTextSplitter has two methods:

    def get_data_input(self) -> Any:

        return self.data_input

    def build_text_splitter(self) -> TextSplitter:

        if not self.separators:

            separators: list[str] | None = None

        else:

            # check if the separators list has escaped characters

            # if there are escaped characters, unescape them

            separators = [unescape_string(x) for x in self.separators]

        return RecursiveCharacterTextSplitter(

            separators=separators,

            chunk_size=self.chunk_size,

            chunk_overlap=self.chunk_overlap,

        )

The get_data_input method retrieves the text to be split from the component’s input, which makes the data available to the class. The build_text_splitter method creates a RecursiveCharacterTextSplitter object by calling its parent class’s build method. Then, the text is split with the created splitter and passed to the next component.

Component versions

Versioning Overview

Robility Flow maintains an internal database to track component versions and states. When you add a component to a flow, a detached copy of that component is created based on the database version at that time.

This detached copy:

a. Is isolated from future updates in the Robility Flow database.
b. Retains its version and configuration as it was initially added.
c. Does not automatically update, even if newer versions become available after a platform upgrade.

Example:
If a component is at version 1.0 when added to a flow, it remains at 1.0 until explicitly updated—even if a newer version (e.g., 1.2) is later introduced.

Updating Components

Robility Flow notifies you when a component in your flow is out of sync with its latest available version:

a. Update ready: Safe to update. No breaking changes are expected.

b. Update available: The update may include breaking changes, such as modifications to input/output structure. These updates may require reconfiguration or reconnection of component ports.

Breaking changes may disconnect components or affect flow execution. Review changes before applying.

How to Update Components

You can update components using two methods:

1. Single Component Update
Click Update on a specific component when no breaking changes are present.

2. Review and Bulk Update

a. Click Review to see all components with available updates.
b. Optionally enable Create backup flow before updating to generate a snapshot with the suffix (backup) in the same project folder.
c. Select specific components to update or update all in one go by clicking Update Components.

Components will be updated to the latest version compatible with your current Robility Flow installation.

Grouping Components

Grouping allows you to combine multiple components into a single, reusable unit. This is ideal for organizing complex flows and encapsulating logic—for example, bundling a RAG Agent with its Vector Database.

To Group Components:

1. Hold Ctrl (Windows) or Cmd (Mac) and click each component you want to group.
2. Click Group to merge them into a single component.

Grouped components:

a. Share a unified configuration, name, and codebase.
b. Can be reused, managed, and edited as one logical block.

To Ungroup Components:

1. Click the grouped component in the Workspace.
2. Open the header menu.
3. Select Show More → Ungroup.

To Reuse Grouped Components Across Flows:

1. Select the grouped component in the Workspace.
2. Open the header menu.
3. Click Show More → Save to add it to your Components menu for reuse in other flows.