@vectorstores/astra 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) vectorstores contributors 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,215 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var astraDbTs = require('@datastax/astra-db-ts');
+var core = require('@vectorstores/core');
+var env = require('@vectorstores/env');
+
+class AstraDBVectorStore extends core.BaseVectorStore {
+    constructor(init){
+        super(init), this.storesText = true, this.flatMetadata = true;
+        const token = init?.params?.token ?? env.getEnv("ASTRA_DB_APPLICATION_TOKEN");
+        const endpoint = init?.params?.endpoint ?? env.getEnv("ASTRA_DB_API_ENDPOINT");
+        if (!token) {
+            throw new Error("Must specify ASTRA_DB_APPLICATION_TOKEN via env variable.");
+        }
+        if (!endpoint) {
+            throw new Error("Must specify ASTRA_DB_API_ENDPOINT via env variable.");
+        }
+        const namespace = init?.params?.namespace ?? env.getEnv("ASTRA_DB_NAMESPACE") ?? "default_keyspace";
+        this.astraClient = new astraDbTs.DataAPIClient(token, {
+            caller: [
+                "LlamaIndexTS"
+            ]
+        });
+        this.astraDB = this.astraClient.db(endpoint, {
+            namespace
+        });
+        this.idKey = init?.idKey ?? "_id";
+        this.contentKey = init?.contentKey ?? "content";
+    }
+    /**
+   * Create a new collection in your Astra DB vector database and connects to it.
+   * You must call this method or `connect` before adding, deleting, or querying.
+   *
+   * @param collection - Your new collection's name
+   * @param options - CreateCollectionOptions used to set the number of vector dimensions and similarity metric
+   * @returns Promise that resolves if the creation did not throw an error.
+   */ async createAndConnect(collection, options) {
+        this.collection = await this.astraDB.createCollection(collection, options);
+        console.debug("Created Astra DB collection");
+        return;
+    }
+    /**
+   * Connect to an existing collection in your Astra DB vector database.
+   * You must call this method or `createAndConnect` before adding, deleting, or querying.
+   *
+   * @param collection - Your existing collection's name
+   * @returns Promise that resolves if the connection did not throw an error.
+   */ async connect(collection) {
+        this.collection = await this.astraDB.collection(collection);
+        console.debug("Connected to Astra DB collection");
+        return;
+    }
+    /**
+   * Get an instance of your Astra DB client.
+   * @returns the AstraDB client
+   */ client() {
+        return this.astraClient;
+    }
+    /**
+   * Add your document(s) to your Astra DB collection.
+   *
+   * @returns an array of node ids which were added
+   */ async add(nodes) {
+        if (!this.collection) {
+            throw new Error("Must connect to collection before adding.");
+        }
+        const collection = this.collection;
+        if (!nodes || nodes.length === 0) {
+            return [];
+        }
+        const dataToInsert = nodes.map((node)=>{
+            const metadata = core.nodeToMetadata(node, true, this.contentKey, this.flatMetadata);
+            return {
+                $vector: node.getEmbedding(),
+                [this.idKey]: node.id_,
+                [this.contentKey]: node.getContent(core.MetadataMode.NONE),
+                ...metadata
+            };
+        });
+        console.debug(`Adding ${dataToInsert.length} rows to table`);
+        const insertResult = await collection.insertMany(dataToInsert);
+        return insertResult.insertedIds;
+    }
+    /**
+   * Delete a document from your Astra DB collection.
+   *
+   * @param refDocId - The id of the document to delete
+   * @param deleteOptions - DeleteOneOptions to pass to the delete query
+   * @returns Promise that resolves if the delete query did not throw an error.
+   */ async delete(refDocId, deleteOptions) {
+        if (!this.collection) {
+            throw new Error("Must connect to collection before deleting.");
+        }
+        const collection = this.collection;
+        console.debug(`Deleting row with id ${refDocId}`);
+        await collection.deleteOne({
+            _id: refDocId
+        }, deleteOptions);
+    }
+    /**
+   * Query documents from your Astra DB collection to get the closest match to your embedding.
+   *
+   * @param query - VectorStoreQuery
+   * @param options - FindOptions
+   */ async query(query, options) {
+        if (!this.collection) {
+            throw new Error("Must connect to collection before querying.");
+        }
+        const collection = this.collection;
+        const astraFilter = this.toAstraFilter(query.filters);
+        const cursor = await collection.find(astraFilter, {
+            ...options,
+            sort: query.queryEmbedding ? {
+                $vector: query.queryEmbedding
+            } : options?.sort,
+            limit: query.similarityTopK,
+            includeSimilarity: true
+        });
+        const nodes = [];
+        const ids = [];
+        const similarities = [];
+        for await (const row of cursor){
+            const { $vector: embedding, $similarity: similarity, [this.idKey]: id, [this.contentKey]: content, ...metadata } = row;
+            const node = core.metadataDictToNode(metadata, {
+                fallback: {
+                    id,
+                    text: content,
+                    ...metadata
+                }
+            });
+            node.setContent(content);
+            ids.push(id);
+            similarities.push(similarity);
+            nodes.push(node);
+        }
+        return {
+            similarities,
+            ids,
+            nodes
+        };
+    }
+    toAstraFilter(filters) {
+        if (!filters || filters.filters?.length === 0) return {};
+        const condition = filters.condition ?? core.FilterCondition.AND;
+        const listFilter = filters.filters.map((f)=>this.buildFilterItem(f));
+        if (condition === core.FilterCondition.OR) return {
+            $or: listFilter
+        };
+        if (condition === core.FilterCondition.AND) return {
+            $and: listFilter
+        };
+        throw new Error(`Not supported filter condition: ${condition}`);
+    }
+    buildFilterItem(filter) {
+        const { key, operator, value } = filter;
+        switch(operator){
+            case core.FilterOperator.EQ:
+                return {
+                    [key]: value
+                };
+            case core.FilterOperator.NE:
+                return {
+                    [key]: {
+                        $ne: value
+                    }
+                };
+            case core.FilterOperator.GT:
+                return {
+                    [key]: {
+                        $gt: value
+                    }
+                };
+            case core.FilterOperator.LT:
+                return {
+                    [key]: {
+                        $lt: value
+                    }
+                };
+            case core.FilterOperator.GTE:
+                return {
+                    [key]: {
+                        $gte: value
+                    }
+                };
+            case core.FilterOperator.LTE:
+                return {
+                    [key]: {
+                        $lte: value
+                    }
+                };
+            case core.FilterOperator.IN:
+                return {
+                    [key]: {
+                        $in: core.parseArrayValue(value)
+                    }
+                };
+            case core.FilterOperator.NIN:
+                return {
+                    [key]: {
+                        $nin: core.parseArrayValue(value)
+                    }
+                };
+            case core.FilterOperator.IS_EMPTY:
+                return {
+                    [key]: {
+                        $size: 0
+                    }
+                };
+            default:
+                throw new Error(`Not supported filter operator: ${operator}`);
+        }
+    }
+}
+
+exports.AstraDBVectorStore = AstraDBVectorStore;

