TypeScript client reference

import { AstraDB } from '@datastax/astra-db-ts'

// Create a new AstraDB instance with the default namespace
const defaultDb = new AstraDB("TOKEN", "API_ENDPOINT");

// Create a new AstraDB instance with a specified namespace
const db = new AstraDB("TOKEN", "API_ENDPOINT", "NAMESPACE");

import { AstraDB, Collection } from '@datastax/astra-db-ts'

// Create a new AstraDB instance
const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function createCollections() {

    // Create a non-vector collection
    const collectionSimple = await db.createCollection('collection');

    // Create a vector collection
    const collectionVector = await db.createCollection('vector_collection', {
        "vector": {
            "dimension": 3,
            "metric": "cosine"
        }
    });
}

createCollections();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function getCollectionReference() {
    // Get a reference to a collection
    const collection = await db.collection('vector_collection');
}

getCollectionReference();

import { AstraDB } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function deleteCollection() {
    // Delete an existing collection
    const response = await db.dropCollection("vector_collection");
}

deleteCollection();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function insertDocuments() {
    const collection = await db.collection("vector_collection");

    // Insert a document with a specific ID
    const response1 = await collection.insertOne({
        _id: '1',
        name: 'John Doe',
        $vector: [.12, .52, .32]
    });

    // Insert a document without specifying an ID (ID is generated automatically)
    const response2 = await collection.insertOne({
        name: 'Jane Doe',
        $vector: [.08, .68, .30]
    });
}

insertDocuments();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

// Create a new AstraDB instance
const db = new AstraDB("*TOKEN*", "*API_ENDPOINT*");

async function insertMultipleDocuments() {
    const collection = await db.collection("vector_collection");

    // Insert multiple documents into the collection
    const response = await collection.insertMany(
        [
            {
                _id: '1',
                name: 'John Doe',
                $vector: [.12, .52, .32]
            },
            {
                // _id is generated automatically
                name: 'Jane Doe',
                $vector: [.08, .68, .30]
            }
        ],
        { ordered: true }
    );
}

insertMultipleDocuments();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function findDocuments() {
    const collection = await db.collection("vector_collection");

    // Retrieve a single document
    const document1 = await collection.findOne({
        _id: '1'
    });

    // Retrieve the most similar document
    const document2 = await collection.findOne({}, {
        sort: {
            $vector: [.12, .52, .32]
        }
    });

    // Only retrieve the name field
    const document3 = await collection.findOne(
        { _id: '1' },
        { projection: { "name": 1 } }
    );
}

findDocuments();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function performSimilaritySearch() {
    const collection = await db.collection("vector_collection");

    // Define the metadata filter
    const metadataFilter = { name: "Jane Doe" };

    // Define the search vector and number of documents to return
    const options = {
        sort: {
            "$vector": [.12, .52, .32],
        },
        limit: 5
    };

    // Perform a similarity search
    const docs = await collection.find(metadataFilter, options).toArray();
}

performSimilaritySearch();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function updateDocumentName() {
    const collection = await db.collection("vector_collection");

    // Insert a document
    const insertResults = await collection.insertOne({
        _id: '1',
        name: 'John Doe'
    });

    // Update the name of the document
    const updateResults = await collection.updateOne(
        { _id: '1' },
        { $set: { name: "John Smith" } },
    );
}

updateDocumentName();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function updateMultipleDocumentsName() {
    const collection = await db.collection("vector_collection");

    // Insert some documents
    const insertResults = await collection.insertMany([
        { _id: '1', name: 'John Doe', car: 'Renault Twizy' },
        { car: 'BMW 330i' },
        { car: 'McLaren 4x4 SUV' },
    ]);

    // Update the names of some documents
    const updateResults = await collection.updateMany(
        { name: { $exists: false } },
        { $set: { name: 'unknown' } }
    );
}

updateMultipleDocumentsName();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function deleteSingleDocumentByName() {
    const collection = await db.collection("vector_collection");

    // Insert a document into the collection
    const insertResponse = await collection.insertOne({
        _id: '1',
        name: 'John Doe'
    });

    // Delete the document from the collection
    const deleteResponse = await collection.deleteOne({ _id: '1' });
}

deleteSingleDocumentByName();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function deleteDocuments() {
    const collection = await db.collection("vector_collection");

    // Insert some documents into the collection
    const insertResult = await collection.insertMany([
        { _id: '1', name: 'John Doe', car: 'Renault Twizy' },
        { name: 'John Doe', car: 'BMW 330i' },
        { name: 'Jane Doe', car: 'McLaren 4x4 SUV' }
    ]);

    // Delete some documents from the collection
    const deleteResult = await collection.deleteMany({ name: "John Doe" });
}

deleteDocuments();

import { AstraDB, Collection } from '@datastax/astra-db-ts'

const db = new AstraDB("TOKEN", "API_ENDPOINT");

async function deleteDocuments() {
    const collection = await db.collection("vector_collection");

    // Insert some documents
    const insertResult = await collection.insertMany([
        { _id: '1', name: 'John Doe' },
        { name: 'Jane Doe' }
    ]);

    // Delete all documents in the collection
    await collection.deleteAll();
}

deleteDocuments();