Create a new collection

This page shows you how to create a collection with various configurations.

Parameters

Parameter	Type	Required	Description
collectionName	string	✓	Collection name must be unique within a project and the supported maximum length is 52 characters
indexConfigs	object		Field configuration for indexing. Required when creating from scratch
sourceProjectName	string		Source project name for PITR or branching operations
sourceCollectionName	string		Source collection name for PITR or branching operations
sourceDatetime	string		ISO 8601 formatted datetime for PITR (e.g., “2024-01-15T10:30:00Z”)
sourceProjectApiKey	string		API key for the source project
partitionConfig	object		Partition configuration

Create a collection from scratch

The simplest way to create a collection is to provide the collection name and the field index configurations.

from lambdadb import LambdaDB, models

with LambdaDB(
    project_api_key="YOUR_API_KEY",
    base_url="YOUR_BASE_URL",
    project_name="YOUR_PROJECT_NAME",
) as client:
    basic_config = {
        "url": {"type": "keyword"},
        "author": {"type": "keyword"},
        "content": {
            "type": "text",
            "analyzers": ["japanese", "korean", "english"],
        },
    }
    client.collections.create(collection_name="example-collection", index_configs=basic_config)

Python: LambdaDB supports context manager usage. __enter__ returns the client, and __exit__ calls client.close() (closing the SDK-owned HTTP client) and makes the client unusable after the with block. If you don’t use with, call client.close() when you’re done. If you pass a custom client=/async_client=, you own closing it.

import { LambdaDBClient } from "@functional-systems/lambdadb";

const client = new LambdaDBClient({
  projectApiKey: "YOUR_API_KEY",
  baseUrl: "YOUR_BASE_URL",
  projectName: "YOUR_PROJECT_NAME",
});
await client.createCollection({
  collectionName: "example-collection",
  indexConfigs: {
    url: { type: "keyword" },
    author: { type: "keyword" },
    content: { type: "text", analyzers: ["japanese", "korean", "english"] },
  },
});

client := lambdadb.New(
  lambdadb.WithBaseURL("YOUR_BASE_URL"),
  lambdadb.WithProjectName("YOUR_PROJECT_NAME"),
  lambdadb.WithAPIKey("YOUR_API_KEY"),
)
_, err := client.Collections.Create(ctx, lambdadb.CreateCollectionOptions{
  CollectionName: "example-collection",
  IndexConfigs: map[string]interface{}{
    "url":     map[string]interface{}{"type": "keyword"},
    "author":  map[string]interface{}{"type": "keyword"},
    "content": map[string]interface{}{"type": "text", "analyzers": []string{"japanese", "korean", "english"}},
  },
})

LAMBDADB_PROJECT_API_KEY="YOUR_API_KEY"

curl -i -X POST "$BASE_URL/projects/$PROJECT_NAME/collections" \
  -H "content-type: application/json" \
  -H "x-api-key: $LAMBDADB_PROJECT_API_KEY" \
  -d '{
        "collectionName": "example-collection",
        "indexConfigs": {
          "url": { "type": "keyword" },
          "author": { "type": "keyword" },
          "content": { "type": "text", "analyzers": ["japanese", "korean", "english"] }
        }
      }'

Create a collection with managed embeddings

Managed embeddings let LambdaDB derive vector values from a source text field. Define the vector field with managedEmbedding: true and an embedding block. The source field must be a text field in the same collection. For the current provider and model matrix, see Managed embeddings.

from lambdadb import LambdaDB

with LambdaDB(
    project_api_key="YOUR_API_KEY",
    base_url="YOUR_BASE_URL",
    project_name="YOUR_PROJECT_NAME",
) as client:
    client.collections.create(
        collection_name="semantic-docs",
        index_configs={
            "body": {
                "type": "text",
                "analyzers": ["english"],
            },
            "bodyEmbedding": {
                "type": "vector",
                "managedEmbedding": True,
                "embedding": {
                    "provider": "openai",
                    "model": "text-embedding-3-small",
                    "sourceField": "body",
                },
            },
        },
    )

await client.createCollection({
  collectionName: "semantic-docs",
  indexConfigs: {
    body: {
      type: "text",
      analyzers: ["english"],
    },
    bodyEmbedding: {
      type: "vector",
      managedEmbedding: true,
      embedding: {
        provider: "openai",
        model: "text-embedding-3-small",
        sourceField: "body",
      },
    },
  },
});

curl -i -X POST "$BASE_URL/projects/$PROJECT_NAME/collections" \
  -H "content-type: application/json" \
  -H "x-api-key: $LAMBDADB_PROJECT_API_KEY" \
  -d '{
        "collectionName": "semantic-docs",
        "indexConfigs": {
          "body": {
            "type": "text",
            "analyzers": ["english"]
          },
          "bodyEmbedding": {
            "type": "vector",
            "managedEmbedding": true,
            "embedding": {
              "provider": "openai",
              "model": "text-embedding-3-small",
              "sourceField": "body"
            }
          }
        }
      }'

For managed embedding vector fields, do not send top-level dimensions or similarity in the field config. LambdaDB resolves and stores those values under embedding.

Create a partitioned collection

LambdaDB supports hash-based partitioning for a specified field.

from lambdadb import LambdaDB, models

