Quick Start

Copyconstructor(config: Partial<MemoryConfig> = {}) {
  // Merge and validate config
  this.config = ConfigManager.mergeConfig(config);

Copyadd_memory: tool({
  description: "Add a new memory. This method is called everytime the user informs anything about themselves, their preferences, or anything that has any relevant information which can be useful in the future conversation. This can also be called when the user asks you to remember something. Set infer to false to store the memory verbatim without LLM fact extraction.",
  args: {
    text: tool.schema.string().describe("Memory text content"),
    user_id: tool.schema.string().optional().describe("User ID"),
    app_id: tool.schema.string().optional().describe("App/Project ID"),
    agent_id: tool.schema.string().optional().describe("Agent ID"),
    metadata: tool.schema.record(tool.schema.string(), tool.schema.any()).optional().describe("Metadata key-value pairs"),
    infer: tool.schema.boolean().optional().describe("Set to false to store memory verbatim without LLM fact extraction"),
    scope: tool.schema.string().optional().describe('Write scope: "project" (this repo, default), "session" (this run), or "global" (user-wide, all projects). Use "global" only when explicitly asked.')
  },

Copypip install mem0ai
npm install mem0ai @langchain/core @langchain/community

Copyimport { Mem0Memory } from "./mem0";
 
const memory = new Mem0Memory({
  sessionId: "user123",
  apiKey: "your-api-key",
  memoryOptions: {
    user_id: "user123",
  },
});

Copyimport { Mem0Memory } from "./mem0";
import { ChatOpenAI } from "@langchain/openai";
import { ConversationChain } from "langchain/chains";
 
const memory = new Mem0Memory({
  sessionId: "user123",
  apiKey: process.env.MEM0_API_KEY!,
  memoryOptions: {
    user_id: "user123",
  },
});
 
const model = new ChatOpenAI({
  modelName: "gpt-4o-mini",
  temperature: 0,
});
 
const chain = new ConversationChain({ llm: model, memory });

Copyexport const condenseMem0MemoryIntoHumanMessage = (
  memory: Memory[],
): HumanMessage => {
  const basePrompt =
    "These are the memories I have stored. Give more weightage to the question by users and try to answer that first. You have to modify your answer based on the memories I have provided. If the memories are irrelevant you can ignore them. Also don't reply to this section of the prompt, or the memories, they are only for your reference. The MEMORIES of the USER are: \n\n";
  const systemPrompt = mem0MemoryContextToSystemPrompt(memory);
 
  return new HumanMessage(`${basePrompt}\n${systemPrompt}`);
};

Copyexport const mem0MemoryToMessages = (memories: Memory[]): BaseMessage[] => {
  if (!memories || !Array.isArray(memories)) {
    return [];
  }
 
  const messages: BaseMessage[] = [];
 
  const memoryContent = memories
    .filter((m) => m?.memory)
    .map((m) => m.memory)
    .join("\n");
 
  if (memoryContent) {
    messages.push(new SystemMessage(memoryContent));
  }
 
  memories.forEach((memory) => {
    if (memory.messages) {
      memory.messages.forEach((msg) => {
        const content =
          typeof msg.content === "string"
            ? msg.content
            : JSON.stringify(msg.content);
        if (msg.role === "user") {
          messages.push(new HumanMessage(content));
        } else if (msg.role === "assistant") {
          messages.push(new AIMessage(content));
        } else if (content) {
          messages.push(new ChatMessage(content, msg.role));
        }
      });
    }
  });
 
  return messages;
};

Copyasync loadMemoryVariables(values: InputValues): Promise<MemoryVariables> {
  const searchType = values.input ? "search" : "get_all";
  let memories: Memory[] = [];
 
  try {
    if (searchType === "get_all") {
      memories = await this.mem0Client.getAll({
        user_id: this.sessionId,
        ...this.memoryOptions,
      });
    } else {
      memories = await this.mem0Client.search(values.input, {
        user_id: this.sessionId,
        ...this.memoryOptions,
      });
    }
  } catch (error) {
    console.error("Error loading memories:", error);
    return this.returnMessages
      ? { [this.memoryKey]: [] }
      : { [this.memoryKey]: "" };
  }
 
  if (this.returnMessages) {
    return {
      [this.memoryKey]: this.separateMessages
        ? mem0MemoryToMessages(memories)
        : [condenseMem0MemoryIntoHumanMessage(memories)],
    };
  }
 
  return {
    [this.memoryKey]: this.separateMessages
      ? getBufferString(
          mem0MemoryToMessages(memories),
          this.humanPrefix,
          this.aiPrefix,
        )
      : (condenseMem0MemoryIntoHumanMessage(memories).content ?? ""),
  };
}

Copyconst scopeParams = {
  userId: {
    type: "string",
    description:
      "Entity that owns the memory. Defaults to the plugin's configured userId; cross-user overrides require allowUserOverride in plugin configuration.",
  },
  agentId: {
    type: "string",
    description: "Optional agent scope, to partition memories by agent.",
  },
  runId: {
    type: "string",
    description: "Optional run/session scope, to partition memories by session.",
  },
} as const;

Copyexport class Mem0Memory extends BaseChatMemory implements Mem0MemoryInput {
  memoryKey = "history";
  apiKey: string;
  sessionId: string;
  humanPrefix = "Human";
  aiPrefix = "AI";
  mem0Client: InstanceType<typeof MemoryClient>;
  memoryOptions: AddMemoryOptions | SearchMemoryOptions | GetAllMemoryOptions;
  mem0Options: ClientOptions;
  separateMessages?: boolean;

Copyexport const condenseMem0MemoryIntoHumanMessage = (
  memory: Memory[],
): HumanMessage => {
  const basePrompt =
    "These are the memories I have stored. Give more weightage to the question by users and try to answer that first. You have to modify your answer based on the memories I have provided. If the memories are irrelevant you can ignore them. Also don't reply to this section of the prompt, or the memories, they are only for your reference. The MEMORIES of the USER are: \n\n";
  const systemPrompt = mem0MemoryContextToSystemPrompt(memory);
 
  return new HumanMessage(`${basePrompt}\n${systemPrompt}`);
};

Copyconst updateMemories = async (messages: Array<Message>, config?: Mem0ConfigSettings) => {
    try {
        const apiKey = loadApiKey({
            apiKey: config?.mem0ApiKey,
            environmentVariableName: "MEM0_API_KEY",
            description: "Mem0",
        });
 
        const body: Record<string, any> = { messages };
        if (config?.user_id) body.user_id = config.user_id;
        if (config?.app_id) body.app_id = config.app_id;
        if (config?.agent_id) body.agent_id = config.agent_id;
        if (config?.run_id) body.run_id = config.run_id;
        if (config?.metadata) body.metadata = config.metadata;
        if (config?.infer != null) body.infer = config.infer;
 
        const options = {
            method: 'POST',
            headers: {
                Authorization: `Token ${apiKey}`,
                'Content-Type': 'application/json',
                // Surface attribution. Set-once by contract: this wrapper is the
                // outermost layer on these raw fetch calls.
                'X-Mem0-Source': 'VERCEL_AI_SDK',
                'X-Mem0-Client': `mem0-vercel-ai-provider/${PROVIDER_VERSION}`
            },
            body: JSON.stringify(body),
        };
 
        const baseUrl = config?.host || 'https://api.mem0.ai';
        const response = await fetch(`${baseUrl}/v3/memories/add/`, options);
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        const data = await response.json();
        return data;
    } catch (error) {
        console.error("Error in updateMemories:", error);
        throw error;
    }
}

Copyconst getMemories = async (prompt: LanguageModelV3Prompt | string, config?: Mem0ConfigSettings) => {
    try {
        const message = typeof prompt === 'string' ? prompt : flattenPrompt(prompt);
        const data = await searchInternalMemories(message, config);
        // Normalize: always return a flat array regardless of API response shape
        return Array.isArray(data) ? data : (data?.results ?? []);
    } catch (error) {
        console.error("Error in getMemories:", error);
        throw error;
    }
}

Copyclass Mem0:
    def __init__(
        self,
        config: Optional[dict] = None,
        api_key: Optional[str] = None,
        host: Optional[str] = None,
    ):
        if api_key:
            self.mem0_client = MemoryClient(api_key, host)
        else:
            self.mem0_client = Memory.from_config(config) if config else Memory()
 
        self.chat = Chat(self.mem0_client)
 

Copyprepared_messages = self._prepare_messages(messages)
if prepared_messages[-1]["role"] == "user":
    self._async_add_to_memory(messages, user_id, agent_id, run_id, metadata, filters)
    relevant_memories = self._fetch_relevant_memories(messages, user_id, agent_id, run_id, filters, top_k)
    logger.debug(f"Retrieved {len(relevant_memories)} relevant memories")
    prepared_messages[-1]["content"] = self._format_query_with_memories(messages, relevant_memories)
 

Copydef _format_query_with_memories(self, messages, relevant_memories):
    # Check if self.mem0_client is an instance of Memory or MemoryClient
 
    entities = []
    if isinstance(self.mem0_client, mem0.memory.main.Memory):
        memories_text = "\n".join(memory["memory"] for memory in relevant_memories["results"])
        if relevant_memories.get("relations"):
            entities = [entity for entity in relevant_memories["relations"]]
    elif isinstance(self.mem0_client, mem0.client.main.MemoryClient):
        memories_text = "\n".join(memory["memory"] for memory in relevant_memories)
    return f"- Relevant Memories/Facts: {memories_text}\n\n- Entities: {entities}\n\n- User Question: {messages[-1]['content']}"

Copyexport const name = "mem0";
export const inject = ["tools", "systemPrompt"];

Copyexport function apply(ctx: Context, config: Config): void {
  const apiKey = config.apiKey ?? process.env.MEM0_API_KEY;
  if (!apiKey) {
    throw new Error("deepseek-plugin: set config.apiKey or the MEM0_API_KEY env var");
  }
  const userId = config.userId?.trim();
  if (!userId || /^\*+$/.test(userId)) {
    throw new Error("deepseek-plugin: config.userId is required");
  }

Copyconst sessionStates = new WeakMap<object, SessionState>();
const stateFor = (session: object): SessionState => {
  let state = sessionStates.get(session);
  if (!state) {
    const lifecycle = createMemoryLifecycle({ recallHeading: USER_RECALL_HEADING });
    lifecycle.beginSession();
    state = { lifecycle, messages: [] };
    sessionStates.set(session, state);
  }
  return state;
};

Copyif (config.autoRecall !== false) {
  ctx.on("system-prompt/assemble", async (_input, context, next): Promise<PromptAssembly> => {
    const assembly = await next();
    const { agent, signal } = context;
    if (!agent || signal?.aborted) return assembly;
 
    const state = stateFor(agent.session);
    const prompt = state.lifecycle.prepareConversation(
      agent.session
        .deriveMessages()
        .filter((message) => message.role === "user" && message.source?.kind === "user"),
    ).at(-1)?.content;
    if (!prompt) return assembly;
 
    const memoryContext = await state.lifecycle.recall(prompt, true, async (query) => {
      const started = Date.now();
      try {
        const result = await client.search(query, {
          filters: resolveSearchFilters({}, userId),
          topK: AUTO_RECALL_LIMIT,
        });