LlamaIndex

LlamaIndex is a data framework for building LLM applications over external data. It provides tools for ingesting, structuring, and querying data, making it straightforward to connect large language models with diverse data sources. Actian VectorAI DB integrates with LlamaIndex as a vector store through the llama-index-vector-stores-actian-vectorai package. This integration supports all standard LlamaIndex vector store operations, including adding nodes, similarity search, metadata filtering, and both synchronous and asynchronous workflows.

Installation

Install the VectorAI DB vector store integration for LlamaIndex:

pip install llama-index-vector-stores-actian-vectorai

You also need LlamaIndex core and an embedding provider:

pip install llama-index-core llama-index-embeddings-openai

Requirements

Python 3.10–3.12
A running Actian VectorAI DB instance (default endpoint: localhost:6574)

Quickstart

The ActianVectorAIVectorStore uses a context manager to handle connection lifecycle automatically. Vector configuration is inferred from the first inserted embedding if not specified.

from llama_index.vector_stores.actian_vectorai import ActianVectorAIVectorStore
from llama_index.core.schema import TextNode
from llama_index.core.vector_stores.types import VectorStoreQuery

# Create nodes with embeddings.
nodes = [
    TextNode(text="VectorAI DB supports semantic search.", embedding=[0.1, 0.2, 0.3]),
    TextNode(text="LlamaIndex builds RAG pipelines.", embedding=[0.4, 0.5, 0.6]),
]

with ActianVectorAIVectorStore() as vector_store:
    # Add nodes to the vector store.
    vector_store.add(nodes)

    # Query the vector store with an embedding.
    query = VectorStoreQuery(query_embedding=[0.1, 0.2, 0.3], similarity_top_k=5)
    result = vector_store.query(query)

Connection management

The integration supports several connection patterns for managing client lifecycle. The examples in this section assume you have nodes and query objects as shown in the Quickstart above.

Context manager (recommended)

Use a context manager for automatic connection handling:

with ActianVectorAIVectorStore(url="localhost:6574") as vector_store:
    vector_store.add(nodes)
    result = vector_store.query(query)

Manual connection

For fine-grained control over connection lifecycle:

vector_store = ActianVectorAIVectorStore()

vector_store.connect()
vector_store.add(nodes)
result = vector_store.query(query)
vector_store.close()

External client

Pass a pre-configured VectorAIClient when you need to share a connection or supply custom client configuration:

from actian_vectorai import VectorAIClient

with VectorAIClient("localhost:6574") as client:
    vector_store = ActianVectorAIVectorStore(client=client)
    vector_store.add(nodes)
    result = vector_store.query(query)

When an external client is provided, url and client_kwargs are ignored. The caller is responsible for managing the client’s lifecycle.

Async operations

All operations have async counterparts for non-blocking workflows. Async methods use AsyncVectorAIClient under the hood. The examples in this section use the same nodes setup as the Quickstart.

Async context manager

Use an async context manager for automatic connection handling:

from llama_index.vector_stores.actian_vectorai import ActianVectorAIVectorStore
from llama_index.core.vector_stores.types import VectorStoreQuery

async with ActianVectorAIVectorStore() as vector_store:
    await vector_store.async_add(nodes)

    query = VectorStoreQuery(query_embedding=[0.1, 0.2, 0.3], similarity_top_k=5)
    result = await vector_store.aquery(query)

    await vector_store.adelete("doc_01")
    await vector_store.aclear()

Async manual connection

For fine-grained control over async connection lifecycle:

vector_store = ActianVectorAIVectorStore()

await vector_store.aconnect()
await vector_store.async_add(nodes)

query = VectorStoreQuery(query_embedding=[0.1, 0.2, 0.3], similarity_top_k=5)
result = await vector_store.aquery(query)
await vector_store.aclose()

Async external client

Pass a pre-configured AsyncVectorAIClient when you need to share an async connection:

from actian_vectorai import AsyncVectorAIClient

async with AsyncVectorAIClient("localhost:6574") as async_client:
    vector_store = ActianVectorAIVectorStore(async_client=async_client)
    await vector_store.async_add(nodes)

    query = VectorStoreQuery(query_embedding=[0.1, 0.2, 0.3], similarity_top_k=5)
    result = await vector_store.aquery(query)

The async_client must be a different instance from the internal async client of a provided sync client.

Deleting data

Remove nodes from the vector store using document IDs, metadata filters, or by clearing the entire collection.

Delete by source document ID

Remove all nodes associated with a source document:

with ActianVectorAIVectorStore() as vector_store:
    vector_store.delete("doc_01")

Delete with metadata filters

Remove nodes matching specific metadata conditions:

from llama_index.core.vector_stores.types import (
    FilterOperator,
    MetadataFilter,
    MetadataFilters,
)

vector_store.delete_nodes(
    filters=MetadataFilters(
        filters=[
            MetadataFilter(
                key="category",
                operator=FilterOperator.IN,
                value=["ai", "energy"],
            ),
        ]
    )
)

Clear collection

Delete the entire collection:

with ActianVectorAIVectorStore() as vector_store:
    vector_store.clear()

Custom vector configuration

Specify explicit vector parameters instead of relying on auto-detection:

from actian_vectorai import VectorParams, Distance

