Quickstart

This guide walks you through getting a project API key, installing an SDK, creating your first searchable knowledge collection, and running hybrid search queries. You’ll store source documents with text, keyword, and dense vector fields, then combine lexical matching with vector similarity to retrieve relevant knowledge.

🔑 Step 1: Create your API key

You’ll use a project API key from LambdaDB Cloud starting in Step 3.

LambdaDB Cloud is in public preview.

Project creation and management are available through LambdaDB Cloud. The public API and SDK documentation starts with an existing project.

Sign in to LambdaDB Cloud — Open app.lambdadb.ai, sign up if needed, and sign in.
Create a project — Accounts without a payment method are on the Free plan. Choose an AWS region that fits your latency or data-residency needs.
Create a project API key — Project creation does not automatically create an API key. Once the project is ready, open its API Keys tab, select Create key (or Create your first key), enter a name, and create the key.
Save the key and connection details — The full key value is shown only once, immediately after key creation. Store it securely, then use it with the project’s base URL and project name from the console starting in Step 3.

Manage API keys

Organization Owners and Admins can create and revoke project API keys in the API Keys tab. If you cannot create a key, ask an Owner or Admin. The key list does not reveal saved key values; if you lose a value, create a replacement key. To replace a key, create a new one, update your application’s credentials, and verify that it works before revoking the old key. Revocation cannot be undone and applications still using the revoked key will lose access. Key management is available through LambdaDB Cloud, not the public data API or SDKs documented here.

LambdaDB Cloud uses region-specific API base URLs. Use your project’s base URL and project name, together with a project API key created in its API Keys tab. Project creation does not automatically issue a key; save the full value when you create it, because it is shown only once. See API key management. Do not assume a global default URL or a fixed project name.

The Free plan includes monthly read, write, storage, and inference usage at no cost. Add a payment method when you need Standard plan usage beyond the Free plan limits. See Understanding costs.

The Cloud console also supports loading data and running queries in the GUI, alongside the SDK examples in this guide.

Keep your API key out of source control and prefer environment variables instead of hardcoding it in scripts.

🚀 Step 2: Install the SDK

Install one of the stable SDK versions used by these examples. See SDK support for the language-specific guides.

pip install lambdadb==0.9.0

npm install @functional-systems/lambdadb@0.5.1

go get github.com/lambdadb/go-lambdadb@v0.4.0

For Python, we recommend using a virtual environment to keep your dependencies organized and avoid conflicts between projects.

📚 Step 3: Create a collection

A collection is where you store the documents, embeddings, and metadata that make up an AI knowledge or memory dataset, and define how each field is indexed for retrieval. LambdaDB supports 9 different index types: text, keyword, long, double, boolean, object, datetime, dense vector, and sparse vector. Let’s create a collection that combines text search with vector similarity: Run the steps in order using one language. Python steps open a new client context for each operation and reuse collection_name. TypeScript steps reuse the initialized client. For Go, append the later snippets inside main, before its closing brace, using the imports shown in Step 3. Replace all connection placeholders before running.

from lambdadb import LambdaDB

# Initialize the LambdaDB client with the base URL and project name from your LambdaDB Cloud project
with LambdaDB(
    project_api_key="your_api_key_here",
    base_url="YOUR_BASE_URL",
    project_name="YOUR_PROJECT_NAME",
) as client:
    collection_name = "your_collection_name_here"
    res = client.collections.create(
        collection_name=collection_name,
        index_configs={
            "text": {
                "type": "text",
                "analyzers": ["english", "korean"],
            },
            "keyword": {"type": "keyword"},
            "vector": {
                "type": "vector",
                "dimensions": 10,
                "similarity": "cosine",
            },
        },
    )
    print(res)

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";

