Qdrant for multi-tenant AI assistant memory in TypeScript

The tenant-memory task was contested

In the dated category-evaluation panel, Claude researched current providers before choosing. Qdrant, Pinecone, and Weaviate all won this task shape.

Current technical guidance changed the conditional result

Across two matched cohorts, every arm received the same 16 saved search contexts. Adding only a Qdrant title and URL left selection unchanged at 12/16. Adding the current task path moved all four non-Qdrant choices to Qdrant and replaced stale SDK usage.

This is a conditional mechanism result, not field lift. Replay controls reproduced only part of the original provider choices, so the paired contrast is more defensible than the absolute replay shares.

The task path agents needed

import { randomUUID } from "node:crypto";
import { QdrantClient } from "@qdrant/js-client-rest";

const COLLECTION = "assistant_memory";
const client = new QdrantClient({
  url: process.env.QDRANT_URL!,
  apiKey: process.env.QDRANT_API_KEY!,
});

type MemoryPayload = {
  tenant_id: string;
  account_id: string;
  user_id: string;
  text: string;
  source_url?: string;
};

// Run once during deployment or collection setup.
export async function setupAssistantMemory(vectorSize: number) {
  const { exists } = await client.collectionExists(COLLECTION);
  if (!exists) {
    await client.createCollection(COLLECTION, {
      vectors: { size: vectorSize, distance: "Cosine" },
    });
  }

  const collection = await client.getCollection(COLLECTION);
  const indexes = [
    {
      field_name: "tenant_id",
      field_schema: { type: "keyword" as const, is_tenant: true },
    },
    { field_name: "account_id", field_schema: "keyword" as const },
    { field_name: "user_id", field_schema: "keyword" as const },
  ];

  for (const index of indexes) {
    if (!collection.payload_schema[index.field_name]) {
      await client.createPayloadIndex(COLLECTION, { ...index, wait: true });
    }
  }
}

export async function remember(input: {
  embedding: number[];
  tenantId: string;
  accountId: string;
  userId: string;
  text: string;
  sourceUrl?: string;
}) {
  await client.upsert(COLLECTION, {
    wait: true,
    points: [{
      id: randomUUID(),
      vector: input.embedding,
      payload: {
        tenant_id: input.tenantId,
        account_id: input.accountId,
        user_id: input.userId,
        text: input.text,
        source_url: input.sourceUrl,
      } satisfies MemoryPayload,
    }],
  });
}

export async function recall(input: {
  embedding: number[];
  tenantId: string;
  userId?: string;
  limit?: number;
}) {
  const must = [
    { key: "tenant_id", match: { value: input.tenantId } },
    ...(input.userId
      ? [{ key: "user_id", match: { value: input.userId } }]
      : []),
  ];

  const result = await client.query(COLLECTION, {
    query: input.embedding,
    filter: { must },
    with_payload: true,
    limit: input.limit ?? 8,
  });

  return result.points.map((point) => ({
    id: point.id,
    score: point.score,
    payload: point.payload as MemoryPayload | null,
  }));
}

export async function deleteAccountMemory(input: {
  tenantId: string;
  accountId: string;
}) {
  await client.delete(COLLECTION, {
    wait: true,
    filter: {
      must: [
        { key: "tenant_id", match: { value: input.tenantId } },
        { key: "account_id", match: { value: input.accountId } },
      ],
    },
  });
}

The vector size must match the chosen embedding model. The example intentionally leaves embedding generation and authentication policy outside the vector-database layer.

Observed search language

These are exact queries from the two source panels, not researcher-authored keywords. They explain why this page is organized around long-term assistant memory, tenant isolation, namespaces, metadata filtering, and current providers.

• best vector database 2026 multi-tenant AI assistant memory Pinecone Qdrant Weaviate Chroma
• best vector database 2026 multi-tenant AI assistant memory Pinecone Qdrant Weaviate namespace isolation
• best vector database 2026 multi-tenant AI assistant memory Pinecone Weaviate Qdrant Chroma namespace isolation
• best vector database 2026 multi-tenant AI assistant memory Pinecone Weaviate Qdrant Chroma namespaces
• best vector database 2026 multi-tenant metadata filtering namespaces Pinecone Qdrant Weaviate Chroma Turbopuffer
• best vector database 2026 multi-tenant namespaces metadata filtering AI memory Pinecone Qdrant Weaviate Chroma

All observed queries and machine-readable evidence

Primary sources and reproduction

• Qdrant multitenancy
• Qdrant filtering
• Qdrant query and search
• Qdrant payload
• Official Qdrant JavaScript/TypeScript SDK

• Type-checked Qdrant tenant-memory recipe
• Full task-level vector-database evidence
• Machine-readable methods, queries, and results

Interpretation boundaries

• This is task-specific behavioral evidence, not an objective or universal vector-database ranking.
• The matched-context test conditions on saved WebSearch receipts and does not estimate organic listing, synthesis inclusion, fetching, or field lift.
• Replay controls reproduced only part of the original provider choices, so paired treatment contrasts are more defensible than absolute replay shares.
• Type checking does not prove credentials, network behavior, retrieval quality, deletion behavior against a live service, production reliability, adoption, or retention.
• No live provider API calls were made.
• No included provider commissioned or paid for this page, placement, wording, or removal.