with ActianVectorAIVectorStore(
    url="localhost:6574",
    collection_name="my_collection",
    dense_vector_name="dense_vector",
    dense_vector_params=VectorParams(size=1536, distance=Distance.Cosine),
) as vector_store:
    vector_store.add(nodes)

When dense_vector_params is omitted, vector configuration is inferred from the first inserted embedding and defaults to cosine distance.

Metadata filtering

Metadata filters can be used with query, delete_nodes, and adelete_nodes to narrow results based on payload fields.

Supported filter operators

Operator	Description
`EQ`	Exact match (string or numeric).
`NE`	Not equal.
`GT` / `LT`	Numeric greater/less than.
`GTE` / `LTE`	Numeric greater/less than or equal.
`IN`	Match any value in a list (or comma-separated string).
`NIN`	Match none of the values in a list (or comma-separated string).
`TEXT_MATCH`	Case-sensitive substring/token match.
`IS_EMPTY`	Field is absent or null.

Unsupported operators (ANY, ALL, TEXT_MATCH_INSENSITIVE, CONTAINS) raise NotImplementedError.

Filter conditions

AND, OR, and NOT conditions are supported through FilterCondition:

from llama_index.core.vector_stores.types import (
    FilterCondition,
    FilterOperator,
    MetadataFilter,
    MetadataFilters,
    VectorStoreQuery,
)

# AND condition
query = VectorStoreQuery(
    query_embedding=[0.1, 0.2, 0.3],
    similarity_top_k=5,
    filters=MetadataFilters(
        filters=[
            MetadataFilter(
                key="category", operator=FilterOperator.EQ, value="ai"
            ),
            MetadataFilter(
                key="score", operator=FilterOperator.GTE, value=0.7
            ),
        ],
        condition=FilterCondition.AND,
    ),
)

result = vector_store.query(query)

Configuration

Parameter	Type	Default	Description
`url`	`str`	`"localhost:6574"`	Actian VectorAI DB endpoint (`host:port`). Ignored when explicit clients are provided.
`collection_name`	`str`	`"llama_index_collection"`	Collection to use for storing vectors and metadata.
`dense_vector_name`	`str`	`"llama_index_dense_vector"`	Name of the dense vector field inside the collection.
`dense_vector_params`	`VectorParams \| None`	`None`	Vector configuration (size, distance metric). Inferred from the first inserted embedding if omitted (defaults to cosine distance).
`stores_text`	`bool`	`False`	Store node text in the point payload in addition to metadata.
`clear_existing_collection`	`bool`	`False`	Delete any existing collection with the same name before the first operation.
`client_kwargs`	`dict \| None`	`None`	Extra keyword arguments forwarded to internally created sync/async clients.
`collection_kwargs`	`dict \| None`	`None`	Extra keyword arguments passed to collection creation. Do not include `vectors_config`; it is derived from `dense_vector_name` and `dense_vector_params`.
`client`	`VectorAIClient \| None`	`None`	Pre-configured synchronous client. When provided, `url` and `client_kwargs` are ignored.
`async_client`	`AsyncVectorAIClient \| None`	`None`	Pre-configured asynchronous client. Must be a different instance from the internal async client of a provided `client`.

API reference

Method	Async variant	Description
`add()`	`async_add()`	Add nodes to the vector store.
`query()`	`aquery()`	Query the vector store with an embedding.
`delete()`	`adelete()`	Delete nodes by source document ID.
`delete_nodes()`	`adelete_nodes()`	Delete nodes matching metadata filters.
`clear()`	`aclear()`	Delete the entire collection.
`connect()`	`aconnect()`	Manually open a connection.
`close()`	`aclose()`	Manually close a connection.

Limitations

get_nodes() and aget_nodes() are not implemented (pending scroll API support in the Actian VectorAI client).
Only VectorStoreQueryMode.DEFAULT (dense vector search) is supported.

Next steps

LangChain — Alternative framework for RAG pipelines.
Search — Understand the underlying vector search operations.
Filtering — Apply metadata conditions to narrow search results.

Get started

SDKs

Guides

Integrations

Support

Legal

Installation

Requirements

Quickstart

Connection management

Context manager (recommended)

Manual connection

External client

Async operations

Async context manager

Async manual connection

Async external client

Deleting data

Delete by source document ID

Delete with metadata filters

Clear collection

Custom vector configuration

Metadata filtering

Supported filter operators

Filter conditions

Configuration

API reference

Limitations

Next steps

​Installation

​Requirements

​Quickstart

​Connection management

​Context manager (recommended)

​Manual connection

​External client

​Async operations

​Async context manager

​Async manual connection

​Async external client

​Deleting data

​Delete by source document ID

​Delete with metadata filters

​Clear collection

​Custom vector configuration

​Metadata filtering

​Supported filter operators

​Filter conditions

​Configuration

​API reference

​Limitations

​Next steps

Installation

Requirements

Quickstart

Connection management

Context manager (recommended)

Manual connection

External client

Async operations

Async context manager

Async manual connection

Async external client

Deleting data

Delete by source document ID

Delete with metadata filters

Clear collection

Custom vector configuration

Metadata filtering

Supported filter operators

Filter conditions

Configuration

API reference

Limitations

Next steps