Qdrant SDK compatibility

LambdaDB provides explicit Qdrant-style compatibility clients for Python and TypeScript applications. Use them when you have already moved or plan to move Qdrant data into LambdaDB, but want to keep common Qdrant client calls while you migrate application code. The compatibility clients are not full Qdrant client replacements. They cover the common dense-vector search and RAG subset, map Qdrant points to LambdaDB documents, and raise an explicit unsupported-feature error for behavior that LambdaDB cannot safely emulate.

When to use this path

Use the Qdrant compatibility clients when:

Your application already uses Qdrant’s Python or JavaScript/TypeScript SDK.
You want a smaller application change than rewriting all query code to LambdaDB native APIs at once.
Your workload uses dense vectors, named dense vectors, payload filters, document retrieval, deletes, scroll, or collection metadata checks.

Use LambdaDB native APIs directly when:

You are building new application code.
You need LambdaDB-specific query features such as lexical plus vector hybrid search.
You want the clearest long-term API surface after migration.

The compatibility clients map Qdrant Dot to LambdaDB dot_product, which requires unit-length document and query vectors. If your inner-product search relies on vector magnitudes, use LambdaDB native APIs with max_inner_product and validate ranking and score handling. See dense-vector similarity requirements.

Install

Python support is available in lambdadb >= 0.8.2:

pip install lambdadb==0.12.1

TypeScript support is available in @functional-systems/lambdadb >= 0.4.3:

npm install @functional-systems/lambdadb@0.8.1

The examples pin Python 0.12.1 and TypeScript 0.8.1; see SDK runtime requirements. These releases reject unsupported payload schema options instead of silently dropping them. Python preserves supported LambdaDB analyzer names in text schema mappings. The TypeScript Qdrant adapter remains type-only and rejects analyzer/tokenizer/lowercase options; use the native SDK to configure LambdaDB analyzer presets. Custom pipelines are not translated. Review existing schema objects when upgrading; removing an unsupported option is an explicit matching-behavior decision.

Connection settings

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.

Pass those values to the compatibility client instead of a Qdrant URL.

Python

Change the import and client construction explicitly:

- from qdrant_client import QdrantClient, models
+ from lambdadb.compat.qdrant import QdrantCompatClient as QdrantClient, models

- client = QdrantClient(url="http://localhost:6333")
+ client = QdrantClient(
+     project_api_key="<YOUR_PROJECT_API_KEY>",
+     base_url="<YOUR_REGION_BASE_URL>",
+     project_name="<YOUR_PROJECT_NAME>",
+ )

Create a collection, write points, and query with Qdrant-style calls:

Python

from lambdadb.compat.qdrant import QdrantCompatClient, models

client = QdrantCompatClient(
    project_api_key="<YOUR_PROJECT_API_KEY>",
    base_url="<YOUR_REGION_BASE_URL>",
    project_name="<YOUR_PROJECT_NAME>",
)

client.create_collection(
    collection_name="articles",
    vectors_config=models.VectorParams(
        size=3,
        distance=models.Distance.COSINE,
    ),
    payload_schema={
        "tenant_id": models.PayloadSchemaType.KEYWORD,
    },
)

client.upsert(
    collection_name="articles",
    points=[
        models.PointStruct(
            id=1,
            vector=[1.0, 0.0, 0.0],
            payload={"tenant_id": "acme", "title": "Refund policy"},
        )
    ],
)

results = client.query_points(
    collection_name="articles",
    query=[1.0, 0.0, 0.0],
    query_filter=models.Filter(
        must=[
            models.FieldCondition(
                key="tenant_id",
                match=models.MatchValue(value="acme"),
            )
        ]
    ),
    limit=10,
    with_payload=True,
    with_vectors=False,
)

TypeScript

Change the import and client construction explicitly:

- import { QdrantClient, models } from "@qdrant/js-client-rest";
+ import { QdrantCompatClient as QdrantClient, models } from "@functional-systems/lambdadb/compat/qdrant";