package/dist/index.d.cts

@@ -0,0 +1,66 @@
+import { Db, DataAPIClient, Collection } from '@datastax/astra-db-ts';
+import { BaseVectorStore, VectorStoreBaseParams, BaseNode, VectorStoreQuery, VectorStoreQueryResult } from '@vectorstores/core';
+
+declare class AstraDBVectorStore extends BaseVectorStore {
+    storesText: boolean;
+    flatMetadata: boolean;
+    idKey: string;
+    contentKey: string;
+    private astraClient;
+    private astraDB;
+    private collection;
+    constructor(init?: Partial<AstraDBVectorStore> & {
+        params?: {
+            token: string;
+            endpoint: string;
+            namespace?: string;
+        };
+    } & VectorStoreBaseParams);
+    /**
+     * Create a new collection in your Astra DB vector database and connects to it.
+     * You must call this method or `connect` before adding, deleting, or querying.
+     *
+     * @param collection - Your new collection's name
+     * @param options - CreateCollectionOptions used to set the number of vector dimensions and similarity metric
+     * @returns Promise that resolves if the creation did not throw an error.
+     */
+    createAndConnect(collection: string, options?: Parameters<Db["createCollection"]>[1]): Promise<void>;
+    /**
+     * Connect to an existing collection in your Astra DB vector database.
+     * You must call this method or `createAndConnect` before adding, deleting, or querying.
+     *
+     * @param collection - Your existing collection's name
+     * @returns Promise that resolves if the connection did not throw an error.
+     */
+    connect(collection: string): Promise<void>;
+    /**
+     * Get an instance of your Astra DB client.
+     * @returns the AstraDB client
+     */
+    client(): DataAPIClient;
+    /**
+     * Add your document(s) to your Astra DB collection.
+     *
+     * @returns an array of node ids which were added
+     */
+    add(nodes: BaseNode[]): Promise<string[]>;
+    /**
+     * Delete a document from your Astra DB collection.
+     *
+     * @param refDocId - The id of the document to delete
+     * @param deleteOptions - DeleteOneOptions to pass to the delete query
+     * @returns Promise that resolves if the delete query did not throw an error.
+     */
+    delete(refDocId: string, deleteOptions?: Parameters<Collection["deleteOne"]>[1]): Promise<void>;
+    /**
+     * Query documents from your Astra DB collection to get the closest match to your embedding.
+     *
+     * @param query - VectorStoreQuery
+     * @param options - FindOptions
+     */
+    query(query: VectorStoreQuery, options?: Parameters<Collection["find"]>[1]): Promise<VectorStoreQueryResult>;
+    private toAstraFilter;
+    private buildFilterItem;
+}
+
+export { AstraDBVectorStore };

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+import { Db, DataAPIClient, Collection } from '@datastax/astra-db-ts';
+import { BaseVectorStore, VectorStoreBaseParams, BaseNode, VectorStoreQuery, VectorStoreQueryResult } from '@vectorstores/core';
+
+declare class AstraDBVectorStore extends BaseVectorStore {
+    storesText: boolean;
+    flatMetadata: boolean;
+    idKey: string;
+    contentKey: string;
+    private astraClient;
+    private astraDB;
+    private collection;
+    constructor(init?: Partial<AstraDBVectorStore> & {
+        params?: {
+            token: string;
+            endpoint: string;
+            namespace?: string;
+        };
+    } & VectorStoreBaseParams);
+    /**
+     * Create a new collection in your Astra DB vector database and connects to it.
+     * You must call this method or `connect` before adding, deleting, or querying.
+     *
+     * @param collection - Your new collection's name
+     * @param options - CreateCollectionOptions used to set the number of vector dimensions and similarity metric
+     * @returns Promise that resolves if the creation did not throw an error.
+     */
+    createAndConnect(collection: string, options?: Parameters<Db["createCollection"]>[1]): Promise<void>;
+    /**
+     * Connect to an existing collection in your Astra DB vector database.
+     * You must call this method or `createAndConnect` before adding, deleting, or querying.
+     *
+     * @param collection - Your existing collection's name
+     * @returns Promise that resolves if the connection did not throw an error.
+     */
+    connect(collection: string): Promise<void>;
+    /**
+     * Get an instance of your Astra DB client.
+     * @returns the AstraDB client
+     */
+    client(): DataAPIClient;
+    /**
+     * Add your document(s) to your Astra DB collection.
+     *
+     * @returns an array of node ids which were added
+     */
+    add(nodes: BaseNode[]): Promise<string[]>;
+    /**
+     * Delete a document from your Astra DB collection.
+     *
+     * @param refDocId - The id of the document to delete
+     * @param deleteOptions - DeleteOneOptions to pass to the delete query
+     * @returns Promise that resolves if the delete query did not throw an error.
+     */
+    delete(refDocId: string, deleteOptions?: Parameters<Collection["deleteOne"]>[1]): Promise<void>;
+    /**
+     * Query documents from your Astra DB collection to get the closest match to your embedding.
+     *
+     * @param query - VectorStoreQuery
+     * @param options - FindOptions
+     */
+    query(query: VectorStoreQuery, options?: Parameters<Collection["find"]>[1]): Promise<VectorStoreQueryResult>;
+    private toAstraFilter;
+    private buildFilterItem;
+}
+
+export { AstraDBVectorStore };