// Initialize the LambdaDB client with the base URL and project name from your LambdaDB Cloud project
const client = new LambdaDBClient({
  projectApiKey: "your_api_key_here",
  baseUrl: "YOUR_BASE_URL",
  projectName: "YOUR_PROJECT_NAME",
});
const collectionName = "your_collection_name_here";
const createResult = await client.createCollection({
  collectionName,
  indexConfigs: {
    text: { type: "text", analyzers: ["english", "korean"] },
    keyword: { type: "keyword" },
    vector: { type: "vector", dimensions: 10, similarity: "cosine" },
  },
});
console.log(createResult);

package main

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

func main() {
  ctx := context.Background()
  client := lambdadb.New(
    lambdadb.WithBaseURL("YOUR_BASE_URL"),
    lambdadb.WithProjectName("YOUR_PROJECT_NAME"),
    lambdadb.WithAPIKey("your_api_key_here"),
  )
  collectionName := "your_collection_name_here"
  createResult, err := client.Collections.Create(ctx, lambdadb.CreateCollectionOptions{
    CollectionName: collectionName,
    IndexConfigs: map[string]components.IndexConfigsUnion{
      "text": components.CreateIndexConfigsUnionText(components.IndexConfigsText{
        Type: components.TypeTextText,
        Analyzers: []components.Analyzer{components.AnalyzerEnglish, components.AnalyzerKorean},
      }),
      "keyword": components.CreateIndexConfigsUnionKeyword(components.IndexConfigs{Type: components.TypeKeyword}),
      "vector": components.CreateIndexConfigsUnionVector(components.IndexConfigsVector{
        Type: components.TypeVectorVector,
        Dimensions: 10,
        Similarity: components.SimilarityCosine.ToPointer(),
      }),
    },
  })
  if err != nil {
    log.Fatal(err)
  }
  fmt.Printf("%+v\n", createResult)
}

The underlying REST response is 201 Created and includes the default branch:

{
  "collection": {
    "collectionName": "your_collection_name_here",
    "description": "",
    "tags": {},
    "defaultBranchName": "main",
    "snapshotRetentionInDays": 30,
    "createdAt": 1788336000000
  }
}

Key configuration details:

Text field: Supports multilingual search with English and Korean analyzers.
Vector field: 10-dimensional vectors using cosine similarity.
Keyword field: Added to support exact match filtering.

201 Created confirms collection creation, not query-serving readiness. If a subsequent operation encounters a loading or transient error, follow Errors and retries; do not recreate the collection to wait for readiness.

📄 Step 4: Add documents

Now let’s add some sample documents. Each document contains text for full-text search, keywords for filtering, and vectors for similarity search:

with LambdaDB(project_api_key="your_api_key_here", base_url="YOUR_BASE_URL", project_name="YOUR_PROJECT_NAME") as client:
    coll = client.collection(collection_name)
    docs = [
        {"id": "doc1", "text": "Serverless computing does not mean no servers are involved. It refers to a cloud computing model where the server management is abstracted away from developers.", "keyword": "serverless", "vector": [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]},
        {"id": "doc2", "text": "Instead, it refers to a cloud computing model where developers can build and run applications without having to manage the underlying infrastructure.", "keyword": "cloud", "vector": [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]},
        {"id": "doc3", "text": "The key aspect is that developers don't need to explicitly provision or manage servers. The cloud provider handles all server management automatically.", "keyword": ["serverless", "infrastructure"], "vector": [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2]},
    ]
    res = coll.docs.upsert(docs=docs)
    print(res)

const collection = client.collection(collectionName);
const docs = [
  { id: "doc1", text: "Serverless computing does not mean no servers are involved...", keyword: "serverless", vector: [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] },
  { id: "doc2", text: "Instead, it refers to a cloud computing model where developers can build and run applications...", keyword: "cloud", vector: [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1] },
  { id: "doc3", text: "The key aspect is that developers don't need to explicitly provision or manage servers...", keyword: ["serverless", "infrastructure"], vector: [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2] },
];
const upsertResult = await collection.docs.upsert({ docs });
console.log(upsertResult);