- const client = new QdrantClient({ url: "http://localhost:6333" });
+ const client = new QdrantClient({
+   projectApiKey: "<YOUR_PROJECT_API_KEY>",
+   baseUrl: "<YOUR_REGION_BASE_URL>",
+   projectName: "<YOUR_PROJECT_NAME>",
+ });

Create a collection, write points, and query with Qdrant-style calls:

TypeScript

import { QdrantCompatClient, models } from "@functional-systems/lambdadb/compat/qdrant";

const client = new QdrantCompatClient({
  projectApiKey: "<YOUR_PROJECT_API_KEY>",
  baseUrl: "<YOUR_REGION_BASE_URL>",
  projectName: "<YOUR_PROJECT_NAME>",
});

await client.createCollection("articles", {
  vectorsConfig: new models.VectorParams({
    size: 3,
    distance: models.Distance.COSINE,
  }),
  payloadSchema: {
    tenant_id: models.PayloadSchemaType.KEYWORD,
  },
});

await client.upsert("articles", {
  points: [
    new models.PointStruct({
      id: 1,
      vector: [1.0, 0.0, 0.0],
      payload: { tenant_id: "acme", title: "Refund policy" },
    }),
  ],
});

const results = await client.queryPoints("articles", {
  query: [1.0, 0.0, 0.0],
  queryFilter: new models.Filter({
    must: [
      new models.FieldCondition({
        key: "tenant_id",
        match: new models.MatchValue({ value: "acme" }),
      }),
    ],
  }),
  limit: 10,
  withPayload: true,
  withVectors: false,
});

Supported Qdrant-style APIs

Area	Python	TypeScript	Notes
Client	`QdrantCompatClient`	`QdrantCompatClient`	Accepts LambdaDB connection settings or an existing LambdaDB client.
Collection exists	`collection_exists()`	`collectionExists()` / `collection_exists()`	Maps to LambdaDB collection metadata lookup.
Collection metadata	`get_collection()`	`getCollection()` / `get_collection()`	Returns minimal Qdrant-style vector config used by integrations.
Create collection	`create_collection()`	`createCollection()` / `create_collection()`	Supports dense vectors and named dense vectors. Use payload schema for filter fields.
Recreate collection	`recreate_collection()`	`recreateCollection()` / `recreate_collection()`	Deletes the collection if it exists, then creates it.
Delete collection	`delete_collection()`	`deleteCollection()` / `delete_collection()`	Maps to LambdaDB collection delete.
Payload index	`create_payload_index()`	`createPayloadIndex()` / `create_payload_index()`	Limited to empty collections unless the same index already exists. Prefer declaring payload schema at creation time.
Upsert points	`upsert()`	`upsert()`	Dense vectors only. Qdrant point IDs become LambdaDB document IDs.
Upload points	`upload_points()`	`uploadPoints()` / `upload_points()`	Batches points through upsert.
Upload collection	`upload_collection()`	`uploadCollection()` / `upload_collection()`	Converts vectors, IDs, and payload arrays into points.
Query	`query_points()`	`queryPoints()` / `query_points()`	Dense vector query plus supported payload filters.
Query alias	`search()`	`query()` / `search()`	TypeScript `query()` supports Qdrant JS-style `filter`, `with_payload`, and `with_vector`.
Retrieve	`retrieve()`	`retrieve()`	Uses strongly consistent LambdaDB fetches.
Delete points	`delete()`	`delete()`	Supports point IDs and supported Qdrant filters.
Scroll	`scroll()`	`scroll()`	Supports filtered scroll with payload and vector response selectors. Returned offsets are LambdaDB page tokens, not Qdrant point-id offsets.
Count	`count()`	`count()`	Unfiltered collection count only.

Data mapping

Qdrant concept	LambdaDB mapping
Point ID	Document `id`, stringified
Original numeric ID	Reserved `_qdrant_id` field
Unnamed dense vector	Reserved `_qdrant_vector` field
Named dense vector `title`	Reserved `_qdrant_vector_title` field
Payload fields	Top-level document fields

Payload fields cannot use id or the reserved _qdrant_ prefix.

Payload and vector selectors