package/dist/index.edge-light.d.ts

@@ -0,0 +1,66 @@
+import { Db, DataAPIClient, Collection } from '@datastax/astra-db-ts';
+import { BaseVectorStore, VectorStoreBaseParams, BaseNode, VectorStoreQuery, VectorStoreQueryResult } from '@vectorstores/core';
+
+declare class AstraDBVectorStore extends BaseVectorStore {
+    storesText: boolean;
+    flatMetadata: boolean;
+    idKey: string;
+    contentKey: string;
+    private astraClient;
+    private astraDB;
+    private collection;
+    constructor(init?: Partial<AstraDBVectorStore> & {
+        params?: {
+            token: string;
+            endpoint: string;
+            namespace?: string;
+        };
+    } & VectorStoreBaseParams);
+    /**
+     * Create a new collection in your Astra DB vector database and connects to it.
+     * You must call this method or `connect` before adding, deleting, or querying.
+     *
+     * @param collection - Your new collection's name
+     * @param options - CreateCollectionOptions used to set the number of vector dimensions and similarity metric
+     * @returns Promise that resolves if the creation did not throw an error.
+     */
+    createAndConnect(collection: string, options?: Parameters<Db["createCollection"]>[1]): Promise<void>;
+    /**
+     * Connect to an existing collection in your Astra DB vector database.
+     * You must call this method or `createAndConnect` before adding, deleting, or querying.
+     *
+     * @param collection - Your existing collection's name
+     * @returns Promise that resolves if the connection did not throw an error.
+     */
+    connect(collection: string): Promise<void>;
+    /**
+     * Get an instance of your Astra DB client.
+     * @returns the AstraDB client
+     */
+    client(): DataAPIClient;
+    /**
+     * Add your document(s) to your Astra DB collection.
+     *
+     * @returns an array of node ids which were added
+     */
+    add(nodes: BaseNode[]): Promise<string[]>;
+    /**
+     * Delete a document from your Astra DB collection.
+     *
+     * @param refDocId - The id of the document to delete
+     * @param deleteOptions - DeleteOneOptions to pass to the delete query
+     * @returns Promise that resolves if the delete query did not throw an error.
+     */
+    delete(refDocId: string, deleteOptions?: Parameters<Collection["deleteOne"]>[1]): Promise<void>;
+    /**
+     * Query documents from your Astra DB collection to get the closest match to your embedding.
+     *
+     * @param query - VectorStoreQuery
+     * @param options - FindOptions
+     */
+    query(query: VectorStoreQuery, options?: Parameters<Collection["find"]>[1]): Promise<VectorStoreQueryResult>;
+    private toAstraFilter;
+    private buildFilterItem;
+}
+
+export { AstraDBVectorStore };