coll := client.Collection(collectionName)
docs := []map[string]interface{}{
  {"id": "doc1", "text": "Serverless computing does not mean no servers...", "keyword": "serverless", "vector": []float64{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}},
  {"id": "doc2", "text": "Instead, it refers to a cloud computing model...", "keyword": "cloud", "vector": []float64{0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1}},
  {"id": "doc3", "text": "The key aspect is that developers don't need to explicitly provision...", "keyword": []string{"serverless", "infrastructure"}, "vector": []float64{0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2}},
}
upsertResult, err := coll.Docs().Upsert(ctx, lambdadb.UpsertDocsInput{Docs: docs})
if err != nil { log.Fatal(err) }
if upsertResult != nil && upsertResult.MessageResponse != nil {
  log.Printf("message: %s", upsertResult.MessageResponse.Message)
}

Response:

MessageResponse(message='Upsert request is accepted')

{
    message: "Upsert request is accepted"
}

message: Upsert request is accepted

Important notes:

Upsert behavior: Documents with the same ID will be replaced; new IDs create new documents.
Auto-generated IDs: If you don’t provide an ID, one will be generated automatically.
Bulk operations: For large-scale document ingestion (5MB+), use the bulk-upsert functionality.
Configurable consistency: 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 or fetching a branch directly. This overlays eligible pending writes, excluding pending bulk imports, and can return 429 if the pending payload exceeds its limit. Tag and alias reads reject this option.

Check committed data: The calls below show collection statistics. numDocs and dataUpdatedAt describe the default main branch’s committed head; dataUpdatedAt may be absent before its first commit. To verify particular writes on any branch, query or fetch the expected records from that branch with consistentRead: false.

with LambdaDB(project_api_key="your_api_key_here", base_url="YOUR_BASE_URL", project_name="YOUR_PROJECT_NAME") as client:
    meta = client.collections.get(collection_name=collection_name)
    print(meta.collection)

const meta = await client.collection(collectionName).get();
console.log(meta);

meta, err := client.Collection(collectionName).Get(ctx)
if err != nil { log.Fatal(err) }
_ = meta

🔍 Step 5: Full-text search

Let’s search for documents that match “I hate managing servers” while filtering for documents tagged exactly with “serverless”. This demonstrates LambdaDB’s powerful query capabilities:

with LambdaDB(project_api_key="your_api_key_here", base_url="YOUR_BASE_URL", project_name="YOUR_PROJECT_NAME") as client:
    coll = client.collection(collection_name)
    res = coll.query(
        size=10,
        query={
            "bool": [
                {"queryString": {"query": "I hate managing servers", "defaultField": "text"}},
                {"queryString": {"query": "keyword:serverless"}, "occur": "must"},
            ]
        },
        consistent_read=True,
    )
    print("🔍 Search Results:")
    # Query responses expose items in `res.docs` (each item includes `doc` and `score`).
    # Use `res.documents` if you want document bodies only (no scores).
    for item in res.docs:
        doc_id = str(item.doc.get("id"))
        score = f"{item.score:.2f}" if item.score is not None else "n/a"
        keyword = str(item.doc.get("keyword"))
        text = str(item.doc.get("text", ""))[:60]
        print(f"{doc_id:<5} | {score:<5} | {keyword:<15} | {text}...")

const fullTextResult = await collection.query({
  size: 10,
  query: {
    bool: [
      { queryString: { query: "I hate managing servers", defaultField: "text" } },
      { queryString: { query: "keyword:serverless" }, occur: "must" },
    ],
  },
  consistentRead: true,
});
console.log("🔍 Search Results:");
for (const item of fullTextResult.docs ?? []) {
  const docId = String(item.doc?.id);
  const score = item.score?.toFixed(2);
  const keyword = String(item.doc?.keyword);
  const text = String(item.doc?.text ?? "").slice(0, 60);
  console.log(`${docId.padEnd(5)} | ${score} | ${keyword.padEnd(15)} | ${text}...`);
}