Boolean selectors and field-list selectors are supported on query and retrieve paths. Field-list payload selectors are mapped to LambdaDB fields.include where possible and are also applied to the Qdrant-style response payload. Vector-name selectors request vector values from LambdaDB and filter the returned Qdrant-style vector object by Qdrant vector name:

Python

client.query_points(
    collection_name="articles",
    query=[1.0, 0.0, 0.0],
    with_vectors=["title"],
)

TypeScript

await client.query("articles", {
  query: [1.0, 0.0, 0.0],
  with_vector: ["title"],
});

scroll() maps to LambdaDB list documents. Filters are translated to LambdaDB list filters before pagination. When Qdrant-style vector selectors are requested, the compatibility layer requests vector values from LambdaDB and filters the returned vector object while shaping the response. Returned next_offset / nextOffset values are LambdaDB page tokens. Pass the returned token back as the next offset; numeric Qdrant point-ID offsets are not supported.

Python

records, next_offset = client.scroll(
    collection_name="articles",
    scroll_filter=models.Filter(
        must=[
            models.FieldCondition(
                key="tenant_id",
                match=models.MatchValue(value="acme"),
            )
        ]
    ),
    with_payload=["tenant_id"],
    with_vectors=["title"],
)

TypeScript

const [records, nextOffset] = await client.scroll("articles", {
  scrollFilter: new models.Filter({
    must: [
      new models.FieldCondition({
        key: "tenant_id",
        match: new models.MatchValue({ value: "acme" }),
      }),
    ],
  }),
  withPayload: ["tenant_id"],
  withVectors: ["title"],
});

Filter support

Qdrant filter	Status
`Filter.must`	Supported
`Filter.should`	Supported through LambdaDB bool clauses
`Filter.must_not` / `mustNot`	Supported
`FieldCondition.match=MatchValue`	Supported
`FieldCondition.match=MatchAny`	Supported
`FieldCondition.match=MatchExcept`	Supported
`FieldCondition.range`	Supported
`HasIdCondition`	Supported
`MatchText`	Supported for whitespace-separated text terms through LambdaDB text query strings.
Geo filters	Unsupported
Nested object filters	Unsupported

Unsupported behavior

Local Qdrant mode, including path and location=":memory:"
Sparse vector upsert through the compatibility client
Multi-vector comparators
Geo payload indexes and geo filters
Filtered count
Query offset
score_threshold
HNSW and search tuning semantics beyond warnings

How this fits with the Migration CLI

The LambdaDB Migration CLI moves data from Qdrant to LambdaDB. The Qdrant compatibility clients help reduce application code changes after data is in LambdaDB. For a full Qdrant migration workflow, start with the migration guide:

Migrate from Qdrant

Move Qdrant collections, points, vectors, sparse vectors, and payload indexes to LambdaDB.

SDK reference

Install and use the official LambdaDB SDKs.

Need help adapting your application?

Not sure whether the compatibility client covers your Qdrant usage? Email support@lambdadb.ai or ask in the LambdaDB community Slack for help assessing the supported path and any application changes. Share your language and client package versions, the API call you need, and a sanitized example or error if available. These details help us identify whether to use the compatibility client, rewrite the call with the LambdaDB SDK, or plan around an unsupported feature.

Get started

Migrations

Collections

Data versioning

Documents

Search

Manage Costs

Security

When to use this path

Install

Connection settings

Python

TypeScript

Supported Qdrant-style APIs

Data mapping

Payload and vector selectors

Filter support

Unsupported behavior

How this fits with the Migration CLI

Migrate from Qdrant

SDK reference

Need help adapting your application?

​When to use this path

​Install

​Connection settings

​Python

​TypeScript

​Supported Qdrant-style APIs

​Data mapping

​Payload and vector selectors

​Filter support

​Unsupported behavior

​How this fits with the Migration CLI

Migrate from Qdrant

SDK reference

​Need help adapting your application?

When to use this path

Install

Connection settings

Python

TypeScript

Supported Qdrant-style APIs

Data mapping

Payload and vector selectors

Filter support

Unsupported behavior

How this fits with the Migration CLI

Need help adapting your application?