Create a collection (TypeScript)

Creates a new collection in a database.

Ready to write code? See the examples for this method to get started. If you are new to the Data API, check out the quickstart.

Result

Creates a collection with the specified parameters.

Returns a promise that resolves to a Collection object. You can use this object to work with documents in the collection.

A Collection is typed as Collection<Schema>, where Schema defaults to SomeDoc (Record<string, any>). Providing the specific Schema type enables stronger typing for collection operations. For more information, see Typing collections and tables.

Parameters

You cannot edit a collection’s definition after you create the collection.

Use the createCollection method, which belongs to the Db class.

Method signature 
async createCollection<Schema extends SomeDoc = SomeDoc>(
  name: string,
  options?: {
    vector?: CollectionVectorOptions,
    indexing?: CollectionIndexingOptions<Schema>,
    defaultId?: CollectionDefaultIdOptions,
    lexical?: CollectionLexicalOptions,
    rerank?: CollectionRerankOptions,
    logging?: DataAPILoggingConfig,
    keyspace?: string,
    embeddingApiKey?: string | EmbeddingHeadersProvider,
    serdes?: CollectionSerDesConfig,
    timeoutDefaults?: TimeoutDescriptor,
    timeout?: number | TimeoutDescriptor,
  }
): Collection<Schema>
Name Type Summary

name

string

The name of the new collection.

Collection names must follow these rules:

  • Can contain letters, numbers, and underscores

  • Cannot exceed 48 characters

  • Must be unique within the keyspace

options

CreateCollectionOptions

Optional. The options for this operation. See Properties of options for more details.
Properties of options
Name Type Summary

vector

CollectionVectorOptions

Optional. The vector configuration for the collection. This includes things like the vector dimension, similarity metric, and source model. This also includes settings for server-side embedding generation if you want your collection to have vectorize enabled.

Required for vector search and hybrid search.

For examples, see Create a collection that can automatically generate vector embeddings and Create a collection that can store vector embeddings.

The CollectionVectorOptions interface has the following fields:

  • dimension (int): The dimension for vector embeddings in the collection. This should match the dimension of the vector that your embedding model produces. Optional if you specify a vector.service.modelName value that has a default dimension value.

  • metric (string): Optional. The similarity metric to use for vector search. Can be one of the values in astrapy.constants.VectorMetric: COSINE, DOT_PRODUCT, EUCLIDEAN.

  • sourceModel (string): Optional. The model used to generate the vector embeddings. This enables certain vector optimizations on the index. Can be one of: ada002, bert, cohere-v3, gecko, nv-qa-4, openai-v3-large, openai-v3-small, other.

  • service (object): Optional. The configuration for a vectorize embedding provider integration. This lets your collection use vectorize to automatically generate embeddings. See Create a collection that can automatically generate vector embeddings, use findEmbeddingProviders, or see the documentation for your embedding provider integration to determine what values to specify.

lexical

CollectionLexicalOptions

Optional. The lexical search configuration for the collection.

Only collections in databases in the AWS us-east-2 region support this parameter.

The CollectionLexicalOptions object has the following properties:

For examples, see Create a collection that supports lexicographical matching.

Default: A CollectionLexicalOptions object with enabled: true and analyzer: "STANDARD", which corresponds to the standard Apache Lucene™ analyzer.

rerank

CollectionRerankOptions

Optional. The reranker configuration for the collection.

Only collections in databases in the AWS us-east-2 region support this parameter.

The CollectionRerankOptions object has the following properties:

For examples, see Create a collection that supports hybrid search.

Default: A RerankServiceOptions object with enabled: true and a service value corresponding to the NVIDIA llama-3.2-nv-rerankqa-1b-v2 reranking model. This means that reranking is enabled by default.

indexing

CollectionIndexingOptions<Schema>

Optional. The selective indexing configuration for the collection.

You must use & to escape any . or & in field names in the indexing clause. You cannot use & to escape any other characters. Dot notation, which is used to reference nested fields, should not be escaped. For more information, see Work with . and & in field names (TypeScript).

For examples, see Create a collection and specify which fields to index and Create a collection and specify which fields shouldn’t be indexed.

Default: All fields of all documents.

defaultId

CollectionDefaultIdOptions

Optional. Specifies the default ID type for documents in the collection. This is used when you insert a document without an _id field.