fullTextResult, err := coll.Query(ctx, lambdadb.QueryInput{
  Size: lambdadb.Int64(10),
  Query: map[string]interface{}{
    "bool": []interface{}{
      map[string]interface{}{"queryString": map[string]interface{}{"query": "I hate managing servers", "defaultField": "text"}},
      map[string]interface{}{"queryString": map[string]interface{}{"query": "keyword:serverless"}, "occur": "must"},
    },
  },
  ConsistentRead: lambdadb.Bool(true),
})
if err != nil { log.Fatal(err) }
log.Println("🔍 Search Results:")
for _, r := range fullTextResult.Docs {
  doc := r.Doc
  docID := fmt.Sprintf("%v", doc["id"])
  score := "n/a"
  if r.Score != nil { score = fmt.Sprintf("%.2f", *r.Score) }
  keyword := fmt.Sprintf("%v", doc["keyword"])
  text := fmt.Sprintf("%v", doc["text"])
  if len(text) > 60 { text = text[:60] }
  log.Printf("%-5s | %-5s | %-15s | %s...", docID, score, keyword, text)
}

Response:

🔍 Search Results:
doc3  | 0.83  | ['serverless', 'infrastructure'] | The key aspect is that developers don't need to explicitly provision or manage servers. The cloud provider handles all server management automatically.
doc1  | 0.80  | serverless      | Serverless computing does not mean no servers are involved. It refers to a cloud computing model where the server management is abstracted away from developers.

🔍 Search Results:
doc3  | 0.83  | ['serverless', 'infrastructure'] | The key aspect is that developers don't need to explicitly provision or manage servers. The cloud provider handles all server management automatically.
doc1  | 0.80  | serverless      | Serverless computing does not mean no servers are involved. It refers to a cloud computing model where the server management is abstracted away from developers.

🔍 Search Results:
doc3  | 0.83  | [serverless infrastructure] | The key aspect is that developers don't need to explicitly provision or manage servers. The cloud provider handles all server management automatically.
doc1  | 0.80  | serverless      | Serverless computing does not mean no servers are involved. It refers to a cloud computing model where the server management is abstracted away from developers.

Why these results? doc3 scored highest because it directly mentions “manage servers”, while doc1 matched on “server management” and “serverless computing”.

🔍 Step 6: Hybrid search

Now let’s combine full-text search with vector similarity for more comprehensive results. This is where LambdaDB really shines:

with LambdaDB(project_api_key="your_api_key_here", base_url="YOUR_BASE_URL", project_name="YOUR_PROJECT_NAME") as client:
    coll = client.collection(collection_name)
    res = coll.query(
        size=10,
        query={
            "l2": [
                {"queryString": {"query": "I hate managing servers", "defaultField": "text"}},
                {"knn": {"field": "vector", "k": 5, "queryVector": [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1.0]}},
            ]
        },
        consistent_read=True,
    )
    print("🔄 Hybrid Search Results:")
    for item in res.docs:
        score = f"{item.score:.2f}" if item.score is not None else "n/a"
        print(f"{item.doc.get('id')} | {score} | {item.doc.get('text', '')[:50]}...")

const hybridResult = await collection.query({
  size: 10,
  query: {
    l2: [
      { queryString: { query: "I hate managing servers", defaultField: "text" } },
      { knn: { field: "vector", k: 5, queryVector: [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1.0] } },
    ],
  },
  consistentRead: true,
});
console.log("🔄 Hybrid Search Results:");
for (const item of hybridResult.docs ?? []) {
  console.log(`${item.doc?.id} | ${item.score?.toFixed(2)} | ${String(item.doc?.text).slice(0, 50)}...`);
}

hybridResult, err := coll.Query(ctx, lambdadb.QueryInput{
  Size: lambdadb.Int64(10),
  Query: map[string]interface{}{
    "l2": []interface{}{
      map[string]interface{}{"queryString": map[string]interface{}{"query": "I hate managing servers", "defaultField": "text"}},
      map[string]interface{}{"knn": map[string]interface{}{"field": "vector", "k": 5, "queryVector": []float64{0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1.0}}},
    },
  },
  ConsistentRead: lambdadb.Bool(true),
})
if err != nil { log.Fatal(err) }
log.Println("🔄 Hybrid Search Results:")
for _, r := range hybridResult.Docs {
  doc := r.Doc
  docID := fmt.Sprintf("%v", doc["id"])
  score := "n/a"
  if r.Score != nil { score = fmt.Sprintf("%.2f", *r.Score) }
  keyword := fmt.Sprintf("%v", doc["keyword"])
  text := fmt.Sprintf("%v", doc["text"])
  if len(text) > 50 { text = text[:50] }
  log.Printf("%s | %s | %s | %s...", docID, score, keyword, text)
}

