---
title: DataStax
slug: /bundles-datastax
---

import Icon from "@site/src/components/icon";
import PartialParams from '@site/docs/_partial-hidden-params.mdx';
import PartialConditionalParams from '@site/docs/_partial-conditional-params.mdx';
import PartialVectorSearchResults from '@site/docs/_partial-vector-search-results.mdx';
import PartialVectorStoreInstance from '@site/docs/_partial-vector-store-instance.mdx';

<Icon name="Blocks" aria-hidden="true" /> [**Bundles**](/components-bundle-components) contain custom components that support specific third-party integrations with Langflow.

This page describes the components that are available in the **DataStax** bundle, including components that read and write to Astra DB databases.

## Astra DB

:::warning
It is recommended 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.
:::

The **Astra DB** component reads and writes to Astra DB Serverless databases, using an instance of `AstraDBVectorStore` to call the Data API and DevOps API.

<details>
<summary>About vector store instances</summary>

<PartialVectorStoreInstance />

</details>

### Astra DB 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.

<PartialParams />

<PartialConditionalParams />

For information about accepted values and functionality, see the [Astra DB Serverless documentation](https://docs.datastax.com/en/astra-db-serverless/index.html) or inspect [component code](/concepts-components#component-code).

| 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. Typically always `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 before setting the remaining parameters. |
| endpoint | Astra DB API Endpoint | Input parameter. For multi-region databases, select the API endpoint for your nearest datacenter. To get the list of regions for a multi-region database, see [List database regions](https://docs.datastax.com/en/astra-db-serverless/databases/manage-regions.html#list-db-regions). This field is automatically populated when you select a database, and it defaults to the primary region's 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. 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. Accepts `JSON` or `Table` input. |
| 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 vector-enabled 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 is only available for collections that support hybrid search. To determine 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 [Hybrid search example](#astra-db-examples). |
| 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. |

### Astra DB examples

<details>
<summary>Example: Vector RAG</summary>

import PartialVectorRagFlow from '@site/docs/_partial-vector-rag-flow.mdx';

<PartialVectorRagFlow />

</details>

<details>
<summary>Example: Hybrid search</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. 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 don't already have one.

    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.

    After loading the template, check for **Upgrade available** alerts on the components.
    If any components have an upgrade pending, upgrade and reconnect them before continuing.

3. In the **Language Model** components, add your OpenAI API key.
If you want to use a different provider or model, see [Language model components](/components-models).

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. 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.

7. Update the **Structured Output** template:

    1. Click the **Structured Output** component to expose the [component inspection panel](/concepts-components#component-menus).
    2. 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.
        You should convert the query into:
        1. A list of keywords to use against a Lucene text analyzer index, no more than 4. Strictly unigrams.
        2. A question to use as the basis for a QA embedding engine.
        Avoid common keywords associated with the user's subject matter.
        ```

    3. Click **Finish Editing**, and then click **Close** to save your changes to the component.

8. Open the **Playground**, and then enter a natural language question that you would ask about your database.

    In this example, your input is sent to both the **Astra DB** and **Structured Output** components:

    * 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.

    * 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 `Table` that is transformed into a text string `Message` by another **Parser** component.
    Finally, the **Chat Output** component prints the `Message` response to the **Playground**.

9. 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 `JSON` 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 `JSON`, and then used as lexical terms for the hybrid search.

    * **Astra DB component**: The output is the `Table` containing the results of the hybrid search as returned by the Data API.

</details>

### Astra DB output

<PartialVectorSearchResults />

<details>
<summary>Vector Store Connection port</summary>

The **Astra DB** component has 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.

The only non-legacy component that supports this input is the [**Graph RAG** component](#graph-rag), which can be a Graph RAG extension to the **Astra DB** component.
Instead, use the **Astra DB Graph** component that includes both the vector store connection and Graph RAG functionality.

</details>

## Astra DB CQL

The **Astra DB CQL** component allows agents to query data from CQL tables in Astra DB.

The output is a list of [`JSON`](/data-types#json) objects containing the query results from the Astra DB CQL table. Each Data object contains the document fields specified by the projection fields. Limited by the `number_of_results` parameter.

### Astra DB CQL parameters

<PartialParams />

| Name | Type | Description |
|------|------|-------------|
| Tool Name | String | Input parameter. The name used to reference the tool in the agent's prompt. |
| Tool Description | String | Input parameter. A brief description of the tool to guide the model in using it. |
| Keyspace | String | Input parameter. The name of the keyspace. |
| Table Name | String | Input parameter. The name of the Astra DB CQL table to query. |
| Token | SecretString | Input parameter. The authentication token for Astra DB. |
| API Endpoint | String | Input parameter. The Astra DB API endpoint. |
| Projection Fields | String | Input parameter. The attributes to return, separated by commas. Default: "*". |
| Partition Keys | Dict | Input parameter. Required parameters that the model must fill to query the tool. |
| Clustering Keys | Dict | Input parameter. Optional parameters the model can fill to refine the query. Required parameters should be marked with an exclamation mark, for example, `!customer_id`. |
| Static Filters | Dict | Input parameter. Attribute-value pairs used to filter query results. |
| Limit | String | Input parameter. The number of records to return. |

## Astra DB Data API

The **Astra DB Data API** component runs document-level Data API operations — `find`, `find_one`, `insert_one`, `insert_many`, `update_one`, `update_many`, `delete_one`, `delete_many`, `count_documents`, and `estimated_document_count` — against a collection using the [`astrapy`](https://github.com/datastax/astrapy) Python SDK directly.

Unlike the [**Astra DB** component](#astra-db), which wraps `AstraDBVectorStore` from `langchain-astradb` and is oriented around vector ingest/search, the **Astra DB Data API** component is a thin, direct pass-through to `astrapy`. No `langchain-astradb` code path is used at runtime, which makes it a good fit for:

* Exact-match and compound metadata queries on collections that may or may not be vector-enabled.
* CRUD-style writes and updates (`$set`, `$inc`, `$push`, `$unset`, and other Data API operators).
* Document counts (bounded with `count_documents`, statistical with `estimated_document_count`).
* Wiring an agent tool that can *both* read and write to Astra DB.

The component also provides an **astrapy-only** "Create new collection" dialog (equivalent to the one on the **Astra DB** component) so you can spin up a collection — with or without a vectorize integration — without installing `langchain-astradb`.

:::note
The operation tab dynamically shows and hides only the inputs relevant to the selected operation, so the configuration surface stays minimal. For example, selecting **Insert One** hides all filter/projection/sort inputs and shows a single **Document** input.
:::

### Astra DB Data API parameters

<PartialParams />

| Name | Display Name | Info |
|------|--------------|------|
| token | Astra DB Application Token | Input parameter. An Astra application token with permission to access your database. |
| environment | Environment | Input parameter. The Astra DB environment, typically `prod`. |
| database_name | Database | Input parameter. The database the component will connect to. Supports in-app database creation. |
| api_endpoint | Astra DB API Endpoint | Input parameter. Auto-populated from the selected database. |
| keyspace | Keyspace | Input parameter. Defaults to `default_keyspace`. |
| collection_name | Collection | Input parameter. The target collection. Supports in-app collection creation via `astrapy` directly (no `langchain-astradb` dependency). |
| operation | Operation | Input parameter. One of `Find`, `Find One`, `Insert One`, `Insert Many`, `Update One`, `Update Many`, `Delete One`, `Delete Many`, `Count Documents`, `Estimated Count`. |
| filter_query | Filter | Input parameter. MongoDB-style filter document, e.g. `{"status": "active", "age": {"$gte": 18}}`. Used by find, update, delete, and count operations. |
| projection | Projection | Input parameter. Fields to include (`1`) or exclude (`0`), e.g. `{"name": 1, "email": 1}`. |
| sort | Sort | Input parameter. Sort specification. Use `$vector` or `$vectorize` for vector search, e.g. `{"$vectorize": "search query"}`. |
| limit | Limit | Input parameter. Maximum number of documents returned by `find`. Default: `100`. |
| skip | Skip | Input parameter. Number of documents to skip. |
| include_similarity | Include Similarity | Input parameter. Include the `$similarity` score on returned documents (vector searches only). |
| document | Document | Input parameter. Single JSON document for `Insert One`. |
| documents | Documents | Input parameter. List of JSON documents for `Insert Many`. |
| ordered | Ordered Insert | Input parameter. If `true`, `Insert Many` stops at the first error. Default: `false`. |
| update | Update | Input parameter. Update-operator document for `Update One` / `Update Many`, e.g. `{"$set": {"status": "archived"}}`. |
| upsert | Upsert | Input parameter. If `true`, inserts a new document when no match is found. Default: `false`. |
| upper_bound | Count Upper Bound | Input parameter. Maximum count `count_documents` will scan to. Default: `1000`. |

### Astra DB Data API outputs

| Output | Type | Description |
|--------|------|-------------|
| **Data** | `list[Data]` | List of JSON documents returned by the selected operation. Writes return a single-element list summarising the result (e.g. `inserted_ids`, `modified_count`, `deleted_count`). |
| **Table** | `Table` | The same result expressed as a tabular [`Table`](/data-types#table) for easy preview and downstream tabular processing. |
| **Raw Result** | `Data` | The raw `astrapy` result envelope as a single JSON object — useful for debugging or accessing fields like `matched_count` vs `modified_count`. |

Because key inputs (`operation`, `filter_query`, `limit`, `document`, `documents`, `update`) expose **Tool Mode**, the component can also be connected to an **Agent** component as a tool. When used as a tool, the agent controls the selected operation and the payload while you retain control of the database, keyspace, and collection via the component's configuration.

### Astra DB Data API examples

<details>
<summary>Example: Insert documents</summary>

1. In a flow, add the **Astra DB Data API** component.
2. Provide a token and select a database, keyspace, and collection.
3. Set **Operation** to **Insert Many**.
4. In **Documents**, provide a JSON list of documents, for example:

    ```json
    [
      {"name": "Ada Lovelace", "role": "engineer"},
      {"name": "Grace Hopper", "role": "engineer"}
    ]
    ```

5. Run the component. The **Data** output contains a single summary object with `inserted_ids` and `inserted_count`.

</details>

<details>
<summary>Example: Filter-based search</summary>

1. Set **Operation** to **Find**.
2. In **Filter**, provide a MongoDB-style filter, for example:

    ```json
    {"role": "engineer", "active": true}
    ```

3. Optionally set **Projection** (e.g. `{"name": 1, "role": 1}`), **Sort**, and **Limit**.
4. Run the component. The **Data** output contains matching documents as a list of JSON objects; the **Table** output renders the same result as a [`Table`](/data-types#table).

</details>

<details>
<summary>Example: Use as an agent tool</summary>

1. In a flow with an **Agent** component, add the **Astra DB Data API** component.
2. Select the database, keyspace, and collection.
3. Toggle **Tool Mode** on the **Astra DB Data API** component, and connect its tool output to the agent's **Tools** input.
4. Leave **Operation**, **Filter**, **Limit**, **Document**, **Documents**, and **Update** unset — the agent will populate them per tool call based on the user's request.

</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/).

### Graph RAG 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.

<PartialParams />

<PartialConditionalParams />

| Name | Display Name | Info |
|------|--------------|------|
| embedding_model | Embedding Model | Input parameter. Specify the embedding model to use. Not required if the connected vector store has a [vectorize integration](https://docs.datastax.com/en/astra-db-serverless/databases/embedding-generation.html). |
| vector_store | Vector Store Connection | Input parameter. An instance of `AstraDbVectorStore` inherited from the [**Astra DB** component](#astra-db)'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 [`JSON`](/data-types#json) objects or as a tabular [`Table`](/data-types#table). You can set the desired output type near the component's output port. |

## Hyper-Converged Database (HCD)

The **Hyper-Converged Database (HCD)** component uses your cluster's Data API server to read and write to your 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)

<details>
<summary>About vector store instances</summary>

<PartialVectorStoreInstance />

</details>

<PartialVectorSearchResults />

For more information about HCD, see [Get started with HCD 1.2](https://docs.datastax.com/en/hyper-converged-database/1.2/get-started/get-started-hcd.html) and [Get started with the Data API in HCD 1.2](https://docs.datastax.com/en/hyper-converged-database/1.2/api-reference/dataapiclient.html).

### HCD 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.

<PartialParams />

<PartialConditionalParams />

| Name | Display Name | Info |
|------|--------------|------|
| 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 for 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 to 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. A 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. A 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. |

## Other DataStax components

The following components are also included in the **DataStax** bundle.

### Astra DB Chat Memory

The **Astra DB Chat Memory** component retrieves and stores chat messages using an Astra DB database.

Chat memories are passed between memory storage components as the [`Memory`](/data-types#memory) data type.
Specifically, the component creates an instance of `AstraDBChatMessageHistory`, which is a LangChain chat message history class that uses Astra DB for storage.

:::warning
The **Astra DB Chat Memory** component isn't recommended for most memory storage because memories tend to be long JSON objects or strings, often exceeding the maximum size of a document or object supported by Astra DB.

However, Langflow's **Agent** component includes built-in chat memory that is enabled by default.
Your agentic flows don't need an external database to store chat memory.
For more information, see [Memory management options](/memory).
:::

For more information about using external chat memory in flows, see the [**Message History** component](/message-history).

#### Astra DB Chat Memory parameters

<PartialParams />

| Name             | Type          | Description                                                           |
|------------------|---------------|-----------------------------------------------------------------------|
| collection_name  | String        | Input parameter. The name of the Astra DB collection for storing messages. Required. |
| token            | SecretString  | Input parameter. The authentication token for Astra DB access. Required. |
| api_endpoint     | SecretString  | Input parameter. The API endpoint URL for the Astra DB service. Required. |
| namespace        | String        | Input parameter. The optional namespace within Astra DB for the collection. |
| session_id       | MessageText   | Input parameter. The unique identifier for the chat session. Uses the current session ID if not provided. |


## Legacy DataStax components

import PartialLegacy from '@site/docs/_partial-legacy.mdx';

<PartialLegacy />

The following DataStax components are in legacy status:

<details>
<summary>Astra DB Tool</summary>

Replace the **Astra DB Tool** component with the [**Astra DB** component](#astra-db).

The **Astra DB Tool** component enables searching data in Astra DB collections, including hybrid search, vector search, and regular filter-based search.
Specialized searches require that the collection is pre-configured with the required parameters.

Outputs a list of [`JSON`](/data-types#json) objects containing the query results from Astra DB. Each `JSON` object contains the document fields specified by the projection attributes. Limited by the `number_of_results` parameter and the upper limit of the Astra DB Data API, depending on the type of search.

You can use the component to execute queries directly as isolated steps in a flow, or you can connect it as a [tool for an agent](/agents-tools) to allow the agent to query data from Astra DB collections as needed to respond to user queries.


The values for **Collection Name**, **Astra DB Application Token**, and **Astra DB API Endpoint** are found in your Astra DB deployment. For more information, see the [Astra DB Serverless documentation](https://docs.datastax.com/en/astra-db-serverless/databases/create-database.html).

| Name              | Type   | Description   |
|-------------------|--------|--------|
| Tool Name         | String | Input parameter. The name used to reference the tool in the agent's prompt.  |
| Tool Description  | String | Input parameter. A brief description of the tool. This helps the model decide when to use it. |
| Keyspace Name     | String | Input parameter. The name of the keyspace in Astra DB. Default: `default_keyspace` |
| Collection Name   | String | Input parameter. The name of the Astra DB collection to query.    |
| Token             | SecretString | Input parameter. The authentication token for accessing Astra DB.  |
| API Endpoint      | String | Input parameter. The Astra DB API endpoint.  |
| Projection Fields | String | Input parameter. Comma-separated list of attributes to return from matching documents. The default is the default projection, `*`, which returns all attributes except reserved fields like `$vector`.  |
| Tool Parameters  | Dict   | Input parameter. [Astra DB Data API `find` filters](https://docs.datastax.com/en/astra-db-serverless/api-reference/document-methods/find-many.html#parameters) that become tools for an agent. These Filters _may_ be used in a search, if the agent selects them. |
| Static Filters    | Dict   | Input parameter. Attribute-value pairs used to filter query results. Equivalent to [Astra DB Data API `find` filters](https://docs.datastax.com/en/astra-db-serverless/api-reference/document-methods/find-many.html#parameters). **Static Filters** are included with _every_ query. Use **Static Filters** without semantic search to perform a regular filter search. |
| Number of Results  | Int | Input parameter. The maximum number of documents to return.   |
| Semantic Search | Boolean | Input parameter. Whether to run a similarity search by generating a vector embedding from the chat input and following the **Semantic Search Instruction**. Default: `false`. If `true`, you must attach an [embedding model component](/components-embedding-models) or have vectorize pre-enabled on your collection. |
| Use Astra DB Vectorize | Boolean | Input parameter. Whether to use the Astra DB vectorize feature for embedding generation when running a semantic search. Default: `false`. If `true`, you must have vectorize pre-enabled on your collection. |
| Embedding Model | Embedding | Input parameter. A port to attach an embedding model component to generate a vector from input text for semantic search. This can be used when **Semantic Search** is `true`, with or without vectorize. Be sure to use a model that aligns with the dimensions of the embeddings already present in the collection. |
| Semantic Search Instruction | String | Input parameter. The query to use for similarity search. Default: `"Find documents similar to the query."`. This instruction is used to guide the model in performing semantic search. |

</details>


<details>
<summary>Astra DB Graph</summary>

Replace the **Astra DB Graph** component with the [**Graph RAG** component](#graph-rag).

The **Astra DB Graph** component uses `AstraDBGraphVectorStore`, an instance of [LangChain graph vector store](https://python.langchain.com/api_reference/community/graph_vectorstores.html), 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).


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.

<PartialParams />

<PartialConditionalParams />

For information about accepted values and functionality, see the [Astra DB Serverless documentation](https://docs.datastax.com/en/astra-db-serverless/index.html) or inspect [component code](/concepts-components#component-code).

| 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. |
| 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 to 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. A 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. A 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. |

</details>

<details>
<summary>Environment variable components</summary>

The following DataStax components were used to load and retrieve environment variables in a flow:

* **Dotenv**: Loads environment variables from a `.env` file
* **Get Environment Variable**: Retrieves the value of an environment variable

These components are legacy. Use Langflow's built-in environment variable support or global variables instead.

</details>

<details>
<summary>Astra Vectorize</summary>

This component was deprecated in Langflow version 1.1.2.
Replace it with the [**Astra DB** component](#astra-db).

The **Astra DB Vectorize** component was used to generate embeddings with Astra DB's vectorize feature in conjunction with an **Astra DB** component.

The vectorize functionality is now built into the **Astra DB** component.
You no longer need a separate component for vectorize embedding generation.

</details>

## See also

* [**Cassandra** bundle](/bundles-cassandra)
* [Create a vector RAG chatbot](/chat-with-rag)