Can be one of:

  • {type: "objectId"}: Each autogenerated _id value is an objectId as provided by the bson library.

  • {type: "uuidv7"}: Each autogenerated _id value is a version 7 UUID. This is designed as a replacement for version 1 time UUID, and it is recommended for use in new systems.

  • {type: "uuidv6"}: Each autogenerated _id value is a version 6 UUID. This is field-compatible with version 1 time UUIDs, and it supports lexicographical sorting.

  • {type: "uuid"}: Each autogenerated _id value is a version 4 UUID. This type is analogous to the uuid type and functions in Apache Cassandra®.

For examples, see Create a collection and specify the default ID format.

For more information, see Document IDs (TypeScript).

Default: Each autogenerated _id value is a string form of a version 4 UUID

embeddingApiKey

string | EmbeddingHeadersProvider

Optional. This only applies to collections with a vectorize embedding provider integration.

Use this option to provide the embedding provider API key directly with headers instead of using an API key in the Astra DB KMS.

The API key is sent to the Data API for every operation on the collection. It is useful when a vectorize integration is configured but no credentials are stored, or when you want to override the stored credentials. For more information, see Manage embedding provider integrations for vectorize.

If you use an AWS embedding provider, the embeddingApiKey option must instead use the AWSEmbeddingHeadersProvider class to pass your access ID and secret ID.

keyspace

string

Optional. The keyspace in which to create the collection.

For an example, see Create a collection and specify the keyspace.

Default: The working keyspace for the database. This is default_keyspace unless you set a different working keyspace when you created the Db object.

logging

string

Optional. The configuration for logging events emitted by the DataAPIClient.

serdes

string

Optional. The configuration for serialization/deserialization by the DataAPIClient.

For more information, see Custom Ser/Des.

timeoutDefaults

TimeoutDescriptor

Optional.

The default timeout(s) to apply to operations performed on this Collection instance. You can specify requestTimeoutMs, generalMethodTimeoutMs, and collectionAdminTimeoutMs.

For more information about the TimeoutDescriptor, see TypeScript client internals: TimeoutDescriptor.

timeout

number | TimeoutDescriptor

Optional.

The timeout to apply to this method.

Only collectionAdminTimeoutMs applies to this method. This is the maximum time, in milliseconds, for collection admin operations like creating, dropping, and listing collections.

Default: 60 seconds, unless you specified a different default along the Options Hierarchy.

Examples

The following examples demonstrate how to create a collection.

Create a collection that is not vector-enabled

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient();
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User {
  name: string;
  age?: number;
}