package/dist/index.edge-light.js

@@ -0,0 +1,213 @@
+import { DataAPIClient } from '@datastax/astra-db-ts';
+import { BaseVectorStore, nodeToMetadata, MetadataMode, metadataDictToNode, FilterCondition, FilterOperator, parseArrayValue } from '@vectorstores/core';
+import { getEnv } from '@vectorstores/env';
+
+class AstraDBVectorStore extends BaseVectorStore {
+    constructor(init){
+        super(init), this.storesText = true, this.flatMetadata = true;
+        const token = init?.params?.token ?? getEnv("ASTRA_DB_APPLICATION_TOKEN");
+        const endpoint = init?.params?.endpoint ?? getEnv("ASTRA_DB_API_ENDPOINT");
+        if (!token) {
+            throw new Error("Must specify ASTRA_DB_APPLICATION_TOKEN via env variable.");
+        }
+        if (!endpoint) {
+            throw new Error("Must specify ASTRA_DB_API_ENDPOINT via env variable.");
+        }
+        const namespace = init?.params?.namespace ?? getEnv("ASTRA_DB_NAMESPACE") ?? "default_keyspace";
+        this.astraClient = new DataAPIClient(token, {
+            caller: [
+                "LlamaIndexTS"
+            ]
+        });
+        this.astraDB = this.astraClient.db(endpoint, {
+            namespace
+        });
+        this.idKey = init?.idKey ?? "_id";
+        this.contentKey = init?.contentKey ?? "content";
+    }
+    /**
+   * Create a new collection in your Astra DB vector database and connects to it.
+   * You must call this method or `connect` before adding, deleting, or querying.
+   *
+   * @param collection - Your new collection's name
+   * @param options - CreateCollectionOptions used to set the number of vector dimensions and similarity metric
+   * @returns Promise that resolves if the creation did not throw an error.
+   */ async createAndConnect(collection, options) {
+        this.collection = await this.astraDB.createCollection(collection, options);
+        console.debug("Created Astra DB collection");
+        return;
+    }
+    /**
+   * Connect to an existing collection in your Astra DB vector database.
+   * You must call this method or `createAndConnect` before adding, deleting, or querying.
+   *
+   * @param collection - Your existing collection's name
+   * @returns Promise that resolves if the connection did not throw an error.
+   */ async connect(collection) {
+        this.collection = await this.astraDB.collection(collection);
+        console.debug("Connected to Astra DB collection");
+        return;
+    }
+    /**
+   * Get an instance of your Astra DB client.
+   * @returns the AstraDB client
+   */ client() {
+        return this.astraClient;
+    }
+    /**
+   * Add your document(s) to your Astra DB collection.
+   *
+   * @returns an array of node ids which were added
+   */ async add(nodes) {
+        if (!this.collection) {
+            throw new Error("Must connect to collection before adding.");
+        }
+        const collection = this.collection;
+        if (!nodes || nodes.length === 0) {
+            return [];
+        }
+        const dataToInsert = nodes.map((node)=>{
+            const metadata = nodeToMetadata(node, true, this.contentKey, this.flatMetadata);
+            return {
+                $vector: node.getEmbedding(),
+                [this.idKey]: node.id_,
+                [this.contentKey]: node.getContent(MetadataMode.NONE),
+                ...metadata
+            };
+        });
+        console.debug(`Adding ${dataToInsert.length} rows to table`);
+        const insertResult = await collection.insertMany(dataToInsert);
+        return insertResult.insertedIds;
+    }
+    /**
+   * Delete a document from your Astra DB collection.
+   *
+   * @param refDocId - The id of the document to delete
+   * @param deleteOptions - DeleteOneOptions to pass to the delete query
+   * @returns Promise that resolves if the delete query did not throw an error.
+   */ async delete(refDocId, deleteOptions) {
+        if (!this.collection) {
+            throw new Error("Must connect to collection before deleting.");
+        }
+        const collection = this.collection;
+        console.debug(`Deleting row with id ${refDocId}`);
+        await collection.deleteOne({
+            _id: refDocId
+        }, deleteOptions);
+    }
+    /**
+   * Query documents from your Astra DB collection to get the closest match to your embedding.
+   *
+   * @param query - VectorStoreQuery
+   * @param options - FindOptions
+   */ async query(query, options) {
+        if (!this.collection) {
+            throw new Error("Must connect to collection before querying.");
+        }
+        const collection = this.collection;
+        const astraFilter = this.toAstraFilter(query.filters);
+        const cursor = await collection.find(astraFilter, {
+            ...options,
+            sort: query.queryEmbedding ? {
+                $vector: query.queryEmbedding
+            } : options?.sort,
+            limit: query.similarityTopK,
+            includeSimilarity: true
+        });
+        const nodes = [];
+        const ids = [];
+        const similarities = [];
+        for await (const row of cursor){
+            const { $vector: embedding, $similarity: similarity, [this.idKey]: id, [this.contentKey]: content, ...metadata } = row;
+            const node = metadataDictToNode(metadata, {
+                fallback: {
+                    id,
+                    text: content,
+                    ...metadata
+                }
+            });
+            node.setContent(content);
+            ids.push(id);
+            similarities.push(similarity);
+            nodes.push(node);
+        }
+        return {
+            similarities,
+            ids,
+            nodes
+        };
+    }
+    toAstraFilter(filters) {
+        if (!filters || filters.filters?.length === 0) return {};
+        const condition = filters.condition ?? FilterCondition.AND;
+        const listFilter = filters.filters.map((f)=>this.buildFilterItem(f));
+        if (condition === FilterCondition.OR) return {
+            $or: listFilter
+        };
+        if (condition === FilterCondition.AND) return {
+            $and: listFilter
+        };
+        throw new Error(`Not supported filter condition: ${condition}`);
+    }
+    buildFilterItem(filter) {
+        const { key, operator, value } = filter;
+        switch(operator){
+            case FilterOperator.EQ:
+                return {
+                    [key]: value
+                };
+            case FilterOperator.NE:
+                return {
+                    [key]: {
+                        $ne: value
+                    }
+                };
+            case FilterOperator.GT:
+                return {
+                    [key]: {
+                        $gt: value
+                    }
+                };
+            case FilterOperator.LT:
+                return {
+                    [key]: {
+                        $lt: value
+                    }
+                };
+            case FilterOperator.GTE:
+                return {
+                    [key]: {
+                        $gte: value
+                    }
+                };
+            case FilterOperator.LTE:
+                return {
+                    [key]: {
+                        $lte: value
+                    }
+                };
+            case FilterOperator.IN:
+                return {
+                    [key]: {
+                        $in: parseArrayValue(value)
+                    }
+                };
+            case FilterOperator.NIN:
+                return {
+                    [key]: {
+                        $nin: parseArrayValue(value)
+                    }
+                };
+            case FilterOperator.IS_EMPTY:
+                return {
+                    [key]: {
+                        $size: 0
+                    }
+                };
+            default:
+                throw new Error(`Not supported filter operator: ${operator}`);
+        }
+    }
+}
+
+export { AstraDBVectorStore };

