Search overview

A search query, or query, is a request for information about data in LambdaDB collections. LambdaDB supports several search methods:

Search for exact values: search for exact values or ranges of numbers, dates, IPs, or strings.
Full-text search: use full text queries to query unstructured textual data and find documents that best match query terms.
Vector search: store vectors in LambdaDB and use approximate nearest neighbor (ANN) to find vectors that are similar, supporting use cases like semantic search.

If you use managed embedding vector fields, see Managed embeddings for the current supported providers and models. Common parameters for the request body of a query are as follows:

Parameter	Description	Type	Required	Default
size	The number of results to return for each query	integer	✓
query	Query object (details in the subsections)	object	✓
includeVectors	Indicates whether vector values are included in the response	boolean		false
consistentRead	Determines the read consistency model: If set to true, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.	boolean		false
fields	A list of field names to include and/or exclude in the result. Use dot notation (e.g., user.name) to specify nested fields.	object
sort	Specifies the sorting criteria for the results (details in the subsection)	object[]
partitionFilter	Partition filter	object

Depending on your data and your query, you may get fewer than size results. This happens when size is larger than the number of possible matching documents for your query.

Setting includeVectors (or include_vectors in Python) to true will increase response size significantly, especially for high-dimensional vectors. Use this option only when vector data is specifically needed for your application.

include is applied first, and then exclude is applied to the included fields when you set both in the fields parameter.

LambdaDB is eventually consistent by default, so there can be a slight delay before new or changed documents are visible to queries. If your application requires strong (read-after-write) consistency, set consistentRead (or consistent_read in Python) to true when querying data from a collection, at the expense of potential higher latency and cost.

Query results are returned in the following format:

Field	Description	Type
took	Milliseconds it took LambdaDB to execute the request	long
maxScore	Highest returned document `score`	float
total	The total number of matching documents	long
docs	Contains returned documents and metadata	object[]

Example

from lambdadb import LambdaDB

with LambdaDB(project_api_key="YOUR_API_KEY", base_url="YOUR_BASE_URL", project_name="YOUR_PROJECT_NAME") as client:
    coll = client.collection("my_collection")
    results = coll.query(query={"queryString": {"query": "*:*"}}, size=10)
    # `results.docs` contains items (each item includes `doc` and `score`).
    # `results.documents` contains document bodies only (no scores).

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",
});
const results = await client.collection("my_collection").query({
  query: { queryString: { query: "*:*" } },
  size: 10,
});

package main

import (
  "context"
  "log"
  lambdadb "github.com/lambdadb/go-lambdadb"
)

func main() {
  ctx := context.Background()
  client := lambdadb.New(
    lambdadb.WithBaseURL("YOUR_BASE_URL"),
    lambdadb.WithProjectName("YOUR_PROJECT_NAME"),
    lambdadb.WithAPIKey("YOUR_API_KEY"),
  )
  coll := client.Collection("my_collection")
  results, err := coll.Query(ctx, lambdadb.QueryCollectionInput{
    Query: map[string]interface{}{"queryString": map[string]interface{}{"query": "*:*"}},
    Size:  10,
  })
  if err != nil {
    log.Fatal(err)
  }
  _ = results
}

The response will look like this:

{
  "took": 76,
  "maxScore": 1.0,
  "total": 1,
  "docs": [
    {
      "collection": "example_collection",
      "score": 1.0,
      "doc": {
        "id": "33201222",
        "url": "https://en.wikipedia.org/wiki/LambdaDB",
        "title": "LambdaDB is awesome",
        "text": null
      }
    }
  ],
  "isDocsInline": true
}

Matched documents are ordered by similarity from most similar to least similar by default. Similarity is expressed as a score, and it is calculated based on the BM25 algorithm for full-text search and the configured similarity metric for vector search.

Get started

Migrations

Collections

Documents

Search

Manage Costs

Example

​Example

Example