diff --git a/docs/docs/Components/components-agents.mdx b/docs/docs/Components/components-agents.mdx
index b6c96e010..47e4bc81b 100644
--- a/docs/docs/Components/components-agents.mdx
+++ b/docs/docs/Components/components-agents.mdx
@@ -43,7 +43,7 @@ For examples of flows using the **Agent** and **MCP Tools** components, see the
 The **Agent** component is the primary agent actor in your agent flows.
 This component uses an LLM integration to respond to input, such as a chat message or file upload.
 
-The agent can use the tools already available in the base LLM model as well as additional tools that you connect to the **Agent** component's **Tools** port.
+The agent can use the tools already available in the base LLM as well as additional tools that you connect to the **Agent** component's **Tools** port.
 You can connect any Langflow component as a tool, including other **Agent** components and MCP servers through the [**MCP Tools** component](#mcp-connection).
 
 For more information about using this component, see [Use Langflow agents](/agents).
diff --git a/docs/docs/Components/components-data.mdx b/docs/docs/Components/components-data.mdx
index 3bc8b7a16..82e272275 100644
--- a/docs/docs/Components/components-data.mdx
+++ b/docs/docs/Components/components-data.mdx
@@ -396,7 +396,7 @@ There are two settings that control the output of the **URL** component at diffe
 When used as a standard component in a flow, the **URL** component must be connected to a component that accepts the selected output data type (`DataFrame` or `Message`).
 You can connect the **URL** component directly to a compatible component, or you can use a [**Type Convert** component](/components-processing#type-convert) to convert the output to another type before passing the data to other components if the data types aren't directly compatible.
 
-Processing components, like the **Type Convert** component, are useful with the **URL** component because it can extract a large amount of data from the crawled pages.
+**Processing** components like the **Type Convert** component are useful with the **URL** component because it can extract a large amount of data from the crawled pages.
 For example, if you only want to pass specific fields to other components, you can use a [**Parser** component](/components-processing#parser) to extract only that data from the crawled pages before passing the data to other components.
 
 When used in **Tool Mode** with an **Agent** component, the **URL** component can be connected directly to the **Agent** component's **Tools** port without converting the data.
diff --git a/docs/docs/Components/components-logic.mdx b/docs/docs/Components/components-logic.mdx
index 6c0389561..61e451ec5 100644
--- a/docs/docs/Components/components-logic.mdx
+++ b/docs/docs/Components/components-logic.mdx
@@ -33,7 +33,10 @@ The following example uses the **If-Else** component to check incoming chat mess
 
 1. Add an **If-Else** component to your flow, and then configure it as follows:
 
-    * **Text Input**: Connect the **Text Input** port to a **Chat Input** component.
+    * **Text Input**: Connect the **Text Input** port to a **Chat Input** component or another `Message` input.
+
+        If your input isn't in `Message` format, you can use another component to transform it, such as the [**Type Convert** component](/components-processing#type-convert) or [**Parser** component](/components-processing#parser).
+        If your input isn't appropriate for `Message` format, consider using another component for conditional routing, such as the [**Data Operations** component](/components-processing#data-operations).
 
     * **Match Text**: Enter `.*(urgent|warning|caution).*` so the component looks for these values in incoming input. The regex match is case sensitive, so if you need to look for all permutations of `warning`, enter `warning|Warning|WARNING`.
 
@@ -96,7 +99,10 @@ You can toggle parameters through the <Icon name="SlidersHorizontal" aria-hidden
 
 ## Loop
 
-The **Loop** component iterates over a list of input by passing individual items to other components attached at the **Item** output port until there are no items left to process. Then, the **Loop** component passes the aggregated result of all looping to the component connected to the **Done** port.
+The **Loop** component iterates over a list of input by passing individual items to other components attached at the **Item** output port until there are no items left to process.
+Then, the **Loop** component passes the aggregated result of all looping to the component connected to the **Done** port.
+
+### The looping process
 
 The **Loop** component is like a miniature flow within your flow.
 Here's a breakdown of the looping process:
@@ -115,9 +121,13 @@ Here's a breakdown of the looping process:
 
     Only one component connects to the **Item** port, but you can pass the data through as many components as you need, as long as the last component in the chain connects back to the **Looping** port.
 
+    The **If-Else** component isn't compatible with the **Loop** component.
+    For more information, see [Conditional looping](#conditional-looping).
+
 4. After processing all items, the results are aggregated into a single `Data` object that is passed from the **Loop** component's **Done** port to the next component in the flow.
 
-In terms of simplified code, the **Loop** component works like this:
+The following simplified Python code summarizes how the **Loop** component works.
+This _isn't_ the actual component code; it is only meant to help you understand the general process.
 
 ```python
 for i in input:             # Receive input data as a list
@@ -132,8 +142,7 @@ done = aggregate_results()  # Compile all returned items
 print(done)                 # Send the aggregated results from the Done port to another component
 ```
 
-<details>
-<summary>Loop example</summary>
+### Loop example
 
 In the follow example, the **Loop** component iterates over a CSV file until there are no rows left to process.
 In this case, the **Item** port passes each row to a **Type Convert** component to convert the row into a `Message` object, passes the `Message` to a **Structured Output** component to be processed into structured data that is then passed back to the **Loop** component's **Looping** port.
@@ -145,7 +154,13 @@ After processing all rows, the **Loop** component loads the aggregated list of s
 For more examples of the **Loop** component, try the **Research Translation Loop** template in Langflow, or see the video tutorial [Mastering the Loop Component & Agentic RAG in Langflow](https://www.youtube.com/watch?v=9Wx7WODSKTo).
 :::
 
-</details>
+### Conditional looping
+
+The **If-Else** component isn't compatible with the **Loop** component.
+If you need conditional loop events, redesign your flow to process conditions before the loop.
+For example, if you are looping over a `DataFrame`, you could use multiple [**DataFrame Operations** components](/components-processing#dataframe-operations) to conditionally filter data, and then run separate loops on each set of filtered data.
+
+![A flow with conditional looping.](/img/conditional-looping.png)
 
 ## Notify and Listen
 
diff --git a/docs/docs/Components/components-processing.mdx b/docs/docs/Components/components-processing.mdx
index ca2c1ec43..9855077fe 100644
--- a/docs/docs/Components/components-processing.mdx
+++ b/docs/docs/Components/components-processing.mdx
@@ -4,6 +4,8 @@ slug: /components-processing
 ---
 
 import Icon from "@site/src/components/icon";
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
 
 Langflow's **Processing** components process and transform data within a flow.
 They have many uses, including:
@@ -11,7 +13,7 @@ They have many uses, including:
 * Feed instructions and context to your LLMs and agents with the [**Prompt Template** component](#prompt-template).
 * Extract content from larger chunks of data with a [**Parser** component](#parser).
 * Filter data with natural language with the [**Smart Function** component](#smart-function).
-* Save data to your local machine with the [**Save To File** component](#save-to-file).
+* Save data to your local machine with the [**Save File** component](#save-file).
 * Transform data into a different data type with the [**Type Convert** component](#type-convert) to pass it between incompatible components.
 
 ## Prompt Template
@@ -21,8 +23,7 @@ See [Prompt Template](/components-prompts).
 ## Batch Run
 
 The **Batch Run** component runs a language model over _each row of one text column_ in a [`DataFrame`](/data-types#dataframe), and then returns a new `DataFrame` with the original text and an LLM response.
-
-The response contains the following columns:
+The output contains the following columns:
 
 * `text_input`: The original text from the input `DataFrame`
 * `model_response`: The model's response for each input
@@ -31,7 +32,7 @@ The response contains the following columns:
 
 ### Use the Batch Run component in a flow
 
-If you pass this output to a [**Parser** component](/components-processing#parser), you can use variables in the parsing template to reference these keys, such as `{text_input}` and `{model_response}`.
+If you pass the **Batch Run** output to a [**Parser** component](/components-processing#parser), you can use variables in the parsing template to reference these keys, such as `{text_input}` and `{model_response}`.
 This is demonstrated in the following example.
 
 ![A batch run component connected to OpenAI and a Parser](/img/component-batch-run.png)
@@ -57,7 +58,7 @@ For example, `Create a business card for each name.`
     record_number: {batch_index}, name: {text_input}, summary: {model_response}
     ```
 
-7. To test the processing, click the **Parser** component, and then click <Icon name="Play" aria-hidden="True" /> **Run component**, and then click <Icon name="TextSearch" aria-hidden="True" /> **Inspect output** to view the final `DataFrame`.
+7. To test the processing, click the **Parser** component, click <Icon name="Play" aria-hidden="True" /> **Run component**, and then click <Icon name="TextSearch" aria-hidden="True" /> **Inspect output** to view the final `DataFrame`.
 
     You can also connect a **Chat Output** component to the **Parser** component if you want to see the output in the **Playground**.
 
@@ -78,26 +79,41 @@ You can toggle parameters through the <Icon name="SlidersHorizontal" aria-hidden
 
 ## Data Operations
 
-The **Data Operations** component performs operations on [`Data`](/data-types#data) objects, including selecting keys, evaluating literals, combining data, filtering values, appending/updating data, removing keys, and renaming keys.
+The **Data Operations** component performs operations on [`Data`](/data-types#data) objects, including extracting, filtering, and editing keys and values in the `Data`.
+For all options, see [Available data operations](#available-data-operations).
+The output is a new `Data` object containing the modified data after running the selected operation.
 
-1. To use the **Data Operations** component in a flow, you must connect its **Data** input port to the output port of a component that outputs `Data`.
-All operations in the **Data Operations** component require at least one `Data` input.
+### Use the Data Operations component in a flow
 
-    For this example, add a **Webhook** component to the flow, and then connect it to a **Data Operations** component. Assume you'll send requests to the webhook with a consistent payload that has `name`, `username`, and `email` keys.
+The following example demonstrates how to use a **Data Operations** component in a flow using data from a webhook payload:
+
+1. Create a flow with a **Webhook** component and a **Data Operations** component, and then connect the **Webhook** component's output to the **Data Operations** component's **Data** input.
+
+    All operations in the **Data Operations** component require at least one `Data` input from another component.
+    If the preceding component doesn't produce `Data` output, you can use another component, such as the **Type Convert** component, to reformat the data before passing it to the **Data Operations** component.
+    Alternatively, you could consider using a component that is designed to process the original data type, such as the **Parser** or **DataFrame Operations** components.
 
 2. In the **Operations** field, select the operation you want to perform on the incoming `Data`.
-For this example, select the **Select Keys** operation to extract specific user information.
+For this example, select the **Select Keys** operation.
 
-3. Add keys for `name`, `username`, and `email` to select those values from the incoming request payload.
+    :::tip
+    You can select only one operation.
+    If you need to perform multiple operations on the data, you can chain multiple **Data Operations** components together to execute each operation in sequence.
+    For more complex multi-step operations, consider using a component like the **Smart Function** component.
+    :::
 
-    To add additional keys, click <Icon name="Plus" aria-hidden="True" /> **Add more**.
+3. Under **Select Keys**, add keys for `name`, `username`, and `email`.
+Click <Icon name="Plus" aria-hidden="True" /> **Add more** to add a field for each key.
 
-4. Connect a **Chat Output** component.
+    For this example, assume that the webhook will receive consistent payloads that always contain `name`, `username`, and `email` keys.
+    The **Select Keys** operation extracts the value of these keys from each incoming payload.
 
+4. Optional: If you want to view the output in the **Playground**, connect the **Data Operations** component's output to a **Chat Output** component.
 
     ![A flow with Webhook, Data Operations, and Chat Output components](/img/component-data-operations-select-key.png)
 
-5. To test the flow, send the following request to your flow's webhook endpoint, and then open the **Playground** to see the resulting output from processing the payload.
+5. To test the flow, send the following request to your flow's webhook endpoint.
+For more information about the webhook endpoint, see [Trigger flows with webhooks](/webhook).
 
     ```bash
     curl -X POST "http://$LANGFLOW_SERVER_URL/api/v1/webhook/$FLOW_ID" \
@@ -128,15 +144,19 @@ For this example, select the **Select Keys** operation to extract specific user
     }'
     ```
 
+6. To view the `Data` resulting from the **Select Keys** operation, do one of the following:
+
+   * If you attached a **Chat Output** component, open the **Playground** to see the result as a chat message.
+   * Click <Icon name="TextSearch" aria-hidden="true" /> **Inspect output** on the **Data Operations** component.
+
 ### Data Operations parameters
 
-Some **Data Operations** component input parameters are hidden by default in the visual editor.
-You can toggle parameters through the <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls** in the [component's header menu](/concepts-components#component-menus).
+Many **Data Operations** component input parameters are conditional based on the selected **Operation** (`operation`).
 
 | Name | Display Name | Info |
 |------|--------------|------|
 | data | Data | Input parameter. The `Data` object to operate on. |
-| operations | Operations | Input parameter. The operation to perform on the data. See [Data Operations operations](#data-operations-operations) |
+| operation | Operation | Input parameter. The operation to perform on the data. See [Available data operations](#available-data-operations) |
 | select_keys_input | Select Keys | Input parameter. A list of keys to select from the data. |
 | filter_key | Filter Key | Input parameter. The key to filter by. |
 | operator | Comparison Operator | Input parameter. The operator to apply for comparing values. |
@@ -144,9 +164,8 @@ You can toggle parameters through the <Icon name="SlidersHorizontal" aria-hidden
 | append_update_data | Append or Update | Input parameter. The data to append or update the existing data with. |
 | remove_keys_input | Remove Keys | Input parameter. A list of keys to remove from the data. |
 | rename_keys_input | Rename Keys | Input parameter. A list of keys to rename in the data. |
-| data_output | Data | Output parameter. The resulting Data object after the operation. |
 
-### Data Operations operations
+#### Available data operations
 
 Options for the `operations` input parameter are as follows.
 All operations act on an incoming `Data` object.
@@ -163,123 +182,230 @@ All operations act on an incoming `Data` object.
 
 ## DataFrame Operations
 
-The **DataFrame Operations** component performs operations on [`DataFrame`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) rows and columns.
+The **DataFrame Operations** component performs operations on [`DataFrame`](/data-types#dataframe) (table) rows and columns, including schema changes, record changes, sorting, and filtering.
+For all options, see [DataFrame Operations parameters](#dataframe-operations-parameters).
 
-To use the **DataFrame Operations** component in a flow, you must connect its **DataFrame** input port to the output port of a component that outputs `DataFrame`.
-All operations in the **DataFrame Operations** component require at least one `DataFrame` input.
+The output is a new `DataFrame` containing the modified data after running the selected operation.
 
-The following example fetches JSON data from an API. The **Smart Filter** component extracts and flattens the results into a tabular `DataFrame` that is then processed through the **DataFrame Operations** component.
+### Use the DataFrame Operations component in a flow
 
-![A flow that ingests an API response, extracts it to a DataFrame with a Smart Filter component, and the processes it through a DataFrame Operations component](/img/component-dataframe-operations.png)
+The following steps explain how to configure a **DataFrame Operations** component in a flow.
+You can follow along with an example or use your own flow.
+The only requirement is that the preceding component must create `DataFrame` output that you can pass to the **DataFrame Operations** component.
 
-1. The **API Request** component retrieves data with only `source` and `result` fields.
-For this example, the desired data is nested within the `result` field.
-2. Connect a **Language Model** component to a **Smart Filter** component, and then connect the **Smart Filter** component to the **API Request** component. This example connects a **Groq** language model component.
-3. In the **Groq** component, add your Groq API key.
-4. To filter the data, in the **Smart Filter** component, in the **Instructions** field, use natural language to describe how the data should be filtered.
-For this example, enter:
-```
-I want to explode the result column out into a Data object
-```
-:::tip
-Avoid punctuation in the **Instructions** field, as it can cause errors.
-:::
-5. To run the flow, in the **Smart Filter** component, click <Icon name="Play" aria-hidden="true" /> **Run component**.
-6. To inspect the filtered data, in the **Smart Filter** component, click <Icon name="TextSearch" aria-hidden="true" /> **Inspect output**.
-The result is a structured DataFrame.
+1. Create a new flow or use an existing flow.
 
-```text
-id | name             | company               | username        | email                              | address           | zip
----|------------------|----------------------|-----------------|------------------------------------|-------------------|-------
-1  | Emily Johnson    | ABC Corporation      | emily_johnson   | emily.johnson@abccorporation.com   | 123 Main St       | 12345
-2  | Michael Williams | XYZ Corp             | michael_williams| michael.williams@xyzcorp.com       | 456 Elm Ave       | 67890
-```
+    <details>
+    <summary>API response extraction flow example</summary>
 
-7. Add **DataFrame Operations** and **Chat Output** components to the flow.
-8. In the **DataFrame Operations** component, in the **Operation** field, select **Filter**.
-9. To apply a filter, in the **Column Name** field, enter a column to filter on. This example filters by `name`.
-10. Click **Playground**, and then click **Run Flow**.
-The flow extracts the values from the `name` column.
+    The following example flow uses five components to extract `Data` from an API response, transform it to a `DataFrame`, and then perform further processing on the tabular data using a **DataFrame Operations** component.
+    The sixth component, **Chat Output**, is optional in this example.
+    It only serves as a convenient way for you to view the final output in the **Playground**, rather than inspecting the component logs.
 
-```text
-name
-Emily Johnson
-Michael Williams
-John Smith
-...
-```
+    ![A flow that ingests an API response, extracts it to a DataFrame with a Smart Function component, and the processes it through a DataFrame Operations component](/img/component-dataframe-operations.png)
 
-### Operations
+    If you want to use this example to test the **DataFrame Operations** component, do the following:
 
-This component can perform the following operations on Pandas [DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html).
+    1. Create a flow with the following components:
 
-| Operation | Required Inputs | Info |
-|-----------|----------------|-------------|
-| Add Column | new_column_name, new_column_value | Adds a new column with a constant value. |
-| Drop Column | column_name | Removes a specified column. |
-| Filter | column_name, filter_value | Filters rows based on column value. |
-| Head | num_rows | Returns first `n` rows. |
-| Rename Column | column_name, new_column_name | Renames an existing column. |
-| Replace Value | column_name, replace_value, replacement_value | Replaces values in a column. |
-| Select Columns | columns_to_select | Selects specific columns. |
-| Sort | column_name, ascending | Sorts DataFrame by column. |
-| Tail | num_rows | Returns last `n` rows. |
+        * **API Request**
+        * **Language Model**
+        * **Smart Function**
+        * **Type Convert**
 
-<details>
-<summary>Parameters</summary>
+    2. Configure the [**Smart Function** component](#smart-function) and its dependencies:
 
-**Inputs**
+        * **API Request**: Configure the [**API Request** component](/components-data#api-request) to get JSON data from an endpoint of your choice, and then connect the **API Response** output to the **Smart Function** component's **Data** input.
+        * **Language Model**: Select your preferred provider and model, and then enter a valid API key.
+        Change the output to **Language Model**, and then connect the `LanguageModel` output to the **Smart Function** component's **Language Model** input.
+        * **Smart Function**: In the **Instructions** field, enter natural language instructions to extract data from the API response.
+        Your instructions depend on the response content and desired outcome.
+        For example, if the response contains a large `result` field, you might provide instructions like `explode the result field out into a Data object`.
 
-| Name | Display Name | Info |
-|------|--------------|------|
-| df | DataFrame | The input DataFrame to operate on. |
-| operation | Operation | The DataFrame operation to perform. Options include Add Column, Drop Column, Filter, Head, Rename Column, Replace Value, Select Columns, Sort, and Tail. |
-| column_name | Column Name | The column name to use for the operation. |
-| filter_value | Filter Value | The value to filter rows by. |
-| ascending | Sort Ascending | Whether to sort in ascending order. |
-| new_column_name | New Column Name | The new column name when renaming or adding a column. |
-| new_column_value | New Column Value | The value to populate the new column with. |
-| columns_to_select | Columns to Select | A list of column names to select. |
-| num_rows | Number of Rows | The number of rows to return for head/tail operations. The default is 5. |
-| replace_value | Value to Replace | The value to replace in the column. |
-| replacement_value | Replacement Value | The value to replace with. |
+    3. Convert the **Smart Function** component's `Data` output to `DataFrame`:
 
-**Outputs**
+        1. Connect the **Filtered Data** output to the **Type Convert** component's **Data** input.
+        2. Set the **Type Convert** component's **Output Type** to **DataFrame**.
 
-| Name | Display Name | Info |
-|------|--------------|------|
-| output | DataFrame | The resulting DataFrame after the operation. |
+    Now the flow is ready for you to add the **DataFrame Operations** component.
 
-</details>
+    </details>
 
-## LLM router
+2. Add a **DataFrame Operations** component to the flow, and then connect `DataFrame` output from another component to the **DataFrame** input.
 
-This component routes requests to the most appropriate LLM based on [OpenRouter](https://openrouter.ai/docs/quickstart) model specifications.
+    All operations in the **DataFrame Operations** component require at least one `DataFrame` input from another component.
+    If a component doesn't produce `DataFrame` output, you can use another component, such as the **Type Convert** component, to reformat the data before passing it to the **DataFrame Operations** component.
+    Alternatively, you could consider using a component that is designed to process the original data type, such as the **Parser** or **Data Operations** components.
 
-The judge LLM analyzed your input message to understand the evaluation context, and then selects the most appropriate model from your LLM pool.
+    If you are following along with the example flow, connect the **Type Convert** component's **DataFrame Output** port to the **DataFrame** input.
 
-The selected model processes your input and returns the response.
+3. In the **Operations** field, select the operation you want to perform on the incoming `DataFrame`.
+For example, the **Filter** operation filters the rows based on a specified column and value.
 
-To use the **LLM Router** component in a flow, do the following:
+    :::tip
+    You can select only one operation.
+    If you need to perform multiple operations on the data, you can chain multiple **DataFrame Operations** components together to execute each operation in sequence.
+    For more complex multi-step operations, like dramatic schema changes or pivots, consider using an LLM-powered component, like the **Structured Output** or **Smart Function** component, as a replacement or preparation for the **DataFrame Operations** component.
+    :::
 
-1. Connect multiple **Language Model** components to the **LLM Router**'s **Language Models** input.
+    If you're following along with the example flow, select any operation that you want to apply to the data that was extracted by the **Smart Function** component.
+    To view the contents of the incoming `DataFrame`, click <Icon name="Play" aria-hidden="true" /> **Run component** on the **Type Convert** component, and then <Icon name="TextSearch" aria-hidden="true" /> **Inspect output**.
+    If the `DataFrame` seems malformed, click <Icon name="TextSearch" aria-hidden="true" /> **Inspect output** on each upstream component to determine where the error occurs, and then modify your flow's configuration as needed.
+    For example, if the **Smart Function** component didn't extract the expected fields, modify your instructions or verify that the given fields are present in the **API Response** output.
 
-2. Connect a **Judge LLM** component to the **Judge LLM** input.
+4. Configure the operation's parameters.
+The specific parameters depend on the selected operation.
+For example, if you select the **Filter** operation, you must define a filter condition using the **Column Name**, **Filter Value**, and **Filter Operator** parameters.
+For more information, see [DataFrame Operations parameters](#dataframe-operations-parameters)
 
-3. Connect **Chat Input** and **Chat Output** components to the **LLM Router**.
-The flow looks like this:
+5. To test the flow, click <Icon name="Play" aria-hidden="true" /> **Run component** on the **DataFrame Operations** component, and then click <Icon name="TextSearch" aria-hidden="true" /> **Inspect output** to view the new `DataFrame` created from the **Filter** operation.
+
+   If you want to view the output in the **Playground**, connect the **DataFrame Operations** component's output to a **Chat Output** component, rerun the **DataFrame Operations** component, and then click **Playground**.
+
+For another example, see [Conditional looping](/components-logic#conditional-looping).
+
+### DataFrame Operations parameters
+
+Most **DataFrame Operations** parameters are conditional because they only apply to specific operations.
+
+The only permanent parameters are **DataFrame** (`df`), which is the `DataFrame` input, and **Operation** (`operation`), which is the operation to perform on the `DataFrame`.
+Once you select an operation, the conditional parameters for that operation appear on the **DataFrame Operations** component.
+
+<Tabs>
+<TabItem value="addcolumn" label="Add Column" default>
+
+The **Add Column** operation allows you to add a new column to the `DataFrame` with a constant value.
+
+The parameters are **New Column Name** (`new_column_name`) and **New Column Value** (`new_column_value`).
+
+</TabItem>
+<TabItem value="dropcolumn" label="Drop Column">
+
+The **Drop Column** operation allows you to remove a column from the `DataFrame`, specified by **Column Name** (`column_name`).
+
+</TabItem>
+<TabItem value="filter" label="Filter">
+
+The **Filter** operation allows you to filter the `DataFrame` based on a specified condition.
+The output is a `DataFrame` containing only the rows that matched the filter condition.
+
+Provide the following parameters:
+
+* **Column Name** (`column_name`): The name of the column to filter on.
+* **Filter Value** (`filter_value`): The value to filter on.
+* **Filter Operator** (`filter_operator`): The operator to use for filtering, one of `equals` (default), `not equals`, `contains`, `starts with`, `ends with`, `greater than`, or `less than`.
+
+</TabItem>
+<TabItem value="head" label="Head">
+
+The **Head** operation allows you to retrieve the first `n` rows of the `DataFrame`, where `n` is set in **Number of Rows** (`num_rows`).
+The default is `5`.
+
+The output is a `DataFrame` containing only the selected rows.
+
+</TabItem>
+<TabItem value="renamecolumn" label="Rename Column">
+
+The **Rename Column** operation allows you to rename an existing column in the `DataFrame`.
+
+The parameters are **Column Name** (`column_name`), which is the current name, and **New Column Name** (`new_column_name`).
+
+</TabItem>
+<TabItem value="replacevalue" label="Replace Value">
+
+The **Replace Value** operation allows you to replace values in a specific column of the `DataFrame`.
+This operation replaces a target value with a new value.
+All cells matching the target value are replaced with the new value in the new `DataFrame` output.
+
+Provide the following parameters:
+
+* **Column Name** (`column_name`): The name of the column to modify.
+* **Value to Replace** (`replace_value`): The value that you want to replace.
+* **Replacement Value** (`replacement_value`): The new value to use.
+
+</TabItem>
+<TabItem value="selectcolumns" label="Select Columns">
+
+The **Select Columns** operation allows you to select one or more specific columns from the `DataFrame`.
+
+Provide a list of column names in **Columns to Select** (`columns_to_select`).
+In the visual editor, click <Icon name="Plus" aria-hidden="true"/> **Add More** to add multiple fields, and then enter one column name in each field.
+
+The output is a `DataFrame` containing only the specified columns.
+
+</TabItem>
+<TabItem value="sort" label="Sort">
+
+The **Sort** operation allows you to sort the `DataFrame` on a specific column in ascending or descending order.
+
+Provide the following parameters:
+
+* **Column Name** (`column_name`): The name of the column to sort on.
+* **Sort Ascending** (`ascending`): Whether to sort in ascending or descending order. If enabled (true), sorts in ascending order; if disabled (false), sorts in descending order. Default: Enabled (true)
+
+</TabItem>
+<TabItem value="tail" label="Tail">
+
+The **Tail** operation allows you to retrieve the last `n` rows of the `DataFrame`, where `n` is set in **Number of Rows** (`num_rows`).
+The default is `5`.
+
+The output is a `DataFrame` containing only the selected rows.
+
+</TabItem>
+<TabItem value="dropduplicates" label="Drop Duplicates">
+
+The **Drop Duplicates** operation removes rows from the `DataFrame` by identifying all duplicate values within a single column.
+
+The only parameter is the **Column Name** (`column_name`).
+
+When the flow runs, all rows with duplicate values in the given column are removed.
+The output is a `DataFrame` containing all columns from the original `DataFrame`, but only rows with non-duplicate values.
+
+</TabItem>
+</Tabs>
+
+## LLM Router
+
+The **LLM Router** component routes requests to the most appropriate LLM based on [OpenRouter](https://openrouter.ai/docs/quickstart) model specifications.
+
+To use the component in a flow, you connect multiple **Language Model** components to the **LLM Router** components.
+One model is the judge LLM that analyzes input messages to understand the evaluation context, selects the most appropriate model from the other attached LLMs, and then routes the input to the selected model.
+The selected model processes the input, and then returns the generated response.
+
+The following example flow has three **Language Model** components.
+One is the judge LLM, and the other two are in the LLM pool for request routing.
+The **Chat Input** and **Chat Output** components create a seamless chat interaction where you send a message and receive a response without any user awareness of the underlying routing.
 
 ![LLM Router component](/img/component-llm-router.png)
 
-4. In the **LLM Router** component, set your **Optimization** preference:
-   - **Quality**: Prioritizes the highest quality response.
-   - **Speed**: Prioritizes the fastest response time.
-   - **Cost**: Prioritizes the most cost-effective option.
-   - **Balanced**: Strikes a balance between quality, speed, and cost.
+### LLM Router parameters
 
-5. Run the flow.
-Your input is the task that the LLM router evaluates the models against, such as `Write a story about horses` or `How do I parse data objects out of JSON?`.
-6. In the **LLM Router** component, select the **Model Selection Decision** output to view the router's reasoning.
+Some **LLM Router** component input parameters are hidden by default in the visual editor.
+You can toggle parameters through the <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls** in the [component's header menu](/concepts-components#component-menus).
+
+| Name | Display Name | Info |
+|------|--------------|------|
+| `models` | **Language Models** | Input parameter. Connect [`LanguageModel`](/data-types#languagemodel) output from multiple [**Language Model** components](/components-models) to create a pool of models. The `judge_llm` selects models from this pool when routing requests. The first model you connect is the default model if there is a problem with model selection or routing. |
+| `input_value` | **Input** | Input parameter. The incoming query to be routed to the model selected by the judge LLM. |
+| `judge_llm` | **Judge LLM** | Input parameter. Connect `LanguageModel` output from _one_ **Language Model** component to serve as the judge LLM for request routing. |
+| `optimization` | **Optimization** | Input parameter. Set a preferred characteristic for model selection by the judge LLM. The options are `quality` (highest response quality), `speed` (fastest response time), `cost` (most cost-effective model), or `balanced` (equal weight for quality, speed, and cost). Default: `balanced` |
+| `use_openrouter_specs` | **Use OpenRouter Specs** | Input parameter. Whether to fetch model specifications from the OpenRouter API.
+If false, only the model name is provided to the judge LLM. Default: Enabled (true) |
+| `timeout` | **API Timeout** | Input parameter. Set a timeout duration in seconds for API requests made by the router. Default: `10` |
+| `fallback_to_first` | **Fallback to First Model** | Input parameter. Whether to use the first LLM in `models` as a backup if routing fails to reach the selected model. Default: Enabled (true) |
+
+### LLM Router outputs
+
+The **LLM Router** component provides three output options.
+You can set the desired output type near the component's output port.
+
+* **Output**: A `Message` containing the response to the original query as generated by the selected LLM.
+Use this output for regular chat interactions.
+
+* **Selected Model Info**: A `Data` object containing information about the selected model, such as its name and version.
+
+* **Routing Decision**: A `Message` containing the judge model's reasoning for selecting a particular model, including input query length and number of models considered.
+For example:
 
     ```text
     Model Selection Decision:
@@ -292,51 +418,67 @@ Your input is the task that the LLM router evaluates the models against, such as
     - Specifications Source: OpenRouter API
     ```
 
+    This is useful for debugging if you feel the judge model isn't selecting the best model.
+
+## Parser {#parser}
+
+The **Parser** component extracts text from structured data (`DataFrame` or `Data`) using a template or direct stringification.
+The output is a `Message` containing the parsed text.
+
+This is a versatile component for data extraction and manipulation in your flows.
+For examples of **Parser** components in flows, see the following:
+
+* [**Batch Run** component](#batch-run)
+* [**Structured Output** component](#structured-output)
+* **Financial Report Parser** template
+* [**Vector Store** components](/components-vector-stores)
+* [Trigger flows with webhooks](/webhook)
+* [Create a vector RAG chatbot](/chat-with-rag)
+
+![A flow that uses a Parser component to extract text from a Structured Output component.](/img/component-parser.png)
+
+### Parsing modes
+
+The **Parser** component has two modes: **Parser** and **Stringify**.
+
+<Tabs>
+<TabItem value="template" label="Parser (template) mode" default>
+
+In **Parser** mode, you create a template for text output that can include literal strings and variables for extracted keys.
+
+Use curly braces to define variables anywhere in the template.
+Variables must match keys in the `DataFrame` or `Data` input, such as column names.
+For example, `{name}` extracts the value of a `name` key.
+For more information about the content and structure of `DataFrame` and `Data` objects, see [Langflow data types](/data-types).
+
+When the flow runs, the **Parser** component iterates over the input, producing a `Message` for each parsed item.
+For example, parsing a `DataFrame` creates a `Message` for each row, populated with the unique values from that row.
+
 <details>
-<summary>Parameters</summary>
+<summary>Employee summary template</summary>
 
-**Inputs**
+This example template extracts employee data into a natural language summary about an employee's hire date and current role:
 
-| Name | Display Name | Info |
-|------|--------------|------|
-| models | Language Models | A list of LLMs to route between. |
-| input_value | Input | The input message to be routed. |
-| judge_llm | Judge LLM | The LLM that evaluates and selects the most appropriate model. |
-| optimization | Optimization | The optimization preference between quality, speed, cost, or balanced. |
+```text
+{employee_first_name} {employee_last_name} was hired on {start_date}.
+Their current position is {job_title} ({grade}).
+```
 
-**Outputs**
+The resulting `Message` output replaces the variables with the corresponding extracted values.
+For example:
 
-| Name | Display Name | Info |
-|------|--------------|------|
-| output | Output | The response from the selected model. |
-| selected_model | Selected Model | The name of the chosen model. |
+```text
+Renlo Kai was hired on 11-July-2017.
+Their current position is Software Engineer (Principal).
+```
 
 </details>
 
-## Parser
+<details>
+<summary>Employee profile template</summary>
 
-This component formats `DataFrame` or `Data` objects into text using templates, with an option to convert inputs directly to strings using `stringify`.
+This example template uses Markdown syntax and extracted employee data to create an employee profile:
 
-To use this component, create variables for values in the `template` the same way you would in a [**Prompt Template** component](/components-prompts). For `DataFrames`, use column names, for example `Name: {Name}`. For `Data` objects, use `{text}`.
-
-To use the **Parser** component with a **Structured Output** component, do the following:
-
-1. Connect a **Structured Output** component's **DataFrame** output to the **Parser** component's **DataFrame** input.
-2. Connect the **File** component to the **Structured Output** component's **Message** input.
-3. Connect the **OpenAI** component's **Language Model** output to the **Structured Output** component's **Language Model** input.
-
-The flow looks like this:
-
-![A Parser component connected to OpenAI and Structured Output components](/img/component-parser.png)
-
-4. In the **Structured Output** component, click **Open Table**.
-This opens a pane for structuring your table.
-The table contains the rows **Name**, **Description**, **Type**, and **Multiple**.
-5. Create a table that maps to the data you're loading from the **File** loader.
-For example, to create a table for employees, you might have the rows `id`, `name`, and `email`, all of type `string`.
-6. In the **Template** field of the **Parser** component, enter a template for parsing the **Structured Output** component's DataFrame output into structured text.
-Create variables for values in the `template` using curly braces.
-For example, to present a table of employees in Markdown:
 ```text
 # Employee Profile
 ## Personal Information
@@ -344,33 +486,72 @@ For example, to present a table of employees in Markdown:
 - **ID:** {id}
 - **Email:** {email}
 ```
-7. To run the flow, in the **Parser** component, click <Icon name="Play" aria-hidden="true"/> **Run component**.
-8. To view your parsed text, in the **Parser** component, click <Icon name="TextSearch" aria-hidden="true"/> **Inspect output**.
-9. Optionally, connect a **Chat Output** component, and open the **Playground** to see the output.
 
-For an additional example of using the **Parser** component to format a DataFrame from a **Structured Output** component, see the **Market Research** template flow.
-
-<details>
-<summary>Parameters</summary>
-
-**Inputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| mode | Mode | The tab selection between "Parser" and "Stringify" modes. "Stringify" converts input to a string instead of using a template. |
-| pattern | Template | The template for formatting using variables in curly brackets. For DataFrames, use column names, such as `Name: {Name}`. For Data objects, use `{text}`. |
-| input_data | Data or DataFrame | The input to parse. Accepts either a DataFrame or Data object. |
-| sep | Separator | The string used to separate rows or items. The default is a newline. |
-| clean_data | Clean Data | When stringify is enabled, this option cleans data by removing empty rows and lines. |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| parsed_text | Parsed Text | The resulting formatted text as a [Message](/data-types#message) object. |
+When the flow runs, the **Parser** component iterates over each row of the `DataFrame`, populating the template's variables with the appropriate extracted values.
+The resulting text for each row is output as a [`Message`](/data-types#message).
 
 </details>
 
+The following parameters are available in **Parser** mode.
+To view and edit all available parameters, click <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls** in the [component's header menu](/concepts-components#component-menus).
+
+| Name | Display Name | Info |
+|------|--------------|------|
+| input_data | Data or DataFrame | Input parameter. The `Data` or `DataFrame` input to parse. |
+| pattern | Template | Input parameter. The formatting template using plaintext and variables for keys (`{KEY_NAME}`). See the preceding examples for more information. |
+| sep | Separator | Input parameter. A string defining the separator for rows or lines. Default: `\n` (new line). |
+| clean_data | Clean Data | Whether to remove empty rows and lines in each cell or key of the `DataFrame` or `Data` input. Default: Enabled (true) |
+
+</TabItem>
+<TabItem value="stringify" label="Stringify mode">
+
+Use **Stringify** mode to convert the entire input directly to text.
+This mode doesn't support templates or key selection.
+
+The following parameters are available in **Stringify** mode.
+To view and edit all available parameters, click <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls** in the [component's header menu](/concepts-components#component-menus).
+
+| Name | Display Name | Info |
+|------|--------------|------|
+| input_data | Data or DataFrame | Input parameter. The `Data` or `DataFrame` input to parse. |
+| sep | Separator | Input parameter. A string defining the separator for rows or lines. Default: `\n` (new line). |
+| clean_data | Clean Data | Whether to remove empty rows and lines in each cell or key of the `DataFrame` or `Data` input. Default: Enabled (true) |
+
+</TabItem>
+</Tabs>
+
+### Test and troubleshoot parsed text
+
+To test the **Parser** component, click <Icon name="Play" aria-hidden="true"/> **Run component**, and then click <Icon name="TextSearch" aria-hidden="true"/> **Inspect output** to see the `Message` output with the parsed text.
+You can also connect a **Chat Output** component if you want to view the output in the **Playground**.
+
+If the `Message` output from the **Parser** component has empty or unexpected values, there might be a mapping error between the input and the parsing mode, the input has empty values, or the input isn't suitable for plaintext extraction.
+
+For example, assume you use the following template to parse a `DataFrame`:
+
+```text
+{employee_first_name} {employee_last_name} is a {job_title} ({grade}).
+```
+
+The following `Message` could result from parsing a row where `employee_first_name` was empty and `grade` was `null`:
+
+```text
+ Smith is a Software Engineer (null).
+```
+
+To troubleshoot missing or unexpected values, you can do the following:
+
+* Make sure the variables in your template map to keys in the incoming `Data` or `DataFrame`.
+To see the data being passed directly to the **Parser** component, click <Icon name="TextSearch" aria-hidden="true"/> **Inspect output** on the component that is sending data to the **Parser** component.
+
+* Check the source data for missing or incorrect values.
+There are several ways you can address these inconsistencies:
+
+    * Rectify the source data directly.
+    * Use other components to amend or filter anomalies before passing the data to the **Parser** component.
+    There are many components you can use for this depending on your goal, such as the **Data Operations**, **Structured Output**, and **Smart Function** components.
+    * Enable the **Parser** component's **Clean Data** parameter to skip empty rows or lines.
+
 ## Python Interpreter
 
 This component allows you to execute Python code with imported packages.
@@ -446,322 +627,378 @@ If you don't include the package imports in the chat, the agent can still create
 | python_code | Code | Input parameter. The Python code to execute. Only modules specified in Global Imports can be used. |
 | results | Data | Output parameter. The output of the executed Python code, including any printed results or errors. |
 
-## Save to File
+## Save File
 
-This component saves `DataFrame`, `Data`, or `Message` [data types](/data-types) to various file formats.
+The **Save File** component creates a file containing data produced by another component.
+Several file formats are supported, and you can store files in [Langflow storage](/memory) or the local file system.
 
-1. To use this component in a flow, connect a component that outputs [DataFrames, Data, or Messages](/data-types#data) to the **Save to File** component's input.
-The following example connects a **Webhook** component to two **Save to File** components to demonstrate the different outputs.
+To configure the **Save File** component and use it in a flow, do the following:
 
-![Two Save-to File components connected to a Webhook component](/img/component-save-to-file.png)
+1. Connect [`DataFrame`](/data-types#dataframe), [`Data`](/data-types#data), or [`Message`](/data-types#message) output from another component to the **Save File** component's **Input** port.
 
-2. In the **Save to File** component's **Input Type** field, select the expected input type.
-This example expects **Data** from the **Webhook**.
-3. In the **File Format** field, select the file type for your saved file.
-This example uses `.md` in one **Save to File** component, and `.xlsx` in another.
-4. In the **File Path** field, enter the path for your saved file.
-This example uses `./output/employees.xlsx` and `./output/employees.md` to save the files in a directory relative to where Langflow is running.
-The component accepts both relative and absolute paths, and creates any necessary directories if they don't exist.
-:::tip
-If the `file_format` and `file_path` extension don't align, the component appends the specified format to the file.
-For example, if the `file_format` is `csv`, and the `file_path` is `./output/test.txt`, then the file is saved as `./output/test.txt.csv` so the file isn't corrupted.
-:::
-5. Send a POST request to the **Webhook** containing your JSON data.
-Replace `YOUR_FLOW_ID` with your flow ID.
-This example uses the default Langflow server address.
-```text
-curl -X POST "http://127.0.0.1:7860/api/v1/webhook/YOUR_FLOW_ID" \
--H 'Content-Type: application/json' \
--H 'x-api-key: LANGFLOW_API_KEY' \
--d '{
-    "Name": ["Alex Cruz", "Kalani Smith", "Noam Johnson"],
-    "Role": ["Developer", "Designer", "Manager"],
-    "Department": ["Engineering", "Design", "Management"]
-}'
-```
-6. In your local filesystem, open the `outputs` directory.
-You should see two files created from the data you've sent: one in `.xlsx` for structured spreadsheets, and one in Markdown.
-```text
-| Name         | Role      | Department   |
-|:-------------|:----------|:-------------|
-| Alex Cruz    | Developer | Engineering  |
-| Kalani Smith | Designer  | Design       |
-| Noam Johnson | Manager   | Management   |
-```
+    You can connect the same output to multiple **Save File** components if you want to create multiple files, save the data in different file formats, or save files to multiple locations.
 
-### File input format options
+2. In **File Name**, enter a file name and an optional path.
 
-For `DataFrame` and `Data` inputs, the component can create:
-  - `csv`
-  - `excel`
-  - `json`
-  - `markdown`
-  - `pdf`
+    The **File Name** parameter controls where the file is saved.
+    It can contain a file name or an entire file path:
 
-For `Message` inputs, the component can create:
-  - `txt`
-  - `json`
-  - `markdown`
-  - `pdf`
+    * **Default location**: If you only provide a file name, then the file is stored in `.langflow/data`.
 
-<details>
-<summary>Parameters</summary>
+    * **Subdirectory**: To store files in subdirectories, add the path to the **File Name** parameter.
+    For example, `subdirectory/my_file` creates `my_file` in `.langflow/data/subdirectory`.
+    If a given subdirectory doesn't already exist, Langflow automatically creates it.
 
-**Inputs**
+    * **Absolute or relative path**: To store files elsewhere in your `.langflow` installation or the local file system, provide the absolute or relative path to the desired location.
+    For example, `~/Desktop/my_file` saves `my_file` to the desktop.
 
-| Name | Display Name | Info |
-|------|--------------|------|
-| input_text | Input Text | The text to analyze and extract patterns from. |
-| pattern | Regex Pattern | The regular expression pattern to match in the text. |
-| input_type | Input Type | The type of input to save. |
-| df | DataFrame | The DataFrame to save. |
-| data | Data | The Data object to save. |
-| message | Message | The Message to save. |
-| file_format | File Format | The file format to save the input in. |
-| file_path | File Path | The full file path including filename and extension. |
+    Don't include an extension in the file name.
+    If you do, the extension is treated as part of the file name; it has no impact on the **File Format** parameter.
 
-**Outputs**
+3. In the [component's header menu](/concepts-components#component-menus), click <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls**, select the desired file format, and then click **Close**.
 
-| Name | Display Name | Info |
-|------|--------------|------|
-| data | Data | A list of extracted matches as Data objects. |
-| text | Message | The extracted matches formatted as a Message object. |
-| confirmation | Confirmation | The confirmation message after saving the file. |
+    The available **File Format** options depend on the input data type:
 
-</details>
+    * `DataFrame` can be saved to CSV (default), Excel (requires `openpyxl` [custom dependency](/install-custom-dependencies)), JSON (fallback default), or Markdown.
+
+    * `Data` can be saved to CSV, Excel (requires `openpyxl` [custom dependency](/install-custom-dependencies)), JSON (default), or Markdown.
+
+    * `Message` can be saved to TXT, JSON (default), or Markdown.
+
+    :::important Overwrites allowed
+    If you have multiple **Save File** components, in one or more flows, with the same file name, path, and extension, the file contains the data from the most recent run only.
+    Langflow doesn't block overwrites if a matching file already exists.
+    To avoid unintended overwrites, use unique file names and paths.
+    :::
+
+4. To test the **Save File** component, click <Icon name="Play" aria-hidden="True" /> **Run component**, and then click <Icon name="TextSearch" aria-hidden="True" /> **Inspect output** to get the filepath where the file was saved.
+
+    The component's literal output is a `Message` containing the original data type, the file name and extension, and the absolute filepath to the file based on the **File Name** parameter.
+    For example:
+
+    ```text
+    DataFrame saved successfully as 'my_file.csv' at /Users/user.name/.langflow/data/my_file.csv
+    ```
+
+    If the **File Name** contains a subdirectory or other non-default path, this is reflected in the `Message` output.
+    For example, a CSV file with the file name `~/Desktop/my_file` could produce the following output:
+
+    ```text
+    DataFrame saved successfully as '/Users/user.name/Desktop/my_file.csv' at /Users/user.name/Desktop/my_file.csv
+    ```
+
+
+5. Optional: If you want to use the saved file in a flow, you must use an API call or another component to retrieve the file from the given filepath.
 
 ## Smart Function
 
 In Langflow version 1.5, this component was renamed from **Lambda Filter** to **Smart Function**.
 
-This component uses an LLM to generate a function for filtering or transforming structured data.
+The **Smart Function** component uses an LLM to generate a Lambda function to filter or transform structured data based on natural language instructions.
+You must connect this component to a [**Language Model** component](/components-models), which is used to generate a function based on the natural language instructions you provide in the **Instructions** parameter.
+The LLM runs the function against the data input, and then outputs the results as [`Data`](/data-types#data).
 
-To use the **Smart Function** component, you must connect it to a [**Language Model** component](/components-models), which the **Smart Filter** component uses to generate a function based on the natural language instructions in the **Instructions** field.
+:::tip
+Provide brief, clear instructions, focusing on the desired outcome or specific actions, such as `Filter the data to only include items where the 'status' is 'active'`.
+One sentence or less is preferred because end punctuation, like periods, can cause errors or unexpected behavior.
 
-This example gets JSON data from the `https://jsonplaceholder.typicode.com/users` API endpoint.
-The **Instructions** field in the **Smart Function** component specifies the task `extract emails`.
-The connected LLM creates a filter based on the instructions, and successfully extracts a list of email addresses from the JSON data.
+If you need to provide more details instructions that aren't directly relevant to the Lambda function, you can input them in the **Language Model** component's **Input** field or through a **Prompt Template** component.
+:::
 
-![Smart function connected to an LLM](/img/component-lambda-filter.png)
+The following example uses the **API Request** endpoint to pass JSON data from the `https://jsonplaceholder.typicode.com/users` endpoint to the **Smart Function** component.
+Then, the **Smart Function** component passes the data and the instruction `extract emails` to the attached **Language Model** component.
+From there, the LLM generates a filter function that extracts email addresses from the JSON data, returning the filtered data as chat output.
 
-<details>
-<summary>Parameters</summary>
+![A small flow using a Smart Function component to extract data from an API response.](/img/component-lambda-filter.png)
 
-**Inputs**
+### Smart Function parameters
+
+Some **Smart Function** component input parameters are hidden by default in the visual editor.
+You can toggle parameters through the <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls** in the [component's header menu](/concepts-components#component-menus).
 
 | Name | Display Name | Info |
 |------|--------------|------|
-| data | Data | The structured data to filter or transform using a Lambda function. |
-| llm | Language Model | The connection port for a **Language Model** component. |
-| filter_instruction | Instructions | The natural language instructions for how to filter or transform the data using a Lambda function, such as `Filter the data to only include items where the 'status' is 'active'`. |
-| sample_size | Sample Size | For large datasets, the number of characters to sample from the dataset head and tail. |
-| max_size | Max Size | The number of characters for the data to be considered "large", which triggers sampling by the `sample_size` value. |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| filtered_data | Filtered Data | The filtered or transformed `Data` object. |
-| dataframe | DataFrame | The filtered data as a `DataFrame`. |
-
-</details>
+| data | Data | Input parameter. The structured data to filter or transform using a Lambda function. |
+| llm | Language Model | Input parameter. Connect [`LanguageModel`](/data-types#languagemodel) output from a **Language Model** component. |
+| filter_instruction | Instructions | Input parameter. The natural language instructions for how to filter or transform the data. The LLM uses these instructions to create a Lambda function. |
+| sample_size | Sample Size | Input parameter. For large datasets, the number of characters to sample from the dataset head and tail. Only applied if the dataset meets or exceeds `max_size`. Default: `1000`. |
+| max_size | Max Size | Input parameter. The number of characters for the dataset to be considered large, which triggers sampling by the `sample_size` value. Default: `30000`. |
 
 ## Split Text
 
-This component splits text into chunks based on specified criteria. It's ideal for chunking data to be tokenized and embedded into vector databases.
+The **Split Text** component splits data into chunks based on parameters like chunk size and separator.
+It is often used to chunk data to be tokenized and embedded into vector databases.
+For examples, see [Use Vector Store components in a flow](/components-vector-stores#use-vector-store-components-in-a-flow), [Use Embedding Model components in a flow](/components-embedding-models#use-embedding-model-components-in-a-flow), and [Create a Vector RAG chatbot](/chat-with-rag).
 
-The **Split Text** component outputs **Chunks** or **DataFrame**.
-The **Chunks** output returns a list of individual text chunks.
-The **DataFrame** output returns a structured data format, with additional `text` and `metadata` columns applied.
+![An embedding generation flow that uses a Split Text component to chunk data.](/img/component-split-text.png)
 
-1. To use this component in a flow, connect a component that outputs [Data or DataFrame](/data-types#data) to the **Split Text** component's **Data** port.
-This example uses the **URL** component, which is fetching JSON placeholder data.
+The component accepts `Message`, `Data`, or `DataFrame`, and then outputs either **Chunks** or **DataFrame**.
+The **Chunks** output returns a list of [`Data`](/data-types#data) objects containing individual text chunks.
+The **DataFrame** output returns the list of chunks as a structured [`DataFrame`](/data-types#dataframe) with additional `text` and `metadata` columns.
 
-![Split Text and Chroma DB components](/img/component-split-text.png)
+### Split Text parameters
 
-2. In the **Split Text** component, define your data splitting parameters.
+The **Split Text** component's parameters control how the text is split into chunks, specifically the `chunk_size`, `chunk_overlap`, and `separator` parameters.
 
-This example splits incoming JSON data at the separator `},`, so each chunk contains one JSON object.
+To test the chunking behavior, add a **Text Input** or **File** component with some sample data to chunk, click <Icon name="Play" aria-hidden="True" /> **Run component** on the **Split Text** component, and then click <Icon name="TextSearch" aria-hidden="True" /> **Inspect output** to view the list of chunks and their metadata. The **text** column contains the actual text chunks created from your chunking settings.
+If the chunks aren't split as you expect, adjust the parameters, rerun the component, and then inspect the new output.
 
-The order of precedence is **Separator**, then **Chunk Size**, and then **Chunk Overlap**.
-If any segment after separator splitting is longer than `chunk_size`, it is split again to fit within `chunk_size`.
-
-After `chunk_size`, **Chunk Overlap** is applied between chunks to maintain context.
-
-3. Connect a **Chat Output** component to the **Split Text** component's **DataFrame** output to view its output.
-4. Click **Playground**, and then click **Run Flow**.
-The output contains a table of JSON objects split at `},`.
-```text
-{
-"userId": 1,
-"id": 1,
-"title": "Introduction to Artificial Intelligence",
-"body": "Learn the basics of Artificial Intelligence and its applications in various industries.",
-"link": "https://example.com/article1",
-"comment_count": 8
-},
-{
-"userId": 2,
-"id": 2,
-"title": "Web Development with React",
-"body": "Build modern web applications using React.js and explore its powerful features.",
-"link": "https://example.com/article2",
-"comment_count": 12
-},
-```
-5. Clear the **Separator** field, and then run the flow again.
-Instead of JSON objects, the output contains 50-character lines of text with 10 characters of overlap.
-```text
-First chunk:  "title": "Introduction to Artificial Intelligence""
-Second chunk: "elligence", "body": "Learn the basics of Artif"
-Third chunk:  "s of Artificial Intelligence and its applications"
-```
-
-<details>
-<summary>Parameters</summary>
-
-**Inputs**
+Some **Split Text** component input parameters are hidden by default in the visual editor.
+You can toggle parameters through the <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls** in the [component's header menu](/concepts-components#component-menus).
 
 | Name | Display Name | Info |
 |------|--------------|------|
-| data_inputs | Input Documents | The data to split. The component accepts [Data](/data-types#data) or [DataFrame](/data-types#dataframe) objects. |
-| chunk_overlap | Chunk Overlap | The number of characters to overlap between chunks. Default: `200`. |
-| chunk_size | Chunk Size | The maximum number of characters in each chunk. Default: `1000`. |
-| separator | Separator | The character to split on. Default: `newline`. |
-| text_key | Text Key | The key to use for the text column. Default: `text`. |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| chunks | Chunks | A list of split text chunks as [Data](/data-types#data) objects. |
-| dataframe | DataFrame | A list of split text chunks as [DataFrame](/data-types#dataframe) objects. |
-
-</details>
+| data_inputs | Input | Input parameter. The data to split. Input must be in `Message`, `Data`, or `DataFrame` format. |
+| chunk_overlap | Chunk Overlap | Input parameter. The number of characters to overlap between chunks. This helps maintain context across chunks. When a separator is encountered, the overlap is applied at the point of the separator so that the subsequent chunk contains the last _n_ characters of the preceding chunk. Default: `200`. |
+| chunk_size | Chunk Size | Input parameter. The target length for each chunk after splitting. The data is first split by separator, and then chunks smaller than the `chunk_size` are merged up to this limit. However, if the initial separator split produces any chunks larger than the `chunk_size`, those chunks are neither further subdivided nor combined with any smaller chunks; these chunks will be output as-is even though they exceed the the `chunk_size`. Default: `1000`. |
+| separator | Separator | Input parameter. A string defining a character to split on, such as `\n` to split on new line characters, `\n\n` to split at paragraph breaks, or `},` to split at the end of JSON objects. You can directly provide the separator string, or pass a separator string from another component as `Message` input. |
+| text_key | Text Key | Input parameter. The key to use for the text column that is extracted from the input and then split. Default: `text`. |
+| keep_separator | Keep Separator | Input parameter. Select how to handle separators in output chunks. If False, separators are omitted from output chunks. Options include `False` (remove separators), `True` (keep separators in chunks without preference for placement), `Start` (place separators at the beginning of chunks), or `End` (place separators at the end of chunks). Default: `False`. |
 
 ### Other text splitters
 
 See [LangChain text splitter components](/bundles-langchain#text-splitters).
 
-## Structured output
+## Structured Output
 
-This component transforms LLM responses into structured data formats.
+The **Structured Output** component uses an LLM to transform any input into structured data (`Data` or `DataFrame`) using natural language formatting instructions and an output schema definition.
+For example, you can extract specific details from documents, like email messages or scientific papers.
 
-In this example from the **Financial Support Parser** template, the **Structured Output** component transforms unstructured financial reports into structured data.
+### Use the Structured Output component in a flow
 
-![Structured output example](/img/component-structured-output.png)
+To use the **Structured Output** component in a flow, do the following:
 
-The connected LLM model is prompted by the **Structured Output** component's `Format Instructions` parameter to extract structured output from the unstructured text. `Format Instructions` is utilized as the system prompt for the **Structured Output** component.
+1. Provide an **Input Message**, which is the source material from which you want to extract structured data.
+This can come from practically any component, but it is typically a **Chat Input**, **File**, or other component that provides some unstructured or semi-structured input.
 
-In the **Structured Output** component, click the **Open table** button to view the `Output Schema` table.
-The `Output Schema` parameter defines the structure and data types for the model's output using a table with the following fields:
+    :::tip
+    Not all source material has to become structured output.
+    The power of the **Structured Output** component is that you can specify the information you want to extract, even if that data isn't explicitly labeled or an exact keyword match.
+    Then, the LLM can use your instructions to analyze the source material, extract the relevant data, and format it according to your specifications.
+    Any irrelevant source material isn't included in the structured output.
+    :::
 
-* **Name**: The name of the output field.
-* **Description**: The purpose of the output field.
-* **Type**: The data type of the output field. The available types are `str`, `int`, `float`, `bool`, `list`, or `dict`. The default is `text`.
-* **Multiple (deprecated)**: Always true to allow multiple output values for a single field.
+2. Define **Format Instructions** and an **Output Schema** to specify the data to extract from the source material and how to structure it in the final `Data` or `DataFrame` output.
 
-The **Parse DataFrame** component parses the structured output into a template for orderly presentation in chat output. The template receives the values from the `output_schema` table with curly braces.
+    The instructions are a prompt that tell the LLM what data to extract, how to format it, how to handle exceptions, and any other instructions relevant to preparing the structured data.
 
-For example, the template `EBITDA: {EBITDA}  ,  Net Income: {NET_INCOME} , GROSS_PROFIT: {GROSS_PROFIT}` presents the extracted values in the **Playground** as `EBITDA: 900 million , Net Income: 500 million , GROSS_PROFIT: 1.2 billion`.
+    The schema is a table that defines the fields (keys) and data types to organize the data extracted by the LLM into a structured `Data` or `DataFrame` object.
+    For more information, see [Output Schema options](#output-schema-options)
+
+3. Attach a [**Language Model** component](/components-models) that is set to emit [`LanguageModel`](/data-types#languagemodel) output.
+
+    The **Language Model** component uses the **Input Message** and **Format Instructions** from the **Structured Output** component to extract specific pieces of data from the input text.
+    The output schema is applied to the model's response to produce the final `Data` or `DataFrame` structured object.
+
+4. Optional: Typically, the structured output is passed to downstream components that use the extracted data for other processes, such as other **Processing** components like the **Parser** or **Data Operations** components.
+
+![A basic flow with Structured Output, Language Model, Type Convert, and Chat Input and Output components.](/img/component-structured-output.png)
 
 <details>
-<summary>Parameters</summary>
+<summary>Structured Output example: Financial Report Parser template</summary>
 
-**Inputs**
+The **Financial Report Parser** template provides an example of how the **Structured Output** component can be used to extract structured data from unstructured text.
 
-| Name | Type | Description |
-|------|------|-------------|
-| llm | LanguageModel | The language model to use to generate the structured output. |
-| input_value | String | The input message to the language model. |
-| system_prompt | String | The instructions to the language model for formatting the output. |
-| schema_name | String | The name for the output data schema. |
-| output_schema | Table | The structure and data types for the model's output. |
-| multiple | Boolean | [Deprecated] Always true. |
+The template's **Structured Output** component has the following configuration:
 
-**Outputs**
+* The **Input Message** comes from a **Chat Input** component that is preloaded with quotes from sample financial reports
 
-| Name | Type | Description |
-|------|------|-------------|
-| structured_output | Data | The structured output is a Data object based on the defined schema. |
+* The **Format Instructions** are as follows:
+
+    ```text
+    You are an AI that extracts structured JSON objects from unstructured text.
+    Use a predefined schema with expected types (str, int, float, bool, dict).
+    Extract ALL relevant instances that match the schema - if multiple patterns exist, capture them all.
+    Fill missing or ambiguous values with defaults: null for missing values.
+    Remove exact duplicates but keep variations that have different field values.
+    Always return valid JSON in the expected format, never throw errors.
+    If multiple objects can be extracted, return them all in the structured format.
+    ```
+
+* The **Output Schema** includes keys for `EBITDA`, `NET_INCOME`, and `GROSS_PROFIT`.
+
+The structured `Data` object is passed to a **Parser** component that produces a text string by mapping the schema keys to variables in the parsing template:
+
+```text
+EBITDA: {EBITDA}  ,  Net Income: {NET_INCOME} , GROSS_PROFIT: {GROSS_PROFIT}
+```
+
+When printed to the **Playground**, the resulting `Message` replaces the variables with the actual values extracted by the **Structured Output** component. For example:
+
+```text
+EBITDA: 900 million , Net Income: 500 million , GROSS_PROFIT: 1.2 billion
+```
 
 </details>
 
-## Type convert
+### Structured Output parameters
 
-This component converts data types between different formats. It can transform data between [`Data`](/data-types#data), [`DataFrame`](/data-types#dataframe), and [`Message`](/data-types#message) objects.
+Some **Structured Output** component input parameters are hidden by default in the visual editor.
+You can toggle parameters through the <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls** in the [component's header menu](/concepts-components#component-menus).
+
+| Name | Type | Description |
+|------|------|-------------|
+| Language Model (`llm`) | `LanguageModel` | Input parameter. The [`LanguageModel`](/data-types#languagemodel) output from a **Language Model** component that defines the LLM to use to analyze, extract, and prepare the structured output. |
+| Input Message (`input_value`) | String | Input parameter. The input message containing source material for extraction. |
+| Format Instructions (`system_prompt`) | String | Input parameter. The instructions to the language model for extracting and formatting the output. |
+| Schema Name (`schema_name`) | String | Input parameter. An optional title for the **Output Schema**. |
+| Output Schema (`output_schema`)| Table | Input parameter. A table describing the schema of the desired structured output, ultimately determining the content of the `Data` or `DataFrame` output. See [Output Schema options](#output-schema-options). |
+| Structured Output (`structured_output`) | `Data` or `DataFrame` | Output parameter. The final structured output produced by the component. Near the component's output port, you can select the output data type as either **Structured Output Data** or **Structured Output DataFrame**. The specific content and structure of the output depends on the input parameters. |
+
+#### Output Schema options {#output-schema-options}
+
+After the LLM extracts the relevant data from the **Input Message** and **Format Instructions**, the data is organized according to the **Output Schema**.
+
+The schema is a table that defines the fields (keys) and data types for the final `Data` or `DataFrame` output from the **Structured Output** component.
+
+The default schema is a single `field` string.
+
+To add a key to the schema, click <Icon name="Plus" aria-hidden="true"/> **Add a new row**, and then edit each column to define the schema:
+
+* **Name**: The name of the output field. Typically a specific key for which you want to extract a value.
+
+    You can reference these keys as variables in downstream components, such as a **Parser** component's template.
+    For example, the schema key `NET_INCOME` could be referenced by the variable `{NET_INCOME}`.
+
+* **Description**: An optional metadata description of the field's contents and purpose.
+
+* **Type**: The data type of the value stored in the field.
+Supported types are `str` (default), `int`, `float`, `bool`, and `dict`.
+
+* **As List**: Enable this setting if you want the field to contain a list of values rather than a single value.
+
+For simple schemas, you might only extract a few `string` or `int` fields.
+For more complex schemas with lists and dictionaries, it might help to refer to the `Data` and `DataFrame` structures and attributes, as described in [Langflow data types](/data-types).
+You can also emit a rough `Data` or `DataFrame`, and then use downstream components for further refinement, such as a **Data Operations** component.
+
+## Type Convert
+
+The **Type Convert** component converts data from one type to another.
+It supports `Data`, `DataFrame`, and `Message` data types.
+
+<Tabs>
+<TabItem value="data" label="Data" default>
+
+A `Data` object is a structured object that contains a primary `text` key and other key-value pairs:
+
+```json
+"data": {
+  "text": "User Profile",
+  "name": "Charlie Lastname",
+  "age": 28,
+  "email": "charlie.lastname@example.com"
+},
+```
+
+The larger context associated with a component's `data` dictionary also identifies which key is the primary `text_key`, and it can provide an optional default value if the primary key isn't specified.
+For example:
 
-* **Data**: A structured object that contains both text and metadata.
 ```json
 {
-  "text": "User Profile",
+  "text_key": "text",
   "data": {
-    "name": "John Smith",
-    "age": 30,
-    "email": "john@example.com"
-  }
+    "text": "User Profile",
+    "name": "Charlie Lastname",
+    "age": 28,
+    "email": "charlie.lastname@example.com"
+  },
+  "default_value": ""
 }
 ```
-* **DataFrame**: A tabular data structure with rows and columns.
-Keys are columns, and each dictionary (a collection of key-value pairs) in the list is a row.
+
+</TabItem>
+<TabItem value="dataframe" label="DataFrame">
+
+A `DataFrame` is an array that represents a tabular data structure with rows and columns.
+
+It consists of a list (array) of dictionary objects, where each dictionary represents a row.
+Each key in the dictionaries corresponds to a column name.
+For example, the following `DataFrame` contains two rows with columns for `name`, `age`, and `email`:
+
 ```json
 [
   {
-    "name": "John Smith",
-    "age": 30,
-    "email": "john@example.com"
+    "name": "Charlie Lastname",
+    "age": 28,
+    "email": "charlie.lastname@example.com"
   },
   {
-    "name": "Jane Doe",
+    "name": "Bobby Othername",
     "age": 25,
-    "email": "jane@example.com"
+    "email": "bobby.othername@example.com"
   }
 ]
 ```
-* **Message**: A string, such as`"Name: John Smith, Age: 30, Email: john@example.com"`.
 
-To use this component in a flow, do the following:
+</TabItem>
+<TabItem value="message" label="Message">
 
-1. Add the **Web Search** component to the **Basic Prompting** template. In the **Search Query** field, enter a query, such as `environmental news`.
-2. Connect the **Web Search** component's output to a component that accepts the `DataFrame` input.
-This example uses a **Prompt Template** component to give the chatbot context, so you must convert the **Web Search** component's `DataFrame` output to a `Message` type.
-3. Connect a **Type Convert** component to convert the `DataFrame` to a `Message`.
-4. In the **Type Convert** component, in the **Output Type** field, select **Message**.
+A `Message` is primarily for passing a `text` string, such as`"Name: Charlie Lastname, Age: 28, Email: charlie.lastname@example.com"`.
+However, the entire `Message` object can include metadata about the message, particularly when used as chat input or output.
 
-    ![Type convert web search output to chat](/img/component-type-convert-and-web-search.png)
+</TabItem>
+</Tabs>
 
-5. In the **Language Model** component, in the **OpenAI API Key** field, add your OpenAI API key.
-6. Click **Playground**, and then ask about `latest news`.
+For more information, see [Langflow data types](/data-types).
 
-The search results are returned to the **Playground** as a message.
+### Use the Type Convert component in a flow
 
-Result:
-```text
-Latest news
-AI
-gpt-4o-mini
-Here are some of the latest news articles related to the environment:
-Ozone Pollution and Global Warming: A recent study highlights that ozone pollution is a significant global environmental concern, threatening human health and crop production while exacerbating global warming. Read more
-...
-```
+The **Type Convert** component is typically used to transform data into a format required by a downstream component.
+For example, if a component outputs a `Message`, but the following component requires `Data`, then you can use the **Type Convert** component to reformat the `Message` as `Data` before passing it to the downstream component.
 
-<details>
-<summary>Parameters</summary>
+The following example uses the **Type Convert** component to convert the `DataFrame` output from a **Web Search** component into `Message` data that is passed as text input for an LLM:
 
-**Inputs**
+1. Create a flow based on the **Basic prompting** template.
+
+2. Add a **Web Search** component to the flow, and then enter a search query, such as `environmental news`.
+
+3. In the **Prompt Template** component, replace the contents of the **Template** field with the following text:
+
+    ```text
+    Answer the user's question using the {context}
+    ```
+
+    The curly braces define a [prompt variable](/components-prompts#define-variables-in-prompts) that becomes an input field on the **Prompt Template** component.
+    In this example, you will use the **context** field to pass the search results into the template, as explained in the next steps.
+
+3. Add a **Type Convert** component to the flow, and then set the **Output Type** to **Message**.
+
+    Because the **Web Search** component's `DataFrame` output is incompatible with the **context** variable's `Message` input, you must use the **Type Convert** component to change the `DataFrame` to a `Message` in order to pass the search results to the **Prompt Template** component.
+
+4. Connect the additional components to the rest of the flow:
+
+    * Connect the **Web Search** component's output to the **Type Convert** component's input.
+    * Connect the **Type Convert** component's output to the **Prompt Template** component's **context** input.
+
+    ![Convert web search output to text input](/img/component-type-convert-and-web-search.png)
+
+5. In the **Language Model** component, add your OpenAI API key.
+
+    If you want to use a different provider or model, edit the **Model Provider**, **Model Name**, and **API Key** fields accordingly.
+
+6. Click **Playground**, and then ask something relevant to your search query, such as `latest news` or `what's the latest research on the environment?`.
+
+    <details>
+    <summary>Result</summary>
+
+    The LLM uses the search results context, your chat message, and it's built-in training data to respond to your question.
+    For example:
+
+    ```text
+    Here are some of the latest news articles related to the environment:
+    Ozone Pollution and Global Warming: A recent study highlights that ozone pollution is a significant global environmental concern, threatening human health and crop production while exacerbating global warming. Read more
+    ...
+    ```
+
+    </details>
+
+### Type Convert parameters
 
 | Name | Display Name | Info |
 |------|--------------|------|
-| input_data | Input Data | The data to convert. Accepts Data, DataFrame, or Message objects. |
-| output_type | Output Type | The desired output type. Options: Data, DataFrame, or Message. |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| output | Output | The converted data in the specified format. |
-
-</details>
+| input_data | Input Data | Input parameter. The data to convert. Accepts `Data`, `DataFrame`, or `Message` input. |
+| output_type | Output Type | Input parameter. The desired output type, as one of **Data**, **DataFrame** or **Message**. |
+| output | Output | Output parameter. The converted data in the specified format. The output port changes depending on the selected **Output Type**. |
 
 ## Legacy Processing components
 
diff --git a/docs/docs/Components/components-vector-stores.mdx b/docs/docs/Components/components-vector-stores.mdx
index 701163091..09719649f 100644
--- a/docs/docs/Components/components-vector-stores.mdx
+++ b/docs/docs/Components/components-vector-stores.mdx
@@ -4,121 +4,455 @@ slug: /components-vector-stores
 ---
 
 import Icon from "@site/src/components/icon";
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
 
-Langflow's **Vector Store** components connect to your vector databases or create in-memory vector stores for storing and retrieving vector data in flows.
+Langflow's **Vector Store** components are used to read and write vector data, including embedding storage, vector search, Graph RAG traversals, and specialized provider-specific search, such as OpenSearch, Elasticsearch, and Vectara.
 
-Vector databases and **Vector Store** components are specifically designed for storing and retrieving vector data, such as embeddings generated by language models. They are used to perform similarity searches, enabling applications like chatbots to retrieve relevant context from large datasets.
+These components are critical for vector search applications, such as Retrieval Augmented Generation (RAG) chatbots that need to retrieve relevant context from large datasets.
+
+Most of these components connect to a specific vector database provider, but some components support multiple providers or platforms.
+For example, the **Cassandra** vector store component can connect to self-managed Apache Cassandra-based clusters as well as Astra DB, which is a managed Cassandra DBaaS.
 
 Other types of storage, like traditional structured databases and chat memory, are handled through other components like the [**SQL Database** component](/components-data#sql-database) or the [**Message History** component](/components-helpers#message-history).
 
-## Use a Vector Store component in a flow
+## Use Vector Store components in a flow
 
 :::tip
-For an tutorial using **Vector Store** components in a flow, see [Create a vector RAG chatbot](/chat-with-rag).
+For a tutorial using **Vector Store** components in a flow, see [Create a vector RAG chatbot](/chat-with-rag).
 :::
 
-This example uses the **Chroma DB** vector store component. Your **Vector Store** component's parameters and authentication may be different, but the document ingestion workflow is the same. A document is loaded from a local machine and chunked. The **Vector Store** component generates embeddings with the connected [**Embedding Model** component](/components-embedding-models), and stores them in the connected vector database.
-This vector data can then be retrieved for workloads like Retrieval Augmented Generation (RAG).
+The following steps introduce the use of **Vector Store** components in a flow, including configuration details, how the components work when you run a flow, why you might need multiple **Vector Store** components in one flow, and useful supporting components, such as **Embedding Model** and **Parser** components.
 
-![Embedding data into a vector store](/img/vector-store-document-ingestion.png)
+1. Create a flow with the **Vector Store RAG** template.
 
-The user's chat input is embedded and compared to the vectors embedded during document ingestion for a similarity search.
-The results are output from the **Vector Store** component as a [`Data`](/data-types#data) object and parsed into text.
-This text fills the `{context}` variable in the **Prompt Template** component, which informs the **OpenAI** language model component's responses.
+    This template has two subflows.
+    The **Load Data** subflow loads embeddings and content into a vector database, and the **Retriever** subflow runs a vector search to retrieve relevant context based on a user's query.
 
-![Retrieval from a vector store](/img/vector-store-retrieval.png)
+2. Configure the database connection for both [**Astra DB** components](#astra-db), or replace them with another pair of **Vector Store** components of your choice.
+Make sure the components connect to the same vector store, and that the component in the **Retriever** subflow is able to run a similarity search.
 
-### Configure vector store parameters
+    The parameters you set in each **Vector Store** component depend on the component's role in your flow.
+    In this example, the **Load Data** subflow _writes_ to the vector store, whereas the **Retriever** subflow _reads_ from the vector store.
+    Therefore, search-related parameters are only relevant to the **Vector Search** component in the **Retriever** subflow.
 
-Most **Vector Store** components have the same utility within a flow, but each provider can offer different parameters and functionality.
-Inspect a component's parameters to learn more about the inputs it accepts and how to configure it.
+    For information about specific configuration parameters, see the section of this page for your chosen **Vector Store** component and [Hidden parameters](#hidden-parameters).
+
+3. To configure the embedding model, do one of the following:
+
+    * **Use an OpenAI model**: In both **OpenAI Embeddings** components, enter your OpenAI API key.
+    You can use the default model or select a different OpenAI embedding model.
+
+    * **Use another provider**: Replace the **OpenAI Embeddings** components with another pair of [**Embedding Model** component](/components-embedding-models) of your choice, and then configure the parameters and credentials accordingly.
+
+    * **Use Astra DB vectorize**: If you are using an Astra DB vector store that has a vectorize integration, you can remove both **OpenAI Embeddings** components.
+    If you do this, the vectorize integration automatically generates embeddings from the **Ingest Data** (in the **Load Data** subflow) and **Search Query** (in the **Retriever** subflow).
+
+    :::tip
+    If your vector store already contains embeddings, make sure your **Embedding Model** components use the same model as your previous embeddings.
+    Mixing embedding models in the same vector store can produce inaccurate search results.
+    :::
+
+4. Recommended: In the [**Split Text** component](/components-processing#split-text), optimize the chunking settings for your embedding model.
+For example, if your embedding model has a token limit of 512, then the **Chunk Size** parameter must not exceed that limit.
+
+    Additionally, because the **Retriever** subflow passes the chat input directly to the **Vector Store** component for vector search, make sure that your chat input string doesn't exceed your embedding model's limits.
+    For this example, you can enter a query that is within the limits; however, in a production environment, you might need to implement additional checks or preprocessing steps to ensure compliance.
+    For example, use additional components to prepare the chat input before running the vector search, or enforce chat input limits in your application code.
+
+5. In the **Language Model** component, enter your OpenAI API key, or select a different provider and model to use for the chat portion of the flow.
+
+6. Run the **Load Data** subflow to populate your vector store.
+In the **File** component, select one or more files, and then click <Icon name="Play" aria-hidden="True" /> **Run component** on the **Vector Store** component in the **Load Data** subflow.
+
+    The **Load Data** subflow loads files from your local machine, chunks them, generates embeddings for the chunks, and then stores the chunks and their embeddings in the vector database.
+
+    ![Embedding data into a vector store](/img/vector-store-document-ingestion.png)
+
+    The **Load Data** subflow is separate from the **Retriever** subflow because you probably won't run it every time you use the chat.
+    You can run the **Load Data** subflow as needed to preload or update the data in your vector store.
+    Then, your chat interactions only use the components that are necessary for chat.
+
+    If your vector store already contains data that you want to use for vector search, then you don't need to run the **Load Data** subflow.
+
+7. Open the **Playground** and start chatting to run the **Retriever** subflow.
+
+    The **Retriever** subflow generates an embedding from chat input, runs a vector search to retrieve similar content from your vector store, parses the search results into supplemental context for the LLM, and then uses the LLM to generate a natural language response to your query.
+    The LLM uses the vector search results along with its internal training data and tools, such as basic web search and datetime information, to produce the response.
+
+    ![Retrieval from a vector store](/img/vector-store-retrieval.png)
+
+    To avoid passing the entire block of raw search results to the LLM, the **Parser** component extracts `text` strings from the search results `Data` object, and then passes them to the **Prompt Template** component in `Message` format.
+    From there, the strings and other template content are compiled into natural language instructions for the LLM.
+
+    You can use other components for this transformation, such as the **Data Operations** component, depending on how you want to use the search results.
+
+    To view the raw search results, click <Icon name="TextSearch" aria-hidden="True" /> **Inspect output** on the **Vector Store** component after running the **Retriever** subflow.
+
+### Hidden parameters
+
+You can inspect a **Vector Store** component's parameters to learn more about the inputs it accepts, the features it supports, and how to configure it.
 
 Many input parameters for **Vector Store** components are hidden by default in the visual editor.
 You can toggle parameters through the <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls** in each [component's header menu](/concepts-components#component-menus).
 
-For details about a specific provider's parameters, see the provider's documentation.
+Some parameters are conditional, and they are only available after you set other parameters or select specific options for other parameters.
+Conditional parameters may not be visible on the **Controls** pane until you set the required dependencies.
+However, all parameters are always listed in a [component's code](/concepts-components#component-code).
 
-## Astra DB
+For information about a specific component's parameters, see the provider's documentation and the component details.
 
-This component implements an [Astra DB Serverless vector store](https://docs.datastax.com/en/astra-db-serverless/databases/create-database.html) with search capabilities.
+### Search results output
+
+If you use a **Vector Store** component to query your vector store, it produces search results that you can pass to downstream components in your flow as a list of [`Data`](/data-types#data) objects or a tabular [`DataFrame`](/data-types#dataframe).
+If both types are supported, you can set the format near the component's output port in the visual editor.
+
+The exception to this pattern is the **Vectara RAG** component, which outputs only an `answer` string in [`Message`](/data-types#message) format.
+
+### Vector store instances
+
+Because Langflow is based on LangChain, **Vector Store** components use an instance of [LangChain vector store](https://python.langchain.com/docs/integrations/vectorstores/) to drive the underlying vector search functions.
+In the component code, this is often instantiated as `vector_store`, but some components use a different name, such as the provider name.
+
+For the **Cassandra Graph** and **Astra DB Graph** components, `vector_store` is an instance of [LangChain graph vector store](https://python.langchain.com/api_reference/community/graph_vectorstores.html).
+
+These instances are provider-specific and configured according to the component's parameters.
+For example, the **Redis** component creates an instance of [`RedisVectorStore`](https://python.langchain.com/docs/integrations/vectorstores/redis/) based on the component's parameters, such as the connection string, index name, and schema.
+
+Some LangChain classes don't expose all possible options as component parameters.
+Depending on the provider, these options might use default values or allow modification through environment variables, if they are supported in Langflow.
+For information about specific options, see the LangChain API reference and provider documentation.
 
 <details>
-<summary>Parameters</summary>
+<summary>Vector Store Connection ports</summary>
 
-**Inputs**
+The **Astra DB** and **OpenSearch** components have an additional **Vector Store Connection** output.
+This output can only connect to a `VectorStore` input port, and it was intended for use with dedicated Graph RAG components.
 
-| Name | Display Name | Info |
-|------|--------------|------|
-| token | Astra DB Application Token | An Astra application token with permission to access your vector database. Once the connection is verified, additional fields are populated with your existing databases and collections. |
-| environment | Environment | The environment for the Astra DB API Endpoint. For example, `dev` or `prod`. |
-| database_name | Database | The name of the database that you want this component to connect to, or select **New Database** to create a new database. To create a new database, you must provide the database details, and then wait for the database to initialize. |
-| api_endpoint | Astra DB API Endpoint | The API endpoint for the Astra DB instance. This supersedes the database selection. |
-| collection_name | Collection | The name of the collection that you want to use with this flow, or click **New Collection** to create a new collection. |
-| keyspace | Keyspace | An optional keyspace within Astra DB to use for the collection. |
-| embedding_choice | Embedding Model or Astra Vectorize | Choose an embedding model or use Astra vectorize. If the collection has a vectorize integration, **Astra Vectorize** can be selected automatically. |
-| embedding_model | Embedding Model | Specify the embedding model. Not required if the embedding choice is **Astra Vectorize** because the component automatically uses the integrated model. |
-| number_of_results | Number of Search Results | The number of search results to return. Default:`4`. |
-| search_type | Search Type | The search type to use. The options are `Similarity`, `Similarity with score threshold`, and `MMR (Max Marginal Relevance)`. |
-| search_score_threshold | Search Score Threshold | The minimum similarity score threshold for search results when using the `Similarity with score threshold` option. |
-| advanced_search_filter | Search Metadata Filter | An optional dictionary of filters to apply to the search query. |
-| autodetect_collection | Autodetect Collection | Boolean flag to determine whether to autodetect the collection. |
-| content_field | Content Field | A field to use as the text content field for the vector store. |
-| deletion_field | Deletion Based On Field | When provided, documents in the target collection with metadata field values matching the input metadata field value are deleted before new data is loaded. |
-| ignore_invalid_documents | Ignore Invalid Documents | Boolean flag to determine whether to ignore invalid documents at runtime. |
-| astradb_vectorstore_kwargs | AstraDBVectorStore Parameters | An optional dictionary of additional parameters for the AstraDBVectorStore. |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| vector_store | Vector Store | The Astra DB vector store instance configured with the specified parameters. |
-| search_results | Search Results | The results of the similarity search as a list of [Data](/data-types#data) objects. |
+The only non-legacy component that supports this input is the **Graph RAG** component, which was meant as a Graph RAG extension to the **Astra DB** component.
+Instead, you can use the **Astra DB Graph** component that includes both the vector store connection and Graph RAG functionality.
+OpenSearch instances support Graph traversal through built-in RAG functionality and plugins.
 
 </details>
 
-### Generate embeddings
+## Apache Cassandra
 
-The **Astra DB** component offers two methods for generating embeddings.
+The **Cassandra** and **Cassandra Graph** components can be used with Cassandra clusters that support vector search, including Astra DB.
 
-* ***Embedding Model**: Use your own embedding model by connecting an [**Embedding Model** component](/components-embedding-models) in Langflow.
+For more information, see the following:
 
-* **Astra Vectorize**: Use Astra DB's built-in embedding generation service. When creating a new collection, choose the embeddings provider and models, including NVIDIA's `NV-Embed-QA` model hosted by DataStax.
-For more information, see the [Astra DB Serverless documentation](https://docs.datastax.com/en/astra-db-serverless/databases/embedding-generation.html).
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Vector search in Cassandra](https://cassandra.apache.org/doc/latest/cassandra/vector-search/overview.html)
 
-    :::important
-    With vectorize, the embedding model you choose when you create a collection cannot be changed later.
-    :::
+### Cassandra
 
-For an example of using the **Astra DB** component with an embedding model, see the **Vector Store RAG** template.
+Use the **Cassandra** component to read or write to a Cassandra vector store using a `CassandraVectorStore` instance.
 
-### Hybrid search
+<details>
+<summary>Cassandra parameters</summary>
 
-The **Astra DB** component includes Astra DB's [hybrid search](https://docs.datastax.com/en/astra-db-serverless/databases/hybrid-search.html) feature through the Astra DB Data API.
+| Name | Type | Description |
+|------|------|-------------|
+| database_ref | String | Input parameter. Contact points for the database or an Astra database ID. |
+| username | String | Input parameter. Username for the database. Leave empty for Astra DB. |
+| token | SecretString | Input parameter. User password for the database or an Astra application token. |
+| keyspace | String | Input parameter. The name of the keyspace containing the vector store specified in **Table Name** (`table_name`). |
+| table_name | String | Input parameter. The name of the table or collection that is the vector store. |
+| ttl_seconds | Integer | Input parameter. Time-to-live for added texts, if supported by the cluster. Only relevant for writes. |
+| batch_size | Integer | Input parameter. Amount of records to process in a single batch. |
+| setup_mode | String | Input parameter. Configuration mode for setting up a Cassandra table. |
+| cluster_kwargs | Dict | Input parameter. Additional keyword arguments for a Cassandra cluster. |
+| search_query | String | Input parameter. Query string for similarity search. Only relevant for reads. |
+| ingest_data | Data | Input parameter. Data to be loaded into the vector store as raw chunks and embeddings. Only relevant for writes. |
+| embedding | Embeddings | Input parameter. Embedding function to use. |
+| number_of_results | Integer | Input parameter. Number of results to return in search. Only relevant for reads. |
+| search_type | String | Input parameter. Type of search to perform. Only relevant for reads. |
+| search_score_threshold | Float | Input parameter. Minimum similarity score for search results. Only relevant for reads. |
+| search_filter | Dict | Input parameter. An optional dictionary of metadata search filters to apply in addition to vector search. Only relevant for reads. |
+| body_search | String | Input parameter. Document textual search terms. Only relevant for reads. |
+| enable_body_search | Boolean | Input parameter. Flag to enable body search. Only relevant for reads. |
 
-Hybrid search performs a vector similarity search and a lexical search, compares the results of both searches, and then returns the most relevant results overall.
+</details>
 
-To use hybrid search through the **Astra DB** component, you must [create a collection with that supports hybrid search](https://docs.datastax.com/en/astra-db-serverless/api-reference/collection-methods/create-collection.html#example-hybrid).
+### Cassandra Graph
 
-The following **Astra DB** component parameters are used for hybrid search:
+The **Cassandra Graph** component uses a `CassandraGraphVectorStore` instance for graph traversal and graph-based document retrieval in a compatible Cassandra cluster.
+It also supports writing to the vector store.
 
-* **Search Query**: The query to use for vector search.
-* **Lexical Terms**: A comma-separated string of keywords, like `features, data, attributes, characteristics`.
-* **Reranker**: The re-ranker model to use for hybrid search, such as `nvidia/llama-3.2-nv.reranker`.
+<details>
+<summary>Cassandra Graph parameters</summary>
+
+| Name | Display Name | Info |
+|------|--------------|------|
+| database_ref | Contact Points / Astra Database ID | Input parameter. The contact points for the database or an Astra database ID. Required. |
+| username | Username | Input parameter. The username for the database. Leave empty for Astra DB. |
+| token | Password / Astra DB Token | Input parameter. The user password for the database or an Astra application token. Required. |
+| keyspace | Keyspace | Input parameter. The name of the keyspace containing the vector store specified in **Table Name** (`table_name`). Required. |
+| table_name | Table Name | Input parameter. The name of the table or collection that is the vector store. Required. |
+| setup_mode | Setup Mode | Input parameter. The configuration mode for setting up the Cassandra table. The options are `Sync` (default) or `Off`. |
+| cluster_kwargs | Cluster arguments | Input parameter. An optional dictionary of additional keyword arguments for the Cassandra cluster. |
+| search_query | Search Query | Input parameter. The query string for similarity search. Only relevant for reads. |
+| ingest_data | Ingest Data | Input parameter. Data to be loaded into the vector store as raw chunks and embeddings. Only relevant for writes. |
+| embedding | Embedding | Input parameter. The embedding model to use. |
+| number_of_results | Number of Results | Input parameter. The number of results to return in similarity search. Only relevant for reads. Default: 4. |
+| search_type | Search Type | Input parameter. The search type to use. The options are `Traversal` (default), `MMR Traversal`, `Similarity`, `Similarity with score threshold`, or `MMR (Max Marginal Relevance)`. |
+| depth | Depth of traversal | Input parameter. The maximum depth of edges to traverse. Only relevant if **Search Type** (`search_type`) is `Traversal` or `MMR Traversal`. Default: 1. |
+| search_score_threshold | Search Score Threshold | Input parameter. The minimum similarity score threshold for search results. Only relevant for reads using the `Similarity with score threshold` search type. |
+| search_filter | Search Metadata Filter | Input parameter. An optional dictionary of metadata search filters to apply in addition to graph traversal and similarity search. |
+
+</details>
+
+## Chroma
+
+The **Chroma DB** and **Local DB** components read and write to Chroma vector stores using an instance of `Chroma` vector store.
+Includes support for remote or in-memory instances with or without persistence.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Chroma documentation](https://docs.trychroma.com/)
+
+### Chroma DB
+
+You can use the **Chroma DB** component to read and write to a Chroma database in local storage or a remote Chroma server with options for persistence and caching.
+When writing, the component can create a new database or collection at the specified location.
+
+:::tip
+An ephemeral (non-persistent) local Chroma vector store is helpful for testing vector search flows where you don't need to retain the database.
+:::
+
+The following example flow uses one **Chroma DB** component for both reads and writes:
+
+* When writing, it splits `Data` from a [**URL** component](/components-data#url) into chunks, computes embeddings with attached **Embedding Model** component, and then loads the chunks and embeddings into the Chroma vector store.
+To trigger writes, click <Icon name="Play" aria-hidden="true"/> **Run component** on the **Chroma DB** component.
+
+* When reading, it uses chat input to perform a similarity search on the vector store, and then print the search results to the chat.
+To trigger reads, open the **Playground** and enter a chat message.
+
+After running the flow once, you can click <Icon name="TextSearch" aria-hidden="true"/> **Inspect Output** on each component to understand how the data transformed as it passed from component to component.
+
+![ChromaDB receiving split text](/img/component-chroma-db.png)
+
+<details>
+<summary>Chroma DB parameters</summary>
+
+| Name | Type | Description |
+|------|------|-------------|
+| **Collection Name** (`collection_name`) | String | Input parameter.  The name of your Chroma vector store collection. Default: `langflow`. |
+| **Persist Directory** (`persist_directory`) | String | Input parameter. To persist the Chroma database, enter a relative or absolute path to a directory to store the `chroma.sqlite3` file. Leave empty for an ephemeral database. When reading or writing to an existing persistent database, specify the path to the persistent directory. |
+| **Ingest Data** (`ingest_data`) | Data or DataFrame | Input parameter. `Data` or `DataFrame` input containing the records to write to the vector store. Only relevant for writes. |
+| **Search Query** (`search_query`) | String | Input parameter. The query to use for vector search. Only relevant for reads. |
+| **Cache Vector Store** (`cache_vector_store`) | Boolean | Input parameter. If true, the component caches the vector store in memory for faster reads. Default: Enabled (true). |
+| **Embedding** (`embedding`) | Embeddings | Input parameter. The embedding function to use for the vector store. By default, Chroma DB uses its built-in embeddings model, or you can attach an **Embedding Model** component to use a different provider or model. |
+| **CORS Allow Origins** (`chroma_server_cors_allow_origins`) | String | Input parameter. The CORS allow origins for the Chroma server. |
+| **Chroma Server Host** (`chroma_server_host`) | String | Input parameter. The host for the Chroma server. |
+| **Chroma Server HTTP Port** (`chroma_server_http_port`) | Integer | Input parameter. The HTTP port for the Chroma server. |
+| **Chroma Server gRPC Port** (`chroma_server_grpc_port`) | Integer | Input parameter. The gRPC port for the Chroma server. |
+| **Chroma Server SSL Enabled** (`chroma_server_ssl_enabled`) | Boolean | Input parameter. Enable SSL for the Chroma server. |
+| **Allow Duplicates** (`allow_duplicates`) | Boolean | Input parameter. If true (default), writes don't check for existing duplicates in the collection, allowing you to store multiple copies of the same content. If false, writes won't add documents that match existing documents already present in the collection. If false, it can strictly enforce deduplication by searching the entire collection or only search the number of records, specified in `limit`. Only relevant for writes.|
+| **Search Type** (`search_type`) | String | Input parameter. The type of search to perform, either `Similarity` or `MMR`. Only relevant for reads. |
+| **Number of Results** (`number_of_results`) | Integer | Input parameter. The number of search results to return. Default: `10`. Only relevant for reads. |
+| **Limit** (`limit`) | Integer | Input parameter. Limit the number of records to compare when **Allow Duplicates** is false. This can help improve performance when writing to large collections, but it can result in some duplicate records. Only relevant for writes. |
+
+</details>
+
+### Local DB
+
+The **Local DB** component reads and writes to a persistent, in-memory Chroma DB instance intended for use with Langflow.
+It has separate modes for reads and writes, automatic collection management, and default persistence in your Langflow cache directory.
+
+![A basic flow with a Local DB component in Retrieve mode.](/img/component-local-db.png)
+
+Set the **Mode** parameter to reflect the operation you want the component to perform, and the configure the other parameters accordingly.
+Some parameters are only available for one mode.
+
+<Tabs>
+<TabItem value="ingest" label="Ingest">
+
+To create or write to your local Chroma vector store, use **Ingest** mode.
+
+The following parameters are available in **Ingest** mode:
+
+| Name | Type | Description |
+|------|------|-------------|
+| **Name Your Collection** (`collection_name`) | String | Input parameter. The name for your Chroma vector store collection. Default: `langflow`. Only available in **Ingest** mode. |
+| **Persist Directory** (`persist_directory`) | String | Input parameter. The base directory where you want to create and persist the vector store. If you use the **Local DB** component in multiple flows or to create multiple collections, collections are stored at `$PERSISTENT_DIRECTORY/vector_stores/$COLLECTION_NAME`. If not specified, the default location is your Langflow cache directory (`LANGFLOW_CONFIG_DIR`). For more information, see [Memory management options](/memory). |
+| **Embedding** (`embedding`) | Embeddings | Input parameter. The embedding function to use for the vector store. |
+| **Allow Duplicates** (`allow_duplicates`) | Boolean | Input parameter. If true (default), writes don't check for existing duplicates in the collection, allowing you to store multiple copies of the same content. If false, writes won't add documents that match existing documents already present in the collection. If false, it can strictly enforce deduplication by searching the entire collection or only search the number of records, specified in `limit`. Only available in **Ingest** mode. |
+| **Ingest Data** (`ingest_data`) | Data or DataFrame | Input parameter. The records to write to the collection. Records are embedded and indexed for semantic search. Only available in **Ingest** mode. |
+| **Limit** (`limit`) | Integer | Input parameter. Limit the number of records to compare when **Allow Duplicates** is false. This can help improve performance when writing to large collections, but it can result in some duplicate records. Only available in **Ingest** mode. |
+
+</TabItem>
+<TabItem value="retrieve" label="Retrieve">
+
+To read from your local Chroma vector store, use **Retrieve** mode.
+
+The following parameters are available in **Retrieve** mode:
+
+| Name | Type | Description |
+|------|------|-------------|
+| **Persist Directory** (`persist_directory`) | String | Input parameter. The base directory where you want to create and persist the vector store. If you use the **Local DB** component in multiple flows or to create multiple collections, collections are stored at `$PERSISTENT_DIRECTORY/vector_stores/$COLLECTION_NAME`. If not specified, the default location is your Langflow cache directory (`LANGFLOW_CONFIG_DIR`). For more information, see [Memory management options](/memory). |
+| **Existing Collections** (`existing_collections`) | String | Input parameter. Select a previously-created collection to search. Only available in **Retrieve** mode. |
+| **Embedding** (`embedding`) | Embeddings | Input parameter. The embedding function to use for the vector store. |
+| **Search Type** (`search_type`) | String | Input parameter. The type of search to perform, either `Similarity` or `MMR`. Only available in **Retrieve** mode. |
+| **Search Query** (`search_query`) | String | Input parameter. Enter a query for similarity search. Only available in **Retrieve** mode. |
+| **Number of Results** (`number_of_results`) | Integer | Input parameter. Number of search results to return. Default: 10. Only available in **Retrieve** mode. |
+
+</TabItem>
+</Tabs>
+
+## Clickhouse
+
+The **Clickhouse** component reads and writes to a Clickhouse vector store using an instance of `Clickhouse` vector store.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Clickhouse Documentation](https://clickhouse.com/docs/en/intro)
+
+<details>
+<summary>Clickhouse parameters</summary>
+
+| Name | Display Name | Info |
+|------|--------------|------|
+| host | hostname | Input parameter. The Clickhouse server hostname. Required. Default: `localhost`. |
+| port | port | Input parameter. The Clickhouse server port. Required. Default: `8123`. |
+| database | database | Input parameter. The Clickhouse database name. Required. |
+| table | Table name | Input parameter. The Clickhouse table name. Required. |
+| username | Username | Input parameter. Clickhouse username for authentication. Required. |
+| password | Password | Input parameter. Clickhouse password for authentication. Required. |
+| index_type | index_type | Input parameter. Type of the index, either `annoy` (default) or `vector_similarity`. |
+| metric | metric | Input parameter. Metric to compute distance for similarity search. The options are `angular` (default), `euclidean`, `manhattan`, `hamming`, `dot`. |
+| secure | Use HTTPS/TLS | Input parameter. If true, enables HTTPS/TLS for the Clickhouse server and overrides inferred values for interface or port arguments. Default: false. |
+| index_param | Param of the index | Input parameter. Index parameters. Default: `100,'L2Distance'`. |
+| index_query_params | index query params | Input parameter. Additional index query parameters. |
+| search_query | Search Query | Input parameter. The query string for similarity search. Only relevant for reads. |
+| ingest_data | Ingest Data | Input parameter. The records to load into the vector store. |
+| cache_vector_store | Cache Vector Store | Input parameter. If true, the component caches the vector store in memory for faster reads. Default: Enabled (true). |
+| embedding | Embedding | Input parameter. The embedding model to use. |
+| number_of_results | Number of Results | Input parameter. The number of search results to return. Default: `4`. Only relevant for reads. |
+| score_threshold | Score threshold | Input parameter. The threshold for similarity score comparison. Default: Unset (no threshold). Only relevant for reads. |
+
+</details>
+
+## Couchbase
+
+The **Couchbase** component reads and writes to a Couchbase vector store using an instance of `CouchbaseSearchVectorStore`.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Couchbase documentation](https://docs.couchbase.com/home/index.html)
+
+<details>
+<summary>Couchbase parameters</summary>
+
+| Name | Type | Description |
+|------|------|-------------|
+| couchbase_connection_string | SecretString | Input parameter. Couchbase Cluster connection string. Required. |
+| couchbase_username | String | Input parameter. Couchbase username for authentication. Required. |
+| couchbase_password | SecretString | Input parameter. Couchbase password for authentication. Required. |
+| bucket_name | String | Input parameter. Name of the Couchbase bucket. Required. |
+| scope_name | String | Input parameter. Name of the Couchbase scope. Required. |
+| collection_name | String | Input parameter. Name of the Couchbase collection. Required. |
+| index_name | String | Input parameter. Name of the Couchbase index. Required. |
+| ingest_data | Data | Input parameter. The records to load into the vector store. Only relevant for writes. |
+| search_query | String | Input parameter. The query string for vector search. Only relevant for reads. |
+| cache_vector_store | Boolean | Input parameter. If true, the component caches the vector store in memory for faster reads. Default: Enabled (true). |
+| embedding | Embeddings | Input parameter. The embedding function to use for the vector store. |
+| number_of_results | Integer | Input parameter. Maximum number of search results to return. Default: 4. Only relevant for reads. |
+
+</details>
+
+## DataStax
+
+The following components support DataStax vector stores.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Astra DB Serverless documentation](https://docs.datastax.com/en/astra-db-serverless/index.html)
+* [Hyper-Converged Database (HCD) documentation](https://docs.datastax.com/en/hyper-converged-database/1.2/get-started/get-started-hcd.html)
+
+### Astra DB
+
+The **Astra DB** component read and writes to Astra DB Serverless databases, using an instance of `AstraDBVectorStore` to call the Data API and DevOps API.
+
+:::important
+It is recommend that you create any databases, keyspaces, and collections you need before configuring the **Astra DB** component.
+
+You can create new databases and collections through this component, but this is only possible in the Langflow visual editor, not at runtime, and you must wait while the database or collection initializes before proceeding with flow configuration.
+Additionally, not all database and collection configuration options are available through the **Astra DB** component, such as hybrid search options, PCU groups, vectorize integration management, and multi-region deployments.
+:::
+
+<details>
+<summary>Astra DB parameters</summary>
+
+| Name | Display Name | Info |
+|------|--------------|------|
+| token | Astra DB Application Token | Input parameter. An Astra application token with permission to access your vector database. Once the connection is verified, additional fields are populated with your existing databases and collections. If you want to create a database through this component, the application token must have Organization Administrator permissions. |
+| environment | Environment | Input parameter. The environment for the Astra DB API endpoint. Always use `prod`. |
+| database_name | Database | Input parameter. The name of the database that you want this component to connect to. Or, you can select **New Database** to create a new database, and then wait for the database to initialize. |
+| keyspace | Keyspace | Input parameter. The keyspace in your database that contains the collection specified in `collection_name`. Default: `default_keyspace`. |
+| collection_name | Collection | Input parameter. The name of the collection that you want to use with this flow. Or, select **New Collection** to create a new collection with limited configuration options. To ensure your collection is configured with the correct embedding provider and search capabilities, it is recommended to create the collection in the Astra Portal or with the Data API *before* configuring this component. For more information, see [Manage collections in Astra DB Serverless](https://docs.datastax.com/en/astra-db-serverless/databases/manage-collections.html). |
+| embedding_model | Embedding Model | Input parameter. Attach an [**Embedding Model** component](/components-embedding-models) to generate embeddings. Only available if the specified collection doesn't have a [vectorize integration](https://docs.datastax.com/en/astra-db-serverless/databases/embedding-generation.html). If a vectorize integration exists, the component automatically uses the collection's integrated model. |
+| ingest_data | Ingest Data | Input parameter. The documents to load into the specified collection. |
+| search_query | Search Query | Input parameter. The query string for vector search. |
+| cache_vector_store | Cache Vector Store | Input parameter. Whether to cache the vector store in Langflow memory for faster reads. Default: Enabled (true). |
+| search_method | Search Method | Input parameter. The search methods to use, either `Hybrid Search` or `Vector Search`. Your collection must be configured to support the chosen option, and the default depends on what your collection supports. All collections in Astra DB Serverless (Vector) databases support vector search, but hybrid search requires that you set specific collection settings when creating the collection. These options are only available when creating a collection programmatically. For more information, see [Ways to find data in Astra DB Serverless](https://docs.datastax.com/en/astra-db-serverless/databases/about-search.html) and [Create a collection that supports hybrid search](https://docs.datastax.com/en/astra-db-serverless/api-reference/collection-methods/create-collection.html#example-hybrid). |
+| reranker | Reranker | Input parameter. The re-ranker model to use for hybrid search, depending on the collection configuration. **This parameter shows the default reranker even if the selected collection doesn't support hybrid search.** To verify if a collection supports hybrid search, [get collection metadata](https://docs.datastax.com/en/astra-db-serverless/api-reference/collection-methods/list-collection-metadata.html), and then check that `lexical` and `rerank` both have `"enabled": true`. |
+| lexical_terms | Lexical Terms | Input parameter. A space-separated string of keywords for hybrid search, like `features, data, attributes, characteristics`. This parameter is only available if the collection supports hybrid search. For more information, see the following **Hybrid search example**. |
+| number_of_results | Number of Search Results | Input parameter. The number of search results to return. Default: 4. |
+| search_type | Search Type | Input parameter. The search type to use, either `Similarity` (default), `Similarity with score threshold`, and `MMR (Max Marginal Relevance)`. |
+| search_score_threshold | Search Score Threshold | Input parameter. The minimum similarity score threshold for vector search results with the `Similarity with score threshold` search type. Default: 0. |
+| advanced_search_filter | Search Metadata Filter | Input parameter. An optional dictionary of metadata filters to apply in addition to vector or hybrid search. |
+| autodetect_collection | Autodetect Collection | Input parameter. Whether to automatically fetch a list of available collections after providing an application token and API endpoint. |
+| content_field | Content Field | Input parameter. For writes, this parameter specifies the name of the field in the documents that contains text strings for which you want to generate embeddings. |
+| deletion_field | Deletion Based On Field | Input parameter. When provided, documents in the target collection with metadata field values matching the input metadata field value are deleted before new records are loaded. Use this setting for writes with upserts (overwrites). |
+| ignore_invalid_documents | Ignore Invalid Documents | Input parameter. Whether to ignore invalid documents during writes. If disabled (false), then an error is raised for invalid documents. Default: Enabled (true). |
+| astradb_vectorstore_kwargs | AstraDBVectorStore Parameters | Input parameter. An optional dictionary of additional parameters for the `AstraDBVectorStore` instance. For more information, see [Vector store instances](#vector-store-instances). |
+
+</details>
 
 <details>
 <summary>Hybrid search example</summary>
 
+The **Astra DB** component supports the Data API's [hybrid search](https://docs.datastax.com/en/astra-db-serverless/databases/hybrid-search.html) feature.
+Hybrid search performs a vector similarity search and a lexical search, compares the results of both searches, and then returns the most relevant results overall.
+
 To use hybrid search through the **Astra DB** component, do the following:
 
-1. Create a flow based on the **Hybrid Search RAG** template.
-2. In the **OpenAI** component, add your OpenAI API key.
-3. In the **Astra DB** vector store component, add your **Astra DB Application Token**.
-4. In the **Database** field, select your database.
-5. In the **Collection** field, select or create a collection with hybrid search capabilities enabled.
-6. In the **Playground**, enter a question about your data, such as `What are the features of my data?`
+1. Use the Data API to [create a collection that supports hybrid search](https://docs.datastax.com/en/astra-db-serverless/api-reference/collection-methods/create-collection.html#example-hybrid) if you haven't already created one.
 
-    Your query is sent to the **OpenAI** and **Astra DB** components.
-    The **OpenAI** component contains a prompt for creating the lexical query from your input:
+    Although you can create a collection through the **Astra DB** component, you have more control and insight into the collection settings when using the Data API for this operation.
+
+2. Create a flow based on the **Hybrid Search RAG** template, which includes an **Astra DB** component that is pre-configured for hybrid search.
+3. In the **Language Model** components, add your OpenAI API key.
+4. Delete the **Language Model** component that is connected to the **Structured Output** component's **Input Message** port, and then connect the **Chat Input** component to that port.
+5. Configure the **Astra DB** vector store component:
+
+    1. Enter your Astra DB application token.
+    2. In the **Database** field, select your database.
+    3. In the **Collection** field, select your collection with hybrid search enabled.
+
+        Once you select a collection that supports hybrid search, the other parameters automatically update to allow hybrid search options.
+
+6. In the [component's header menu](/concepts-components#component-menus), click <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls**, find the **Lexical Terms** field, enable the **Show** toggle, and then click **Close**.
+
+7. Connect the first **Parser** component's **Parsed Text** output to the **Astra DB** component's **Lexical Terms** input.
+This input only appears after connecting a collection that support hybrid search with reranking.
+
+8. Click the **Structured Output** component to expose the [component's header menu](/concepts-components#component-menus), click <Icon name="SlidersHorizontal" aria-hidden="true"/> **Controls**, find the **Format Instructions** row, click <Icon name="Expand" aria-hidden="true"/> **Expand**, and then replace the prompt with the following text:
 
     ```text
     You are a database query planner that takes a user's requests, and then converts to a search against the subject matter in question.
@@ -128,808 +462,522 @@ To use hybrid search through the **Astra DB** component, do the following:
     Avoid common keywords associated with the user's subject matter.
     ```
 
-7. To view the keywords and questions the **OpenAI** component generates from your collection, in the **OpenAI** component, click <Icon name="TextSearch" aria-hidden="true"/> **Inspect Output**.
+9. Click **Finish Editing**, and then click **Close** to save your changes to the component.
 
-    ```
-    1. Keywords: features, data, attributes, characteristics
-    2. Question: What characteristics can be identified in my data?
-    ```
+10. Open the **Playground**, and then enter a natural language question that you would ask about your database.
 
-8. To view the [DataFrame](/data-types#dataframe) generated from the **OpenAI** component's response, in the **Structured Output** component, click <Icon name="TextSearch" aria-hidden="true"/> **Inspect output**.
+    In this example, your input is sent to both the **Astra DB** and **Structured Output** components:
 
-    The DataFrame is passed to a **Parser** component, which parses the contents of the **Keywords** column into a string.
+    * The input sent directly to the **Astra DB** component's **Search Query** port is used as a string for similarity search.
+    An embedding is generated from the query string using the collection's Astra DB vectorize integration.
 
-    This string of comma-separated words is passed to the **Lexical Terms** port of the **Astra DB** component.
-    Note that the **Search Query** port of the **Astra DB** component is connected to the **Chat Input** component.
-    The search query is vectorized, and both the **Search Query** and **Lexical Terms** content are sent to the reranker at the `find_and_rerank` endpoint.
-    The reranker compares the vector search results against the string of terms from the lexical search.
-    The highest-ranked results of your hybrid search are returned to the **Playground**.
+    * The input sent to the **Structured Output** component is processed by the **Structured Output**, **Language Model**, and **Parser** components to extract space-separated `keywords` used for the lexical search portion of the hybrid search.
+
+    The complete hybrid search query is executed against your database using the Data API's `find_and_rerank` command.
+    The API's response is output as a `DataFrame` that is transformed into a text string `Message` by another **Parser** component.
+    Finally, the **Chat Output** component prints the `Message` response to the **Playground**.
+
+11. Optional: Exit the **Playground**, and then click <Icon name="TextSearch" aria-hidden="true"/> **Inspect Output** on each individual component to understand how lexical keywords were constructed and view the raw response from the Data API.
+This is helpful for debugging flows where a certain component isn't receiving input as expected from another component.
+
+    * **Structured Output component**: The output is the `Data` object produced by applying the output schema to the LLM's response to the input message and format instructions.
+    The following example is based on the aforementioned instructions for keyword extraction:
+
+        ```
+        1. Keywords: features, data, attributes, characteristics
+        2. Question: What characteristics can be identified in my data?
+        ```
+
+    * **Parser component**: The output is the string of keywords extracted from the structured output `Data`, and then used as lexical terms for the hybrid search.
+
+    * **Astra DB component**: The output is the `DataFrame` containing the results of the hybrid search as returned by the Data API.
 
 </details>
 
-## Astra DB Graph
+### Astra DB Graph
 
-This component implements a vector store using Astra DB with graph capabilities.
-For more information, see the [Astra DB Serverless documentation](https://docs.datastax.com/en/astra-db-serverless/tutorials/graph-rag.html).
+The **Astra DB Graph** component uses a `AstraDBGraphVectorStore` instance for graph traversal and graph-based document retrieval in an Astra DB collection. It also supports writing to the vector store.
+For more information, see [Build a Graph RAG system with LangChain and GraphRetriever](https://docs.datastax.com/en/astra-db-serverless/tutorials/graph-rag.html).
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Astra DB Graph parameters</summary>
 
 | Name | Display Name | Info |
 |------|--------------|------|
-| collection_name | Collection Name | The name of the collection within Astra DB where the vectors are stored. Required. |
-| token | Astra DB Application Token | Authentication token for accessing Astra DB. Required. |
-| api_endpoint | API Endpoint | API endpoint URL for the Astra DB service. Required. |
-| search_input | Search Input | Query string for similarity search. |
-| ingest_data | Ingest Data | Data to be ingested into the vector store. |
-| keyspace | Keyspace | Optional keyspace within Astra DB to use for the collection. |
-| embedding | Embedding Model | Embedding model to use. |
-| metric | Metric | Distance metric for vector comparisons. The options are "cosine", "euclidean", "dot_product". |
-| setup_mode | Setup Mode | Configuration mode for setting up the vector store. The options are "Sync", "Async", "Off". |
-| pre_delete_collection | Pre Delete Collection | Boolean flag to determine whether to delete the collection before creating a new one. |
-| number_of_results | Number of Results | Number of results to return in similarity search. Default: 4. |
-| search_type | Search Type | Search type to use. The options are "Similarity", "Graph Traversal", "Hybrid". |
-| traversal_depth | Traversal Depth | Maximum depth for graph traversal searches. Default: 1. |
-| search_score_threshold | Search Score Threshold | Minimum similarity score threshold for search results. |
-| search_filter | Search Metadata Filter | Optional dictionary of filters to apply to the search query. |
+| token | Astra DB Application Token | Input parameter. An Astra application token with permission to access your vector database. Once the connection is verified, additional fields are populated with your existing databases and collections. If you want to create a database through this component, the application token must have Organization Administrator permissions. |
+| api_endpoint | API Endpoint | Input parameter. Your database's API endpoint. |
+| keyspace | Keyspace | Input parameter. The keyspace in your database that contains the collection specified in `collection_name`. Default: `default_keyspace`. |
+| collection_name | Collection | Input parameter. The name of the collection that you want to use with this flow. For write operations, if a matching collection doesn't exist, a new one is created. |
+| metadata_incoming_links_key | Metadata Incoming Links Key | Input parameter. The metadata key for the incoming links in the vector store. |
+| ingest_data | Ingest Data | Input parameter. Records to load into the vector store. Only relevant for writes. |
+| search_input | Search Query | Input parameter. Query string for similarity search. Only relevant for reads. |
+| cache_vector_store | Cache Vector Store | Input parameter. Whether to cache the vector store in Langflow memory for faster reads. Default: Enabled (true). |
+| embedding_model | Embedding Model | Input parameter. Attach an [**Embedding Model** component](/components-embedding-models) to generate embeddings. If the collection has a [vectorize integration](https://docs.datastax.com/en/astra-db-serverless/databases/embedding-generation.html), don't attach an **Embedding Model** component. |
+| metric | Metric | Input parameter. The metrics to use for similarity search calculations, either `cosine` (default), `dot_product`, or `euclidean`. This is a collection setting. |
+| batch_size | Batch Size | Input parameter. Optional number of records to process in a single batch. |
+| bulk_insert_batch_concurrency | Bulk Insert Batch Concurrency | Input parameter. Optional concurrency level for bulk write operations. |
+| bulk_insert_overwrite_concurrency | Bulk Insert Overwrite Concurrency | Input parameter. Optional concurrency level for bulk write operations that allow upserts (overwriting existing records). |
+| bulk_delete_concurrency | Bulk Delete Concurrency | Input parameter. Optional concurrency level for bulk delete operations. |
+| setup_mode | Setup Mode | Input parameter. Configuration mode for setting up the vector store, either `Sync` (default) or `Off`. |
+| pre_delete_collection | Pre Delete Collection | Input parameter. Whether to delete the collection before creating a new one. Default: Disabled (false). |
+| metadata_indexing_include | Metadata Indexing Include | Input parameter. An list of metadata fields to index if you want to enable [selective indexing](https://docs.datastax.com/en/astra-db-serverless/api-reference/collection-indexes.html) *only* when creating a collection. Doesn't apply to existing collections. Only one `*_indexing_*` parameter can be set per collection. If all `*_indexing_*` parameters are unset, then all fields are indexed (default indexing). |
+| metadata_indexing_exclude | Metadata Indexing Exclude | Input parameter. An list of metadata fields to exclude from indexing if you want to enable selective indexing *only* when creating a collection. Doesn't apply to existing collections. Only one `*_indexing_*` parameter can be set per collection. If all `*_indexing_*` parameters are unset, then all fields are indexed (default indexing). |
+| collection_indexing_policy | Collection Indexing Policy | Input parameter. A dictionary to define the indexing policy if you want to enable selective indexing *only* when creating a collection. Doesn't apply to existing collections. Only one `*_indexing_*` parameter can be set per collection. If all `*_indexing_*` parameters are unset, then all fields are indexed (default indexing). The `collection_indexing_policy` dictionary is used when you need to set indexing on subfields or a complex indexing definition that isn't compatible as a list. |
+| number_of_results | Number of Results | Input parameter. Number of search results to return. Default: 4. Only relevant to reads. |
+| search_type | Search Type | Input parameter. Search type to use, either `Similarity`, `Similarity with score threshold`, or `MMR (Max Marginal Relevance)`, `Graph Traversal`, or `MMR (Max Marginal Relevance) Graph Traversal` (default). Only relevant to reads. |
+| search_score_threshold | Search Score Threshold | Input parameter. Minimum similarity score threshold for search results if the `search_type` is `Similarity with score threshold`. Default: 0. |
+| search_filter | Search Metadata Filter | Input parameter. Optional dictionary of metadata filters to apply in addition to vector search. |
 
-**Outputs**
+</details>
+
+### Graph RAG
+
+The **Graph RAG** component uses an instance of [`GraphRetriever`](https://datastax.github.io/graph-rag/reference/langchain_graph_retriever/) for Graph RAG traversal enabling graph-based document retrieval in an Astra DB vector store.
+For more information, see the [DataStax Graph RAG documentation](https://datastax.github.io/graph-rag/).
+
+:::tip
+This component was meant as a Graph RAG extension for the **Astra DB** vector store component.
+However, the **Astra DB Graph** component includes both the vector store connection and Graph RAG functionality.
+:::
+
+<details>
+<summary>Graph RAG parameters</summary>
 
 | Name | Display Name | Info |
 |------|--------------|------|
-| vector_store | Vector Store | The Graph RAG vector store instance configured with the specified parameters. |
-| search_results | Search Results | The results of the similarity search as a list of [Data](/data-types#data) objects. |
+| embedding_model | Embedding Model | Input parameter. Specify the embedding model to use. Not required if the connected vector store has an [vectorize integration](https://docs.datastax.com/en/astra-db-serverless/databases/embedding-generation.html). |
+| vector_store | Vector Store Connection | Input parameter. A [`vector_store`](#vector-store-instances) instance inherited from an **Astra DB** component's **Vector Store Connection** output. |
+| edge_definition | Edge Definition | Input parameter. [Edge definition](https://datastax.github.io/graph-rag/reference/graph_retriever/edges/) for the graph traversal. |
+| strategy | Traversal Strategies | Input parameter. The strategy to use for graph traversal. Strategy options are dynamically loaded from available strategies. |
+| search_query | Search Query | Input parameter. The query to search for in the vector store. |
+| graphrag_strategy_kwargs | Strategy Parameters | Input parameter. Optional dictionary of additional parameters for the [retrieval strategy](https://datastax.github.io/graph-rag/reference/graph_retriever/strategies/). |
+| search_results | **Search Results** or **DataFrame** | Output parameter. The results of the graph-based document retrieval as a list of [`Data`](/data-types#data) objects or as a tabular [`DataFrame`](/data-types#dataframe). You can set the desired output type near the component's output port. |
 
 </details>
 
-## Cassandra
+### Hyper-Converged Database (HCD)
 
-This component creates a Cassandra vector store with search capabilities.
-For more information, see the [Cassandra documentation](https://cassandra.apache.org/doc/latest/cassandra/vector-search/overview.html).
+The **Hyper-Converged Database (HCD)** component uses your cluster's the Data API server to read and write to an HCD vector store.
+Because the underlying functions call the Data API, which originated from Astra DB, the component uses an instance of `AstraDBVectorStore`.
+
+![A flow using the HCD component to load vector data.](/img/component-hcd-example-flow.png)
+
+For more information about using the Data API with an HCD deployment, see [Get started with the Data API in HCD 1.2](https://docs.datastax.com/en/hyper-converged-database/1.2/api-reference/dataapiclient.html).
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
-
-| Name | Type | Description |
-|------|------|-------------|
-| database_ref | String | Contact points for the database or Astra DB database ID. |
-| username | String | Username for the database (leave empty for Astra DB). |
-| token | SecretString | User password for the database or Astra DB token. |
-| keyspace | String | Table or keyspace. |
-| table_name | String | Name of the table or Astra DB collection. |
-| ttl_seconds | Integer | Time-to-live for added texts. |
-| batch_size | Integer | Number of data to process in a single batch. |
-| setup_mode | String | Configuration mode for setting up the Cassandra table. |
-| cluster_kwargs | Dict | Additional keyword arguments for the Cassandra cluster. |
-| search_query | String | Query for similarity search. |
-| ingest_data | Data | Data to be ingested into the vector store. |
-| embedding | Embeddings | Embedding function to use. |
-| number_of_results | Integer | Number of results to return in search. |
-| search_type | String | Type of search to perform. |
-| search_score_threshold | Float | Minimum similarity score for search results. |
-| search_filter | Dict | Metadata filters for search query. |
-| body_search | String | Document textual search terms. |
-| enable_body_search | Boolean | Flag to enable body search. |
-
-**Outputs**
-
-| Name | Type | Description |
-|------|------|-------------|
-| vector_store | Cassandra | The Cassandra vector store instance configured with the specified parameters. |
-| search_results | List[Data] | The results of the similarity search as a list of `Data` objects. |
-
-</details>
-
-## Cassandra Graph
-
-This component implements a Cassandra Graph vector store with search capabilities.
-
-<details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>HCD parameters</summary>
 
 | Name | Display Name | Info |
 |------|--------------|------|
-| database_ref | Contact Points / Astra Database ID | The contact points for the database or Astra DB database ID. Required. |
-| username | Username | The username for the database. Leave this field empty for Astra DB. |
-| token | Password / Astra DB Token | The user password for the database or Astra DB token. Required. |
-| keyspace | Keyspace | The table or keyspace. Required. |
-| table_name | Table Name | The name of the table or Astra DB collection where vectors are stored. Required. |
-| setup_mode | Setup Mode | The configuration mode for setting up the Cassandra table. The options are "Sync" or "Off". Default: "Sync". |
-| cluster_kwargs | Cluster arguments | An optional dictionary of additional keyword arguments for the Cassandra cluster. |
-| search_query | Search Query | The query string for similarity search. |
-| ingest_data | Ingest Data | The list of data to be ingested into the vector store. |
-| embedding | Embedding | The embedding model to use. |
-| number_of_results | Number of Results | The number of results to return in similarity search. Default: 4. |
-| search_type | Search Type | The search type to use. The options are "Traversal", "MMR traversal", "Similarity", "Similarity with score threshold", or "MMR (Max Marginal Relevance)". Default: "Traversal". |
-| depth | Depth of traversal | The maximum depth of edges to traverse. Used for "Traversal" or "MMR traversal" search types. Default: 1. |
-| search_score_threshold | Search Score Threshold | The minimum similarity score threshold for search results. Used for "Similarity with score threshold" search types. |
-| search_filter | Search Metadata Filter | An optional dictionary of filters to apply to the search query. |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| vector_store | Vector Store | The Cassandra Graph vector store instance configured with the specified parameters. |
-| search_results | Search Results | The results of the similarity search as a list of [Data](/data-types#data) objects. |
-
-</details>
-
-## Chroma DB
-
-The **Chroma DB** component creates an ephemeral, Chroma vector database with search capabilities that you can use for experimentation and vector storage.
-For more information, see the [Chroma documentation](https://docs.trychroma.com/).
-
-<details>
-<summary>Chroma DB sample flow</summary>
-
-1. To use this component in a flow, connect it to a component that outputs `Data` or `DataFrame`.
-
-    This example splits text from a [**URL** component](/components-data#url), and then computes embeddings with the connected **OpenAI Embeddings** component. Chroma DB computes embeddings by default, but you can connect your own embeddings model, as seen in this example.
-
-    ![ChromaDB receiving split text](/img/component-chroma-db.png)
-
-2. In the **Chroma DB** component, in the **Collection** field, enter a name for your embeddings collection.
-3. Optional: To persist the Chroma database, in the **Persist** field, enter a directory to store the `chroma.sqlite3` file.
-This example uses `./chroma-db` to create a directory relative to where Langflow is running.
-4. To load data and embeddings into your Chroma database, in the **Chroma DB** component, click <Icon name="Play" aria-hidden="true"/> **Run component**.
-
-    :::tip
-    When loading duplicate documents, enable the **Allow Duplicates** option in Chroma DB if you want to store multiple copies of the same content, or disable it to automatically deduplicate your data.
-    :::
-
-5. To view the split data, in the **Split Text** component, click <Icon name="TextSearch" aria-hidden="true"/> **Inspect Output**.
-6. To query your loaded data, open the **Playground** and query your database.
-Your input is converted to vector data and compared to the stored vectors in a vector similarity search.
-
-</details>
-
-<details>
-<summary>Parameters</summary>
-
-**Inputs**
-
-| Name                         | Type          | Description                                      |
-|------------------------------|---------------|--------------------------------------------------|
-| collection_name               | String        | The name of the Chroma collection. Default: "langflow". |
-| persist_directory             | String        | The directory to persist the Chroma database.     |
-| search_query                  | String        | The query to search for in the vector store.      |
-| ingest_data                   | Data          | The data to ingest into the vector store (list of `Data` objects). |
-| embedding                     | Embeddings    | The embedding function to use for the vector store. |
-| chroma_server_cors_allow_origins | String     | The CORS allow origins for the Chroma server.         |
-| chroma_server_host            | String        | The host for the Chroma server.                       |
-| chroma_server_http_port       | Integer       | The HTTP port for the Chroma server.                  |
-| chroma_server_grpc_port       | Integer       | The gRPC port for the Chroma server.                  |
-| chroma_server_ssl_enabled     | Boolean       | Enable SSL for the Chroma server.                 |
-| allow_duplicates              | Boolean       | Allow duplicate documents in the vector store.    |
-| search_type                   | String        | The type of search to perform: "Similarity" or "MMR". |
-| number_of_results             | Integer       | The number of results to return from the search. Default: `10`. |
-| limit                         | Integer       | The limit of the number of records to compare when `Allow Duplicates` is false. |
-
-**Outputs**
-
-| Name           | Type          | Description                    |
-|----------------|---------------|--------------------------------|
-| vector_store   | Chroma        | The Chroma vector store instance.  |
-| search_results | List[Data]    | The results of the similarity search as a list of [Data](/data-types#data) objects.    |
-
-</details>
-
-## Clickhouse
-
-This component implements a Clickhouse vector store with search capabilities.
-For more information, see the [Clickhouse Documentation](https://clickhouse.com/docs/en/intro).
-
-<details>
-<summary>Parameters</summary>
-
-**Inputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| host | hostname | The Clickhouse server hostname. Required. Default: "localhost". |
-| port | port | The Clickhouse server port. Required. Default: 8123. |
-| database | database | The Clickhouse database name. Required. |
-| table | Table name | The Clickhouse table name. Required. |
-| username | The ClickHouse user name. | Username for authentication. Required. |
-| password | The password for username. | Password for authentication. Required. |
-| index_type | index_type | Type of the index. The options are "annoy" and "vector_similarity". Default: "annoy". |
-| metric | metric | Metric to compute distance. The options are "angular", "euclidean", "manhattan", "hamming", "dot". Default: "angular". |
-| secure | Use https/TLS | Overrides inferred values from the interface or port arguments. Default: false. |
-| index_param | Param of the index | Index parameters. Default: "'L2Distance',100". |
-| index_query_params | index query params | Additional index query parameters. |
-| search_query | Search Query | The query string for similarity search. |
-| ingest_data | Ingest Data | The data to be ingested into the vector store. |
-| embedding | Embedding | The embedding model to use. |
-| number_of_results | Number of Results | The number of results to return in similarity search. Default: 4. |
-| score_threshold | Score threshold | The threshold for similarity scores. |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| vector_store | Vector Store | The Clickhouse vector store. |
-| search_results | Search Results | The results of the similarity search as a list of Data objects. |
-
-</details>
-
-## Couchbase
-
-This component creates a Couchbase vector store with search capabilities.
-For more information, see the [Couchbase documentation](https://docs.couchbase.com/home/index.html).
-
-<details>
-<summary>Parameters</summary>
-
-**Inputs**
-
-| Name                    | Type          | Description                                      |
-|-------------------------|---------------|--------------------------------------------------|
-| couchbase_connection_string | SecretString | Couchbase Cluster connection string. Required.   |
-| couchbase_username       | String        | Couchbase username. Required.                   |
-| couchbase_password       | SecretString  | Couchbase password. Required.                   |
-| bucket_name              | String        | Name of the Couchbase bucket. Required.         |
-| scope_name               | String        | Name of the Couchbase scope. Required.          |
-| collection_name          | String        | Name of the Couchbase collection. Required.     |
-| index_name               | String        | Name of the Couchbase index. Required.          |
-| search_query             | String        | The query to search for in the vector store.     |
-| ingest_data              | Data          | The list of data to ingest into the vector store. |
-| embedding                | Embeddings    | The embedding function to use for the vector store. |
-| number_of_results        | Integer       | Number of results to return from the search. Default: 4. |
-
-**Outputs**
-
-| Name           | Type                   | Description                    |
-|----------------|------------------------|--------------------------------|
-| vector_store   | CouchbaseVectorStore    | A Couchbase vector store instance configured with the specified parameters. |
+| collection_name | Collection Name | Input parameter. The name of a vector store collection in HCD. For write operations, if the collection doesn't exist, then a new one is created. Required. |
+| username | HCD Username | Input parameter. Username for authenticating to your HCD deployment. Default: `hcd-superuser`. Required. |
+| password | HCD Password | Input parameter. Password for authenticating to your HCD deployment. Required. |
+| api_endpoint | HCD API Endpoint | Input parameter. Your deployment's HCD Data API endpoint, formatted as `http[s]://**CLUSTER_HOST**:**GATEWAY_PORT` where `CLUSTER_HOST` is the IP address of any node in your cluster and `GATEWAY_PORT` is the port number ofr your API gateway service. For example, `http://192.0.2.250:8181`. Required. |
+| ingest_data | Ingest Data | Input parameter. Records to load into the vector store. Only relevant for writes. |
+| search_input | Search Input | Input parameter. Query string for similarity search. Only relevant for reads. |
+| namespace | Namespace | Input parameter. The namespace in HCD that contains or will contain the collection specified in `collection_name`. Default: `default_namespace`. |
+| ca_certificate | CA Certificate | Input parameter. Optional CA certificate for TLS connections to HCD. |
+| metric | Metric | Input parameter. The metrics to use for similarity search calculations, either `cosine`, `dot_product`, or `euclidean`. This is a collection setting. If calling an existing collection, leave unset to use the collection's metric. If a write operation creates a new collection, specify the desired similarity metric setting. |
+| batch_size | Batch Size | Input parameter. Optional number of records to process in a single batch. |
+| bulk_insert_batch_concurrency | Bulk Insert Batch Concurrency | Input parameter. Optional concurrency level for bulk write operations. |
+| bulk_insert_overwrite_concurrency | Bulk Insert Overwrite Concurrency | Input parameter. Optional concurrency level for bulk write operations that allow upserts (overwriting existing records). |
+| bulk_delete_concurrency | Bulk Delete Concurrency | Input parameter. Optional concurrency level for bulk delete operations. |
+| setup_mode | Setup Mode | Input parameter. Configuration mode for setting up the vector store, either `Sync` (default), `Async`, or `Off`. |
+| pre_delete_collection | Pre Delete Collection | Input parameter. Whether to delete the collection before creating a new one. |
+| metadata_indexing_include | Metadata Indexing Include | Input parameter. An list of metadata fields to index if you want to enable [selective indexing](https://docs.datastax.com/en/hyper-converged-database/1.2/api-reference/collection-indexes.html) *only* when creating a collection. Doesn't apply to existing collections. Only one `*_indexing_*` parameter can be set per collection. If all `*_indexing_*` parameters are unset, then all fields are indexed (default indexing). |
+| metadata_indexing_exclude | Metadata Indexing Exclude | Input parameter. An list of metadata fields to exclude from indexing if you want to enable selective indexing *only* when creating a collection. Doesn't apply to existing collections. Only one `*_indexing_*` parameter can be set per collection. If all `*_indexing_*` parameters are unset, then all fields are indexed (default indexing). |
+| collection_indexing_policy | Collection Indexing Policy | Input parameter. A dictionary to define the indexing policy if you want to enable selective indexing *only* when creating a collection. Doesn't apply to existing collections. Only one `*_indexing_*` parameter can be set per collection. If all `*_indexing_*` parameters are unset, then all fields are indexed (default indexing). The `collection_indexing_policy` dictionary is used when you need to set indexing on subfields or a complex indexing definition that isn't compatible as a list. |
+| embedding | Embedding or Astra Vectorize | Input parameter. The embedding model to use by attaching an **Embedding Model** component. This component doesn't support additional vectorize authentication headers, so it isn't possible to use a vectorize integration with this component, even if you have enabled one on an existing HCD collection. |
+| number_of_results | Number of Results | Input parameter. Number of search results to return. Default: 4. Only relevant to reads. |
+| search_type | Search Type | Input parameter. Search type to use, either `Similarity` (default), `Similarity with score threshold`, or `MMR (Max Marginal Relevance)`. Only relevant to reads. |
+| search_score_threshold | Search Score Threshold | Input parameter. Minimum similarity score threshold for search results if the `search_type` is `Similarity with score threshold`. Default: 0. |
+| search_filter | Search Metadata Filter | Input parameter. Optional dictionary of metadata filters to apply in addition to vector search. |
 
 </details>
 
 ## Elasticsearch
 
-This component creates an Elasticsearch vector store with search capabilities.
-For more information, see the [Elasticsearch documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/dense-vector.html).
+The **Elasticsearch** component reads and writes to an Elasticsearch instance using `ElasticsearchStore`.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Elasticsearch documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/dense-vector.html)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Elasticsearch parameters</summary>
 
 | Name | Type | Description |
 |------|------|-------------|
-| es_url | String | Elasticsearch server URL. |
-| es_user | String | Username for Elasticsearch authentication. |
-| es_password | SecretString | Password for Elasticsearch authentication. |
-| index_name | String | Name of the Elasticsearch index. |
-| strategy | String | Strategy for vector search. The options are "approximate_k_nearest_neighbors" or "script_scoring". |
-| distance_strategy | String | Strategy for distance calculation. The options are "COSINE", "EUCLIDEAN_DISTANCE", or "DOT_PRODUCT". |
-| search_query | String | Query for similarity search. |
-| ingest_data | Data | Data to be ingested into the vector store. |
-| embedding | Embeddings | Embedding function to use. |
-| number_of_results | Integer | Number of results to return in search. Default: `4`. |
-
-**Outputs**
-
-| Name | Type | Description |
-|------|------|-------------|
-| vector_store | ElasticsearchStore | The Elasticsearch vector store instance. |
-| search_results | List[Data] | The results of the similarity search as a list of [Data](/data-types#data) objects.  |
+| es_url | String | Input parameter. Elasticsearch server URL. |
+| es_user | String | Input parameter. Username for Elasticsearch authentication. |
+| es_password | SecretString | Input parameter. Password for Elasticsearch authentication. |
+| index_name | String | Input parameter. Name of the Elasticsearch index. |
+| strategy | String | Input parameter. Strategy for vector search, either `approximate_k_nearest_neighbors` or `script_scoring`. |
+| distance_strategy | String | Input parameter. Strategy for distance calculation, either `COSINE`, `EUCLIDEAN_DISTANCE`, or `DOT_PRODUCT`. |
+| search_query | String | Input parameter. Query string for similarity search. |
+| ingest_data | Data | Input parameter. Records to load into the vector store. |
+| embedding | Embeddings | Input parameter. The embedding model to use. |
+| number_of_results | Integer | Input parameter. Number of search results to return. Default: 4. |
 
 </details>
 
 ## FAISS
 
-This component creates a FAISS vector store with search capabilities.
-For more information, see the [FAISS documentation](https://faiss.ai/index.html).
+The **FAISS** component providese access to the Facebook AI Similarity Search (FAISS) library through an instance of `FAISS` vector store.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [FAISS documentation](https://faiss.ai/index.html)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>FAISS parameters</summary>
 
 | Name                      | Type          | Description                                      |
 |---------------------------|---------------|--------------------------------------------------|
-| index_name                 | String        | The name of the FAISS index. Default: "langflow_index". |
-| persist_directory          | String        | Path to save the FAISS index. It is relative to where Langflow is running. |
-| search_query               | String        | The query to search for in the vector store.     |
-| ingest_data                | Data          | The list of data to ingest into the vector store. |
-| allow_dangerous_deserialization | Boolean  | Set to True to allow loading pickle files from untrusted sources. Default: True. |
-| embedding                  | Embeddings    | The embedding function to use for the vector store. |
-| number_of_results          | Integer       | Number of results to return from the search. Default: 4. |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| vector_store | Vector Store | The FAISS vector store instance configured with the specified parameters. |
-| search_results | Search Results | The results of the similarity search as a list of [Data](/data-types#data) objects. |
-
-</details>
-
-
-## Graph RAG
-
-This component performs Graph RAG traversal in a vector store, enabling graph-based document retrieval.
-For more information, see the [Graph RAG documentation](https://datastax.github.io/graph-rag/).
-
-For an example flow, see the **Graph RAG** template in Langflow.
-
-<details>
-<summary>Parameters</summary>
-
-**Inputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| embedding_model | Embedding Model | Specify the embedding model. This isn't required for collections embedded with [Astra vectorize](https://docs.datastax.com/en/astra-db-serverless/databases/embedding-generation.html). |
-| vector_store | Vector Store Connection | Connection to the vector store. |
-| edge_definition | Edge Definition | Edge definition for the graph traversal. For more information, see the [GraphRAG documentation](https://datastax.github.io/graph-rag/reference/graph_retriever/edges/). |
-| strategy | Traversal Strategies | The strategy to use for graph traversal. Strategy options are dynamically loaded from available strategies. |
-| search_query | Search Query | The query to search for in the vector store. |
-| graphrag_strategy_kwargs | Strategy Parameters | Optional dictionary of additional parameters for the retrieval strategy. For more information, see the [strategy documentation](https://datastax.github.io/graph-rag/reference/graph_retriever/strategies/). |
-
-**Outputs**
-
-| Name | Type | Description |
-|------|------|-------------|
-| search_results | List[Data] | Results of the graph-based document retrieval as a list of [Data](/data-types#data) objects. |
-
-</details>
-
-## Hyper-Converged Database (HCD)
-
-This component implements a vector store using HCD.
-
-To use the HCD vector store, add your deployment's collection name, username, password, and HCD Data API endpoint.
-The endpoint must be formatted like `http[s]://**DOMAIN_NAME** or **IP_ADDRESS**[:port]`, for example, `http://192.0.2.250:8181`.
-
-Replace **DOMAIN_NAME** or **IP_ADDRESS** with the domain name or IP address of your HCD Data API connection.
-
-To use the HCD vector store for embeddings ingestion, connect it to an embeddings model and a file loader.
-
-![HCD vector store embeddings ingestion](/img/component-hcd-example-flow.png)
-
-<details>
-<summary>Parameters</summary>
-
-**Inputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| collection_name | Collection Name | The name of the collection within HCD where the vectors will be stored. Required. |
-| username | HCD Username | Authentication username for accessing HCD. Default is "hcd-superuser". Required. |
-| password | HCD Password | Authentication password for accessing HCD. Required. |
-| api_endpoint | HCD API Endpoint | API endpoint URL for the HCD service. Required. |
-| search_input | Search Input | Query string for similarity search. |
-| ingest_data | Ingest Data | Data to be ingested into the vector store. |
-| namespace | Namespace | Optional namespace within HCD to use for the collection. Default is "default_namespace". |
-| ca_certificate | CA Certificate | Optional CA certificate for TLS connections to HCD. |
-| metric | Metric | Optional distance metric for vector comparisons. Options are "cosine", "dot_product", "euclidean". |
-| batch_size | Batch Size | Optional number of data to process in a single batch. |
-| bulk_insert_batch_concurrency | Bulk Insert Batch Concurrency | Optional concurrency level for bulk insert operations. |
-| bulk_insert_overwrite_concurrency | Bulk Insert Overwrite Concurrency | Optional concurrency level for bulk insert operations that overwrite existing data. |
-| bulk_delete_concurrency | Bulk Delete Concurrency | Optional concurrency level for bulk delete operations. |
-| setup_mode | Setup Mode | Configuration mode for setting up the vector store. Options are "Sync", "Async", "Off". Default is "Sync". |
-| pre_delete_collection | Pre Delete Collection | Boolean flag to determine whether to delete the collection before creating a new one. |
-| metadata_indexing_include | Metadata Indexing Include | Optional list of metadata fields to include in the indexing. |
-| embedding | Embedding or Astra Vectorize | Allows either an embedding model or an Astra Vectorize configuration. |
-| metadata_indexing_exclude | Metadata Indexing Exclude | Optional list of metadata fields to exclude from the indexing. |
-| collection_indexing_policy | Collection Indexing Policy | Optional dictionary defining the indexing policy for the collection. |
-| number_of_results | Number of Results | Number of results to return in similarity search. Default is 4. |
-| search_type | Search Type | Search type to use. Options are "Similarity", "Similarity with score threshold", "MMR (Max Marginal Relevance)". Default is "Similarity". |
-| search_score_threshold | Search Score Threshold | Minimum similarity score threshold for search results. Default is 0. |
-| search_filter | Search Metadata Filter | Optional dictionary of filters to apply to the search query. |
-
-**Outputs**
-
-| Name          | Type         | Description                               |
-|---------------|--------------|-------------------------------------------|
-| vector_store  | HyperConvergedDatabaseVectorStore | The HCD vector store instance. |
-| search_results| List[Data]   | The results of the similarity search as a list of [Data](/data-types#data) objects.               |
-
-</details>
-
-## Local DB
-
-The **Local DB** component is Langflow's enhanced version of Chroma DB.
-
-The component adds a user-friendly interface with two modes (Ingest and Retrieve), automatic collection management, and built-in persistence in Langflow's cache directory.
-
-Local DB includes **Ingest** and **Retrieve** modes.
-
-The **Ingest** mode works similarly to [ChromaDB](#chroma-db), and persists your database to the Langflow cache directory. The Langflow cache directory location is specified in the `LANGFLOW_CONFIG_DIR` environment variable. For more information, see [Flow storage and logs](/concepts-flows#flow-storage-and-logs).
-
-The **Retrieve** mode can query your **Chroma DB** collections.
-
-![Local DB retrieving vectors](/img/component-local-db.png)
-
-For more information, see the [Chroma documentation](https://docs.trychroma.com/).
-
-<details>
-<summary>Parameters</summary>
-
-**Inputs**
-
-| Name | Type | Description |
-|------|------|-------------|
-| collection_name | String | The name of the Chroma collection. Default: "langflow". |
-| persist_directory | String | Custom base directory to save the vector store. Collections are stored under `$DIRECTORY/vector_stores/$COLLECTION_NAME`. If not specified, it uses your system's cache folder. |
-| existing_collections | String | Select a previously created collection to search through its stored data. |
-| embedding | Embeddings | The embedding function to use for the vector store. |
-| allow_duplicates | Boolean | If false, the component won't add documents that are already in the vector store. |
-| search_type | String | Type of search to perform: "Similarity" or "MMR". |
-| ingest_data | Data/DataFrame | Data to store. It is embedded and indexed for semantic search. |
-| search_query | String | Enter text to search for similar content in the selected collection. |
-| number_of_results | Integer | Number of results to return. Default: 10. |
-| limit | Integer | Limit the number of records to compare when Allow Duplicates is False. |
-
-**Outputs**
-
-| Name | Type | Description |
-|------|------|-------------|
-| vector_store | Chroma | A local Chroma vector store instance configured with the specified parameters. |
-| search_results | List[Data](/data-types#data) | The results of the similarity search as a list of [Data](/data-types#data) objects.  |
+| index_name                 | String        | Input parameter. The name of the FAISS index. Default: "langflow_index". |
+| persist_directory          | String        | Input parameter. Path to save the FAISS index. It is relative to where Langflow is running. |
+| search_query               | String        | Input parameter. The query to search for in the vector store.     |
+| ingest_data                | Data          | Input parameter. The list of data to ingest into the vector store. |
+| allow_dangerous_deserialization | Boolean  | Input parameter. Set to True to allow loading pickle files from untrusted sources. Default: True. |
+| embedding                  | Embeddings    | Input parameter. The embedding function to use for the vector store. |
+| number_of_results          | Integer       | Input parameter. Number of results to return from the search. Default: 4. |
 
 </details>
 
 ## Milvus
 
-This component creates a Milvus vector store with search capabilities.
-For more information, see the [Milvus documentation](https://milvus.io/docs).
+The **Milvus** component reads and writes to Milvus vector stores using an instance of `Milvus` vector store.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Milvus documentation](https://milvus.io/docs)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Milvus parameters</summary>
 
 | Name                    | Type          | Description                                      |
 |-------------------------|---------------|--------------------------------------------------|
-| collection_name          | String        | Name of the Milvus collection.                   |
-| collection_description   | String        | Description of the Milvus collection.            |
-| uri                      | String        | Connection URI for Milvus.                       |
-| password                 | SecretString  | Password for Milvus.                             |
-| username                 | SecretString  | Username for Milvus.                             |
-| batch_size               | Integer       | Number of data to process in a single batch.     |
-| search_query             | String        | Query for similarity search.                     |
-| ingest_data              | Data          | Data to be ingested into the vector store.       |
-| embedding                | Embeddings    | Embedding function to use.                       |
-| number_of_results        | Integer       | Number of results to return in search.           |
-| search_type              | String        | Type of search to perform.                       |
-| search_score_threshold   | Float         | Minimum similarity score for search results.     |
-| search_filter            | Dict          | Metadata filters for search query.               |
-| setup_mode               | String        | Configuration mode for setting up the vector store. |
-| vector_dimensions        | Integer       | Number of dimensions of the vectors.             |
-| pre_delete_collection    | Boolean       | Whether to delete the collection before creating a new one. |
-
-**Outputs**
-
-| Name           | Type                   | Description                    |
-|----------------|------------------------|--------------------------------|
-| vector_store   | Milvus                 | A Milvus vector store instance configured with the specified parameters. |
+| collection_name          | String        | Input parameter. Name of the Milvus collection.                   |
+| collection_description   | String        | Input parameter. Description of the Milvus collection.            |
+| uri                      | String        | Input parameter. Connection URI for Milvus.                       |
+| password                 | SecretString  | Input parameter. Password for Milvus.                             |
+| username                 | SecretString  | Input parameter. Username for Milvus.                             |
+| batch_size               | Integer       | Input parameter. Number of data to process in a single batch.     |
+| search_query             | String        | Input parameter. Query for similarity search.                     |
+| ingest_data              | Data          | Input parameter. Data to be ingested into the vector store.       |
+| embedding                | Embeddings    | Input parameter. Embedding function to use.                       |
+| number_of_results        | Integer       | Input parameter. Number of results to return in search.           |
+| search_type              | String        | Input parameter. Type of search to perform.                       |
+| search_score_threshold   | Float         | Input parameter. Minimum similarity score for search results.     |
+| search_filter            | Dict          | Input parameter. Metadata filters for search query.               |
+| setup_mode               | String        | Input parameter. Configuration mode for setting up the vector store. |
+| vector_dimensions        | Integer       | Input parameter. Number of dimensions of the vectors.             |
+| pre_delete_collection    | Boolean       | Input parameter. Whether to delete the collection before creating a new one. |
 
 </details>
 
 ## MongoDB Atlas
 
-This component creates a MongoDB Atlas vector store with search capabilities.
-For more information, see the [MongoDB Atlas documentation](https://www.mongodb.com/docs/atlas/atlas-vector-search/tutorials/vector-search-quick-start/).
+The **MongoDB Atlas** component reads and writes to MongoDB Atlas vector stores using an instance of `MongoDBAtlasVectorSearch`.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [MongoDB Atlas documentation](https://www.mongodb.com/docs/atlas/atlas-vector-search/tutorials/vector-search-quick-start/)
 
 <details>
-<summary>Parameters</summary>
+<summary>MongoDB Atlas parameters</summary>
 
-**Inputs**
 | Name                      | Type         | Description                               |
 | ------------------------- | ------------ | ----------------------------------------- |
-| mongodb_atlas_cluster_uri | SecretString | The connection URI for your MongoDB Atlas cluster. Required. |
-| enable_mtls               | Boolean      | Enable mutual TLS authentication. Default: false. |
-| mongodb_atlas_client_cert | SecretString | Client certificate combined with private key for mTLS authentication. Required if mTLS is enabled. |
-| db_name                   | String       | The name of the database to use. Required. |
-| collection_name           | String       | The name of the collection to use. Required. |
-| index_name                | String       | The name of the Atlas Search index, it should be a Vector Search. Required. |
-| insert_mode               | String       | How to insert new documents into the collection. The options are "append" or "overwrite". Default: "append". |
-| embedding                 | Embeddings   | The embedding model to use. |
-| number_of_results         | Integer      | Number of results to return in similarity search. Default: 4. |
-| index_field               | String       | The field to index. Default: "embedding". |
-| filter_field              | String       | The field to filter the index. |
-| number_dimensions         | Integer      | Embedding context length. Default: 1536. |
-| similarity                | String       | The method used to measure similarity between vectors. The options are "cosine", "euclidean", or "dotProduct". Default: "cosine". |
-| quantization              | String       | Quantization reduces memory costs by converting 32-bit floats to smaller data types. The options are "scalar" or "binary". |
-
-**Outputs**
-
-| Name          | Type                   | Description                               |
-| ------------- | ---------------------- | ----------------------------------------- |
-| vector_store  | MongoDBAtlasVectorSearch| The MongoDB Atlas vector store instance.       |
-| search_results| List[Data]             | The results of the similarity search as a list of [Data](/data-types#data) objects.               |
+| mongodb_atlas_cluster_uri | SecretString | Input parameter. The connection URI for your MongoDB Atlas cluster. Required. |
+| enable_mtls               | Boolean      | Input parameter. Enable mutual TLS authentication. Default: false. |
+| mongodb_atlas_client_cert | SecretString | Input parameter. Client certificate combined with private key for mTLS authentication. Required if mTLS is enabled. |
+| db_name                   | String       | Input parameter. The name of the database to use. Required. |
+| collection_name           | String       | Input parameter. The name of the collection to use. Required. |
+| index_name                | String       | Input parameter. The name of the Atlas Search index, it should be a Vector Search. Required. |
+| insert_mode               | String       | Input parameter. How to insert new documents into the collection. The options are "append" or "overwrite". Default: "append". |
+| embedding                 | Embeddings   | Input parameter. The embedding model to use. |
+| number_of_results         | Integer      | Input parameter. Number of results to return in similarity search. Default: 4. |
+| index_field               | String       | Input parameter. The field to index. Default: "embedding". |
+| filter_field              | String       | Input parameter. The field to filter the index. |
+| number_dimensions         | Integer      | Input parameter. Embedding context length. Default: 1536. |
+| similarity                | String       | Input parameter. The method used to measure similarity between vectors. The options are "cosine", "euclidean", or "dotProduct". Default: "cosine". |
+| quantization              | String       | Input parameter. Quantization reduces memory costs by converting 32-bit floats to smaller data types. The options are "scalar" or "binary". |
 
 </details>
 
 ## OpenSearch
 
-This component creates an OpenSearch vector store with search capabilities
-For more information, see [OpenSearch documentation](https://opensearch.org/platform/search/vector-database.html).
+The **OpenSearch** component reads and writes to OpenSearch instances using `OpenSearchVectorSearch`.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [OpenSearch documentation](https://opensearch.org/platform/search/vector-database.html)
 
 <details>
-<summary>Parameters</summary>
+<summary>OpenSearch parameters</summary>
 
-**Inputs**
-| Name                   | Type         | Description                                                                                                            |
-|------------------------|--------------|------------------------------------------------------------------------------------------------------------------------|
-| opensearch_url         | String       | URL for OpenSearch cluster, such as `https://192.168.1.1:9200`.                                                             |
-| index_name             | String       | The index name where the vectors are stored in OpenSearch cluster.                                                  |
-| search_input           | String       | Enter a search query. Leave empty to retrieve all documents or if hybrid search is being used.                          |
-| ingest_data            | Data         | The data to be ingested into the vector store.                                                                              |
-| embedding              | Embeddings   | The embedding function to use.                                                                                              |
-| search_type            | String       | The options are "similarity", "similarity_score_threshold", "mmr".                                                     |
-| number_of_results      | Integer      | The number of results to return in search.                                                                                  |
-| search_score_threshold | Float        | The minimum similarity score threshold for search results.                                                                  |
-| username               | String       | The username for the opensource cluster.                                                                                    |
-| password               | SecretString | The password for the opensource cluster.                                                                                    |
-| use_ssl                | Boolean      | Use SSL.                                                                                                                |
-| verify_certs           | Boolean      | Verify certificates.                                                                                                    |
-| hybrid_search_query    | String       | Provide a custom hybrid search query in JSON format. This allows you to combine vector similarity and keyword matching. |
-
-**Outputs**
-
-| Name          | Type                   | Description                                 |
-| ------------- |------------------------|---------------------------------------------|
-| vector_store  | OpenSearchVectorSearch | OpenSearch vector store instance            |
-| search_results| List[Data]             | The results of the similarity search as a list of [Data](/data-types#data) objects.                 |
+| Name | Type | Description |
+|------|------|-------------|
+| opensearch_url | String | Input parameter. URL for OpenSearch cluster, such as `https://192.168.1.1:9200`. |
+| index_name | String | Input parameter. The index name where the vectors are stored in OpenSearch cluster. |
+| search_input | String | Input parameter. Enter a search query. Leave empty to retrieve all documents or if hybrid search is being used. |
+| ingest_data | Data | Input parameter. The data to be ingested into the vector store. |
+| embedding | Embeddings | Input parameter. The embedding function to use. |
+| search_type | String | Input parameter. The options are "similarity", "similarity_score_threshold", "mmr". |
+| number_of_results | Integer | Input parameter. The number of results to return in search. |
+| search_score_threshold | Float | Input parameter. The minimum similarity score threshold for search results. |
+| username | String | Input parameter. The username for the opensource cluster. |
+| password | SecretString | Input parameter. The password for the opensource cluster. |
+| use_ssl | Boolean | Input parameter. Use SSL. |
+| verify_certs | Boolean | Input parameter. Verify certificates. |
+| hybrid_search_query | String | Input parameter. Provide a custom hybrid search query in JSON format. This allows you to combine vector similarity and keyword matching. |
 
 </details>
 
 ## PGVector
 
-This component creates a PGVector vector store with search capabilities.
-For more information, see the [PGVector documentation](https://github.com/pgvector/pgvector).
+The **PGVector** component reads and writes to PostgreSQL vector stores using an instance of `PGVector`.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [PGVector documentation](https://github.com/pgvector/pgvector)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>PGVector parameters</summary>
 
 | Name            | Type         | Description                               |
 | --------------- | ------------ | ----------------------------------------- |
-| pg_server_url   | SecretString | The PostgreSQL server connection string.       |
-| collection_name | String       | The table name for the vector store.           |
-| search_query    | String       | The query for similarity search.               |
-| ingest_data     | Data         | The data to be ingested into the vector store. |
-| embedding       | Embeddings   | The embedding function to use.                 |
-| number_of_results | Integer    | The number of results to return in search.     |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| vector_store | Vector Store | The PGVector vector store instance configured with the specified parameters. |
-| search_results | Search Results | The results of the similarity search as a list of [Data](/data-types#data) objects. |
+| pg_server_url   | SecretString | Input parameter. The PostgreSQL server connection string.       |
+| collection_name | String       | Input parameter. The table name for the vector store.           |
+| search_query    | String       | Input parameter. The query for similarity search.               |
+| ingest_data     | Data         | Input parameter. The data to be ingested into the vector store. |
+| embedding       | Embeddings   | Input parameter. The embedding function to use.                 |
+| number_of_results | Integer    | Input parameter. The number of results to return in search.     |
 
 </details>
 
 ## Pinecone
 
-This component creates a Pinecone vector store with search capabilities.
-For more information, see the [Pinecone documentation](https://docs.pinecone.io/home).
+The **Pinecone** component reads and writes to Pinecone vector stores using an instance of `PineconeVectorStore`.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Pinecone documentation](https://docs.pinecone.io/home)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Pinecone parameters</summary>
 
 | Name              | Type         | Description                               |
 | ----------------- | ------------ | ----------------------------------------- |
-| index_name        | String       | The name of the Pinecone index.                |
-| namespace         | String       | The namespace for the index.                   |
-| distance_strategy | String       | The strategy for calculating distance between vectors. |
-| pinecone_api_key  | SecretString | The API key for Pinecone.                      |
-| text_key          | String       | The key in the record to use as text.          |
-| search_query      | String       | The query for similarity search.               |
-| ingest_data       | Data         | The data to be ingested into the vector store. |
-| embedding         | Embeddings   | The embedding function to use.                 |
-| number_of_results | Integer      | The number of results to return in search.     |
-
-**Outputs**
-
-| Name | Display Name | Info |
-|------|--------------|------|
-| vector_store | Vector Store | The Pinecone vector store instance configured with the specified parameters. |
-| search_results | Search Results | The results of the similarity search as a list of [Data](/data-types#data) objects. |
+| index_name        | String       | Input parameter. The name of the Pinecone index.                |
+| namespace         | String       | Input parameter. The namespace for the index.                   |
+| distance_strategy | String       | Input parameter. The strategy for calculating distance between vectors. |
+| pinecone_api_key  | SecretString | Input parameter. The API key for Pinecone.                      |
+| text_key          | String       | Input parameter. The key in the record to use as text.          |
+| search_query      | String       | Input parameter. The query for similarity search.               |
+| ingest_data       | Data         | Input parameter. The data to be ingested into the vector store. |
+| embedding         | Embeddings   | Input parameter. The embedding function to use.                 |
+| number_of_results | Integer      | Input parameter. The number of results to return in search.     |
 
 </details>
 
 ## Qdrant
 
-This component creates a Qdrant vector store with search capabilities.
-For more information, see the [Qdrant documentation](https://qdrant.tech/documentation/).
+The **Qdrant** component reads and writes to Qdrant vector stores using an instance of `QdrantVectorStore`.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Qdrant documentation](https://qdrant.tech/documentation/)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Qdrant parameters</summary>
 
 | Name                 | Type         | Description                               |
 | -------------------- | ------------ | ----------------------------------------- |
-| collection_name       | String       | The name of the Qdrant collection.             |
-| host                 | String       | The Qdrant server host.                        |
-| port                 | Integer      | The Qdrant server port.                        |
-| grpc_port            | Integer      | The Qdrant gRPC port.                          |
-| api_key              | SecretString | The API key for Qdrant.                        |
-| prefix               | String       | The prefix for Qdrant.                         |
-| timeout              | Integer      | The timeout for Qdrant operations.             |
-| path                 | String       | The path for Qdrant.                           |
-| url                  | String       | The URL for Qdrant.                            |
-| distance_func        | String       | The distance function for vector similarity.   |
-| content_payload_key  | String       | The content payload key.                  |
-| metadata_payload_key | String       | The metadata payload key.                 |
-| search_query         | String       | The query for similarity search.               |
-| ingest_data          | Data         | The data to be ingested into the vector store. |
-| embedding            | Embeddings   | The embedding function to use.                 |
-| number_of_results    | Integer      | The number of results to return in search.     |
-
-**Outputs**
-
-| Name          | Type     | Description                               |
-| ------------- | -------- | ----------------------------------------- |
-| vector_store  | Qdrant   | A Qdrant vector store instance.              |
-| search_results| List[Data] | The results of the similarity search as a list of [Data](/data-types#data) objects.             |
+| collection_name      | String       | Input parameter. The name of the Qdrant collection.             |
+| host                 | String       | Input parameter. The Qdrant server host.                        |
+| port                 | Integer      | Input parameter. The Qdrant server port.                        |
+| grpc_port            | Integer      | Input parameter. The Qdrant gRPC port.                          |
+| api_key              | SecretString | Input parameter. The API key for Qdrant.                        |
+| prefix               | String       | Input parameter. The prefix for Qdrant.                         |
+| timeout              | Integer      | Input parameter. The timeout for Qdrant operations.             |
+| path                 | String       | Input parameter. The path for Qdrant.                           |
+| url                  | String       | Input parameter. The URL for Qdrant.                            |
+| distance_func        | String       | Input parameter. The distance function for vector similarity.   |
+| content_payload_key  | String       | Input parameter. The content payload key.                       |
+| metadata_payload_key | String       | Input parameter. The metadata payload key.                      |
+| search_query         | String       | Input parameter. The query for similarity search.               |
+| ingest_data          | Data         | Input parameter. The data to be ingested into the vector store. |
+| embedding            | Embeddings   | Input parameter. The embedding function to use.                 |
+| number_of_results    | Integer      | Input parameter. The number of results to return in search.     |
 
 </details>
 
 ## Redis
 
-This component creates a Redis vector store with search capabilities.
-For more information, see the [Redis documentation](https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/vectors/).
+The **Redis** component reads and writes to Redis vector stores using an instance of `Redis` vector store.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Redis documentation](https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/vectors/)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Redis parameters</summary>
 
 | Name              | Type         | Description                               |
 | ----------------- | ------------ | ----------------------------------------- |
-| redis_server_url  | SecretString | The Redis server connection string.            |
-| redis_index_name  | String       | The name of the Redis index.                   |
-| code              | String       | The custom code for Redis (advanced).          |
-| schema            | String       | The schema for Redis index.                    |
-| search_query      | String       | The query for similarity search.               |
-| ingest_data       | Data         | The data to be ingested into the vector store. |
-| number_of_results | Integer      | The number of results to return in search.     |
-| embedding         | Embeddings   | The embedding function to use.                 |
-
-**Outputs**
-
-| Name          | Type     | Description                               |
-| ------------- | -------- | ----------------------------------------- |
-| vector_store  | Redis    | Redis vector store instance               |
-| search_results| List[Data] | The results of the similarity search as a list of [Data](/data-types#data) objects.              |
+| redis_server_url  | SecretString | Input parameter. The Redis server connection string.            |
+| redis_index_name  | String       | Input parameter. The name of the Redis index.                   |
+| code              | String       | Input parameter. The custom code for Redis (advanced).          |
+| schema            | String       | Input parameter. The schema for Redis index.                    |
+| search_query      | String       | Input parameter. The query for similarity search.               |
+| ingest_data       | Data         | Input parameter. The data to be ingested into the vector store. |
+| number_of_results | Integer      | Input parameter. The number of results to return in search.     |
+| embedding         | Embeddings   | Input parameter. The embedding function to use.                 |
 
 </details>
 
 ## Supabase
 
-This component creates a connection to a Supabase vector store with search capabilities.
-For more information, see the [Supabase documentation](https://supabase.com/docs/guides/ai).
+The **Supabase** component reads and writes to Supabase vector stores using an instance of `SupabaseVectorStore`.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Supabase documentation](https://supabase.com/docs/guides/ai)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Supabase parameters</summary>
 
 | Name                | Type         | Description                               |
 | ------------------- | ------------ | ----------------------------------------- |
-| supabase_url        | String       | The URL of the Supabase instance.              |
-| supabase_service_key| SecretString | The service key for Supabase authentication.   |
-| table_name          | String       | The name of the table in Supabase.             |
-| query_name          | String       | The name of the query to use.                  |
-| search_query        | String       | The query for similarity search.               |
-| ingest_data         | Data         | The data to be ingested into the vector store. |
-| embedding           | Embeddings   | The embedding function to use.                 |
-| number_of_results   | Integer      | The number of results to return in search.     |
-
-**Outputs**
-
-| Name          | Type               | Description                               |
-| ------------- | ------------------ | ----------------------------------------- |
-| vector_store  | SupabaseVectorStore | A Supabase vector store instance.            |
-| search_results| List[Data]          | The results of the similarity search as a list of [Data](/data-types#data) objects.               |
+| supabase_url        | String       | Input parameter. The URL of the Supabase instance.              |
+| supabase_service_key| SecretString | Input parameter. The service key for Supabase authentication.   |
+| table_name          | String       | Input parameter. The name of the table in Supabase.             |
+| query_name          | String       | Input parameter. The name of the query to use.                  |
+| search_query        | String       | Input parameter. The query for similarity search.               |
+| ingest_data         | Data         | Input parameter. The data to be ingested into the vector store. |
+| embedding           | Embeddings   | Input parameter. The embedding function to use.                 |
+| number_of_results   | Integer      | Input parameter. The number of results to return in search.     |
 
 </details>
 
 ## Upstash
 
-This component creates an Upstash vector store with search capabilities.
-For more information, see the [Upstash documentation](https://upstash.com/docs/introduction).
+The **Upstash** component reads and writes to Upstash vector stores using an instance of `UpstashVectorStore`.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Upstash documentation](https://upstash.com/docs/introduction)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Upstash parameters</summary>
 
 | Name            | Type         | Description                               |
 | --------------- | ------------ | ----------------------------------------- |
-| index_url       | String       | The URL of the Upstash index.              |
-| index_token     | SecretString | The token for the Upstash index.           |
-| text_key        | String       | The key in the record to use as text.      |
-| namespace       | String       | The namespace for the index.                   |
-| search_query    | String       | The query for similarity search.               |
-| metadata_filter | String       | Filter documents by metadata.             |
-| ingest_data     | Data         | The data to be ingested into the vector store. |
-| embedding       | Embeddings   | The embedding function to use.      |
-| number_of_results | Integer    | The number of results to return in search.     |
-
-**Outputs**
-
-| Name          | Type             | Description                               |
-| ------------- | ---------------- | ----------------------------------------- |
-| vector_store  | UpstashVectorStore| An Upstash vector store instance.             |
-| search_results| List[Data]        | The results of the similarity search as a list of [Data](/data-types#data) objects.               |
+| index_url       | String       | Input parameter. The URL of the Upstash index.              |
+| index_token     | SecretString | Input parameter. The token for the Upstash index.           |
+| text_key        | String       | Input parameter. The key in the record to use as text.      |
+| namespace       | String       | Input parameter. The namespace for the index.                   |
+| search_query    | String       | Input parameter. The query for similarity search.               |
+| metadata_filter | String       | Input parameter. Filter documents by metadata.             |
+| ingest_data     | Data         | Input parameter. The data to be ingested into the vector store. |
+| embedding       | Embeddings   | Input parameter. The embedding function to use.      |
+| number_of_results | Integer    | Input parameter. The number of results to return in search.     |
 
 </details>
 
-## Vectara
+## Vectara Platform
 
-This component creates a Vectara vector store with search capabilities.
-For more information, see the [Vectara documentation](https://docs.vectara.com/docs/).
+The **Vectara** and **Vectara RAG** components support Vectara vector store, search, and RAG functionality using instances of `Vectara` vector store.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Vector store instances](#vector-store-instances)
+* [Vectara documentation](https://docs.vectara.com/docs/)
+
+### Vectara
+
+The **Vectara** component reads and writes to Vectara vector stores, and then produces [search results output](#search-results-output).
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Vectara parameters</summary>
 
 | Name             | Type         | Description                               |
 | ---------------- | ------------ | ----------------------------------------- |
-| vectara_customer_id | String     | The Vectara customer ID.                       |
-| vectara_corpus_id   | String     | The Vectara corpus ID.                         |
-| vectara_api_key   | SecretString | The Vectara API key.                           |
-| embedding         | Embeddings   | The embedding function to use (optional).      |
-| ingest_data       | List[Document/Data] | The data to be ingested into the vector store. |
-| search_query      | String       | The query for similarity search.               |
-| number_of_results | Integer      | The number of results to return in search.     |
-
-**Outputs**
-
-| Name          | Type              | Description                               |
-| ------------- | ----------------- | ----------------------------------------- |
-| vector_store  | VectaraVectorStore | Vectara vector store instance.             |
-| search_results| List[Data]         | The results of the similarity search as a list of [Data](/data-types#data) objects.               |
+| vectara_customer_id | String     | Input parameter. The Vectara customer ID.                       |
+| vectara_corpus_id   | String     | Input parameter. The Vectara corpus ID.                         |
+| vectara_api_key   | SecretString | Input parameter. The Vectara API key.                           |
+| embedding         | Embeddings   | Input parameter. The embedding function to use (optional).      |
+| ingest_data       | List[Document/Data] | Input parameter. The data to be ingested into the vector store. |
+| search_query      | String       | Input parameter. The query for similarity search.               |
+| number_of_results | Integer      | Input parameter. The number of results to return in search.     |
 
 </details>
 
-## Vectara RAG
+### Vectara RAG
 
-This component enabled Vectara's full end-to-end RAG capabilities with reranking options.
-For more information, see the [Vectara documentation](https://docs.vectara.com/docs/).
+This component enables Vectara's full end-to-end RAG capabilities with reranking options.
+
+This component uses a `Vectara` vector store to execute the vector search and reranking functions, and then outputs an **Answer** string in [`Message`](/data-types#message) format.
 
 ## Weaviate
 
-This component facilitates a Weaviate vector store setup, optimizing text and document indexing and retrieval.
-For more information, see the [Weaviate Documentation](https://weaviate.io/developers/weaviate).
+The **Weaviate** component reads and writes to Weaviate vector stores using an instance of `Weaviate` vector store.
+
+For more information, see the following:
+
+* [Hidden parameters](#hidden-parameters)
+* [Search results output](#search-results-output)
+* [Vector store instances](#vector-store-instances)
+* [Weaviate Documentation](https://weaviate.io/developers/weaviate)
 
 <details>
-<summary>Parameters</summary>
-
-**Inputs**
+<summary>Weaviate parameters</summary>
 
 | Name          | Type         | Description                               |
 |---------------|--------------|-------------------------------------------|
-| weaviate_url  | String       | The default instance URL.                      |
-| search_by_text| Boolean      | Indicates whether to search by text.       |
-| api_key       | SecretString | The optional API key for authentication.       |
-| index_name    | String       | The optional index name.                       |
-| text_key      | String       | The default text extraction key.               |
-| input         | Document     | The document or record.                        |
-| embedding     | Embeddings   | The embedding model used.                                |
-| attributes    | List[String] | Optional additional attributes.            |
-
-**Outputs**
-
-| Name         | Type             | Description                   |
-|--------------|------------------|-------------------------------|
-| vector_store | WeaviateVectorStore | The Weaviate vector store instance. |
+| weaviate_url  | String       | Input parameter. The default instance URL.                      |
+| search_by_text| Boolean      | Input parameter. Indicates whether to search by text.       |
+| api_key       | SecretString | Input parameter. The optional API key for authentication.       |
+| index_name    | String       | Input parameter. The optional index name.                       |
+| text_key      | String       | Input parameter. The default text extraction key.               |
+| input         | Document     | Input parameter. The document or record.                        |
+| embedding     | Embeddings   | Input parameter. The embedding model used.                     |
+| attributes    | List[String] | Input parameter. Optional additional attributes.            |
 
 </details>
\ No newline at end of file
diff --git a/docs/docs/Concepts/data-types.mdx b/docs/docs/Concepts/data-types.mdx
index 430d2057a..9bc346290 100644
--- a/docs/docs/Concepts/data-types.mdx
+++ b/docs/docs/Concepts/data-types.mdx
@@ -39,39 +39,33 @@ The schema is defined in [`data.py`](https://github.com/langflow-ai/langflow/blo
 
 The following attributes are available:
 
-- `data`: A dictionary that stores key-value pairs.
+- `data`: A `Data` object stores key-value pairs within the `.data` attribute. This is the `Data` object's core dictionary. Each key is a field name, and the values can be any supported data type.
 - `text_key`: The key in `data` that is considered the primary text value.
 - `default_value`: Fallback if `text_key` is missing. The default `text_key` is `"text"`.
 
-### Data structure
-
-A `Data` object stores key-value pairs within the `.data` attribute, where each key is a field name and its value can be any supported data type. `text_key` tells Langflow which key in the data dictionary is the primary text value for that object.
-
 ```python
 data_obj = Data(
-    text_key="text",            # Field 1
-    data={                      # Field 2 (the actual dict)
+    text_key="text",
+    data={
         "text": "Hello world",
         "name": "Charlie",
         "age": 28
     },
-    default_value=""            # Field 3
+    default_value=""
 )
 ```
 
 `Data` objects can be serialized to JSON, created from JSON, or created from other dictionary data.
 However, the resulting `Data` object is a structured object with validation and methods, not a plain dictionary.
-
-For example, when serialized into JSON, the previous example becomes the following JSON object:
+For example, when serialized into JSON, the previous Python example becomes the following JSON object:
 
 ```json
 {
   "text_key": "text",
   "data": {
-    "text": "User Profile",
-    "name": "Charlie Lastname",
-    "age": 28,
-    "email": "charlie.lastname@example.com"
+    "text": "Hello world",
+    "name": "Charlie",
+    "age": 28
   },
   "default_value": ""
 }
@@ -263,7 +257,7 @@ Hover over the port to see the accepted or produced data types.
 In Langflow, you can use <Icon name="TextSearch" aria-hidden="True" /> **Inspect output** to view the output of individual components.
 This can help you learn about the different data type and debug problems with invalid or malformed inputs and output.
 
-The following example shows how to inspect the output of a **Type Convert** component, which can convert `Message`, `Data`, or `DataFrame` input into `Message`, `Data`, or `DataFrame` output:
+The following example shows how to inspect the output of a [**Type Convert** component](/components-processing#type-convert), which can convert data from one type to another:
 
 1. Create a flow, and then connect a **Chat Input** component to a **Type Convert** component.
 
@@ -344,6 +338,7 @@ The following example shows how to inspect the output of a **Type Convert** comp
 
 ## See also
 
+- [**Processing** components](/components-processing)
 - [Custom components](/components-custom-components)
 - [Pydantic Models](https://docs.pydantic.dev/latest/api/base_model/)
 - [pandas.DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html)
\ No newline at end of file
diff --git a/docs/docs/Configuration/api-keys-and-authentication.mdx b/docs/docs/Configuration/api-keys-and-authentication.mdx
index 5553ae711..ca6c63020 100644
--- a/docs/docs/Configuration/api-keys-and-authentication.mdx
+++ b/docs/docs/Configuration/api-keys-and-authentication.mdx
@@ -317,7 +317,7 @@ Additionally, you must sign in as a superuser to manage users and [create a Lang
     uv run langflow run --env-file .env
     ```
 
-    Starting Langflow with an `.env` file automatically authenticates you as the superuser set in `LANGFLOW_SUPERUSER` and `LANGFLOW_SUPERUSER_PASSWORD`.
+    Starting Langflow with a `.env` file automatically authenticates you as the superuser set in `LANGFLOW_SUPERUSER` and `LANGFLOW_SUPERUSER_PASSWORD`.
     If you don't explicitly set these variables, the default values are `langflow` and `langflow` for system auto-login.
 
 6. Verify the server is running. The default location is `http://localhost:7860`.
diff --git a/docs/docs/Configuration/configuration-cli.mdx b/docs/docs/Configuration/configuration-cli.mdx
index a751e2f4b..211429003 100644
--- a/docs/docs/Configuration/configuration-cli.mdx
+++ b/docs/docs/Configuration/configuration-cli.mdx
@@ -230,7 +230,7 @@ Use this mode to previews the changes that would be made to the database schema
   </TabItem>
 </Tabs>
 
-### langflow run
+### langflow run {#langflow-run}
 
 Starts the Langflow server.
 
diff --git a/docs/docs/Configuration/environment-variables.mdx b/docs/docs/Configuration/environment-variables.mdx
index d4bf13414..53ba25c12 100644
--- a/docs/docs/Configuration/environment-variables.mdx
+++ b/docs/docs/Configuration/environment-variables.mdx
@@ -151,7 +151,7 @@ The following table lists the environment variables supported by Langflow.
 | `LANGFLOW_AUTO_SAVING_INTERVAL` | Integer | `1000` | Set the interval for flow auto-saving in milliseconds. |
 | `LANGFLOW_BACKEND_ONLY` | Boolean | False | Run only the Langflow backend service (no frontend). |
 | `LANGFLOW_BUNDLE_URLS` | List[String] | `[]` | A list of URLs from which to load component bundles and flows. Supports GitHub URLs. If LANGFLOW_AUTO_LOGIN is enabled, flows from these bundles are loaded into the database. |
-| `LANGFLOW_CACHE_TYPE` | String | `async` | Set the cache type for Langflow. Possible values: `async`, `redis`, `memory`, `disk`. If you set the type to `redis`, then you must also set the following environment variables: `LANGFLOW_REDIS_HOST`, `LANGFLOW_REDIS_PORT`, `LANGFLOW_REDIS_DB`, and `LANGFLOW_REDIS_CACHE_EXPIRE`. |
+| `LANGFLOW_CACHE_TYPE` | String | `async` | Set the cache type for Langflow. Possible values: `async`, `redis`, `memory`, `disk`. If you set the type to `redis`, then you must also set the following environment variables: `LANGFLOW_REDIS_HOST`, `LANGFLOW_REDIS_PORT`, `LANGFLOW_REDIS_DB`, and `LANGFLOW_REDIS_CACHE_EXPIRE`. See also [`langflow run`](/configuration-cli#langflow-run). |
 | `LANGFLOW_COMPONENTS_PATH` | String | Not set | Path to the directory containing custom components. |
 | `LANGFLOW_CONFIG_DIR` | String | Varies | Set the Langflow configuration directory where files, logs, and the Langflow database are stored. Default path depends on your installation. See [Flow storage and logs](/concepts-flows#flow-storage-and-logs). |
 | `LANGFLOW_DATABASE_URL` | String | Not set | Set the database URL for Langflow. If not provided, Langflow uses a SQLite database. |
@@ -163,14 +163,14 @@ The following table lists the environment variables supported by Langflow.
 | `LANGFLOW_DISABLE_TRACK_APIKEY_USAGE` | Boolean | False | Whether to track API key usage. If true, disables tracking of API key usage (`total_uses` and `last_used_at`) to avoid database contention under high concurrency. |
 | `LANGFLOW_ENABLE_SUPERUSER_CLI` | Boolean | True | Allow creation of superusers with the Langflow CLI command [`langflow superuser`](./configuration-cli.mdx#langflow-superuser). Recommended to be disabled (false) in production for security reasons. |
 | `LANGFLOW_FALLBACK_TO_ENV_VAR` | Boolean | True | If enabled, [global variables](/configuration-global-variables) set in your Langflow **Settings** can use an environment variable with the same name if Langflow can't retrieve the variable value from the global variables. |
-| `LANGFLOW_FRONTEND_PATH` | String | `./frontend` | Path to the frontend directory containing build files. This is for development purposes only. See [`--frontend-path`](./configuration-cli.mdx#run-frontend-path). |
-| `LANGFLOW_HEALTH_CHECK_MAX_RETRIES` | Integer | `5` | Set the maximum number of retries for the health check. See [`--health-check-max-retries`](./configuration-cli.mdx#run-health-check-max-retries). |
-| `LANGFLOW_HOST` | String | `localhost` | The host on which the Langflow server will run. See [`--host`](./configuration-cli.mdx#run-host). |
-| `LANGFLOW_LANGCHAIN_CACHE` | String | `InMemoryCache` | Type of cache to use. Possible values: `InMemoryCache`, `SQLiteCache`. See [`--cache`](./configuration-cli.mdx#run-cache). |
+| `LANGFLOW_FRONTEND_PATH` | String | `./frontend` | Path to the frontend directory containing build files. This is for development purposes only. See [`langflow run`](/configuration-cli#langflow-run). |
+| `LANGFLOW_HEALTH_CHECK_MAX_RETRIES` | Integer | `5` | Set the maximum number of retries for the health check. See [`langflow run`](/configuration-cli#langflow-run). |
+| `LANGFLOW_HOST` | String | `localhost` | The host on which the Langflow server will run. See [`langflow run`](/configuration-cli#langflow-run). |
+| `LANGFLOW_LANGCHAIN_CACHE` | String | `InMemoryCache` | Type of cache storage to use, separate from `LANGFLOW_CACHE_TYPE`. Possible values: `InMemoryCache`, `SQLiteCache`. |
 | `LANGFLOW_LOG_LEVEL` | String | `INFO` | Set the logging level for Langflow. Possible values: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`. |
 | `LANGFLOW_LOG_FILE` | String | Not set | Path to the log file. If this option isn't set, logs are written to stdout. |
 | `LANGFLOW_LOG_RETRIEVER_BUFFER_SIZE` | Integer | `10000` | Set the buffer size for log retrieval. Only used if `LANGFLOW_ENABLE_LOG_RETRIEVAL` is enabled. |
-| `LANGFLOW_MAX_FILE_SIZE_UPLOAD` | Integer | `100` | Set the maximum file size for the upload in megabytes. See [`--max-file-size-upload`](./configuration-cli.mdx#run-max-file-size-upload). |
+| `LANGFLOW_MAX_FILE_SIZE_UPLOAD` | Integer | `100` | Set the maximum file size for the upload in megabytes. See [`langflow run`](/configuration-cli#langflow-run). |
 | `LANGFLOW_MAX_ITEMS_LENGTH` | Integer | `100` | Maximum number of items to store and display in the visual editor. Lists longer than this will be truncated when displayed in the visual editor. Doesn't affect data passed between components nor outputs. |
 | `LANGFLOW_MAX_TEXT_LENGTH` | Integer | `1000` | Maximum number of characters to store and display in the visual editor. Responses longer than this will be truncated when displayed in the visual editor. Doesn't truncate responses between components nor outputs. |
 | `LANGFLOW_MCP_SERVER_ENABLED` | Boolean | True | If this option is set to False, Langflow doesn't enable the MCP server. |
diff --git a/docs/docs/Support/troubleshooting.mdx b/docs/docs/Support/troubleshooting.mdx
index cfadf7cf6..06a6e2629 100644
--- a/docs/docs/Support/troubleshooting.mdx
+++ b/docs/docs/Support/troubleshooting.mdx
@@ -146,7 +146,7 @@ The following error can occur during Langflow upgrades when the new version can'
 
 To resolve this error, clear the cache by deleting the contents of your Langflow cache folder.
 The filepath depends on your operating system, installation type, and configuration options.
-For more information and default filepaths, see [Memory management options](/memory#flow-storage-and-logs).
+For more information and default filepaths, see [Memory management options](/memory).
 
 :::important
 Clearing the cache erases your settings.
diff --git a/docs/docs/Tutorials/chat-with-files.mdx b/docs/docs/Tutorials/chat-with-files.mdx
index b9bb2cccb..3400446f0 100644
--- a/docs/docs/Tutorials/chat-with-files.mdx
+++ b/docs/docs/Tutorials/chat-with-files.mdx
@@ -31,8 +31,10 @@ The following steps modify the **Basic Prompting** template to accept file input
 2. In the **Language Model** component, enter your OpenAI API key.
 
     If you want to use a different provider or model, edit the **Model Provider**, **Model Name**, and **API Key** fields accordingly.
+
 3. To verify that your API key is valid, click <Icon name="Play" aria-hidden="true" /> **Playground**, and then ask the LLM a question.
 The LLM should respond according to the specifications in the **Prompt Template** component's **Template** field.
+
 4. Exit the **Playground**, and then modify the **Prompt Template** component to accept file input in addition to chat input.
 To do this, edit the **Template** field, and then replace the default prompt with the following text:
 
diff --git a/docs/static/img/conditional-looping.png b/docs/static/img/conditional-looping.png
new file mode 100644
index 000000000..3f3efadab
Binary files /dev/null and b/docs/static/img/conditional-looping.png differ