Index types

LambdaDB currently supports nine types of indexes. Note that the whole document is stored as is regardless of its existence in index configurations, but being stored does not necessarily mean it is searchable.

The dot (.) character cannot be used as a field name, and you can only add indexes to existing collections. Modifying or deleting existing indexes is not supported.

text

This type is for full-text values, such as the body of an email or the description of a product. These full-text values are analyzed by passing them through an analyzer to convert the string into a list of individual terms before being indexed. The analysis process allows LambdaDB to search for individual words within each full text field. text indexes are best suited for unstructured but human-readable content. If you need to index structured content such as email addresses, hostnames, status codes, or tags, you should rather use a keyword index. Choose one or more supported analyzers for each text field. Omitting analyzers uses ["standard"]. LambdaDB applies every analyzer you select; it does not automatically detect the language. See Choose text analyzers for single-language and multilingual selection, configuration examples, and the tradeoffs of combining analyzers.

{
    "content": {
        "type": "text",
        "analyzers": [
            "english",
            "korean",
            "japanese"
        ]
    }
}

{
    "content": {
        "type": "text",
        "analyzers": [
            "english",
            "korean", 
            "japanese"
        ]
    }
}

keyword

keyword type is used for structured content such as IDs, email addresses, hostnames, status codes, zip codes, or tags. Use keyword indexes for sorting, exact-value filters, and keyword facets.

LambdaDB does not index any string longer than 4096 characters.

You can also store multiple keyword values as an array for fields like tags or categories. Each distinct indexed value contributes once per document to a facet. Array sorting uses the smallest value for ascending order and the largest for descending order.

{
    "status": {"type": "keyword"},
    "category": {"type": "keyword"}
}

{
    "status": {"type": "keyword"},
    "category": {"type": "keyword"}
}

long

This type is for a signed 64-bit integer with a minimum value of

-2^{63}

and a maximum value of

2^{63}-1

. long indexes are optimized for scoring, sorting, and range queries.

{
    "user_id": {"type": "long"},
    "timestamp": {"type": "long"}
}

{
    "user_id": {"type": "long"},
    "timestamp": {"type": "long"}
}

double

This type is for a double-precision 64-bit IEEE 754 floating point number, restricted to finite values. double indexes are optimized for scoring, sorting, and range queries.

{
    "score": {"type": "double"},
    "price": {"type": "double"}
}

{
    "score": {"type": "double"},
    "price": {"type": "double"}
}

boolean

boolean indexes accept JSON true and false values, but can also accept strings which are interpreted as either true or false.

{
    "is_active": {"type": "boolean"},
    "published": {"type": "boolean"}
}

{
    "is_active": {"type": "boolean"},
    "published": {"type": "boolean"}
}

datetime

This type is for date and time in RFC 3339 format. datetime indexes are optimized for sorting and range queries.

from datetime import datetime, timezone

# Example datetime usage
dt = datetime.now(timezone.utc)
print(dt.isoformat(timespec="seconds"))
# Output: 2024-11-05T14:27:56+00:00

# Index configuration
{
    "created_at": {"type": "datetime"},
    "updated_at": {"type": "datetime"}
}

{
    "created_at": {"type": "datetime"},
    "updated_at": {"type": "datetime"}
}

vector

The vector type indexes dense vectors of numeric values. vector indexes are primarily used for k-nearest neighbor (kNN) search. The vector type does not support aggregations or sorting. You add a vector field as an array of numeric values. A kNN search finds the k nearest vectors to a query vector, as measured by a similarity metric. LambdaDB supports four similarity metrics: euclidean, dot_product, cosine, max_inner_product. You can define the vector similarity to use in kNN search. LambdaDB supports two vector field modes:

vector fields with caller-provided values, where you send vector values directly
native embedding vector fields, where LambdaDB generates vector values from a source text field

LambdaDB also supports multi-field vector search, allowing you to perform kNN searches across multiple vector fields simultaneously within a single query. This enables complex semantic search scenarios where you can combine different types of embeddings (e.g., text embeddings, image embeddings) in one search operation.

{
    "embedding": {
        "type": "vector",
        "dimensions": 768,
        "similarity": "cosine"
    },
    "image_vector": {
        "type": "vector",
        "dimensions": 512,
        "similarity": "euclidean"
    }
}

