The Memory Layer for AI Agents - Drop-in memory infrastructure for AI agents and apps. Context that persists. Built for production.
Python agentic-memoryagentic-memory-systemagentsaiai-agentschatgptgenaillmlong-term-memorymemorymemory-managementpythonragstate-management
TypeScript OSS: Langchain Integration (#2556)
Saket Aryanc3c9205ffa52
diff --git a/docs/changelog.mdx b/docs/changelog.mdxindex 0a0801224..68504fde1 100644--- a/docs/changelog.mdx+++ b/docs/changelog.mdx@@ -127,6 +127,17 @@ mode: "wide"<Tab title="TypeScript">+<Update label="2025-04-14" description="v2.1.17">+**New Features:**+- **OSS SDK:** Added support for Langchain LLM+- **OSS SDK:** Added support for Langchain Embedder+- **OSS SDK:** Added support for Langchain Vector Store++**Improvements:**+- **OSS SDK:** Changed `model` in LLM and Embedder to use type any from `string` to use langchain llm models+- **OSS SDK:** Added client to vector store config for langchain vector store+</Update>+<Update label="2025-04-11" description="v2.1.16-patch.1">**Bug Fixes:**- **Azure OpenAI:** Fixed issues with Azure OpenAIdiff --git a/docs/components/embedders/models/langchain.mdx b/docs/components/embedders/models/langchain.mdxindex 00dc4c777..aa48ae265 100644--- a/docs/components/embedders/models/langchain.mdx+++ b/docs/components/embedders/models/langchain.mdx@@ -42,6 +42,32 @@ messages = []m.add(messages, user_id="alice", metadata={"category": "movies"})```++```typescript TypeScript+import { Memory } from "mem0ai";+import { OpenAIEmbeddings } from "@langchain/openai";++const embeddings = new OpenAIEmbeddings();+const config = {+ "embedder": {+ "provider": "langchain",+ "config": {+ "model": embeddings+ }+ }+}++const memory = new Memory(config);++const messages = [+ { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },+ { role: "assistant", content: "How about a thriller movies? They can be quite engaging." },+ { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },+ { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." }+]++memory.add(messages, user_id="alice", metadata={"category": "movies"})+```</CodeGroup>## Supported LangChain Embedding Providersdiff --git a/docs/components/llms/models/langchain.mdx b/docs/components/llms/models/langchain.mdxindex 3198ca83a..4113bc052 100644--- a/docs/components/llms/models/langchain.mdx+++ b/docs/components/llms/models/langchain.mdx@@ -43,6 +43,37 @@ messages = []m.add(messages, user_id="alice", metadata={"category": "movies"})```++```typescript TypeScript+import { Memory } from "mem0ai";+import { ChatOpenAI } from "@langchain/openai";++const openai_model = new ChatOpenAI({+ model: "gpt-4o",+ temperature: 0.2,+ max_tokens: 2000+})++const config = {+ "llm": {+ "provider": "langchain",+ "config": {+ "model": openai_model+ }+ }+}++const memory = new Memory(config);++const messages = [+ { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },+ { role: "assistant", content: "How about a thriller movies? They can be quite engaging." },+ { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },+ { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." }+]++memory.add(messages, user_id="alice", metadata={"category": "movies"})+```</CodeGroup>## Supported LangChain Providersdiff --git a/docs/components/vectordbs/dbs/langchain.mdx b/docs/components/vectordbs/dbs/langchain.mdxindex 8c2a2f1ab..d87ff583a 100644--- a/docs/components/vectordbs/dbs/langchain.mdx+++ b/docs/components/vectordbs/dbs/langchain.mdx@@ -44,6 +44,33 @@ messages = []m.add(messages, user_id="alice", metadata={"category": "movies"})```++```typescript TypeScript+import { Memory } from "mem0ai";+import { OpenAIEmbeddings } from "@langchain/openai";+import { MemoryVectorStore as LangchainMemoryStore } from "langchain/vectorstores/memory";++const embeddings = new OpenAIEmbeddings();+const vectorStore = new LangchainVectorStore(embeddings);++const config = {+ "vector_store": {+ "provider": "langchain",+ "config": { "client": vectorStore }+ }+}++const memory = new Memory(config);++const messages = [+ { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },+ { role: "assistant", content: "How about a thriller movies? They can be quite engaging." },+ { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },+ { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." }+]++memory.add(messages, user_id="alice", metadata={"category": "movies"})+```</CodeGroup>## Supported LangChain Vector Storesdiff --git a/mem0-ts/package.json b/mem0-ts/package.jsonindex 3727095f6..833e223bf 100644--- a/mem0-ts/package.json+++ b/mem0-ts/package.json@@ -1,6 +1,6 @@{"name": "mem0ai",- "version": "2.1.16-patch.1",+ "version": "2.1.17","description": "The Memory Layer For Your AI Apps","main": "./dist/index.js","module": "./dist/index.mjs",@@ -98,14 +98,15 @@},"peerDependencies": {"@anthropic-ai/sdk": "0.18.0",- "@qdrant/js-client-rest": "1.13.0",- "@mistralai/mistralai": "^1.5.2","@google/genai": "^0.7.0",+ "@mistralai/mistralai": "^1.5.2",+ "@qdrant/js-client-rest": "1.13.0","@supabase/supabase-js": "^2.49.1","@types/jest": "29.5.14","@types/pg": "8.11.0","@types/sqlite3": "3.1.11","groq-sdk": "0.3.0",+ "@langchain/core": "^0.3.44","neo4j-driver": "^5.28.1","ollama": "^0.5.14","pg": "8.11.3",diff --git a/mem0-ts/pnpm-lock.yaml b/mem0-ts/pnpm-lock.yamlindex 768365120..f9012f084 100644--- a/mem0-ts/pnpm-lock.yaml+++ b/mem0-ts/pnpm-lock.yaml@@ -13,6 +13,9 @@ importers:"@google/genai":specifier: ^0.7.0version: 0.7.0([email protected])+ "@langchain/core":+ specifier: ^0.3.44"@mistralai/mistralai":specifier: ^1.5.2version: 1.5.2([email protected])@@ -376,6 +379,12 @@ packages:integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==,}+ "@cfworker/[email protected]":+ resolution:+ {+ integrity: sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og==,+ }+"@cspotcode/[email protected]":resolution:{@@ -796,6 +805,13 @@ packages:integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==,}+ "@langchain/[email protected]":+ resolution:+ {+ integrity: sha512-3BsSFf7STvPPZyl2kMANgtVnCUvDdyP4k+koP+nY2Tczd5V+RFkuazIn/JOj/xxy/neZjr4PxFU4BFyF1aKXOA==,+ }+ engines: { node: ">=18" }+"@mistralai/[email protected]":resolution:{@@ -1263,6 +1279,12 @@ packages:integrity: sha512-PIzZZlEppgrpoT2QgbnDU+MMzuR6BbCjllj0bM70lWoejMeNJAxCchxnv7J3XFkI8MpygtRpzXrIlmWUBclP5A==,}+ "@types/[email protected]":+ resolution:+ {+ integrity: sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==,+ }+"@types/[email protected]":resolution:{@@ -1275,6 +1297,12 @@ packages:integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==,}+ "@types/[email protected]":+ resolution:+ {+ integrity: sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==,+ }+"@types/[email protected]":resolution:{@@ -1812,6 +1840,12 @@ packages:integrity: sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==,}+ resolution:+ {+ integrity: sha512-wKGOQRRvdnd89pCeH96e2Fn4wkbenSP6LMHfjfyNLMbGuHEFbMqQNuxXqd0oXG9caIOQ1FTvc5Uijp9/4jujnQ==,+ }+resolution:{@@ -1857,6 +1891,13 @@ packages:supports-color:optional: true+ resolution:+ {+ integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==,+ }+ engines: { node: ">=0.10.0" }+resolution:{@@ -2091,6 +2132,12 @@ packages:}engines: { node: ">=6" }+ resolution:+ {+ integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==,+ }+resolution:{@@ -2928,6 +2975,12 @@ packages:}engines: { node: ">=10" }+ resolution:+ {+ integrity: sha512-XC63YQeEcS47Y53gg950xiZ4IWmkfMe4p2V9OSaBt26q+p47WHn18izuXzSclCI73B7yGqtfRsT6jcZQI0y08g==,+ }+resolution:{@@ -3007,6 +3060,17 @@ packages:integrity: sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==,}+ resolution:+ {+ integrity: sha512-cv3ebg0Hh0gRbl72cv/uzaZ+KOdfa2mGF1s74vmB2vlNVO/Ap/O9RYaHV+tpR8nwhGZ50R3ILnTOwSwGP+XQxw==,+ }+ peerDependencies:+ openai: "*"+ peerDependenciesMeta:+ openai:+ optional: true+resolution:{@@ -3275,6 +3339,13 @@ packages:integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==,}+ resolution:+ {+ integrity: sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==,+ }+ hasBin: true+resolution:{@@ -3470,6 +3541,13 @@ packages:zod:optional: true+ resolution:+ {+ integrity: sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==,+ }+ engines: { node: ">=4" }+resolution:{@@ -3498,6 +3576,27 @@ packages:}engines: { node: ">=10" }+ resolution:+ {+ integrity: sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==,+ }+ engines: { node: ">=8" }++ resolution:+ {+ integrity: sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==,+ }+ engines: { node: ">=8" }++ resolution:+ {+ integrity: sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==,+ }+ engines: { node: ">=8" }+resolution:{@@ -3936,6 +4035,13 @@ packages:}engines: { node: ">= 4" }+ resolution:+ {+ integrity: sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==,+ }+ engines: { node: ">= 4" }+resolution:{@@ -4057,6 +4163,12 @@ packages:}engines: { node: ">=10" }+ resolution:+ {+ integrity: sha512-xMO/8eNREtaROt7tJvWJqHBDTMFN4eiQ5I4JRMuilwfnFcV5W9u7RUkueNkdw0jPqGMX36iCywelS5yilTuOxg==,+ }+resolution:{@@ -4550,6 +4662,13 @@ packages:integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==,}+ resolution:+ {+ integrity: sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==,+ }+ hasBin: true+resolution:{@@ -4957,6 +5076,8 @@ snapshots:"@bcoe/[email protected]": {}+ "@cfworker/[email protected]": {}+"@cspotcode/[email protected]":dependencies:"@jridgewell/trace-mapping": 0.3.9@@ -5254,6 +5375,23 @@ snapshots:"@jridgewell/resolve-uri": 3.1.2"@jridgewell/sourcemap-codec": 1.5.0+ "@langchain/[email protected]([email protected]([email protected])([email protected])([email protected]))":+ dependencies:+ "@cfworker/json-schema": 4.1.1+ ansi-styles: 5.2.0+ camelcase: 6.3.0+ decamelize: 1.2.0+ js-tiktoken: 1.0.19+ mustache: 4.2.0+ p-queue: 6.6.2+ p-retry: 4.6.2+ uuid: 10.0.0+ zod: 3.24.2+ zod-to-json-schema: 3.24.5([email protected])+ transitivePeerDependencies:+ - openai+"@mistralai/[email protected]([email protected])":dependencies:zod: 3.24.2@@ -5511,12 +5649,16 @@ snapshots:"@types/[email protected]": {}+ "@types/[email protected]": {}+"@types/[email protected]":dependencies:"@types/node": 22.13.5"@types/[email protected]": {}+ "@types/[email protected]": {}+"@types/[email protected]": {}"@types/[email protected]":@@ -5844,6 +5986,10 @@ snapshots:optional: true+ dependencies:+ simple-wcswidth: 1.0.1+[email protected](@types/[email protected])([email protected](@types/[email protected])([email protected])):@@ -5877,6 +6023,8 @@ snapshots:optionalDependencies:supports-color: 5.5.0+ [email protected]: {}+dependencies:mimic-response: 3.1.0@@ -6001,6 +6149,8 @@ snapshots:+ [email protected]: {}+dependencies:cross-spawn: 7.0.6@@ -6720,6 +6870,10 @@ snapshots:+ dependencies:+ base64-js: 1.5.1+@@ -6757,6 +6911,18 @@ snapshots:+ dependencies:+ "@types/uuid": 10.0.0+ chalk: 4.1.2+ console-table-printer: 2.12.1+ p-queue: 6.6.2+ p-retry: 4.6.2+ semver: 7.7.1+ uuid: 10.0.0+ optionalDependencies:+@@ -6908,6 +7074,8 @@ snapshots:+ [email protected]: {}+dependencies:any-promise: 1.3.0@@ -7042,6 +7210,8 @@ snapshots:transitivePeerDependencies:- encoding+ [email protected]: {}+dependencies:p-try: 2.2.0@@ -7059,6 +7229,20 @@ snapshots:aggregate-error: 3.1.0optional: true+ dependencies:+ eventemitter3: 4.0.7+ p-timeout: 3.2.0++ dependencies:+ "@types/retry": 0.12.0+ retry: 0.13.1++ dependencies:+ p-finally: 1.0.0+@@ -7297,6 +7481,8 @@ snapshots:optional: true+ [email protected]: {}+@@ -7376,6 +7562,8 @@ snapshots:dependencies:semver: 7.7.1+ [email protected]: {}+@@ -7687,6 +7875,8 @@ snapshots:+ [email protected]: {}+diff --git a/mem0-ts/src/oss/src/config/defaults.ts b/mem0-ts/src/oss/src/config/defaults.tsindex a855e5b3f..b2c9d19fc 100644--- a/mem0-ts/src/oss/src/config/defaults.ts+++ b/mem0-ts/src/oss/src/config/defaults.ts@@ -22,6 +22,7 @@ export const DEFAULT_MEMORY_CONFIG: MemoryConfig = {config: {apiKey: process.env.OPENAI_API_KEY || "",model: "gpt-4-turbo-preview",+ modelProperties: undefined,},},enableGraph: false,diff --git a/mem0-ts/src/oss/src/config/manager.ts b/mem0-ts/src/oss/src/config/manager.tsindex 1e50f3552..4e9cbb46f 100644--- a/mem0-ts/src/oss/src/config/manager.ts+++ b/mem0-ts/src/oss/src/config/manager.ts@@ -9,43 +9,84 @@ export class ConfigManager {provider:userConfig.embedder?.provider ||DEFAULT_MEMORY_CONFIG.embedder.provider,- config: {- apiKey:- userConfig.embedder?.config?.apiKey ||- DEFAULT_MEMORY_CONFIG.embedder.config.apiKey,- model:- userConfig.embedder?.config?.model ||- DEFAULT_MEMORY_CONFIG.embedder.config.model,- },+ config: (() => {+ const defaultConf = DEFAULT_MEMORY_CONFIG.embedder.config;+ const userConf = userConfig.embedder?.config;+ let finalModel: string | any = defaultConf.model;++ if (userConf?.model && typeof userConf.model === "object") {+ finalModel = userConf.model;+ } else if (userConf?.model && typeof userConf.model === "string") {+ finalModel = userConf.model;+ }++ return {+ apiKey:+ userConf?.apiKey !== undefined+ ? userConf.apiKey+ : defaultConf.apiKey,+ model: finalModel,+ url: userConf?.url,+ };+ })(),},vectorStore: {provider:userConfig.vectorStore?.provider ||DEFAULT_MEMORY_CONFIG.vectorStore.provider,- config: {- collectionName:- userConfig.vectorStore?.config?.collectionName ||- DEFAULT_MEMORY_CONFIG.vectorStore.config.collectionName,- dimension:- userConfig.vectorStore?.config?.dimension ||- DEFAULT_MEMORY_CONFIG.vectorStore.config.dimension,- ...userConfig.vectorStore?.config,- },+ config: (() => {+ const defaultConf = DEFAULT_MEMORY_CONFIG.vectorStore.config;+ const userConf = userConfig.vectorStore?.config;++ // Prioritize user-provided client instance+ if (userConf?.client && typeof userConf.client === "object") {+ return {+ client: userConf.client,+ // Include other fields from userConf if necessary, or omit defaults+ collectionName: userConf.collectionName, // Can be undefined+ dimension: userConf.dimension || defaultConf.dimension, // Merge dimension+ ...userConf, // Include any other passthrough fields from user+ };+ } else {+ // If no client provided, merge standard fields+ return {+ collectionName:+ userConf?.collectionName || defaultConf.collectionName,+ dimension: userConf?.dimension || defaultConf.dimension,+ // Ensure client is not carried over from defaults if not provided by user+ client: undefined,+ // Include other passthrough fields from userConf even if no client+ ...userConf,+ };+ }+ })(),},llm: {provider:userConfig.llm?.provider || DEFAULT_MEMORY_CONFIG.llm.provider,- config: {- apiKey:- userConfig.llm?.config?.apiKey ||- DEFAULT_MEMORY_CONFIG.llm.config.apiKey,- model:- userConfig.llm?.config?.model ||- DEFAULT_MEMORY_CONFIG.llm.config.model,- modelProperties:- userConfig.llm?.config?.modelProperties ||- DEFAULT_MEMORY_CONFIG.llm.config.modelProperties,- },+ config: (() => {+ const defaultConf = DEFAULT_MEMORY_CONFIG.llm.config;+ const userConf = userConfig.llm?.config;+ let finalModel: string | any = defaultConf.model;++ if (userConf?.model && typeof userConf.model === "object") {+ finalModel = userConf.model;+ } else if (userConf?.model && typeof userConf.model === "string") {+ finalModel = userConf.model;+ }++ return {+ apiKey:+ userConf?.apiKey !== undefined+ ? userConf.apiKey+ : defaultConf.apiKey,+ model: finalModel,+ modelProperties:+ userConf?.modelProperties !== undefined+ ? userConf.modelProperties+ : defaultConf.modelProperties,+ };+ })(),},historyDbPath:userConfig.historyDbPath || DEFAULT_MEMORY_CONFIG.historyDbPath,diff --git a/mem0-ts/src/oss/src/embeddings/langchain.ts b/mem0-ts/src/oss/src/embeddings/langchain.tsnew file mode 100644index 000000000..7ffb85065--- /dev/null+++ b/mem0-ts/src/oss/src/embeddings/langchain.ts@@ -0,0 +1,50 @@+import { Embeddings } from "@langchain/core/embeddings";+import { Embedder } from "./base";+import { EmbeddingConfig } from "../types";++export class LangchainEmbedder implements Embedder {+ private embedderInstance: Embeddings;+ private batchSize?: number; // Some LC embedders have batch size++ constructor(config: EmbeddingConfig) {+ // Check if config.model is provided and is an object (the instance)+ if (!config.model || typeof config.model !== "object") {+ throw new Error(+ "Langchain embedder provider requires an initialized Langchain Embeddings instance passed via the 'model' field in the embedder config.",+ );+ }+ // Basic check for embedding methods+ if (+ typeof (config.model as any).embedQuery !== "function" ||+ typeof (config.model as any).embedDocuments !== "function"+ ) {+ throw new Error(+ "Provided Langchain 'instance' in the 'model' field does not appear to be a valid Langchain Embeddings instance (missing embedQuery or embedDocuments method).",+ );+ }+ this.embedderInstance = config.model as Embeddings;+ // Store batch size if the instance has it (optional)+ this.batchSize = (this.embedderInstance as any).batchSize;+ }++ async embed(text: string): Promise<number[]> {+ try {+ // Use embedQuery for single text embedding+ return await this.embedderInstance.embedQuery(text);+ } catch (error) {+ console.error("Error embedding text with Langchain Embedder:", error);+ throw error;+ }+ }++ async embedBatch(texts: string[]): Promise<number[][]> {+ try {+ // Use embedDocuments for batch embedding+ // Langchain's embedDocuments handles batching internally if needed/supported+ return await this.embedderInstance.embedDocuments(texts);+ } catch (error) {+ console.error("Error embedding batch with Langchain Embedder:", error);+ throw error;+ }+ }+}diff --git a/mem0-ts/src/oss/src/graphs/tools.ts b/mem0-ts/src/oss/src/graphs/tools.tsindex 57262499d..e0768521f 100644--- a/mem0-ts/src/oss/src/graphs/tools.ts+++ b/mem0-ts/src/oss/src/graphs/tools.ts@@ -1,3 +1,5 @@+import { z } from "zod";+export interface GraphToolParameters {source: string;destination: string;@@ -21,6 +23,58 @@ export interface GraphRelationsParameters {}>;}+// --- Zod Schemas for Tool Arguments ---++// Schema for simple relationship arguments (Update, Delete)+export const GraphSimpleRelationshipArgsSchema = z.object({+ source: z+ .string()+ .describe("The identifier of the source node in the relationship."),+ relationship: z+ .string()+ .describe("The relationship between the source and destination nodes."),+ destination: z+ .string()+ .describe("The identifier of the destination node in the relationship."),+});++// Schema for adding a relationship (includes types)+export const GraphAddRelationshipArgsSchema =+ GraphSimpleRelationshipArgsSchema.extend({+ source_type: z+ .string()+ .describe("The type or category of the source node."),+ destination_type: z+ .string()+ .describe("The type or category of the destination node."),+ });++// Schema for extracting entities+export const GraphExtractEntitiesArgsSchema = z.object({+ entities: z+ .array(+ z.object({+ entity: z.string().describe("The name or identifier of the entity."),+ entity_type: z.string().describe("The type or category of the entity."),+ }),+ )+ .describe("An array of entities with their types."),+});++// Schema for establishing relationships+export const GraphRelationsArgsSchema = z.object({+ entities: z+ .array(GraphSimpleRelationshipArgsSchema)+ .describe("An array of relationships (source, relationship, destination)."),+});++// --- Tool Definitions (using JSON schema, keep as is) ---++// Note: The tool definitions themselves still use JSON schema format+// as expected by the LLM APIs. The Zod schemas above are for internal+// validation and potentially for use with Langchain's .withStructuredOutput+// if we adapt it to handle tool calls via schema.+export const UPDATE_MEMORY_TOOL_GRAPH = {type: "function",function: {diff --git a/mem0-ts/src/oss/src/index.ts b/mem0-ts/src/oss/src/index.tsindex 135080007..c14f37302 100644--- a/mem0-ts/src/oss/src/index.ts+++ b/mem0-ts/src/oss/src/index.ts@@ -5,6 +5,7 @@ export * from "./embeddings/base";export * from "./embeddings/openai";export * from "./embeddings/ollama";export * from "./embeddings/google";+export * from "./embeddings/langchain";export * from "./llms/base";export * from "./llms/openai";export * from "./llms/google";@@ -13,8 +14,11 @@ export * from "./llms/anthropic";export * from "./llms/groq";export * from "./llms/ollama";export * from "./llms/mistral";+export * from "./llms/langchain";export * from "./vector_stores/base";export * from "./vector_stores/memory";export * from "./vector_stores/qdrant";export * from "./vector_stores/redis";+export * from "./vector_stores/supabase";+export * from "./vector_stores/langchain";export * from "./utils/factory";diff --git a/mem0-ts/src/oss/src/llms/base.ts b/mem0-ts/src/oss/src/llms/base.tsindex b15575fcb..24990cc5a 100644--- a/mem0-ts/src/oss/src/llms/base.ts+++ b/mem0-ts/src/oss/src/llms/base.ts@@ -12,7 +12,7 @@ export interface LLMResponse {export interface LLM {generateResponse(messages: Array<{ role: string; content: string }>,- response_format: { type: string },+ response_format?: { type: string },tools?: any[],): Promise<any>;generateChat(messages: Message[]): Promise<LLMResponse>;diff --git a/mem0-ts/src/oss/src/llms/langchain.ts b/mem0-ts/src/oss/src/llms/langchain.tsnew file mode 100644index 000000000..9acaf11f4--- /dev/null+++ b/mem0-ts/src/oss/src/llms/langchain.ts@@ -0,0 +1,255 @@+import { BaseLanguageModel } from "@langchain/core/language_models/base";+import {+ AIMessage,+ HumanMessage,+ SystemMessage,+ BaseMessage,+} from "@langchain/core/messages";+import { z } from "zod";+import { LLM, LLMResponse } from "./base";+import { LLMConfig, Message } from "../types/index";+// Import the schemas directly into LangchainLLM+import { FactRetrievalSchema, MemoryUpdateSchema } from "../prompts";+// Import graph tool argument schemas+import {+ GraphExtractEntitiesArgsSchema,+ GraphRelationsArgsSchema,+ GraphSimpleRelationshipArgsSchema, // Used for delete tool+} from "../graphs/tools";++const convertToLangchainMessages = (messages: Message[]): BaseMessage[] => {+ return messages.map((msg) => {+ const content =+ typeof msg.content === "string"+ ? msg.content+ : JSON.stringify(msg.content);+ switch (msg.role?.toLowerCase()) {+ case "system":+ return new SystemMessage(content);+ case "user":+ case "human":+ return new HumanMessage(content);+ case "assistant":+ case "ai":+ return new AIMessage(content);+ default:+ console.warn(+ `Unsupported message role '${msg.role}' for Langchain. Treating as 'human'.`,+ );+ return new HumanMessage(content);+ }+ });+};++export class LangchainLLM implements LLM {+ private llmInstance: BaseLanguageModel;+ private modelName: string;++ constructor(config: LLMConfig) {+ if (!config.model || typeof config.model !== "object") {+ throw new Error(+ "Langchain provider requires an initialized Langchain instance passed via the 'model' field in the LLM config.",+ );+ }+ if (typeof (config.model as any).invoke !== "function") {+ throw new Error(+ "Provided Langchain 'instance' in the 'model' field does not appear to be a valid Langchain language model (missing invoke method).",+ );+ }+ this.llmInstance = config.model as BaseLanguageModel;+ this.modelName =+ (this.llmInstance as any).modelId ||+ (this.llmInstance as any).model ||+ "langchain-model";+ }++ async generateResponse(+ messages: Message[],+ response_format?: { type: string },+ tools?: any[],+ ): Promise<string | LLMResponse> {+ const langchainMessages = convertToLangchainMessages(messages);+ let runnable: any = this.llmInstance;+ const invokeOptions: Record<string, any> = {};+ let isStructuredOutput = false;+ let selectedSchema: z.ZodSchema<any> | null = null;+ let isToolCallResponse = false;++ // --- Internal Schema Selection Logic (runs regardless of response_format) ---+ const systemPromptContent =+ (messages.find((m) => m.role === "system")?.content as string) || "";+ const userPromptContent =+ (messages.find((m) => m.role === "user")?.content as string) || "";+ const toolNames = tools?.map((t) => t.function.name) || [];++ // Prioritize tool call argument schemas+ if (toolNames.includes("extract_entities")) {+ selectedSchema = GraphExtractEntitiesArgsSchema;+ isToolCallResponse = true;+ } else if (toolNames.includes("establish_relationships")) {+ selectedSchema = GraphRelationsArgsSchema;+ isToolCallResponse = true;+ } else if (toolNames.includes("delete_graph_memory")) {+ selectedSchema = GraphSimpleRelationshipArgsSchema;+ isToolCallResponse = true;+ }+ // Check for memory prompts if no tool schema matched+ else if (+ systemPromptContent.includes("Personal Information Organizer") &&+ systemPromptContent.includes("extract relevant pieces of information")+ ) {+ selectedSchema = FactRetrievalSchema;+ } else if (+ userPromptContent.includes("smart memory manager") &&+ userPromptContent.includes("Compare newly retrieved facts")+ ) {+ selectedSchema = MemoryUpdateSchema;+ }++ // --- Apply Structured Output if Schema Selected ---+ if (+ selectedSchema &&+ typeof (this.llmInstance as any).withStructuredOutput === "function"+ ) {+ // Apply if a schema was selected (for memory or single tool calls)+ if (+ !isToolCallResponse ||+ (isToolCallResponse && tools && tools.length === 1)+ ) {+ try {+ runnable = (this.llmInstance as any).withStructuredOutput(+ selectedSchema,+ { name: tools?.[0]?.function.name },+ );+ isStructuredOutput = true;+ } catch (e) {+ isStructuredOutput = false; // Ensure flag is false on error+ // No fallback to response_format here unless explicitly passed+ if (response_format?.type === "json_object") {+ invokeOptions.response_format = { type: "json_object" };+ }+ }+ } else if (isToolCallResponse) {+ // If multiple tools, don't apply structured output, handle via tool binding below+ }+ } else if (selectedSchema && response_format?.type === "json_object") {+ // Schema selected, but no .withStructuredOutput. Try basic response_format only if explicitly requested.+ if (+ (this.llmInstance as any)._identifyingParams?.response_format ||+ (this.llmInstance as any).response_format+ ) {+ invokeOptions.response_format = { type: "json_object" };+ }+ } else if (!selectedSchema && response_format?.type === "json_object") {+ // Explicit JSON request, but no schema inferred. Try basic response_format.+ if (+ (this.llmInstance as any)._identifyingParams?.response_format ||+ (this.llmInstance as any).response_format+ ) {+ invokeOptions.response_format = { type: "json_object" };+ }+ }++ // --- Handle tool binding ---+ if (tools && tools.length > 0) {+ if (typeof (runnable as any).bindTools === "function") {+ try {+ runnable = (runnable as any).bindTools(tools);+ } catch (e) {}+ } else {+ }+ }++ // --- Invoke and Process Response ---+ try {+ const response = await runnable.invoke(langchainMessages, invokeOptions);++ if (isStructuredOutput && !isToolCallResponse) {+ // Memory prompt with structured output+ return JSON.stringify(response);+ } else if (isStructuredOutput && isToolCallResponse) {+ // Tool call with structured arguments+ if (response?.tool_calls && Array.isArray(response.tool_calls)) {+ const mappedToolCalls = response.tool_calls.map((call: any) => ({+ name: call.name || tools?.[0]?.function.name || "unknown_tool",+ arguments:+ typeof call.args === "string"+ ? call.args+ : JSON.stringify(call.args),+ }));+ return {+ content: response.content || "",+ role: "assistant",+ toolCalls: mappedToolCalls,+ };+ } else {+ // Direct object response for tool args+ return {+ content: "",+ role: "assistant",+ toolCalls: [+ {+ name: tools?.[0]?.function.name || "unknown_tool",+ arguments: JSON.stringify(response),+ },+ ],+ };+ }+ } else if (+ response &&+ response.tool_calls &&+ Array.isArray(response.tool_calls)+ ) {+ // Standard tool call response (no structured output used/failed)+ const mappedToolCalls = response.tool_calls.map((call: any) => ({+ name: call.name || "unknown_tool",+ arguments:+ typeof call.args === "string"+ ? call.args+ : JSON.stringify(call.args),+ }));+ return {+ content: response.content || "",+ role: "assistant",+ toolCalls: mappedToolCalls,+ };+ } else if (response && typeof response.content === "string") {+ // Standard text response+ return response.content;+ } else {+ // Fallback for unexpected formats+ return JSON.stringify(response);+ }+ } catch (error) {+ throw error;+ }+ }++ async generateChat(messages: Message[]): Promise<LLMResponse> {+ const langchainMessages = convertToLangchainMessages(messages);+ try {+ const response = await this.llmInstance.invoke(langchainMessages);+ if (response && typeof response.content === "string") {+ return {+ content: response.content,+ role: (response as BaseMessage).lc_id ? "assistant" : "assistant",+ };+ } else {+ console.warn(+ `Unexpected response format from Langchain instance (${this.modelName}) for generateChat:`,+ response,+ );+ return {+ content: JSON.stringify(response),+ role: "assistant",+ };+ }+ } catch (error) {+ console.error(+ `Error invoking Langchain instance (${this.modelName}) for generateChat:`,+ error,+ );+ throw error;+ }+ }+}diff --git a/mem0-ts/src/oss/src/memory/index.ts b/mem0-ts/src/oss/src/memory/index.tsindex 42e8e3508..1b43747ce 100644--- a/mem0-ts/src/oss/src/memory/index.ts+++ b/mem0-ts/src/oss/src/memory/index.ts@@ -43,7 +43,7 @@ export class Memory {private vectorStore: VectorStore;private llm: LLM;private db: HistoryManager;- private collectionName: string;+ private collectionName: string | undefined;private apiVersion: string;private graphMemory?: MemoryGraph;private enableGraph: boolean;@@ -241,12 +241,10 @@ export class Memory {}const parsedMessages = messages.map((m) => m.content).join("\n");- // Get promptsconst [systemPrompt, userPrompt] = this.customPrompt? [this.customPrompt, `Input:\n${parsedMessages}`]: getFactRetrievalMessages(parsedMessages);- // Extract facts using LLMconst response = await this.llm.generateResponse([{ role: "system", content: systemPrompt },@@ -255,8 +253,18 @@ export class Memory {{ type: "json_object" },);- const cleanResponse = removeCodeBlocks(response);- const facts = JSON.parse(cleanResponse).facts || [];+ const cleanResponse = removeCodeBlocks(response as string);+ let facts: string[] = [];+ try {+ facts = JSON.parse(cleanResponse).facts || [];+ } catch (e) {+ console.error(+ "Failed to parse facts from LLM response:",+ cleanResponse,+ e,+ );+ facts = [];+ }// Get embeddings for new factsconst newMessageEmbeddings: Record<string, number[]> = {};@@ -292,13 +300,24 @@ export class Memory {// Get memory update decisionsconst updatePrompt = getUpdateMemoryMessages(uniqueOldMemories, facts);+const updateResponse = await this.llm.generateResponse([{ role: "user", content: updatePrompt }],{ type: "json_object" },);- const cleanUpdateResponse = removeCodeBlocks(updateResponse);- const memoryActions = JSON.parse(cleanUpdateResponse).memory || [];+ const cleanUpdateResponse = removeCodeBlocks(updateResponse as string);+ let memoryActions: any[] = [];+ try {+ memoryActions = JSON.parse(cleanUpdateResponse).memory || [];+ } catch (e) {+ console.error(+ "Failed to parse memory actions from LLM response:",+ cleanUpdateResponse,+ e,+ );+ memoryActions = [];+ }// Process memory actionsconst results: MemoryItem[] = [];@@ -511,14 +530,47 @@ export class Memory {async reset(): Promise<void> {await this._captureEvent("reset");await this.db.reset();- await this.vectorStore.deleteCol();++ // Check provider before attempting deleteCol+ if (this.config.vectorStore.provider.toLowerCase() !== "langchain") {+ try {+ await this.vectorStore.deleteCol();+ } catch (e) {+ console.error(+ `Failed to delete collection for provider '${this.config.vectorStore.provider}':`,+ e,+ );+ // Decide if you want to re-throw or just log+ }+ } else {+ console.warn(+ "Memory.reset(): Skipping vector store collection deletion as 'langchain' provider is used. Underlying Langchain vector store data is not cleared by this operation.",+ );+ }+if (this.graphMemory) {- await this.graphMemory.deleteAll({ userId: "default" });+ await this.graphMemory.deleteAll({ userId: "default" }); // Assuming this is okay, or needs similar check?}++ // Re-initialize factories/clients based on the original config+ this.embedder = EmbedderFactory.create(+ this.config.embedder.provider,+ this.config.embedder.config,+ );+ // Re-create vector store instance - crucial for Langchain to reset wrapper state if neededthis.vectorStore = VectorStoreFactory.create(this.config.vectorStore.provider,- this.config.vectorStore.config,+ this.config.vectorStore.config, // This will pass the original client instance back);+ this.llm = LLMFactory.create(+ this.config.llm.provider,+ this.config.llm.config,+ );+ // Re-init DB if needed (though db.reset() likely handles its state)+ // Re-init Graph if needed++ // Re-initialize telemetry+ this._initializeTelemetry();}async getAll(config: GetAllMemoryOptions): Promise<SearchResult> {diff --git a/mem0-ts/src/oss/src/prompts/index.ts b/mem0-ts/src/oss/src/prompts/index.tsindex 8220d6f0c..ef8c79756 100644--- a/mem0-ts/src/oss/src/prompts/index.ts+++ b/mem0-ts/src/oss/src/prompts/index.ts@@ -1,3 +1,37 @@+import { z } from "zod";++// Define Zod schema for fact retrieval output+export const FactRetrievalSchema = z.object({+ facts: z+ .array(z.string())+ .describe("An array of distinct facts extracted from the conversation."),+});++// Define Zod schema for memory update output+export const MemoryUpdateSchema = z.object({+ memory: z+ .array(+ z.object({+ id: z.string().describe("The unique identifier of the memory item."),+ text: z.string().describe("The content of the memory item."),+ event: z+ .enum(["ADD", "UPDATE", "DELETE", "NONE"])+ .describe(+ "The action taken for this memory item (ADD, UPDATE, DELETE, or NONE).",+ ),+ old_memory: z+ .string()+ .optional()+ .describe(+ "The previous content of the memory item if the event was UPDATE.",+ ),+ }),+ )+ .describe(+ "An array representing the state of memory items after processing new facts.",+ ),+});+export function getFactRetrievalMessages(parsedMessages: string,): [string, string] {diff --git a/mem0-ts/src/oss/src/types/index.ts b/mem0-ts/src/oss/src/types/index.tsindex 3c15d668b..0cbd1c199 100644--- a/mem0-ts/src/oss/src/types/index.ts+++ b/mem0-ts/src/oss/src/types/index.ts@@ -14,13 +14,15 @@ export interface Message {export interface EmbeddingConfig {apiKey?: string;- model?: string;+ model?: string | any;url?: string;}export interface VectorStoreConfig {- collectionName: string;+ collectionName?: string;dimension?: number;+ client?: any;+ instance?: any;[key: string]: any;}@@ -38,7 +40,7 @@ export interface LLMConfig {provider?: string;config?: Record<string, any>;apiKey?: string;- model?: string;+ model?: string | any;modelProperties?: Record<string, any>;}@@ -110,24 +112,25 @@ export const MemoryConfigSchema = z.object({embedder: z.object({provider: z.string(),config: z.object({- apiKey: z.string(),- model: z.string().optional(),+ apiKey: z.string().optional(),+ model: z.union([z.string(), z.any()]).optional(),}),}),vectorStore: z.object({provider: z.string(),config: z.object({- collectionName: z.string(),+ collectionName: z.string().optional(),dimension: z.number().optional(),+ client: z.any().optional(),}).passthrough(),}),llm: z.object({provider: z.string(),config: z.object({- apiKey: z.string(),- model: z.string().optional(),+ apiKey: z.string().optional(),+ model: z.union([z.string(), z.any()]).optional(),modelProperties: z.record(z.string(), z.any()).optional(),}),}),diff --git a/mem0-ts/src/oss/src/utils/factory.ts b/mem0-ts/src/oss/src/utils/factory.tsindex f5dc222fc..db9c609f6 100644--- a/mem0-ts/src/oss/src/utils/factory.ts+++ b/mem0-ts/src/oss/src/utils/factory.ts@@ -26,6 +26,9 @@ import { HistoryManager } from "../storage/base";import { GoogleEmbedder } from "../embeddings/google";import { GoogleLLM } from "../llms/google";import { AzureOpenAILLM } from "../llms/azure";+import { LangchainLLM } from "../llms/langchain";+import { LangchainEmbedder } from "../embeddings/langchain";+import { LangchainVectorStore } from "../vector_stores/langchain";export class EmbedderFactory {static create(provider: string, config: EmbeddingConfig): Embedder {@@ -36,6 +39,8 @@ export class EmbedderFactory {return new OllamaEmbedder(config);case "google":return new GoogleEmbedder(config);+ case "langchain":+ return new LangchainEmbedder(config);default:throw new Error(`Unsupported embedder provider: ${provider}`);}@@ -44,7 +49,7 @@ export class EmbedderFactory {export class LLMFactory {static create(provider: string, config: LLMConfig): LLM {- switch (provider) {+ switch (provider.toLowerCase()) {case "openai":return new OpenAILLM(config);case "openai_structured":@@ -61,6 +66,8 @@ export class LLMFactory {return new AzureOpenAILLM(config);case "mistral":return new MistralLLM(config);+ case "langchain":+ return new LangchainLLM(config);default:throw new Error(`Unsupported LLM provider: ${provider}`);}@@ -73,11 +80,13 @@ export class VectorStoreFactory {case "memory":return new MemoryVectorStore(config);case "qdrant":- return new Qdrant(config as any); // Type assertion needed as config is extended+ return new Qdrant(config as any);case "redis":- return new RedisDB(config as any); // Type assertion needed as config is extended+ return new RedisDB(config as any);case "supabase":- return new SupabaseDB(config as any); // Type assertion needed as config is extended+ return new SupabaseDB(config as any);+ case "langchain":+ return new LangchainVectorStore(config as any);default:throw new Error(`Unsupported vector store provider: ${provider}`);}diff --git a/mem0-ts/src/oss/src/vector_stores/langchain.ts b/mem0-ts/src/oss/src/vector_stores/langchain.tsnew file mode 100644index 000000000..852ecaa44--- /dev/null+++ b/mem0-ts/src/oss/src/vector_stores/langchain.ts@@ -0,0 +1,231 @@+import { VectorStore as LangchainVectorStoreInterface } from "@langchain/core/vectorstores";+import { Document } from "@langchain/core/documents";+import { VectorStore } from "./base"; // mem0's VectorStore interface+import { SearchFilters, VectorStoreConfig, VectorStoreResult } from "../types";++// Config specifically for the Langchain wrapper+interface LangchainStoreConfig extends VectorStoreConfig {+ client: LangchainVectorStoreInterface;+ // dimension might still be useful for validation if not automatically inferred+}++export class LangchainVectorStore implements VectorStore {+ private lcStore: LangchainVectorStoreInterface;+ private dimension?: number;+ private storeUserId: string = "anonymous-langchain-user"; // Simple in-memory user ID++ constructor(config: LangchainStoreConfig) {+ if (!config.client || typeof config.client !== "object") {+ throw new Error(+ "Langchain vector store provider requires an initialized Langchain VectorStore instance passed via the 'client' field.",+ );+ }+ // Basic checks for core methods+ if (+ typeof config.client.addVectors !== "function" ||+ typeof config.client.similaritySearchVectorWithScore !== "function"+ ) {+ throw new Error(+ "Provided Langchain 'client' does not appear to be a valid Langchain VectorStore (missing addVectors or similaritySearchVectorWithScore method).",+ );+ }++ this.lcStore = config.client;+ this.dimension = config.dimension;++ // Attempt to get dimension from the underlying store if not provided+ if (+ !this.dimension &&+ (this.lcStore as any).embeddings?.embeddingDimension+ ) {+ this.dimension = (this.lcStore as any).embeddings.embeddingDimension;+ }+ if (+ !this.dimension &&+ (this.lcStore as any).embedding?.embeddingDimension+ ) {+ this.dimension = (this.lcStore as any).embedding.embeddingDimension;+ }+ // If still no dimension, we might need to throw or warn, as it's needed for validation+ if (!this.dimension) {+ console.warn(+ "LangchainVectorStore: Could not determine embedding dimension. Input validation might be skipped.",+ );+ }+ }++ // --- Method Mappings ---++ async insert(+ vectors: number[][],+ ids: string[],+ payloads: Record<string, any>[],+ ): Promise<void> {+ if (!ids || ids.length !== vectors.length) {+ throw new Error(+ "IDs array must be provided and have the same length as vectors.",+ );+ }+ if (this.dimension) {+ vectors.forEach((v, i) => {+ if (v.length !== this.dimension) {+ throw new Error(+ `Vector dimension mismatch at index ${i}. Expected ${this.dimension}, got ${v.length}`,+ );+ }+ });+ }++ // Convert payloads to Langchain Document metadata format+ const documents = payloads.map((payload, i) => {+ // Provide empty pageContent, store mem0 id and other data in metadata+ return new Document({+ pageContent: "", // Add required empty pageContent+ metadata: { ...payload, _mem0_id: ids[i] },+ });+ });++ // Use addVectors. Note: Langchain stores often generate their own internal IDs.+ // We store the mem0 ID in the metadata (`_mem0_id`).+ try {+ await this.lcStore.addVectors(vectors, documents, { ids }); // Pass mem0 ids if the store supports it+ } catch (e) {+ // Fallback if the store doesn't support passing ids directly during addVectors+ console.warn(+ "Langchain store might not support custom IDs on insert. Trying without IDs.",+ e,+ );+ await this.lcStore.addVectors(vectors, documents);+ }+ }++ async search(+ query: number[],+ limit: number = 5,+ filters?: SearchFilters, // filters parameter is received but will be ignored+ ): Promise<VectorStoreResult[]> {+ if (this.dimension && query.length !== this.dimension) {+ throw new Error(+ `Query vector dimension mismatch. Expected ${this.dimension}, got ${query.length}`,+ );+ }++ // --- Remove filter processing logic ---+ // Filters passed via mem0 interface are not reliably translatable to generic Langchain stores.+ // let lcFilter: any = undefined;+ // if (filters && ...) { ... }+ // console.warn("LangchainVectorStore: Passing filters directly..."); // Remove warning++ // Call similaritySearchVectorWithScore WITHOUT the filter argument+ const results = await this.lcStore.similaritySearchVectorWithScore(+ query,+ limit,+ // Do not pass lcFilter here+ );++ // Map Langchain results [Document, score] back to mem0 VectorStoreResult+ return results.map(([doc, score]) => ({+ id: doc.metadata._mem0_id || "unknown_id",+ payload: doc.metadata,+ score: score,+ }));+ }++ // --- Methods with No Direct Langchain Equivalent (Throwing Errors) ---++ async get(vectorId: string): Promise<VectorStoreResult | null> {+ // Most Langchain stores lack a direct getById. Simulation is inefficient.+ console.error(+ `LangchainVectorStore: The 'get' method is not directly supported by most Langchain VectorStores.`,+ );+ throw new Error(+ "Method 'get' not reliably supported by LangchainVectorStore wrapper.",+ );+ // Potential (inefficient) simulation:+ // Perform a search with a filter like { _mem0_id: vectorId }, limit 1.+ // This requires the underlying store to support filtering on _mem0_id.+ }++ async update(+ vectorId: string,+ vector: number[],+ payload: Record<string, any>,+ ): Promise<void> {+ // Updates often require delete + add in Langchain.+ console.error(+ `LangchainVectorStore: The 'update' method is not directly supported. Use delete followed by insert.`,+ );+ throw new Error(+ "Method 'update' not supported by LangchainVectorStore wrapper.",+ );+ // Possible implementation: Check if store has delete, call delete({_mem0_id: vectorId}), then insert.+ }++ async delete(vectorId: string): Promise<void> {+ // Check if the underlying store supports deletion by ID+ if (typeof (this.lcStore as any).delete === "function") {+ try {+ // We need to delete based on our stored _mem0_id.+ // Langchain's delete often takes its own internal IDs or filter.+ // Attempting deletion via filter is the most likely approach.+ console.warn(+ "LangchainVectorStore: Attempting delete via filter on '_mem0_id'. Success depends on the specific Langchain VectorStore's delete implementation.",+ );+ await (this.lcStore as any).delete({ filter: { _mem0_id: vectorId } });+ // OR if it takes IDs directly (less common for *our* IDs):+ // await (this.lcStore as any).delete({ ids: [vectorId] });+ } catch (e) {+ console.error(+ `LangchainVectorStore: Delete failed. Underlying store's delete method might expect different arguments or filters. Error: ${e}`,+ );+ throw new Error(`Delete failed in underlying Langchain store: ${e}`);+ }+ } else {+ console.error(+ `LangchainVectorStore: The underlying Langchain store instance does not seem to support a 'delete' method.`,+ );+ throw new Error(+ "Method 'delete' not available on the provided Langchain VectorStore client.",+ );+ }+ }++ async list(+ filters?: SearchFilters,+ limit: number = 100,+ ): Promise<[VectorStoreResult[], number]> {+ // No standard list method in Langchain core interface.+ console.error(+ `LangchainVectorStore: The 'list' method is not supported by the generic LangchainVectorStore wrapper.`,+ );+ throw new Error(+ "Method 'list' not supported by LangchainVectorStore wrapper.",+ );+ // Could potentially be implemented if the underlying store has a specific list/scroll/query capability.+ }++ async deleteCol(): Promise<void> {+ console.error(+ `LangchainVectorStore: The 'deleteCol' method is not supported by the generic LangchainVectorStore wrapper.`,+ );+ throw new Error(+ "Method 'deleteCol' not supported by LangchainVectorStore wrapper.",+ );+ }++ // --- Wrapper-Specific Methods (In-Memory User ID) ---++ async getUserId(): Promise<string> {+ return this.storeUserId;+ }++ async setUserId(userId: string): Promise<void> {+ this.storeUserId = userId;+ }++ async initialize(): Promise<void> {+ // No specific initialization needed for the wrapper itself,+ // assuming the passed Langchain client is already initialized.+ return Promise.resolve();+ }+}