with LambdaDB(project_api_key="YOUR_API_KEY", base_url="YOUR_BASE_URL", project_name="YOUR_PROJECT_NAME") as client:
    basic_config = {
        "url": {"type": "keyword"},
        "author": {"type": "keyword"},
        "content": {"type": "text", "analyzers": ["japanese", "korean", "english"]},
    }
    client.collections.create(
        collection_name="example-collection",
        index_configs=basic_config,
        partition_config={"field_name": "url", "data_type": "keyword", "num_partitions": 4},
    )

await client.createCollection({
  collectionName: "example-collection",
  indexConfigs: { url: { type: "keyword" }, author: { type: "keyword" }, content: { type: "text", analyzers: ["japanese", "korean", "english"] } },
  partitionConfig: { fieldName: "url", dataType: "keyword", numPartitions: 4 },
});

curl -i -X POST "$BASE_URL/projects/$PROJECT_NAME/collections" \
  -H "content-type: application/json" \
  -H "x-api-key: $LAMBDADB_PROJECT_API_KEY" \
  -d '{
        "collectionName": "example-collection",
        "indexConfigs": { "url": {"type": "keyword"}, "author": {"type": "keyword"}, "content": {"type": "text", "analyzers": ["japanese", "korean", "english"]} },
        "partitionConfig": { "fieldName": "url", "dataType": "keyword", "numPartitions": 4 }
      }'

Currently, only keyword type is supported for partitioning.

Point-in-time recovery (PITR)

LambdaDB automatically maintains continuous backups at the collection level with a default retention period of 30 days. You can create a collection from a specific point in time using PITR functionality.

from lambdadb import LambdaDB

with LambdaDB(project_api_key="YOUR_TARGET_API_KEY", base_url="YOUR_BASE_URL", project_name="YOUR_PROJECT_NAME") as client:
    restored_collection = client.collections.create(
        collection_name="restored-collection",
        source_project_name="source-project-name",
        source_project_api_key="YOUR_SOURCE_API_KEY",
        source_collection_name="source-collection-name",
        source_datetime="2024-01-15T10:30:00Z",
    )

LAMBDADB_TARGET_PROJECT_API_KEY="YOUR_TARGET_API_KEY"
LAMBDADB_SOURCE_PROJECT_API_KEY="YOUR_SOURCE_API_KEY"

curl -i -X POST "$BASE_URL/projects/$PROJECT_NAME/collections" \
  -H "content-type: application/json" \
  -H "x-api-key: $LAMBDADB_TARGET_PROJECT_API_KEY" \
  -d '{
        "collectionName": "restored-collection",
        "sourceProjectName": "source-project-name",
        "sourceProjectApiKey": "'$LAMBDADB_SOURCE_PROJECT_API_KEY'",
        "sourceCollectionName": "source-collection-name",
        "sourceDatetime": "2024-01-15T10:30:00Z"
      }'

PITR allows you to restore collections to any point within the configured retention period. The sourceDatetime parameter must be in ISO 8601 format (UTC timezone). If sourceDatetime is not specified, the collection will be restored from the most recent data available.

Fork a collection with additional index configs

You can fork a collection based on an existing collection and extend it with additional indexConfigs. The original collection’s configuration will be preserved, and you can only add new fields.

from lambdadb import LambdaDB, models

with LambdaDB(project_api_key="YOUR_TARGET_API_KEY", base_url="YOUR_BASE_URL", project_name="YOUR_PROJECT_NAME") as client:
    forked = client.collections.create(
        collection_name="forked-collection",
        source_project_name="source-project-name",
        source_project_api_key="YOUR_SOURCE_API_KEY",
        source_collection_name="example-source-collection-name",
        source_datetime="2025-08-08T10:00:00Z",
        index_configs={
            "newText": {"type": "text", "analyzers": ["japanese", "korean", "english"]},
        },
    )

LAMBDADB_TARGET_PROJECT_API_KEY="YOUR_TARGET_API_KEY"
LAMBDADB_SOURCE_PROJECT_API_KEY="YOUR_SOURCE_API_KEY"

curl -i -X POST "$BASE_URL/projects/$PROJECT_NAME/collections" \
  -H "content-type: application/json" \
  -H "x-api-key: $LAMBDADB_TARGET_PROJECT_API_KEY" \
  -d '{
        "collectionName": "forked-collection",
        "sourceProjectId": "example-source-project-id",
        "sourceProjectApiKey": "'$LAMBDADB_SOURCE_PROJECT_API_KEY'",
        "sourceCollectionName": "example-source-collection-name",
        "sourceDatetime": "2025-08-08T10:00:00Z"
      }'

When forking a collection, specifying indexConfigs is optional. You can pass additional indexConfigs to extend the original collection’s configuration, but deleting or modifying the original collection’s indexConfigs is not allowed.

Collection limits

Metric	Limit
Max number of collections	unlimited
Max forked children per collection	30

Get started

Migrations

Collections

Documents

Search

Manage Costs

Parameters

Create a collection from scratch

Create a collection with managed embeddings

Create a partitioned collection

Point-in-time recovery (PITR)

Fork a collection with additional index configs

Collection limits

​Parameters

​Create a collection from scratch

​Create a collection with managed embeddings

​Create a partitioned collection

​Point-in-time recovery (PITR)

​Fork a collection with additional index configs

​Collection limits

Parameters

Create a collection from scratch

Create a collection with managed embeddings

Create a partitioned collection

Point-in-time recovery (PITR)

Fork a collection with additional index configs

Collection limits