{
    "embedding": {
        "type": "vector",
        "dimensions": 768,
        "similarity": "cosine"
    },
    "image_vector": {
        "type": "vector",
        "dimensions": 512,
        "similarity": "euclidean"
    }
}

Native embedding vector fields

Add an embedding block to let LambdaDB generate vectors from a source text field. For supported models and configuration rules, see Native embeddings.

{
    "body": {
        "type": "text",
        "analyzers": ["english"]
    },
    "body_embedding": {
        "type": "vector",
        "embedding": {
            "provider": "openai",
            "model": "text-embedding-3-small",
            "sourceField": "body"
        }
    }
}

{
    "body": {
        "type": "text",
        "analyzers": ["english"]
    },
    "body_embedding": {
        "type": "vector",
        "embedding": {
            "provider": "openai",
            "model": "text-embedding-3-small",
            "sourceField": "body"
        }
    }
}

For native embedding vector fields:

embedding.provider, embedding.model, and embedding.sourceField are required
embedding.sourceField must point to a text field in the same collection
do not send direct vector values for the generated field in upsert or update requests
use knn.queryText for search instead of knn.queryVector
bulk upsert is not supported for collections that contain native embedding fields

sparseVector

The sparseVector type is designed for storing and indexing sparse vectors, where most elements are zero or missing. Unlike dense vectors, sparse vectors only store non-zero values along with their corresponding indexes. sparseVector type only supports the dot_product distance metric.

{
    "sparse_embedding": {"type": "sparseVector"}
}

{
    "sparse_embedding": {"type": "sparseVector"}
}

object

JSON documents are hierarchical in nature: the document may contain inner objects which, in turn, may contain inner objects themselves. Internally, this document is indexed as a simple, flat list of key-value pairs. The fields within the object can be of any data type, including object. objectIndexConfigs should be specified in order to index the fields inside the object.

{
    "metadata": {
        "type": "object",
        "objectIndexConfigs": {
            "url": {"type": "keyword"},
            "author": {"type": "keyword"},
            "content": {
                "type": "text",
                "analyzers": ["english", "korean"]
            }
        }
    }
}

{
    "metadata": {
        "type": "object",
        "objectIndexConfigs": {
            "url": {"type": "keyword"},
            "author": {"type": "keyword"},
            "content": {
                "type": "text",
                "analyzers": ["english", "korean"]
            }
        }
    }
}

Complete example configuration

Here’s a comprehensive example that demonstrates all index types:

from lambdadb import models

complete_index_config = {
    "text": {
        "type": "text",
        "analyzers": [
            "japanese",
            "korean",
            "english",
        ],
    },
    "keyword": {"type": "keyword"},
    "long": {"type": "long"},
    "double": {"type": "double"},
    "boolean": {"type": "boolean"},
    "datetime": {"type": "datetime"},
    "vector": {
        "type": "vector",
        "dimensions": 10,
        "similarity": "cosine",
    },
    "sparseVector": {"type": "sparseVector"},
    "object": {
        "type": "object",
        "objectIndexConfigs": {
            "text": {
                "type": "text",
                "analyzers": [
                    "japanese",
                    "korean",
                    "english",
                ],
            },
            "keyword": {"type": "keyword"},
            "long": {"type": "long"},
            "double": {"type": "double"},
            "boolean": {"type": "boolean"},
            "datetime": {"type": "datetime"},
            "vector": {
                "type": "vector",
                "dimensions": 10,
                "similarity": "cosine",
            },
            "sparseVector": {"type": "sparseVector"},
        },
    },
}

{
    "text": {
        "type": "text",
        "analyzers": [
            "japanese",
            "korean",
            "english"
        ]
    },
    "keyword": {"type": "keyword"},
    "long": {"type": "long"},
    "double": {"type": "double"},
    "boolean": {"type": "boolean"},
    "datetime": {"type": "datetime"},
    "vector": {
        "type": "vector",
        "dimensions": 10,
        "similarity": "cosine"
    },
    "sparseVector": {"type": "sparseVector"},
    "object": {
        "type": "object",
        "objectIndexConfigs": {
            "text": {
                "type": "text",
                "analyzers": [
                    "japanese",
                    "korean",
                    "english"
                ]
            },
            "keyword": {"type": "keyword"},
            "long": {"type": "long"},
            "double": {"type": "double"},
            "boolean": {"type": "boolean"},
            "datetime": {"type": "datetime"},
            "vector": {
                "type": "vector",
                "dimensions": 10,
                "similarity": "cosine"
            },
            "sparseVector": {"type": "sparseVector"}
        }
    }
}