// Create a collection
(async function () {
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient();
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Create a collection
(async function () {
  const collection = await database.createCollection("COLLECTION_NAME");
})();

Create a collection that can store vector embeddings

Collections that are vector-enabled can store vector embeddings in the reserved $vector field and work with vector search.

For optimal vector search results, you should specify the dimension, metric, and source model of your vector embeddings. All vector embeddings in a collection should be generated by the same model with the same dimensions. The source model can be one of: ada002, bert, cohere-v3, gecko, nv-qa-4, openai-v3-large, openai-v3-small, other.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector as an inline field in your interfaces, or you can extend the utility VectorDoc type provided by the client.

import { DataAPIClient, VectorDoc } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient();
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorDoc {
  name: string;
  age?: number;
}

(async function () {
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    {
      vector: {
        dimension: 1024,
        metric: "cosine",
        sourceModel: "nv-qa-4",
      },
    },
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, or type-related issues will occur.

Consider using a type like VectorDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector field to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient();
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

(async function () {
  const collection = await database.createCollection("COLLECTION_NAME", {
    vector: {
      dimension: 1024,
      metric: "cosine",
      sourceModel: "nv-qa-4",
    },
  });
})();

Create a collection that can automatically generate vector embeddings

If you want to automatically generate vector embeddings, create a vector-enabled collection and configure an embedding provider integration for the collection.

The configuration depends on the embedding provider.

Configure Azure OpenAI as the embedding provider

For more detailed instructions, see Integrate Azure OpenAI as an embedding provider.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector and $vectorize as inline fields in your interfaces, or you can extend the utility VectorizeDoc types provided by the client.

import { DataAPIClient, VectorizeDoc } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorizeDoc {
  name: string;
  age?: number;
}

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "azureopenai",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
      parameters: {
        resourceName: "RESOURCE_NAME",
        deploymentId: "DEPLOYMENT_ID",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize field must still be a string, or type-related issues will occur.

Consider using a type like VectorizeDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector and $vectorize fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "azureopenai",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
      parameters: {
        resourceName: "RESOURCE_NAME",
        deploymentId: "DEPLOYMENT_ID",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

Replace the following:

  • COLLECTION_NAME: The name for your collection.

  • SIMILARITY_METRIC: The method you want to use to calculate vector similarity scores. The available metrics are Cosine (default), Dot Product, and Euclidean.

  • API_KEY_NAME: The name of the Azure OpenAI API key that you want to use. Must be the name of an existing Azure OpenAI API key in the Astra Portal. For more information, see Embedding provider authentication.

    Alternatively, you can omit this parameter and instead provide the authentication key in the embeddingApiKey parameter when you instantiate a Collection object with the commands to create a collection or get a collection. The client will send the x-embedding-api-key header with the specified key to any underlying HTTP request that requires vectorize authentication. Header authentication overrides the API_KEY_NAME parameter if you set both. If you use the header instead of specifying the API_KEY_NAME parameter, you must include the header in every command that uses vectorize, including writes and vector search.

  • MODEL_NAME: The model that you want to use to generate embeddings. The available models are: text-embedding-3-small, text-embedding-3-large, text-embedding-ada-002.

    For Azure OpenAI, you must select the model that matches the one deployed to your DEPLOYMENT_ID in Azure.

  • MODEL_DIMENSIONS: The number of dimensions that you want the generated vectors to have. Your chosen embedding model must support the specified number of dimensions.

    If you omit the dimension, Astra DB can use a default dimension value. However, some models don’t have default dimensions. You can use the Data API to find supported embedding providers and their configuration parameters, including dimensions ranges and default dimensions.

  • RESOURCE_NAME: The name of your Azure OpenAI Service resource, as defined in the resource’s Instance details. For more information, see the Azure OpenAI documentation.

  • DEPLOYMENT_ID: Your Azure OpenAI resource’s Deployment name. For more information, see the Azure OpenAI documentation.

Configure Hugging Face (Dedicated) as the embedding provider

For more detailed instructions, see Integrate Hugging Face Dedicated as an embedding provider.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector and $vectorize as inline fields in your interfaces, or you can extend the utility VectorizeDoc types provided by the client.

import { DataAPIClient, VectorizeDoc } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorizeDoc {
  name: string;
  age?: number;
}

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "huggingfacededicated",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
      parameters: {
        endpointName: "ENDPOINT_NAME",
        regionName: "REGION",
        cloudName: "CLOUD_PROVIDER",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize field must still be a string, or type-related issues will occur.

Consider using a type like VectorizeDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector and $vectorize fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "huggingfacededicated",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
      parameters: {
        endpointName: "ENDPOINT_NAME",
        regionName: "REGION",
        cloudName: "CLOUD_PROVIDER",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

Replace the following:

  • COLLECTION_NAME: The name for your collection.

  • SIMILARITY_METRIC: The method you want to use to calculate vector similarity scores. The available metrics are Cosine (default), Dot Product, and Euclidean.

  • API_KEY_NAME: The name of the Hugging Face Dedicated user access token that you want to use. Must be the name of an existing Hugging Face Dedicated user access token in the Astra Portal. For more information, see Embedding provider authentication.

    Alternatively, you can omit this parameter and instead provide the authentication key in the embeddingApiKey parameter when you instantiate a Collection object with the commands to create a collection or get a collection. The client will send the x-embedding-api-key header with the specified key to any underlying HTTP request that requires vectorize authentication. Header authentication overrides the API_KEY_NAME parameter if you set both. If you use the header instead of specifying the API_KEY_NAME parameter, you must include the header in every command that uses vectorize, including writes and vector search.

  • MODEL_NAME: The model that you want to use to generate embeddings. The available models are: endpoint-defined-model.

    For Hugging Face Dedicated, you must deploy the model as a text embeddings inference (TEI) container.

    You must set MODEL_NAME to endpoint-defined-model because this integration uses the model specified in your dedicated endpoint configuration.

  • MODEL_DIMENSIONS: The number of dimensions that you want the generated vectors to have. Your chosen embedding model must support the specified number of dimensions.

    If you omit the dimension, Astra DB can use a default dimension value. However, some models don’t have default dimensions. You can use the Data API to find supported embedding providers and their configuration parameters, including dimensions ranges and default dimensions.

  • ENDPOINT_NAME: The programmatically-generated name of your Hugging Face Dedicated endpoint. This is the first part of the endpoint URL. For example, if your endpoint URL is https://mtp1x7muf6qyn3yh.us-east-2.aws.endpoints.huggingface.cloud, the endpoint name is mtp1x7muf6qyn3yh.

  • REGION: The cloud provider region your Hugging Face Dedicated endpoint is deployed to. For example, us-east-2.

  • CLOUD_PROVIDER: The cloud provider your Hugging Face Dedicated endpoint is deployed to. For example, aws.

Configure Hugging Face (Serverless) as the embedding provider

For more detailed instructions, see Integrate Hugging Face Serverless as an embedding provider.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector and $vectorize as inline fields in your interfaces, or you can extend the utility VectorizeDoc types provided by the client.

import { DataAPIClient, VectorizeDoc } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorizeDoc {
  name: string;
  age?: number;
}

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "huggingface",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize field must still be a string, or type-related issues will occur.

Consider using a type like VectorizeDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector and $vectorize fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "huggingface",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

Replace the following:

  • COLLECTION_NAME: The name for your collection.

  • SIMILARITY_METRIC: The method you want to use to calculate vector similarity scores. The available metrics are Cosine (default), Dot Product, and Euclidean.

  • API_KEY_NAME: The name of the Hugging Face Serverless user access token that you want to use. Must be the name of an existing Hugging Face Serverless user access token in the Astra Portal. For more information, see Embedding provider authentication.

    Alternatively, you can omit this parameter and instead provide the authentication key in the embeddingApiKey parameter when you instantiate a Collection object with the commands to create a collection or get a collection. The client will send the x-embedding-api-key header with the specified key to any underlying HTTP request that requires vectorize authentication. Header authentication overrides the API_KEY_NAME parameter if you set both. If you use the header instead of specifying the API_KEY_NAME parameter, you must include the header in every command that uses vectorize, including writes and vector search.

  • MODEL_NAME: The model that you want to use to generate embeddings. The available models are: sentence-transformers/all-MiniLM-L6-v2, intfloat/multilingual-e5-large, intfloat/multilingual-e5-large-instruct, BAAI/bge-small-en-v1.5, BAAI/bge-base-en-v1.5, BAAI/bge-large-en-v1.5.

  • MODEL_DIMENSIONS: The number of dimensions that you want the generated vectors to have. Your chosen embedding model must support the specified number of dimensions.

    If you omit the dimension, Astra DB can use a default dimension value. However, some models don’t have default dimensions. You can use the Data API to find supported embedding providers and their configuration parameters, including dimensions ranges and default dimensions.

Configure Jina AI as the embedding provider

For more detailed instructions, see Integrate Jina AI as an embedding provider.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector and $vectorize as inline fields in your interfaces, or you can extend the utility VectorizeDoc types provided by the client.

import { DataAPIClient, VectorizeDoc } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorizeDoc {
  name: string;
  age?: number;
}

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "jinaAI",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize field must still be a string, or type-related issues will occur.

Consider using a type like VectorizeDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector and $vectorize fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "jinaAI",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

Replace the following:

  • COLLECTION_NAME: The name for your collection.

  • SIMILARITY_METRIC: The method you want to use to calculate vector similarity scores. The available metrics are Cosine (default), Dot Product, and Euclidean.

  • API_KEY_NAME: The name of the Jina AI API key that you want to use. Must be the name of an existing Jina AI API key in the Astra Portal. For more information, see Embedding provider authentication.

    Alternatively, you can omit this parameter and instead provide the authentication key in the embeddingApiKey parameter when you instantiate a Collection object with the commands to create a collection or get a collection. The client will send the x-embedding-api-key header with the specified key to any underlying HTTP request that requires vectorize authentication. Header authentication overrides the API_KEY_NAME parameter if you set both. If you use the header instead of specifying the API_KEY_NAME parameter, you must include the header in every command that uses vectorize, including writes and vector search.

  • MODEL_NAME: The model that you want to use to generate embeddings. The available models are: jina-embeddings-v2-base-en, jina-embeddings-v2-base-de, jina-embeddings-v2-base-es, jina-embeddings-v2-base-code, jina-embeddings-v2-base-zh.

  • MODEL_DIMENSIONS: The number of dimensions that you want the generated vectors to have. Your chosen embedding model must support the specified number of dimensions.

    If you omit the dimension, Astra DB can use a default dimension value. However, some models don’t have default dimensions. You can use the Data API to find supported embedding providers and their configuration parameters, including dimensions ranges and default dimensions.

Configure Mistral AI as the embedding provider

For more detailed instructions, see Integrate Mistral AI as an embedding provider.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector and $vectorize as inline fields in your interfaces, or you can extend the utility VectorizeDoc types provided by the client.

import { DataAPIClient, VectorizeDoc } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorizeDoc {
  name: string;
  age?: number;
}

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "mistral",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize field must still be a string, or type-related issues will occur.

Consider using a type like VectorizeDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector and $vectorize fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "mistral",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

Replace the following:

  • COLLECTION_NAME: The name for your collection.

  • SIMILARITY_METRIC: The method you want to use to calculate vector similarity scores. The available metrics are Cosine (default), Dot Product, and Euclidean.

  • API_KEY_NAME: The name of the Mistral AI API key that you want to use. Must be the name of an existing Mistral AI API key in the Astra Portal. For more information, see Embedding provider authentication.

    Alternatively, you can omit this parameter and instead provide the authentication key in the embeddingApiKey parameter when you instantiate a Collection object with the commands to create a collection or get a collection. The client will send the x-embedding-api-key header with the specified key to any underlying HTTP request that requires vectorize authentication. Header authentication overrides the API_KEY_NAME parameter if you set both. If you use the header instead of specifying the API_KEY_NAME parameter, you must include the header in every command that uses vectorize, including writes and vector search.

  • MODEL_NAME: The model that you want to use to generate embeddings. The available models are: mistral-embed.

  • MODEL_DIMENSIONS: The number of dimensions that you want the generated vectors to have. Your chosen embedding model must support the specified number of dimensions.

    If you omit the dimension, Astra DB can use a default dimension value. However, some models don’t have default dimensions. You can use the Data API to find supported embedding providers and their configuration parameters, including dimensions ranges and default dimensions.

Configure NVIDIA as the embedding provider

For more detailed instructions, see Integrate NVIDIA as an embedding provider. Your database must be in a supported region.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector and $vectorize as inline fields in your interfaces, or you can extend the utility VectorizeDoc types provided by the client.

import { DataAPIClient, VectorizeDoc } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorizeDoc {
  name: string;
  age?: number;
}

// Define the collection
const collection_definition = {
  vector: {
    metric: "cosine",
    service: {
      provider: "nvidia",
      modelName: "nvidia/nv-embedqa-e5-v5",
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize field must still be a string, or type-related issues will occur.

Consider using a type like VectorizeDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector and $vectorize fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the collection
const collection_definition = {
  vector: {
    metric: "cosine",
    service: {
      provider: "nvidia",
      modelName: "nvidia/nv-embedqa-e5-v5",
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

Configure OpenAI as the embedding provider

For more detailed instructions, see Integrate OpenAI as an embedding provider.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector and $vectorize as inline fields in your interfaces, or you can extend the utility VectorizeDoc types provided by the client.

import { DataAPIClient, VectorizeDoc } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorizeDoc {
  name: string;
  age?: number;
}

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "openai",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
      parameters: {
        organizationId: "ORGANIZATION_ID",
        projectId: "PROJECT_ID",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize field must still be a string, or type-related issues will occur.

Consider using a type like VectorizeDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector and $vectorize fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "openai",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
      parameters: {
        organizationId: "ORGANIZATION_ID",
        projectId: "PROJECT_ID",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

Replace the following:

  • COLLECTION_NAME: The name for your collection.

  • SIMILARITY_METRIC: The method you want to use to calculate vector similarity scores. The available metrics are Cosine (default), Dot Product, and Euclidean.

  • API_KEY_NAME: The name of the OpenAI API key that you want to use. Must be the name of an existing OpenAI API key in the Astra Portal. For more information, see Embedding provider authentication.

    Alternatively, you can omit this parameter and instead provide the authentication key in the embeddingApiKey parameter when you instantiate a Collection object with the commands to create a collection or get a collection. The client will send the x-embedding-api-key header with the specified key to any underlying HTTP request that requires vectorize authentication. Header authentication overrides the API_KEY_NAME parameter if you set both. If you use the header instead of specifying the API_KEY_NAME parameter, you must include the header in every command that uses vectorize, including writes and vector search.

  • MODEL_NAME: The model that you want to use to generate embeddings. The available models are: text-embedding-3-small, text-embedding-3-large, text-embedding-ada-002.

  • MODEL_DIMENSIONS: The number of dimensions that you want the generated vectors to have. Your chosen embedding model must support the specified number of dimensions.

    If you omit the dimension, Astra DB can use a default dimension value. However, some models don’t have default dimensions. You can use the Data API to find supported embedding providers and their configuration parameters, including dimensions ranges and default dimensions.

  • ORGANIZATION_ID: Optional. The ID of the OpenAI organization that owns the API key. Only required if your OpenAI account belongs to multiple organizations or if you are using a legacy user API key to access projects. For more information about organization IDs, see the OpenAI API reference.

  • PROJECT_ID: Optional. The ID of the OpenAI project that owns the API key. This cannot use the default project. Only required if your OpenAI account belongs to multiple organizations or if you are using a legacy user API key to access projects. For more information about project IDs, see the OpenAI API reference.

Configure Upstage as the embedding provider

For more detailed instructions, see Integrate Upstage as an embedding provider.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector and $vectorize as inline fields in your interfaces, or you can extend the utility VectorizeDoc types provided by the client.

import { DataAPIClient, VectorizeDoc } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorizeDoc {
  name: string;
  age?: number;
}

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "upstageAI",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize field must still be a string, or type-related issues will occur.

Consider using a type like VectorizeDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector and $vectorize fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "upstageAI",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

Replace the following:

  • COLLECTION_NAME: The name for your collection.

  • SIMILARITY_METRIC: The method you want to use to calculate vector similarity scores. The available metrics are Cosine (default), Dot Product, and Euclidean.

  • API_KEY_NAME: The name of the Upstage API key that you want to use. Must be the name of an existing Upstage API key in the Astra Portal. For more information, see Embedding provider authentication.

    Alternatively, you can omit this parameter and instead provide the authentication key in the embeddingApiKey parameter when you instantiate a Collection object with the commands to create a collection or get a collection. The client will send the x-embedding-api-key header with the specified key to any underlying HTTP request that requires vectorize authentication. Header authentication overrides the API_KEY_NAME parameter if you set both. If you use the header instead of specifying the API_KEY_NAME parameter, you must include the header in every command that uses vectorize, including writes and vector search.

  • MODEL_NAME: The model that you want to use to generate embeddings. The available models are: solar-embedding-1-large.

  • MODEL_DIMENSIONS: The number of dimensions that you want the generated vectors to have. Your chosen embedding model must support the specified number of dimensions.

    If you omit the dimension, Astra DB can use a default dimension value. However, some models don’t have default dimensions. You can use the Data API to find supported embedding providers and their configuration parameters, including dimensions ranges and default dimensions.

Configure Voyage AI as the embedding provider

For more detailed instructions, see Integrate Voyage AI as an embedding provider.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector and $vectorize as inline fields in your interfaces, or you can extend the utility VectorizeDoc types provided by the client.

import { DataAPIClient, VectorizeDoc } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User extends VectorizeDoc {
  name: string;
  age?: number;
}

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "voyageAI",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize field must still be a string, or type-related issues will occur.

Consider using a type like VectorizeDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector and $vectorize fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Instantiate the client
const client = new DataAPIClient();

// Connect to a database
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the collection
const collection_definition = {
  vector: {
    dimension: MODEL_DIMENSIONS,
    metric: "SIMILARITY_METRIC",
    service: {
      provider: "voyageAI",
      modelName: "MODEL_NAME",
      authentication: {
        providerKey: "API_KEY_NAME",
      },
    },
  },
};

(async function () {
  // Create the collection
  const collection = await database.createCollection(
    "COLLECTION_NAME",
    collection_definition,
  );
})();

Replace the following:

  • COLLECTION_NAME: The name for your collection.

  • SIMILARITY_METRIC: The method you want to use to calculate vector similarity scores. The available metrics are Cosine (default), Dot Product, and Euclidean.

  • API_KEY_NAME: The name of the Voyage AI API key that you want to use. Must be the name of an existing Voyage AI API key in the Astra Portal. For more information, see Embedding provider authentication.

    Alternatively, you can omit this parameter and instead provide the authentication key in the embeddingApiKey parameter when you instantiate a Collection object with the commands to create a collection or get a collection. The client will send the x-embedding-api-key header with the specified key to any underlying HTTP request that requires vectorize authentication. Header authentication overrides the API_KEY_NAME parameter if you set both. If you use the header instead of specifying the API_KEY_NAME parameter, you must include the header in every command that uses vectorize, including writes and vector search.

  • MODEL_NAME: The model that you want to use to generate embeddings. The available models are: voyage-2, voyage-code-2, voyage-finance-2, voyage-large-2, voyage-large-2-instruct, voyage-law-2, voyage-multilingual-2.

  • MODEL_DIMENSIONS: The number of dimensions that you want the generated vectors to have. Your chosen embedding model must support the specified number of dimensions.

    If you omit the dimension, Astra DB can use a default dimension value. However, some models don’t have default dimensions. You can use the Data API to find supported embedding providers and their configuration parameters, including dimensions ranges and default dimensions.

Create a collection that supports hybrid search

If you want to perform hybrid search on your collection, you must create a collection that has vector, lexical, and rerank enabled. Your collection must also be in a database in the AWS us-east-2 region.

Lexical and rerank are enabled by default when you create a collection in a database in the AWS us-east-2 region, but you can optionally configure the lexical analyzer and the reranker model.

For configuration details about the lexical analyzer, see Find data with CQL analyzers. The following example uses a configuration suitable for English text.

For configuration details about the reranker model, inspect the available reranker models. Only the NVIDIA llama-3.2-nv-rerankqa-1b-v2 reranking model reranker model is supported.

For configuration details about vector, see Create a collection that can store vector embeddings and Create a collection that can automatically generate vector embeddings.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $vector, $vectorize, and $lexical as inline fields in your interfaces, or you can extend the utility VectorDoc, VectorizeDoc, and LexicalDoc types provided by the client.

import { DataAPIClient, LexicalDoc, VectorizeDoc } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient("APPLICATION_TOKEN");
const database = client.db("API_ENDPOINT");

// Define the type for the collection
interface User extends VectorizeDoc, LexicalDoc {
  name: string;
  age?: number;
}

(async function () {
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    {
      vector: {
        dimension: 1024,
        metric: "cosine",
        service: {
          provider: "nvidia",
          modelName: "nvidia/nv-embedqa-e5-v5",
        },
      },
      lexical: {
        enabled: true,
        analyzer: {
          tokenizer: {
            name: "standard",
            args: {},
          },
          filters: [
            {
              name: "lowercase",
            },
            {
              name: "stop",
            },
            {
              name: "porterstem",
            },
            {
              name: "asciifolding",
            },
          ],
          charFilters: [],
        },
      },
      rerank: {
        enabled: true,
        service: {
          provider: "nvidia",
          modelName: "nvidia/llama-3.2-nv-rerankqa-1b-v2",
        },
      },
    },
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $vector field must still be number[] or DataAPIVector, and the $vectorize and $lexical fields must still be a string, or type-related issues will occur.

Consider using a type like VectorDoc & LexicalDoc & SomeDoc or VectorizeDoc & LexicalDoc & SomeDoc which allows the documents to remain untyped, but still statically requires the $vector, $vectorize, and $lexical fields to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient("APPLICATION_TOKEN");
const database = client.db("API_ENDPOINT");

(async function () {
  const collection = await database.createCollection("COLLECTION_NAME", {
    vector: {
      dimension: 1024,
      metric: "cosine",
      service: {
        provider: "nvidia",
        modelName: "nvidia/nv-embedqa-e5-v5",
      },
    },
    lexical: {
      enabled: true,
      analyzer: {
        tokenizer: {
          name: "standard",
          args: {},
        },
        filters: [
          {
            name: "lowercase",
          },
          {
            name: "stop",
          },
          {
            name: "porterstem",
          },
          {
            name: "asciifolding",
          },
        ],
        charFilters: [],
      },
    },
    rerank: {
      enabled: true,
      service: {
        provider: "nvidia",
        modelName: "nvidia/llama-3.2-nv-rerankqa-1b-v2",
      },
    },
  });
})();

Create a collection that supports lexicographical matching

If you want to use lexicographical matching to find documents in your collection, you must create a collection that has lexical enabled. Your collection must also be in a database in the AWS us-east-2 region.

Lexical is enabled by default when you create a collection in a database in the AWS us-east-2 region, but you can optionally configure the lexical analyzer.

For configuration details about the lexical analyzer, see Find data with CQL analyzers. The following example uses a configuration suitable for English text.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

You can define $lexical as inline fields in your interfaces, or you can extend the utility LexicalDoc type provided by the client.

import { DataAPIClient, LexicalDoc } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient("APPLICATION_TOKEN");
const database = client.db("API_ENDPOINT");

// Define the type for the collection
interface User extends LexicalDoc {
  name: string;
  age?: number;
}

(async function () {
  const collection = await database.createCollection<User>("COLLECTION_NAME", {
    lexical: {
      enabled: true,
      analyzer: {
        tokenizer: {
          name: "standard",
          args: {},
        },
        filters: [
          {
            name: "lowercase",
          },
          {
            name: "stop",
          },
          {
            name: "porterstem",
          },
          {
            name: "asciifolding",
          },
        ],
        charFilters: [],
      },
    },
  });
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

The $lexical field must still be a string, or type-related issues will occur.

Consider using a type like LexicalDoc & SomeDoc, which allows the documents to remain untyped but still statically requires the $lexical field to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient("APPLICATION_TOKEN");
const database = client.db("API_ENDPOINT");

(async function () {
  const collection = await database.createCollection("COLLECTION_NAME", {
    lexical: {
      enabled: true,
      analyzer: {
        tokenizer: {
          name: "standard",
          args: {},
        },
        filters: [
          {
            name: "lowercase",
          },
          {
            name: "stop",
          },
          {
            name: "porterstem",
          },
          {
            name: "asciifolding",
          },
        ],
        charFilters: [],
      },
    },
  });
})();

Create a collection and specify the default ID format

For more information about the default ID format, see Document IDs (TypeScript). For allowed values, see the Parameters.

  • Typed collections

  • Untyped collections

You can manually define a client-side type for your collection to help statically catch errors.

The _id field type should match the defaultId type.

import { DataAPIClient, ObjectId } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient();
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Define the type for the collection
interface User {
  _id: ObjectId;
  name: string;
  age?: number;
}

(async function () {
  const collection = await database.createCollection<User>(
    "COLLECTION_NAME",
    {
      defaultId: {
        type: "objectId",
      },
    },
  );
})();

If you don’t pass a type parameter, the collection remains untyped. This is a more flexible but less type-safe option.

However, if you later specify _id when you insert a document, DataStax recommends that it has the same type as the defaultId.

Consider using a type like { id: ObjectId } & SomeDoc which allows the documents to remain untyped, but still statically requires the _id field to have the correct type.

import { DataAPIClient } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient();
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

(async function () {
  const collection = await database.createCollection("COLLECTION_NAME", {
    defaultId: {
      type: "objectId",
    },
  });
})();

Create a collection and specify which fields to index

For more information about selective indexing, see Indexes in collections (TypeScript).

import { DataAPIClient } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient();
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

(async function () {
  const collection = await database.createCollection("COLLECTION_NAME", {
    indexing: {
      allow: ["city", "country"],
    },
  });
})();

Create a collection and specify which fields shouldn’t be indexed

For more information about selective indexing, see Indexes in collections (TypeScript).

import { DataAPIClient } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient();
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

(async function () {
  const collection = await database.createCollection("COLLECTION_NAME", {
    indexing: {
      deny: ["city", "country"],
    },
  });
})();

Create a collection and specify the keyspace

import { DataAPIClient } from "@datastax/astra-db-ts";

// Get a database
const client = new DataAPIClient();
const database = client.db("API_ENDPOINT", {
  token: "APPLICATION_TOKEN",
});

// Create a collection
(async function () {
  const collection = await database.createCollection("COLLECTION_NAME", {
    keyspace: "KEYSPACE_NAME",
  });
})();

Client reference

For more information, see the client reference.

Was this helpful?

Give Feedback

How can we improve the documentation?

© Copyright IBM Corporation 2026 | Privacy policy | Terms of use |  Manage Privacy Choices

Apache, Apache Cassandra, Cassandra, Apache Tomcat, Tomcat, Apache Lucene, Apache Solr, Apache Hadoop, Hadoop, Apache Pulsar, Pulsar, Apache Spark, Spark, Apache TinkerPop, TinkerPop, Apache Kafka and Kafka are either registered trademarks or trademarks of the Apache Software Foundation or its subsidiaries in Canada, the United States and/or other countries. Kubernetes is the registered trademark of the Linux Foundation.

General Inquiries: Contact IBM