package/dist/index.js

@@ -0,0 +1,213 @@
+import { DataAPIClient } from '@datastax/astra-db-ts';
+import { BaseVectorStore, nodeToMetadata, MetadataMode, metadataDictToNode, FilterCondition, FilterOperator, parseArrayValue } from '@vectorstores/core';
+import { getEnv } from '@vectorstores/env';
+
+class AstraDBVectorStore extends BaseVectorStore {
+    constructor(init){
+        super(init), this.storesText = true, this.flatMetadata = true;
+        const token = init?.params?.token ?? getEnv("ASTRA_DB_APPLICATION_TOKEN");
+        const endpoint = init?.params?.endpoint ?? getEnv("ASTRA_DB_API_ENDPOINT");
+        if (!token) {
+            throw new Error("Must specify ASTRA_DB_APPLICATION_TOKEN via env variable.");
+        }
+        if (!endpoint) {
+            throw new Error("Must specify ASTRA_DB_API_ENDPOINT via env variable.");
+        }
+        const namespace = init?.params?.namespace ?? getEnv("ASTRA_DB_NAMESPACE") ?? "default_keyspace";
+        this.astraClient = new DataAPIClient(token, {
+            caller: [
+                "LlamaIndexTS"
+            ]
+        });
+        this.astraDB = this.astraClient.db(endpoint, {
+            namespace
+        });
+        this.idKey = init?.idKey ?? "_id";
+        this.contentKey = init?.contentKey ?? "content";
+    }
+    /**
+   * Create a new collection in your Astra DB vector database and connects to it.
+   * You must call this method or `connect` before adding, deleting, or querying.
+   *
+   * @param collection - Your new collection's name
+   * @param options - CreateCollectionOptions used to set the number of vector dimensions and similarity metric
+   * @returns Promise that resolves if the creation did not throw an error.
+   */ async createAndConnect(collection, options) {
+        this.collection = await this.astraDB.createCollection(collection, options);
+        console.debug("Created Astra DB collection");
+        return;
+    }
+    /**
+   * Connect to an existing collection in your Astra DB vector database.
+   * You must call this method or `createAndConnect` before adding, deleting, or querying.
+   *
+   * @param collection - Your existing collection's name
+   * @returns Promise that resolves if the connection did not throw an error.
+   */ async connect(collection) {
+        this.collection = await this.astraDB.collection(collection);
+        console.debug("Connected to Astra DB collection");
+        return;
+    }
+    /**
+   * Get an instance of your Astra DB client.
+   * @returns the AstraDB client
+   */ client() {
+        return this.astraClient;
+    }
+    /**
+   * Add your document(s) to your Astra DB collection.
+   *
+   * @returns an array of node ids which were added
+   */ async add(nodes) {
+        if (!this.collection) {
+            throw new Error("Must connect to collection before adding.");
+        }
+        const collection = this.collection;
+        if (!nodes || nodes.length === 0) {
+            return [];
+        }
+        const dataToInsert = nodes.map((node)=>{
+            const metadata = nodeToMetadata(node, true, this.contentKey, this.flatMetadata);
+            return {
+                $vector: node.getEmbedding(),
+                [this.idKey]: node.id_,
+                [this.contentKey]: node.getContent(MetadataMode.NONE),
+                ...metadata
+            };
+        });
+        console.debug(`Adding ${dataToInsert.length} rows to table`);
+        const insertResult = await collection.insertMany(dataToInsert);
+        return insertResult.insertedIds;
+    }
+    /**
+   * Delete a document from your Astra DB collection.
+   *
+   * @param refDocId - The id of the document to delete
+   * @param deleteOptions - DeleteOneOptions to pass to the delete query
+   * @returns Promise that resolves if the delete query did not throw an error.
+   */ async delete(refDocId, deleteOptions) {
+        if (!this.collection) {
+            throw new Error("Must connect to collection before deleting.");
+        }
+        const collection = this.collection;
+        console.debug(`Deleting row with id ${refDocId}`);
+        await collection.deleteOne({
+            _id: refDocId
+        }, deleteOptions);
+    }
+    /**
+   * Query documents from your Astra DB collection to get the closest match to your embedding.
+   *
+   * @param query - VectorStoreQuery
+   * @param options - FindOptions
+   */ async query(query, options) {
+        if (!this.collection) {
+            throw new Error("Must connect to collection before querying.");
+        }
+        const collection = this.collection;
+        const astraFilter = this.toAstraFilter(query.filters);
+        const cursor = await collection.find(astraFilter, {
+            ...options,
+            sort: query.queryEmbedding ? {
+                $vector: query.queryEmbedding
+            } : options?.sort,
+            limit: query.similarityTopK,
+            includeSimilarity: true
+        });
+        const nodes = [];
+        const ids = [];
+        const similarities = [];
+        for await (const row of cursor){
+            const { $vector: embedding, $similarity: similarity, [this.idKey]: id, [this.contentKey]: content, ...metadata } = row;
+            const node = metadataDictToNode(metadata, {
+                fallback: {
+                    id,
+                    text: content,
+                    ...metadata
+                }
+            });
+            node.setContent(content);
+            ids.push(id);
+            similarities.push(similarity);
+            nodes.push(node);
+        }
+        return {
+            similarities,
+            ids,
+            nodes
+        };
+    }
+    toAstraFilter(filters) {
+        if (!filters || filters.filters?.length === 0) return {};
+        const condition = filters.condition ?? FilterCondition.AND;
+        const listFilter = filters.filters.map((f)=>this.buildFilterItem(f));
+        if (condition === FilterCondition.OR) return {
+            $or: listFilter
+        };
+        if (condition === FilterCondition.AND) return {
+            $and: listFilter
+        };
+        throw new Error(`Not supported filter condition: ${condition}`);
+    }
+    buildFilterItem(filter) {
+        const { key, operator, value } = filter;
+        switch(operator){
+            case FilterOperator.EQ:
+                return {
+                    [key]: value
+                };
+            case FilterOperator.NE:
+                return {
+                    [key]: {
+                        $ne: value
+                    }
+                };
+            case FilterOperator.GT:
+                return {
+                    [key]: {
+                        $gt: value
+                    }
+                };
+            case FilterOperator.LT:
+                return {
+                    [key]: {
+                        $lt: value
+                    }
+                };
+            case FilterOperator.GTE:
+                return {
+                    [key]: {
+                        $gte: value
+                    }
+                };
+            case FilterOperator.LTE:
+                return {
+                    [key]: {
+                        $lte: value
+                    }
+                };
+            case FilterOperator.IN:
+                return {
+                    [key]: {
+                        $in: parseArrayValue(value)
+                    }
+                };
+            case FilterOperator.NIN:
+                return {
+                    [key]: {
+                        $nin: parseArrayValue(value)
+                    }
+                };
+            case FilterOperator.IS_EMPTY:
+                return {
+                    [key]: {
+                        $size: 0
+                    }
+                };
+            default:
+                throw new Error(`Not supported filter operator: ${operator}`);
+        }
+    }
+}
+
+export { AstraDBVectorStore };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@vectorstores/astra",
+  "description": "Astra Storage for vectorstores",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "edge-light": {
+        "types": "./dist/index.edge-light.d.ts",
+        "default": "./dist/index.edge-light.js"
+      },
+      "workerd": {
+        "types": "./dist/index.edge-light.d.ts",
+        "default": "./dist/index.edge-light.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/schiesser/vectorstores.git",
+    "directory": "packages/providers/storage/astra"
+  },
+  "devDependencies": {
+    "@vectorstores/core": "0.1.0",
+    "@vectorstores/env": "0.1.0"
+  },
+  "peerDependencies": {
+    "@vectorstores/core": "0.1.0",
+    "@vectorstores/env": "0.1.0"
+  },
+  "dependencies": {
+    "@datastax/astra-db-ts": "^1.4.1"
+  },
+  "scripts": {
+    "build": "bunchee",
+    "dev": "bunchee --watch"
+  }
+}