Supported analyzers

LambdaDB supports 49 fixed presets for text fields. See SDK and tool compatibility for versions that accept all 49 names.

Analyzer	Description
`standard`	Default general-purpose Unicode text analysis
`english`	English
`korean`	Korean (Nori)
`japanese`	Japanese (Kuromoji)
`chinese`	Simplified Chinese word segmentation (SmartChinese); also processes mixed Chinese-English text
`cjk`	Overlapping two-character tokens for Chinese, Japanese, and Korean text
`arabic`	Arabic
`french`	French
`german`	German
`hindi`	Hindi
`indonesian`	Indonesian
`italian`	Italian
`portuguese`	Portuguese
`russian`	Russian
`spanish`	Spanish
`turkish`	Turkish
`armenian`	Armenian
`basque`	Basque
`bengali`	Bengali
`brazilian`	Brazilian Portuguese
`bulgarian`	Bulgarian
`catalan`	Catalan
`czech`	Czech
`danish`	Danish
`dutch`	Dutch
`estonian`	Estonian
`finnish`	Finnish
`galician`	Galician
`greek`	Greek
`hungarian`	Hungarian
`irish`	Irish
`latvian`	Latvian
`lithuanian`	Lithuanian
`norwegian`	Norwegian
`persian`	Persian
`romanian`	Romanian
`serbian`	Serbian
`sorani`	Sorani Kurdish
`swedish`	Swedish
`thai`	Thai
`simple`	Splits at non-letter characters and lowercases terms
`whitespace`	Splits at whitespace; preserves case
`stop`	Letter tokenization and lowercasing with the default English stopword set
`keyword`	One token for the entire value; preserves case and whitespace; remains a text field
`pattern`	Splits at Java `\W+` separators and lowercases; no stopwords or Unicode-character-class option
`fingerprint`	Lowercases, folds ASCII, sorts and deduplicates terms into one space-separated token; discards output over 255 UTF-16 code units
`nepali`	Nepali (Lucene extension)
`tamil`	Tamil (Lucene extension)
`telugu`	Telugu (Lucene extension)

All names select fixed presets through analyzers; custom pipelines, tokenizers, filters, stopword lists, and analyzer options are not configurable. The keyword analyzer on a text field does not provide the sorting or facet behavior of a keyword field type. nepali, tamil, and telugu are Lucene extensions, not shared Elasticsearch/OpenSearch analyzer support. Use the lowercase names above. Duplicate analyzer names, including case variants, are rejected with HTTP 400. Omit analyzers for the default, or select at least one analyzer; an empty list does not use the default. See Choose text analyzers before combining analyzers or migrating an existing field.

Ask in the LambdaDB community Slack or email support@lambdadb.ai if you need an analyzer not listed above.

Supported similarity metrics

Metric	Description	Use Case
`cosine`	Cosine similarity	Most common for text embeddings
`euclidean`	Euclidean distance	Geometric distance calculations
`dot_product`	Dot product for unit-length vectors	Document and query vectors are already normalized to unit length
`max_inner_product`	Maximum inner product without a normalization requirement	Preserve vector magnitudes when they contribute to relevance

For dense vectors, use dot_product only when both document and query vectors have unit length. Use max_inner_product to preserve an unnormalized inner-product objective; normalizing vectors can change that ranking. These semantics follow Lucene’s vector similarity definitions. This normalization requirement does not apply to sparseVector fields. Dense-vector query results contain relevance scores, not raw distances or inner products. Validate score thresholds separately when migrating between systems.

Get started

Migrations

Collections

Data versioning

Documents

Search

Manage Costs

Security

text

keyword

long

double

boolean

datetime

vector

Native embedding vector fields

sparseVector

object

Complete example configuration

Supported analyzers

Supported similarity metrics

​text

​keyword

​long

​double

​boolean

​datetime

​vector

​Native embedding vector fields

​sparseVector

​object

​Complete example configuration

​Supported analyzers

​Supported similarity metrics

text

keyword

long

double

boolean

datetime

vector

Native embedding vector fields

sparseVector

object

Complete example configuration

Supported analyzers

Supported similarity metrics