mem0ai 3.0.13 → 3.1.0

package/dist/oss/index.d.ts

@@ -1,8 +1,21 @@
 import { z } from 'zod';
+import { MochowClient } from '@mochow/mochow-sdk-node';
 import { QdrantClient } from '@qdrant/js-client-rest';
 import { VectorStore as VectorStore$1 } from '@langchain/core/vectorstores';
 import { ClientConfig } from 'pg';
 
+interface ValkeyConfig extends VectorStoreConfig {
+    valkeyUrl: string;
+    collectionName: string;
+    embeddingModelDims: number;
+    timezone?: string;
+    indexType?: "hnsw" | "flat";
+    hnswM?: number;
+    hnswEfConstruction?: number;
+    hnswEfRuntime?: number;
+    clusterMode?: boolean;
+}
+
 interface MultiModalMessages {
     type: "image_url";
     image_url: {
@@ -20,7 +33,18 @@ interface EmbeddingConfig {
     url?: string;
     embeddingDims?: number;
     modelProperties?: Record<string, any>;
+    huggingfaceBaseUrl?: string;
 }
+interface VertexAIConfig extends EmbeddingConfig {
+    vertexCredentialsJson?: string;
+    googleServiceAccountJson?: string | Record<string, any>;
+    googleProjectId?: string;
+    location?: string;
+    memoryAddEmbeddingType?: string;
+    memoryUpdateEmbeddingType?: string;
+    memorySearchEmbeddingType?: string;
+}
+
 interface VectorStoreConfig {
     collectionName?: string;
     dimension?: number;
@@ -41,6 +65,8 @@ interface HistoryStoreConfig {
 interface LLMConfig {
     provider?: string;
     baseURL?: string;
+    vllmBaseURL?: string;
+    vllm_base_url?: string;
     url?: string;
     config?: Record<string, any>;
     apiKey?: string;
@@ -50,6 +76,57 @@ interface LLMConfig {
     temperature?: number;
     topP?: number;
     maxTokens?: number;
+    awsRegion?: string;
+    awsAccessKeyId?: string;
+    awsSecretAccessKey?: string;
+    awsSessionToken?: string;
+    client?: any;
+}
+interface RerankerConfig {
+    apiKey?: string;
+    /** The reranker model to use. Default varies by provider. */
+    model?: string;
+    /** Maximum number of documents to return after reranking. Default: unset (return all). */
+    topK?: number;
+    /** `cohere` only. Return document texts in the response. Default: `false`. */
+    returnDocuments?: boolean;
+    /** `cohere` only. Maximum number of chunks per document. Default: unset. */
+    maxChunksPerDoc?: number;
+    /**
+     * `sentence_transformer` / `huggingface` only. Transformers.js device, e.g.
+     * `"cpu"`, `"wasm"`, `"webgpu"`. Default: unset (auto-detect).
+     */
+    device?: string;
+    /** `huggingface` only. Max token length per query-document pair. Default: `512`. */
+    maxLength?: number;
+    /**
+     * `sentence_transformer` / `huggingface` only. Sigmoid-normalize raw logits
+     * to `[0, 1]`. Default: `true`; set `false` to surface raw logits.
+     */
+    normalize?: boolean;
+    /** No-op: a search reranks a small candidate set in one forward pass. */
+    batchSize?: number;
+    /** No-op in this runtime. */
+    showProgressBar?: boolean;
+    /**
+     * `llm_reranker` only. LLM provider used to build the scoring LLM when
+     * `llm` is not set. Default: `"openai"`.
+     */
+    provider?: string;
+    /** `llm_reranker` only. Temperature for LLM generation. Default: `0.0`. */
+    temperature?: number;
+    /** `llm_reranker` only. Maximum tokens for the LLM response. Default: `100`. */
+    maxTokens?: number;
+    /**
+     * `llm_reranker` only. Nested LLM configuration. When set, it overrides the
+     * top-level `provider`/`model`/`temperature`/`maxTokens`/`apiKey`, which
+     * then only act as defaults for fields missing from `llm.config`.
+     */
+    llm?: {
+        provider: string;
+        config: LLMConfig;
+    };
+    [key: string]: any;
 }
 interface MemoryConfig {
     version?: string;
@@ -65,6 +142,10 @@ interface MemoryConfig {
         provider: string;
         config: LLMConfig;
     };
+    reranker?: {
+        provider: string;
+        config: RerankerConfig;
+    };
     historyStore?: HistoryStoreConfig;
     disableHistory?: boolean;
     historyDbPath?: string;
@@ -77,6 +158,8 @@ interface MemoryItem {
     createdAt?: string;
     updatedAt?: string;
     score?: number;
+    /** Relevance score added by the reranker, alongside (not replacing) `score`. */
+    rerankScore?: number;
     metadata?: Record<string, any>;
     attributedTo?: string;
 }
@@ -105,17 +188,38 @@ declare const MemoryConfigSchema: z.ZodObject<{
             baseURL: z.ZodOptional<z.ZodString>;
             embeddingDims: z.ZodOptional<z.ZodNumber>;
             url: z.ZodOptional<z.ZodString>;
+            vertexCredentialsJson: z.ZodOptional<z.ZodString>;
+            googleServiceAccountJson: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+            googleProjectId: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodString>;
+            memoryAddEmbeddingType: z.ZodOptional<z.ZodString>;
+            memoryUpdateEmbeddingType: z.ZodOptional<z.ZodString>;
+            memorySearchEmbeddingType: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
-            modelProperties?: Record<string, any> | undefined;
+            vertexCredentialsJson?: string | undefined;
+            googleServiceAccountJson?: string | Record<string, any> | undefined;
+            googleProjectId?: string | undefined;
+            location?: string | undefined;
+            memoryAddEmbeddingType?: string | undefined;
+            memoryUpdateEmbeddingType?: string | undefined;
+            memorySearchEmbeddingType?: string | undefined;
             apiKey?: string | undefined;
             model?: any;
+            modelProperties?: Record<string, any> | undefined;
             baseURL?: string | undefined;
             embeddingDims?: number | undefined;
             url?: string | undefined;
         }, {
-            modelProperties?: Record<string, any> | undefined;
+            vertexCredentialsJson?: string | undefined;
+            googleServiceAccountJson?: string | Record<string, any> | undefined;
+            googleProjectId?: string | undefined;
+            location?: string | undefined;
+            memoryAddEmbeddingType?: string | undefined;
+            memoryUpdateEmbeddingType?: string | undefined;
+            memorySearchEmbeddingType?: string | undefined;
             apiKey?: string | undefined;
             model?: any;
+            modelProperties?: Record<string, any> | undefined;
             baseURL?: string | undefined;
             embeddingDims?: number | undefined;
             url?: string | undefined;
@@ -123,9 +227,16 @@ declare const MemoryConfigSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         provider: string;
         config: {
-            modelProperties?: Record<string, any> | undefined;
+            vertexCredentialsJson?: string | undefined;
+            googleServiceAccountJson?: string | Record<string, any> | undefined;
+            googleProjectId?: string | undefined;
+            location?: string | undefined;
+            memoryAddEmbeddingType?: string | undefined;
+            memoryUpdateEmbeddingType?: string | undefined;
+            memorySearchEmbeddingType?: string | undefined;
             apiKey?: string | undefined;
             model?: any;
+            modelProperties?: Record<string, any> | undefined;
             baseURL?: string | undefined;
             embeddingDims?: number | undefined;
             url?: string | undefined;
@@ -133,9 +244,16 @@ declare const MemoryConfigSchema: z.ZodObject<{
     }, {
         provider: string;
         config: {
-            modelProperties?: Record<string, any> | undefined;
+            vertexCredentialsJson?: string | undefined;
+            googleServiceAccountJson?: string | Record<string, any> | undefined;
+            googleProjectId?: string | undefined;
+            location?: string | undefined;
+            memoryAddEmbeddingType?: string | undefined;
+            memoryUpdateEmbeddingType?: string | undefined;
+            memorySearchEmbeddingType?: string | undefined;
             apiKey?: string | undefined;
             model?: any;
+            modelProperties?: Record<string, any> | undefined;
             baseURL?: string | undefined;
             embeddingDims?: number | undefined;
             url?: string | undefined;
@@ -187,57 +305,96 @@ declare const MemoryConfigSchema: z.ZodObject<{
             model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodAny]>>;
             modelProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
             baseURL: z.ZodOptional<z.ZodString>;
+            vllmBaseURL: z.ZodOptional<z.ZodString>;
+            vllm_base_url: z.ZodOptional<z.ZodString>;
             url: z.ZodOptional<z.ZodString>;
             timeout: z.ZodOptional<z.ZodNumber>;
             temperature: z.ZodOptional<z.ZodNumber>;
             topP: z.ZodOptional<z.ZodNumber>;
             maxTokens: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            modelProperties?: Record<string, any> | undefined;
+            awsRegion: z.ZodOptional<z.ZodString>;
+            awsAccessKeyId: z.ZodOptional<z.ZodString>;
+            awsSecretAccessKey: z.ZodOptional<z.ZodString>;
+            awsSessionToken: z.ZodOptional<z.ZodString>;
+            client: z.ZodOptional<z.ZodAny>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            apiKey: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodAny]>>;
+            modelProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            baseURL: z.ZodOptional<z.ZodString>;
+            vllmBaseURL: z.ZodOptional<z.ZodString>;
+            vllm_base_url: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            awsRegion: z.ZodOptional<z.ZodString>;
+            awsAccessKeyId: z.ZodOptional<z.ZodString>;
+            awsSecretAccessKey: z.ZodOptional<z.ZodString>;
+            awsSessionToken: z.ZodOptional<z.ZodString>;
+            client: z.ZodOptional<z.ZodAny>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            apiKey: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodAny]>>;
+            modelProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            baseURL: z.ZodOptional<z.ZodString>;
+            vllmBaseURL: z.ZodOptional<z.ZodString>;
+            vllm_base_url: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            awsRegion: z.ZodOptional<z.ZodString>;
+            awsAccessKeyId: z.ZodOptional<z.ZodString>;
+            awsSecretAccessKey: z.ZodOptional<z.ZodString>;
+            awsSessionToken: z.ZodOptional<z.ZodString>;
+            client: z.ZodOptional<z.ZodAny>;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        config: {
+            client?: any;
             apiKey?: string | undefined;
             model?: any;
-            baseURL?: string | undefined;
-            url?: string | undefined;
-            timeout?: number | undefined;
             temperature?: number | undefined;
-            topP?: number | undefined;
             maxTokens?: number | undefined;
-        }, {
             modelProperties?: Record<string, any> | undefined;
-            apiKey?: string | undefined;
-            model?: any;
             baseURL?: string | undefined;
             url?: string | undefined;
+            vllmBaseURL?: string | undefined;
+            vllm_base_url?: string | undefined;
             timeout?: number | undefined;
-            temperature?: number | undefined;
             topP?: number | undefined;
-            maxTokens?: number | undefined;
-        }>;
-    }, "strip", z.ZodTypeAny, {
+            awsRegion?: string | undefined;
+            awsAccessKeyId?: string | undefined;
+            awsSecretAccessKey?: string | undefined;
+            awsSessionToken?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+    }, {
         provider: string;
         config: {
-            modelProperties?: Record<string, any> | undefined;
+            client?: any;
             apiKey?: string | undefined;
             model?: any;
-            baseURL?: string | undefined;
-            url?: string | undefined;
-            timeout?: number | undefined;
             temperature?: number | undefined;
-            topP?: number | undefined;
             maxTokens?: number | undefined;
-        };
-    }, {
-        provider: string;
-        config: {
             modelProperties?: Record<string, any> | undefined;
-            apiKey?: string | undefined;
-            model?: any;
             baseURL?: string | undefined;
             url?: string | undefined;
+            vllmBaseURL?: string | undefined;
+            vllm_base_url?: string | undefined;
             timeout?: number | undefined;
-            temperature?: number | undefined;
             topP?: number | undefined;
-            maxTokens?: number | undefined;
+            awsRegion?: string | undefined;
+            awsAccessKeyId?: string | undefined;
+            awsSecretAccessKey?: string | undefined;
+            awsSessionToken?: string | undefined;
+        } & {
+            [k: string]: unknown;
         };
     }>;
     historyDbPath: z.ZodOptional<z.ZodString>;
@@ -252,14 +409,54 @@ declare const MemoryConfigSchema: z.ZodObject<{
         provider: string;
         config: Record<string, any>;
     }>>;
+    reranker: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        config: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        config: Record<string, any>;
+    }, {
+        provider: string;
+        config: Record<string, any>;
+    }>>;
     disableHistory: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    embedder: {
+    llm: {
         provider: string;
         config: {
+            client?: any;
+            apiKey?: string | undefined;
+            model?: any;
+            temperature?: number | undefined;
+            maxTokens?: number | undefined;
             modelProperties?: Record<string, any> | undefined;
+            baseURL?: string | undefined;
+            url?: string | undefined;
+            vllmBaseURL?: string | undefined;
+            vllm_base_url?: string | undefined;
+            timeout?: number | undefined;
+            topP?: number | undefined;
+            awsRegion?: string | undefined;
+            awsAccessKeyId?: string | undefined;
+            awsSecretAccessKey?: string | undefined;
+            awsSessionToken?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+    };
+    embedder: {
+        provider: string;
+        config: {
+            vertexCredentialsJson?: string | undefined;
+            googleServiceAccountJson?: string | Record<string, any> | undefined;
+            googleProjectId?: string | undefined;
+            location?: string | undefined;
+            memoryAddEmbeddingType?: string | undefined;
+            memoryUpdateEmbeddingType?: string | undefined;
+            memorySearchEmbeddingType?: string | undefined;
             apiKey?: string | undefined;
             model?: any;
+            modelProperties?: Record<string, any> | undefined;
             baseURL?: string | undefined;
             embeddingDims?: number | undefined;
             url?: string | undefined;
@@ -276,35 +473,55 @@ declare const MemoryConfigSchema: z.ZodObject<{
             [k: string]: unknown;
         };
     };
+    version?: string | undefined;
+    historyDbPath?: string | undefined;
+    customInstructions?: string | undefined;
+    historyStore?: {
+        provider: string;
+        config: Record<string, any>;
+    } | undefined;
+    reranker?: {
+        provider: string;
+        config: Record<string, any>;
+    } | undefined;
+    disableHistory?: boolean | undefined;
+}, {
     llm: {
         provider: string;
         config: {
-            modelProperties?: Record<string, any> | undefined;
+            client?: any;
             apiKey?: string | undefined;
             model?: any;
+            temperature?: number | undefined;
+            maxTokens?: number | undefined;
+            modelProperties?: Record<string, any> | undefined;
             baseURL?: string | undefined;
             url?: string | undefined;
+            vllmBaseURL?: string | undefined;
+            vllm_base_url?: string | undefined;
             timeout?: number | undefined;
-            temperature?: number | undefined;
             topP?: number | undefined;
-            maxTokens?: number | undefined;
+            awsRegion?: string | undefined;
+            awsAccessKeyId?: string | undefined;
+            awsSecretAccessKey?: string | undefined;
+            awsSessionToken?: string | undefined;
+        } & {
+            [k: string]: unknown;
         };
     };
-    version?: string | undefined;
-    historyDbPath?: string | undefined;
-    customInstructions?: string | undefined;
-    historyStore?: {
-        provider: string;
-        config: Record<string, any>;
-    } | undefined;
-    disableHistory?: boolean | undefined;
-}, {
     embedder: {
         provider: string;
         config: {
-            modelProperties?: Record<string, any> | undefined;
+            vertexCredentialsJson?: string | undefined;
+            googleServiceAccountJson?: string | Record<string, any> | undefined;
+            googleProjectId?: string | undefined;
+            location?: string | undefined;
+            memoryAddEmbeddingType?: string | undefined;
+            memoryUpdateEmbeddingType?: string | undefined;
+            memorySearchEmbeddingType?: string | undefined;
             apiKey?: string | undefined;
             model?: any;
+            modelProperties?: Record<string, any> | undefined;
             baseURL?: string | undefined;
             embeddingDims?: number | undefined;
             url?: string | undefined;
@@ -321,20 +538,6 @@ declare const MemoryConfigSchema: z.ZodObject<{
             [k: string]: unknown;
         };
     };
-    llm: {
-        provider: string;
-        config: {
-            modelProperties?: Record<string, any> | undefined;
-            apiKey?: string | undefined;
-            model?: any;
-            baseURL?: string | undefined;
-            url?: string | undefined;
-            timeout?: number | undefined;
-            temperature?: number | undefined;
-            topP?: number | undefined;
-            maxTokens?: number | undefined;
-        };
-    };
     version?: string | undefined;
     historyDbPath?: string | undefined;
     customInstructions?: string | undefined;
@@ -342,6 +545,10 @@ declare const MemoryConfigSchema: z.ZodObject<{
         provider: string;
         config: Record<string, any>;
     } | undefined;
+    reranker?: {
+        provider: string;
+        config: Record<string, any>;
+    } | undefined;
     disableHistory?: boolean | undefined;
 }>;
 
@@ -355,6 +562,21 @@ interface AddMemoryOptions extends Entity {
     filters?: SearchFilters;
     infer?: boolean;
     timestamp?: number | string | Date | null;
+    /** Date (YYYY-MM-DD) after which the memory is considered expired. */
+    expirationDate?: string | null;
+}
+interface UpdateMemoryOptions {
+    /** New content to update the memory with. */
+    text?: string;
+    /**
+     * New content to update the memory with.
+     * @deprecated Use `text` instead. Will be removed in the next major release.
+     */
+    data?: string;
+    /** Metadata merged into the memory's existing metadata. */
+    metadata?: Record<string, any>;
+    /** Date (YYYY-MM-DD) after which the memory expires, or `null` to clear it. */
+    expirationDate?: string | null;
 }
 interface SearchMemoryOptions {
     topK?: number;
@@ -362,10 +584,19 @@ interface SearchMemoryOptions {
     threshold?: number;
     explain?: boolean;
     referenceDate?: number | string | Date | null;
+    /**
+     * Re-rank the results with the configured reranker before returning. No-op
+     * when no `reranker` is configured on the Memory.
+     */
+    rerank?: boolean;
+    /** Include expired memories in the results. Defaults to false. */
+    showExpired?: boolean;
 }
 interface GetAllMemoryOptions {
     topK?: number;
     filters?: SearchFilters;
+    /** Include expired memories in the results. Defaults to false. */
+    showExpired?: boolean;
 }
 interface DeleteAllMemoryOptions extends Entity {
 }
@@ -374,12 +605,19 @@ interface UpdateProjectOptions {
     [key: string]: any;
 }
 
+declare class LLMError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
 declare class Memory {
     private config;
     private customInstructions;
     private embedder;
     private vectorStore;
     private llm;
+    private reranker;
     private db;
     private collectionName;
     private apiVersion;
@@ -441,7 +679,7 @@ declare class Memory {
     private addToVectorStore;
     get(memoryId: string): Promise<MemoryItem | null>;
     search(query: string, config: SearchMemoryOptions): Promise<SearchResult>;
-    update(memoryId: string, data: string): Promise<{
+    update(memoryId: string, config: string | UpdateMemoryOptions): Promise<{
         message: string;
     }>;
     delete(memoryId: string): Promise<{
@@ -468,6 +706,27 @@ declare class Memory {
 }
 
 interface Embedder {
+    embed(text: string, memoryAction?: "add" | "update" | "search"): Promise<number[]>;
+    embedBatch(texts: string[], memoryAction?: "add" | "update" | "search"): Promise<number[][]>;
+}
+
+/**
+ * HuggingFace embedding provider (hosted inference mode).
+ *
+ * Mirrors the `huggingface_base_url` branch of the Python provider
+ * (`mem0/embeddings/huggingface.py`): a HuggingFace Text Embeddings Inference
+ * (TEI) server, or any HuggingFace OpenAI-compatible inference endpoint,
+ * exposes a `/v1/embeddings` route, so this embedder reuses the existing
+ * `openai` client pointed at that base URL. No new dependency is required.
+ *
+ * A base URL is required. The Python provider's alternative local
+ * `sentence-transformers` path has no lightweight TypeScript equivalent, so
+ * hosted inference is the supported TS mode.
+ */
+declare class HuggingFaceEmbedder implements Embedder {
+    private openai;
+    private model;
+    constructor(config: EmbeddingConfig);
     embed(text: string): Promise<number[]>;
     embedBatch(texts: string[]): Promise<number[][]>;
 }
@@ -501,6 +760,10 @@ declare class LMStudioEmbedder implements Embedder {
     embedBatch(texts: string[]): Promise<number[][]>;
 }
 
+declare class TogetherEmbedder extends OpenAIEmbedder {
+    constructor(config: EmbeddingConfig);
+}
+
 declare class GoogleEmbedder implements Embedder {
     private google;
     private model;
@@ -527,6 +790,40 @@ declare class LangchainEmbedder implements Embedder {
     embedBatch(texts: string[]): Promise<number[][]>;
 }
 
+declare class VertexAIEmbedder implements Embedder {
+    private client;
+    private helpers;
+    private initPromise;
+    private clientOptions;
+    private model;
+    private embeddingDims;
+    private location;
+    private projectId;
+    private embeddingTypes;
+    constructor(config: VertexAIConfig);
+    private initClient;
+    private createClient;
+    private endpoint;
+    private formatInstance;
+    embed(text: string, memoryAction?: "add" | "update" | "search"): Promise<number[]>;
+    embedBatch(texts: string[], memoryAction?: "add" | "update" | "search"): Promise<number[][]>;
+}
+
+declare class FastEmbedEmbedder implements Embedder {
+    private readonly modelName;
+    private embeddingModel?;
+    constructor(config: EmbeddingConfig);
+    private getEmbeddingModel;
+    /**
+     * Lazily import the optional `fastembed` peer and initialize the model, so
+     * consumers that never touch FastEmbed don't need it installed.
+     */
+    private initEmbeddingModel;
+    private normalizeInput;
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+
 interface LLMResponse {
     content: string;
     role: string;
@@ -648,6 +945,71 @@ declare class LiteLLM extends OpenAILLM {
     generateChat(messages: Message[]): Promise<LLMResponse>;
 }
 
+declare class VllmLLM extends OpenAILLM {
+    constructor(config: LLMConfig);
+    generateResponse(messages: Message[], responseFormat?: {
+        type: string;
+    }, tools?: any[]): Promise<string | LLMResponse>;
+    generateChat(messages: Message[]): Promise<LLMResponse>;
+}
+
+/**
+ * Extract the model-family provider from a Bedrock model id
+ * (e.g. `anthropic.claude-3-sonnet-...` -> `anthropic`).
+ */
+declare function extractProvider(model: string): string;
+/**
+ * AWS Bedrock fields (awsRegion / awsAccessKeyId / awsSecretAccessKey /
+ * awsSessionToken / client) now live on the shared `LLMConfig`, so the
+ * provider is configurable through the standard typed `Memory` config path.
+ */
+type AWSBedrockConfig = LLMConfig;
+declare class AWSBedrockLLM implements LLM {
+    private model;
+    private provider;
+    private temperature;
+    private maxTokens;
+    private topP?;
+    private clientConfig;
+    private clientOverride?;
+    private sdkPromise?;
+    private clientPromise?;
+    constructor(config?: AWSBedrockConfig);
+    /**
+     * Load the optional AWS SDK on first use.
+     *
+     * This MUST be a dynamic `import()`, never `require()`: tsup/esbuild rewrite
+     * `require()` in the published ESM bundle (`dist/oss/index.mjs`) into a
+     * `__require` shim that throws `Dynamic require of "..." is not supported`,
+     * so every ESM consumer would hit a dead provider even with the SDK installed.
+     */
+    private getSDK;
+    /** Memoized Bedrock client; an injected `config.client` short-circuits the SDK. */
+    private getClient;
+    /**
+     * Split messages into a top-level `system` block (Converse passes system
+     * prompts separately) and role-tagged content blocks for everything else.
+     */
+    private formatMessages;
+    /**
+     * Build the Converse `inferenceConfig`. Anthropic and MiniMax reasoning
+     * models reject requests carrying both `temperature` and `topP`, so `topP`
+     * is omitted for those families (mirrors the Python `_build_inference_config`).
+     */
+    private buildInferenceConfig;
+    /** Convert OpenAI-style tools to the Converse `toolConfig` shape. */
+    private convertToolsToConverse;
+    private converse;
+    /** Pull the first text block out of a Converse response. */
+    private parseText;
+    /** Collect any toolUse blocks out of a Converse response. */
+    private parseToolCalls;
+    generateResponse(messages: Message[], _responseFormat?: {
+        type: string;
+    }, tools?: any[]): Promise<string | LLMResponse>;
+    generateChat(messages: Message[]): Promise<LLMResponse>;
+}
+
 interface VectorStore {
     insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
     search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
@@ -695,6 +1057,54 @@ declare class MemoryVectorStore implements VectorStore {
     initialize(): Promise<void>;
 }
 
+interface BaiduConfig extends VectorStoreConfig {
+    endpoint: string;
+    account: string;
+    apiKey: string;
+    databaseName: string;
+    tableName: string;
+    embeddingModelDims: number;
+    metricType?: "L2" | "IP" | "COSINE";
+    client?: MochowClient;
+}
+declare class BaiduDB implements VectorStore {
+    private client;
+    private sdk;
+    private readonly endpoint;
+    private readonly account;
+    private readonly apiKey;
+    private readonly databaseName;
+    private readonly tableName;
+    private readonly embeddingModelDims;
+    private readonly metricType;
+    private supportsKeywordSearch;
+    private storeUserId;
+    private _initPromise?;
+    constructor(config: BaiduConfig);
+    private get ns();
+    private loadSdk;
+    private ensureClient;
+    private ready;
+    private buildSchema;
+    private buildFilter;
+    private filterOf;
+    private pollTable;
+    private ensureTable;
+    private applySchema;
+    initialize(): Promise<void>;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    keywordSearch(query: string, topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    reset(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+}
+
 interface QdrantConfig extends VectorStoreConfig {
     /**
      * Pre-configured QdrantClient instance. If using Qdrant Cloud, you must pass
@@ -783,11 +1193,46 @@ declare class RedisDB implements VectorStore {
     setUserId(userId: string): Promise<void>;
 }
 
-interface SupabaseConfig extends VectorStoreConfig {
-    supabaseUrl: string;
-    supabaseKey: string;
-    tableName: string;
-    embeddingColumnName?: string;
+declare class ValkeyDB implements VectorStore {
+    private client;
+    private readonly collectionName;
+    private readonly indexPrefix;
+    private readonly embeddingModelDims;
+    private readonly timezone;
+    private readonly indexType;
+    private readonly hnswM;
+    private readonly hnswEfConstruction;
+    private readonly hnswEfRuntime;
+    private readonly clusterMode;
+    private readonly valkeyUrl;
+    private _initPromise?;
+    constructor(config: ValkeyConfig);
+    private buildIndexCreateCommand;
+    private ensureSearchModule;
+    private createIndex;
+    private connectClient;
+    initialize(): Promise<void>;
+    private _doInitialize;
+    private buildSearchQuery;
+    private docToResult;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    keywordSearch(): Promise<null>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    close(): Promise<void>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+}
+
+interface SupabaseConfig extends VectorStoreConfig {
+    supabaseUrl: string;
+    supabaseKey: string;
+    tableName: string;
+    embeddingColumnName?: string;
     metadataColumnName?: string;
 }
 declare class SupabaseDB implements VectorStore {
@@ -1051,6 +1496,940 @@ declare class PGVector implements VectorStore {
     setUserId(userId: string): Promise<void>;
 }
 
+interface DatabricksConfig extends VectorStoreConfig {
+    workspaceUrl?: string;
+    host?: string;
+    httpPath: string;
+    accessToken?: string;
+    clientId?: string;
+    clientSecret?: string;
+    endpointName?: string;
+    endpointType?: "STANDARD" | "STORAGE_OPTIMIZED";
+    pipelineType?: "TRIGGERED" | "CONTINUOUS";
+    queryType?: "ANN" | "HYBRID";
+    catalog?: string;
+    schema?: string;
+    tableName?: string;
+    embeddingModelDims?: number;
+    syncPollIntervalMs?: number;
+    syncTimeoutMs?: number;
+    sqlClient?: DatabricksSqlClientLike;
+    httpClient?: DatabricksHttpClientLike;
+}
+interface DatabricksSqlClientLike {
+    connect(options: Record<string, any>): Promise<DatabricksSqlClientLike>;
+    openSession(): Promise<DatabricksSqlSessionLike>;
+    close?(): Promise<any>;
+}
+interface DatabricksSqlSessionLike {
+    executeStatement(statement: string): Promise<DatabricksSqlOperationLike>;
+    close?(): Promise<any>;
+}
+interface DatabricksSqlOperationLike {
+    fetchAll(): Promise<Array<Record<string, any>>>;
+    close?(): Promise<any>;
+}
+interface DatabricksHttpClientLike {
+    get(url: string, config?: Record<string, any>): Promise<{
+        data: any;
+    }>;
+    post(url: string, data?: any, config?: Record<string, any>): Promise<{
+        data: any;
+    }>;
+    delete(url: string, config?: Record<string, any>): Promise<{
+        data: any;
+    }>;
+}
+declare class DatabricksVectorStore implements VectorStore {
+    private readonly host;
+    private readonly workspaceUrl;
+    private readonly httpPath;
+    private readonly accessToken?;
+    private readonly clientId?;
+    private readonly clientSecret?;
+    private readonly endpointName;
+    private readonly endpointType;
+    private readonly pipelineType;
+    private readonly queryType;
+    private readonly dimension;
+    private readonly catalog;
+    private readonly schema;
+    private readonly tableName;
+    private readonly indexName;
+    private readonly fullTableName;
+    private readonly fullIndexName;
+    private readonly syncPollIntervalMs;
+    private readonly syncTimeoutMs;
+    private sqlClient;
+    private readonly httpClient;
+    private session?;
+    private _sessionPromise?;
+    private _initPromise?;
+    private sqlModulePromise?;
+    private indexSyncWait;
+    private indexSyncRunning;
+    private indexSyncQueued;
+    private indexSyncError;
+    private readonly oauthTokens;
+    constructor(config: DatabricksConfig);
+    initialize(): Promise<void>;
+    private _doInitialize;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    keywordSearch(query: string, topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+    private ensureEndpointExists;
+    private ensureIndexExists;
+    private ensureChangeDataFeedEnabled;
+    private createHttpClient;
+    private withOAuthHeaders;
+    private getOAuthAuthorizationDetails;
+    private getOAuthAccessToken;
+    private getSession;
+    /**
+     * `@databricks/sql` is an OPTIONAL peer, and `index.ts` re-exports this module eagerly, so a
+     * top-level `import` makes `import "mem0ai/oss"` throw MODULE_NOT_FOUND for every user who
+     * never installed the driver -- including everyone who uses a different vector store. Load it
+     * on the first SQL call instead, the way milvus.ts and baidu.ts load theirs.
+     *
+     * This MUST be a dynamic `import()`, never `require()`: tsup/esbuild rewrite `require()` in
+     * the published ESM bundle (`dist/oss/index.mjs`) into a `__require` shim that throws
+     * `Dynamic require of "..." is not supported`, so every ESM consumer would hit a dead
+     * provider even with the driver installed.
+     */
+    private getSqlModule;
+    private getSqlClient;
+    private openSession;
+    private buildSqlConnectionOptions;
+    /**
+     * Drop the cached session/session-promise so the next `getSession()` opens a fresh one.
+     * Called after any SQL failure below -- a stale session (expired token, dropped socket)
+     * would otherwise keep being handed out and keep failing forever.
+     */
+    private resetSession;
+    private executeSql;
+    /**
+     * A TRIGGERED pipeline only ingests new rows when it is explicitly synced, so every write
+     * must request one. Writers fire the sync and return; only readers wait for it to land.
+     * A sync already in flight absorbs later writes -- deleteAll()'s N sequential deletes
+     * collapse into far fewer than N pipeline runs.
+     */
+    private requestIndexSync;
+    private drainIndexSync;
+    private awaitIndexSync;
+    private waitForEndpointReadiness;
+    private waitForIndexReadiness;
+    private shouldPaginateForLocalFiltering;
+    private extractNextPageToken;
+    private queryIndex;
+    private normalizeQueryResults;
+    private rowToObject;
+    private parsePayload;
+    private extractSessionValues;
+    private assertVectorDimension;
+    private matchFieldCondition;
+    private filterVector;
+}
+
+/**
+ * The `@aws-sdk/client-neptune-graph` dependency is loaded on first use via dynamic
+ * `import()` so the package stays optional (mirrors `aws_bedrock.ts`).
+ */
+interface NeptuneAnalyticsConfig extends VectorStoreConfig {
+    graphIdentifier?: string;
+    endpoint?: string;
+    collectionName: string;
+    dimension?: number;
+    client?: NeptuneGraphClientLike;
+}
+interface NeptuneGraphClientLike {
+    send(command: any): Promise<NeptuneExecuteQueryOutput>;
+}
+interface NeptuneExecuteQueryOutput {
+    payload?: {
+        transformToString(encoding?: string): Promise<string>;
+    };
+}
+declare class NeptuneAnalyticsVectorStore implements VectorStore {
+    private clientConfig;
+    private clientOverride?;
+    private sdkPromise?;
+    private clientPromise?;
+    private readonly graphIdentifier;
+    private readonly collectionName;
+    private readonly collectionLabel;
+    private readonly collectionLabelExpr;
+    private readonly userLabel;
+    private readonly userLabelExpr;
+    private readonly userNodeId;
+    private readonly dimension;
+    private _initPromise?;
+    private cachedUserId?;
+    constructor(config: NeptuneAnalyticsConfig);
+    initialize(): Promise<void>;
+    private _doInitialize;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    keywordSearch(): Promise<null>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+    private findExistingIds;
+    private cleanupFailedInsert;
+    private resolveGraphIdentifier;
+    private buildClientConfig;
+    private escapeLabel;
+    private buildStoredPayload;
+    private buildVertexFilter;
+    private buildMetadataVertexFilter;
+    private combineVertexFilters;
+    private buildFieldVertexFilter;
+    private buildSingleVertexFilter;
+    private negateVertexFilter;
+    private buildWhereClause;
+    private buildFieldWhereClauses;
+    private escapeProperty;
+    private serializeAlgorithmInput;
+    private serializeAlgorithmKey;
+    private assertVectorDimension;
+    private assertBatchDimensions;
+    private normalizeNodeResult;
+    private normalizeSearchResult;
+    private extractNode;
+    private extractPayload;
+    private extractId;
+    private extractUserId;
+    private normalizePayload;
+    private normalizeScore;
+    private assertSuccessfulResults;
+    /**
+     * Load the optional AWS SDK on first use.
+     *
+     * This MUST be a dynamic `import()`, never `require()`: tsup/esbuild rewrite
+     * `require()` in the published ESM bundle (`dist/oss/index.mjs`) into a
+     * `__require` shim that throws `Dynamic require of "..." is not supported`,
+     * so every ESM consumer would hit a dead provider even with the SDK installed.
+     */
+    private getSDK;
+    /** Memoized Neptune client; an injected `config.client` short-circuits the SDK. */
+    private getClient;
+    private executeQuery;
+}
+
+interface ElasticsearchConfig extends VectorStoreConfig {
+    /** Pre-configured Elasticsearch client instance (typed as `any` to keep the
+     *  optional driver's types out of the published type declarations). */
+    client?: any;
+    host?: string;
+    port?: number;
+    cloudId?: string;
+    apiKey?: string;
+    username?: string;
+    password?: string;
+    collectionName: string;
+    embeddingModelDims: number;
+    dimension?: number;
+    useSsl?: boolean;
+    caCerts?: string;
+    verifyCerts?: boolean;
+    autoCreateIndex?: boolean;
+    headers?: Record<string, string>;
+}
+declare class ElasticsearchDB implements VectorStore {
+    private client;
+    private readonly config;
+    private readonly collectionName;
+    private readonly dimension;
+    private readonly autoCreateIndex;
+    private _initPromise?;
+    constructor(config: ElasticsearchConfig);
+    private ensureClient;
+    initialize(): Promise<void>;
+    private _doInitialize;
+    private ensureIndex;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    private generateUUID;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+}
+
+interface UpstashVectorConfig extends VectorStoreConfig {
+    collectionName: string;
+    url?: string;
+    token?: string;
+    /** Pre-configured Upstash Vector client instance (typed as `any` to keep
+     *  the optional driver's types out of the published type declarations). */
+    client?: any;
+}
+declare class UpstashVector implements VectorStore {
+    private client;
+    private readonly config;
+    private readonly collectionName;
+    constructor(config: UpstashVectorConfig);
+    /**
+     * Lazily construct (or reuse) the Upstash Vector client, importing the
+     * optional `@upstash/vector` peer only when the store is first used so
+     * consumers that never touch Upstash Vector don't need it installed.
+     */
+    private ensureClient;
+    initialize(): Promise<void>;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    keywordSearch(query: string, topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(): Promise<void>;
+    reset(): Promise<void>;
+    private parseResult;
+    private stringifyFilterValue;
+    private convertFilters;
+    private matchesFilters;
+}
+
+interface AzureMySQLConfig extends VectorStoreConfig {
+    host: string;
+    port?: number;
+    user: string;
+    password?: string;
+    database: string;
+    collectionName: string;
+    embeddingModelDims: number;
+    useAzureCredential?: boolean;
+    sslCa?: string;
+    sslDisabled?: boolean;
+    maxConn?: number;
+}
+declare class AzureMySQLDB implements VectorStore {
+    private pool?;
+    private readonly collectionName;
+    private readonly config;
+    private _initPromise?;
+    constructor(config: AzureMySQLConfig);
+    private col;
+    initialize(): Promise<void>;
+    private _doInitialize;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    keywordSearch(query: string, topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface CassandraConfig extends VectorStoreConfig {
+    contactPoints?: string[];
+    port?: number;
+    username?: string;
+    password?: string;
+    keyspace?: string;
+    collectionName?: string;
+    embeddingModelDims?: number;
+    secureConnectBundle?: string;
+    localDataCenter?: string;
+    protocolVersion?: number;
+    loadBalancingPolicy?: any;
+    client?: CassandraClientLike;
+    /** Pre-configured Cassandra driver module (typed as `any` to keep the
+     *  optional driver's types out of the published type declarations). */
+    driver?: any;
+}
+interface CassandraClientLike {
+    connect?(): Promise<void>;
+    execute(query: string, params?: any[], options?: Record<string, any>): Promise<{
+        rows?: any[];
+        pageState?: string | null;
+    }>;
+}
+declare class CassandraDB implements VectorStore {
+    private static readonly PAGE_SIZE;
+    private readonly driver?;
+    private readonly contactPoints?;
+    private readonly port;
+    private readonly username?;
+    private readonly password?;
+    private readonly keyspace;
+    private readonly collectionName;
+    private readonly dimension;
+    private readonly secureConnectBundle?;
+    private readonly localDataCenter?;
+    private readonly protocolVersion?;
+    private readonly loadBalancingPolicy?;
+    private client?;
+    private _initPromise?;
+    constructor(config: CassandraConfig);
+    initialize(): Promise<void>;
+    private _doInitialize;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    keywordSearch(): Promise<null>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+    private createClient;
+    private loadDriver;
+    private validateIdentifier;
+    private cosineSimilarity;
+    private normalizeVector;
+    private parsePayload;
+    private matchFieldCondition;
+    private filterVector;
+    private assertVectorDimension;
+    private assertBatchDimensions;
+    private scanRows;
+    private pushTopResult;
+}
+
+interface S3VectorsConfig extends VectorStoreConfig {
+    vectorBucketName: string;
+    collectionName: string;
+    embeddingModelDims?: number;
+    dimension?: number;
+    distanceMetric?: "cosine" | "euclidean";
+    region?: string;
+    regionName?: string;
+    client?: S3VectorsClientLike;
+    /** Pre-configured S3 Vectors client options (typed as `any` to keep the
+     *  optional SDK's types out of the published type declarations). */
+    clientConfig?: any;
+}
+interface S3VectorsClientLike {
+    send(command: any): Promise<any>;
+}
+declare class S3Vectors implements VectorStore {
+    private readonly config;
+    private readonly vectorBucketName;
+    private readonly collectionName;
+    private readonly dimension;
+    private readonly distanceMetric;
+    private client?;
+    private clientPromise?;
+    private sdkPromise?;
+    private _initPromise?;
+    private cachedUserId?;
+    constructor(config: S3VectorsConfig);
+    /**
+     * Lazily import the optional `@aws-sdk/client-s3vectors` peer so consumers
+     * who never use the S3 Vectors store don't need it installed.
+     */
+    private getSdk;
+    /** Lazily construct (or reuse) the S3 Vectors client. */
+    private getClient;
+    private createClient;
+    initialize(): Promise<void>;
+    private _doInitialize;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    keywordSearch(): Promise<null>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+    private ensureBucketExists;
+    private ensureIndexExists;
+    private ensureMigrationIndex;
+    private fetchStoredVector;
+    private convertFilters;
+    private convertFilterNode;
+    private convertFieldFilter;
+    private negateFilter;
+    private matchesFilter;
+    private matchesFieldFilter;
+    private evaluateOperator;
+    private toVectorData;
+    private fromVectorData;
+    private normalizeMetadata;
+    private normalizeQueryVector;
+    private normalizeStoredVector;
+    private normalizeListedVector;
+    private normalizeScore;
+    private assertVectorDimension;
+    private assertBatchDimensions;
+    private isNotFound;
+    private isConflict;
+    private isAlwaysFalseFilter;
+    private isNoOpFilter;
+}
+
+interface GoogleMatchingEngineConfig extends VectorStoreConfig {
+    projectId: string;
+    projectNumber: string;
+    region: string;
+    endpointId: string;
+    indexId: string;
+    deploymentIndexId: string;
+    collectionName?: string;
+    credentialsPath?: string;
+    serviceAccountJson?: Record<string, any>;
+    vectorSearchApiEndpoint?: string;
+}
+declare class VertexAIVectorSearch implements VectorStore {
+    private config;
+    private matchClient;
+    private indexClient;
+    private _initPromise?;
+    constructor(config: GoogleMatchingEngineConfig);
+    initialize(): Promise<void>;
+    private _doInitialize;
+    private _createRestriction;
+    private _createDatapoint;
+    private get indexPath();
+    private get indexEndpointPath();
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    keywordSearch(query: string, topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+}
+
+interface PineconeDBConfig extends VectorStoreConfig {
+    collectionName: string;
+    embeddingModelDims: number;
+    /** Pre-configured Pinecone client instance (typed as `any` to keep the
+     *  optional driver's types out of the published type declarations). */
+    client?: any;
+    apiKey?: string;
+    serverlessConfig?: {
+        cloud: string;
+        region: string;
+    };
+    podConfig?: {
+        environment: string;
+        podType?: string;
+        pods?: number;
+        replicas?: number;
+        shards?: number;
+    };
+    metric?: "cosine" | "dotproduct" | "euclidean";
+    batchSize?: number;
+    namespace?: string;
+    extraParams?: Record<string, any>;
+}
+declare class PineconeDB implements VectorStore {
+    private client;
+    private readonly config;
+    private readonly collectionName;
+    private readonly dimension;
+    private readonly metric;
+    private readonly batchSize;
+    private readonly namespace;
+    private readonly serverlessConfig?;
+    private readonly podConfig?;
+    private readonly extraParams;
+    private _index?;
+    private _initPromise?;
+    constructor(config: PineconeDBConfig);
+    /**
+     * Lazily construct (or reuse) the Pinecone client, importing the optional
+     * `@pinecone-database/pinecone` peer only when the store is first used so
+     * consumers that never touch Pinecone don't need it installed.
+     */
+    private ensureClient;
+    initialize(): Promise<void>;
+    private _doInitialize;
+    private _ensureIndex;
+    private index;
+    private namespacedIndex;
+    private migrationsIndex;
+    private createFilter;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    keywordSearch(_query: string, _topK?: number, _filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+}
+
+interface TurbopufferConfig extends VectorStoreConfig {
+    apiKey?: string;
+    region?: string;
+    collectionName: string;
+    distanceMetric?: string;
+    batchSize?: number;
+}
+declare class TurbopufferDB implements VectorStore {
+    private clientInstance?;
+    private clientPromise?;
+    private readonly apiKey;
+    private readonly region;
+    private readonly collectionName;
+    private readonly distanceMetric;
+    private readonly batchSize;
+    constructor(config: TurbopufferConfig);
+    /**
+     * Lazily construct (or reuse) the Turbopuffer client, importing the optional
+     * `@turbopuffer/turbopuffer` peer only when the store is first used so
+     * consumers that never touch Turbopuffer don't need it installed.
+     */
+    private getClient;
+    private createClient;
+    private getNs;
+    private getMigrationsNs;
+    initialize(): Promise<void>;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    keywordSearch(): Promise<null>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+    private convertFilters;
+    private parseRows;
+}
+
+/**
+ * Supported Milvus metric types. Mirrors the Python provider
+ * (`mem0/configs/vector_stores/milvus.py`).
+ */
+type MilvusMetricType = "L2" | "IP" | "COSINE" | "HAMMING" | "JACCARD";
+interface MilvusConfig extends VectorStoreConfig {
+    /**
+     * Full URL/address for the Milvus or Zilliz server.
+     * Defaults to `http://localhost:19530`.
+     */
+    url?: string;
+    /** Token / API key for Zilliz Cloud. Optional for a local setup. */
+    token?: string;
+    /** Name of the database. Optional (Milvus default database when empty). */
+    dbName?: string;
+    /** Collection name. Defaults to `mem0`. */
+    collectionName?: string;
+    /** Embedding dimensionality. Defaults to 1536 (OpenAI). */
+    embeddingModelDims?: number;
+    dimension?: number;
+    /** Similarity metric. Defaults to `L2` (matches the Python provider). */
+    metricType?: MilvusMetricType;
+    /**
+     * Pre-constructed `MilvusClient` instance. When provided, `url`/`token`/`dbName`
+     * are ignored. Primarily useful for dependency injection in tests.
+     */
+    client?: any;
+}
+/**
+ * Milvus vector store provider for the TypeScript OSS SDK.
+ *
+ * Mirrors the Python provider in `mem0/vector_stores/milvus.py`: dense-vector
+ * CRUD (insert / search / get / update / delete / list + user-id helpers) plus
+ * BM25 hybrid keyword search. New collections are created with a `text` +
+ * `sparse` field pair and a BM25 function so `keywordSearch` can run full-text
+ * search; collections created before BM25 support keep working with it disabled.
+ *
+ * The `@zilliz/milvus2-sdk-node` dependency is lazily required so the package
+ * remains optional. Importing this module never forces the SDK to be installed
+ * until a Milvus store is actually constructed.
+ */
+declare class Milvus implements VectorStore {
+    private client;
+    private readonly collectionName;
+    private readonly dimension;
+    private readonly metricType;
+    private _initPromise?;
+    private DataType;
+    private FunctionType;
+    private hasBm25Schema;
+    constructor(config: MilvusConfig);
+    initialize(): Promise<void>;
+    /**
+     * Create the collection if it does not already exist, with an AUTOINDEX
+     * dense-vector index plus a BM25 `text` -> `sparse` full-text index. Idempotent
+     * (mirrors the Python `create_col`). When the collection already exists, detect
+     * whether the BM25 `text`/`sparse` fields are present so keyword search
+     * degrades gracefully on collections created before BM25 support.
+     */
+    private createCol;
+    /**
+     * Filter keys are interpolated straight into the expression, so restrict them
+     * to safe identifiers (same rule as the Python provider) to block injection.
+     */
+    private static readonly SAFE_FILTER_KEY;
+    /**
+     * Build a Milvus boolean filter expression from a flat filters object.
+     * Mirrors the Python `_create_filter` (equality only, AND-combined): validate
+     * each key, escape string values (backslash first, then double-quote), and
+     * reject value types Milvus can't compare against a scalar field.
+     */
+    private createFilter;
+    /**
+     * Text fed to the BM25 sparse index for a payload. Prefers the lemmatized
+     * text, falls back to the raw memory `data`, and truncates to the VarChar
+     * limit (mirrors the Python provider).
+     */
+    private bm25Text;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    /**
+     * Map raw Milvus search hits to VectorStoreResult. For the L2 metric,
+     * distances are unbounded and smaller-is-better, so normalise them to a 0..1
+     * similarity; every other metric passes the raw score through. Shared by
+     * search and keywordSearch so both match the Python provider's `_parse_output`
+     * (which likewise normalises by metric type regardless of dense vs BM25 score).
+     */
+    private parseHits;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    /**
+     * BM25 full-text keyword search over the sparse field. Milvus tokenizes the
+     * raw query string via the collection's BM25 function. Returns null when the
+     * collection has no BM25 schema so callers fall back to dense search only
+     * (mirrors the Python provider).
+     */
+    keywordSearch(query: string, topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    private generateUUID;
+    private ensureMigrationsCol;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+}
+
+interface MongoDBConfig extends VectorStoreConfig {
+    url?: string;
+    dbName?: string;
+    collectionName?: string;
+    embeddingModelDims?: number;
+    dimension?: number;
+    /** Pre-configured MongoDB client instance (typed as `any` to keep the
+     *  optional driver's types out of the published type declarations). */
+    client?: any;
+}
+declare class MongoDB implements VectorStore {
+    private client;
+    private db;
+    private collection;
+    private readonly config;
+    private readonly collectionName;
+    private readonly dbName;
+    private readonly embeddingModelDims;
+    private readonly indexName;
+    private _initPromise?;
+    constructor(config: MongoDBConfig);
+    private ensureClient;
+    initialize(): Promise<void>;
+    private _doInitialize;
+    private validateFilterValue;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    keywordSearch(query: string, topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+type OpenSearchAuth = {
+    username?: string;
+    password?: string;
+} | {
+    user?: string;
+    password?: string;
+} | Record<string, any>;
+interface OpenSearchConfig extends VectorStoreConfig {
+    /** Pre-configured OpenSearch client instance (typed as `any` to keep the
+     *  optional driver's types out of the published type declarations). */
+    client?: any;
+    host?: string;
+    port?: number;
+    httpAuth?: OpenSearchAuth | [string, string];
+    user?: string;
+    password?: string;
+    useSSL?: boolean;
+    verifyCerts?: boolean;
+    collectionName: string;
+    embeddingModelDims: number;
+    autoRefresh?: boolean;
+}
+declare class OpenSearchDB implements VectorStore {
+    private client;
+    private readonly config;
+    private readonly collectionName;
+    private readonly embeddingModelDims;
+    private readonly autoRefresh;
+    private _initPromise?;
+    constructor(config: OpenSearchConfig);
+    private ensureClient;
+    initialize(): Promise<void>;
+    private _doInitialize;
+    private normalizeAuth;
+    private indexExists;
+    private createCol;
+    private ensureMigrationIndex;
+    private validateVector;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    keywordSearch(query: string, topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    reset(): Promise<void>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+    private hitToResult;
+    private buildFilterClauses;
+    private buildFilterClause;
+    private buildOperatorClause;
+    private payloadField;
+    private assertScalarValue;
+    private assertScalarArray;
+}
+
+interface WeaviateConfig extends VectorStoreConfig {
+    /** Pre-configured Weaviate client instance (typed as `any` to keep the
+     *  optional driver's types out of the published type declarations). */
+    client?: any;
+    clusterUrl?: string;
+    apiKey?: string;
+    additionalHeaders?: Record<string, string>;
+    collectionName: string;
+    embeddingModelDims: number;
+}
+declare class WeaviateDB implements VectorStore {
+    private _config;
+    private _client;
+    private _sdk;
+    private _col;
+    private _userId;
+    private _initPromise?;
+    constructor(config: WeaviateConfig);
+    initialize(): Promise<void>;
+    private ensureClient;
+    private _doInitialize;
+    private _buildFilters;
+    insert(vectors: number[][], ids: string[], payloads: Record<string, any>[]): Promise<void>;
+    search(query: number[], topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[]>;
+    keywordSearch(query: string, topK?: number, filters?: SearchFilters): Promise<VectorStoreResult[] | null>;
+    get(vectorId: string): Promise<VectorStoreResult | null>;
+    update(vectorId: string, vector: number[], payload: Record<string, any>): Promise<void>;
+    delete(vectorId: string): Promise<void>;
+    deleteCol(): Promise<void>;
+    list(filters?: SearchFilters, topK?: number): Promise<[VectorStoreResult[], number]>;
+    getUserId(): Promise<string>;
+    setUserId(userId: string): Promise<void>;
+}
+
+interface RerankResult {
+    /** Index into the input `documents` array. */
+    index: number;
+    /** Relevance of the document to the query, 0..1, higher = more relevant. */
+    rerankScore: number;
+}
+interface Reranker {
+    /**
+     * Rank `documents` by relevance to `query`.
+     *
+     * Returns results sorted by descending relevance. When `topK` is given, at
+     * most that many results are returned. Each result's `index` points back into
+     * the input `documents` array so callers can recover the original item.
+     */
+    rerank(query: string, documents: string[], topK?: number): Promise<RerankResult[]>;
+}
+
+declare class CohereReranker implements Reranker {
+    private clientInstance?;
+    private clientPromise?;
+    private readonly apiKey;
+    private model;
+    private topK?;
+    private returnDocuments;
+    private maxChunksPerDoc?;
+    constructor(config: RerankerConfig);
+    /**
+     * Lazily construct (or reuse) the Cohere client, importing the optional
+     * `cohere-ai` peer only when the reranker is first used so consumers that
+     * never touch Cohere don't need it installed.
+     */
+    private getClient;
+    private createClient;
+    rerank(query: string, documents: string[], topK?: number): Promise<RerankResult[]>;
+}
+
+declare class LLMReranker implements Reranker {
+    private llm;
+    private topK?;
+    constructor(config: RerankerConfig, llm: LLM);
+    rerank(query: string, documents: string[], topK?: number): Promise<RerankResult[]>;
+    private score;
+    private extractScore;
+}
+
+declare class ZeroEntropyReranker implements Reranker {
+    private clientInstance?;
+    private clientPromise?;
+    private readonly apiKey;
+    private model;
+    private topK?;
+    constructor(config: RerankerConfig);
+    /**
+     * Lazily construct (or reuse) the ZeroEntropy client, importing the
+     * optional `zeroentropy` peer only when the reranker is first used so
+     * consumers that never touch ZeroEntropy don't need it installed.
+     */
+    private getClient;
+    private createClient;
+    rerank(query: string, documents: string[], topK?: number): Promise<RerankResult[]>;
+}
+
+declare class CrossEncoderReranker implements Reranker {
+    private modelId;
+    private device?;
+    private maxLength?;
+    private normalize;
+    private topK?;
+    private loaded?;
+    constructor(config: RerankerConfig, defaultModel: string, defaultMaxLength?: number);
+    private load;
+    rerank(query: string, documents: string[], topK?: number): Promise<RerankResult[]>;
+}
+
 interface HistoryManager {
     addHistory(memoryId: string, previousValue: string | null, newValue: string | null, action: string, createdAt?: string, updatedAt?: string, isDeleted?: number): Promise<void>;
     getHistory(memoryId: string): Promise<any[]>;
@@ -1087,8 +2466,12 @@ declare class LLMFactory {
 declare class VectorStoreFactory {
     static create(provider: string, config: VectorStoreConfig): VectorStore;
 }
+declare class RerankerFactory {
+    static create(provider: string, config: RerankerConfig): Reranker;
+    private static buildLLMRerankerLLM;
+}
 declare class HistoryManagerFactory {
     static create(provider: string, config: HistoryStoreConfig): HistoryManager;
 }
 
-export { type AddMemoryOptions, AnthropicLLM, AzureAISearch, AzureOpenAIEmbedder, type DeleteAllMemoryOptions, type Embedder, EmbedderFactory, type EmbeddingConfig, type Entity, type GetAllMemoryOptions, GoogleEmbedder, GoogleLLM, GroqLLM, HistoryManagerFactory, type HistoryStoreConfig, type LLM, type LLMConfig, LLMFactory, type LLMResponse, LMStudioEmbedder, LMStudioLLM, LangchainEmbedder, LangchainLLM, LangchainVectorStore, LiteLLM, Memory, type MemoryConfig, MemoryConfigSchema, type MemoryItem, MemoryVectorStore, type Message, MistralLLM, type MultiModalMessages, OllamaEmbedder, OllamaLLM, OpenAIEmbedder, OpenAILLM, OpenAIStructuredLLM, PGVector, Qdrant, RedisDB, type SearchFilters, type SearchMemoryOptions, type SearchResult, SupabaseDB, type UpdateProjectOptions, type VectorStore, type VectorStoreConfig, VectorStoreFactory, type VectorStoreResult, VectorizeDB, buildFilterConditions };
+export { AWSBedrockLLM, type AddMemoryOptions, AnthropicLLM, AzureAISearch, AzureMySQLDB, AzureOpenAIEmbedder, type BaiduConfig, BaiduDB, CassandraDB, CohereReranker, CrossEncoderReranker, DatabricksVectorStore, type DeleteAllMemoryOptions, ElasticsearchDB, type Embedder, EmbedderFactory, type EmbeddingConfig, type Entity, FastEmbedEmbedder, type GetAllMemoryOptions, GoogleEmbedder, GoogleLLM, type GoogleMatchingEngineConfig, GroqLLM, HistoryManagerFactory, type HistoryStoreConfig, HuggingFaceEmbedder, type LLM, type LLMConfig, LLMError, LLMFactory, LLMReranker, type LLMResponse, LMStudioEmbedder, LMStudioLLM, LangchainEmbedder, LangchainLLM, LangchainVectorStore, LiteLLM, Memory, type MemoryConfig, MemoryConfigSchema, type MemoryItem, MemoryVectorStore, type Message, Milvus, type MilvusConfig, type MilvusMetricType, MistralLLM, MongoDB, type MongoDBConfig, type MultiModalMessages, NeptuneAnalyticsVectorStore, OllamaEmbedder, OllamaLLM, OpenAIEmbedder, OpenAILLM, OpenAIStructuredLLM, OpenSearchDB, PGVector, PineconeDB, Qdrant, RedisDB, type RerankResult, type Reranker, type RerankerConfig, RerankerFactory, S3Vectors, type SearchFilters, type SearchMemoryOptions, type SearchResult, SupabaseDB, TogetherEmbedder, TurbopufferDB, type UpdateMemoryOptions, type UpdateProjectOptions, UpstashVector, type ValkeyConfig, ValkeyDB, type VectorStore, type VectorStoreConfig, VectorStoreFactory, type VectorStoreResult, VectorizeDB, type VertexAIConfig, VertexAIEmbedder, VertexAIVectorSearch, VllmLLM, WeaviateDB, ZeroEntropyReranker, buildFilterConditions, extractProvider };