Response:

🔄 Hybrid Search Results:
doc3  | 0.66  | serverless,infrastructure | The key aspect is that developers don't need to explicitly provision or manage servers. The cloud provider handles all server management automatically.
doc1  | 0.62  | serverless      | Serverless computing does not mean no servers are involved. It refers to a cloud computing model where the server management is abstracted away from developers.
doc2  | 0.33  | cloud           | Instead, it refers to a cloud computing model where developers can build and run applications without having to manage the underlying infrastructure.

🔄 Hybrid Search Results:
doc3  | 0.66  | serverless,infrastructure | The key aspect is that developers don't need to explicitly provision or manage servers. The cloud provider handles all server management automatically.
doc1  | 0.62  | serverless      | Serverless computing does not mean no servers are involved. It refers to a cloud computing model where the server management is abstracted away from developers.
doc2  | 0.33  | cloud           | Instead, it refers to a cloud computing model where developers can build and run applications without having to manage the underlying infrastructure.

🔄 Hybrid Search Results:
doc3  | 0.66  | serverless,infrastructure | The key aspect is that developers don't need to explicitly provision or manage servers. The cloud provider handles all server management automatically.
doc1  | 0.62  | serverless      | Serverless computing does not mean no servers are involved. It refers to a cloud computing model where the server management is abstracted away from developers.
doc2  | 0.33  | cloud           | Instead, it refers to a cloud computing model where developers can build and run applications without having to manage the underlying infrastructure.

Score normalization options:

rrf (Reciprocal Rank Fusion): Great for combining rankings from different search methods
l2 (L2 Normalization): Normalizes scores using L2 norm
mm (Min-Max Normalization): Simple linear scaling to 0-1 range

🧹 Step 7: Clean up

When you’re finished experimenting, clean up your resources:

with LambdaDB(project_api_key="your_api_key_here", base_url="YOUR_BASE_URL", project_name="YOUR_PROJECT_NAME") as client:
    client.collections.delete(collection_name=collection_name)

await client.collection(collectionName).delete();

_, err = client.Collection(collectionName).Delete(ctx)
if err != nil { log.Fatal(err) }

🚀 Next steps

Advanced Queries: Explore complex patterns in our Query Guide
Bulk Operations: Learn about large-scale data ingestion in our Bulk Operations Guide
API Reference: Comprehensive documentation at our API Reference

🤝 Support

Need help? Visit our Community Slack for support and discussions.

Get started

Migrations

Collections

Data versioning

Documents

Search

Manage Costs

🔑 Step 1: Create your API key

Manage API keys

🚀 Step 2: Install the SDK

📚 Step 3: Create a collection

📄 Step 4: Add documents

🔍 Step 5: Full-text search

🔍 Step 6: Hybrid search

🧹 Step 7: Clean up

🚀 Next steps

🤝 Support

​🔑 Step 1: Create your API key

​Manage API keys

​🚀 Step 2: Install the SDK

​📚 Step 3: Create a collection

​📄 Step 4: Add documents

​🔍 Step 5: Full-text search

​🔍 Step 6: Hybrid search

​🧹 Step 7: Clean up

​🚀 Next steps

​🤝 Support

🔑 Step 1: Create your API key

Manage API keys

🚀 Step 2: Install the SDK

📚 Step 3: Create a collection

📄 Step 4: Add documents

🔍 Step 5: Full-text search

🔍 Step 6: Hybrid search

🧹 Step 7: Clean up

🚀 Next steps

🤝 Support