Mem0 Vercel Ai Sdk

Mem0 Vercel AI SDK Provider

Memory-enhanced AI provider for Vercel AI SDK. Automatically retrieves and stores memories during LLM calls.

Step 1: Install

npm install @mem0/vercel-ai-provider ai

Step 2: Set up environment variables

export MEM0_API_KEY="m0-xxx"
export OPENAI_API_KEY="sk-xxx"   # or ANTHROPIC_API_KEY, GOOGLE_API_KEY, etc.

Get a Mem0 API key at: https://app.mem0.ai/dashboard/api-keys?utm_source=oss&utm_medium=skill-mem0-vercel-ai-sdk

Pattern 1: Wrapped Model

The wrapped model approach is the simplest. createMem0 returns a provider that wraps any supported LLM with automatic memory retrieval and storage.

import { generateText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0();
const { text } = await generateText({
  model: mem0("gpt-5-mini", { user_id: "alice" }),
  prompt: "Recommend a restaurant",
});

What happens under the hood: 1. The prompt is sent to Mem0 search (POST /v3/memories/search/) to retrieve relevant memories 2. Retrieved memories are injected as a system message at the start of the prompt 3. The underlying LLM (e.g., OpenAI gpt-5-mini) generates a response using the enriched prompt 4. The conversation is stored back to Mem0 (POST /v3/memories/add/) as a fire-and-forget async call (no await)

Pattern 2: Standalone Utilities

Use standalone utilities when you want full control over the memory retrieve/store cycle, or you want to use a provider that is already configured separately.

import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";
import { retrieveMemories, addMemories } from "@mem0/vercel-ai-provider";

const prompt = "Recommend a restaurant";

// Retrieve memories -- returns a formatted system prompt string
const memories = await retrieveMemories(prompt, {
  user_id: "alice",
  mem0ApiKey: "m0-xxx",
});

// Generate using any provider with injected memories
const { text } = await generateText({
  model: openai("gpt-5-mini"),
  prompt,
  system: memories,
});

// Optionally store the conversation back
await addMemories(
  [
    { role: "user", content: [{ type: "text", text: prompt }] },
    { role: "assistant", content: [{ type: "text", text }] },
  ],
  { user_id: "alice", mem0ApiKey: "m0-xxx" }
);

Pattern 3: Streaming

Use streamText for streaming responses with memory augmentation:

import { streamText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0();
const result = streamText({
  model: mem0("gpt-5-mini", { user_id: "alice" }),
  prompt: "What should I cook for dinner?",
});

for await (const chunk of result.textStream) {
  process.stdout.write(chunk);
}

The wrapped model handles memory retrieval before streaming begins and stores the conversation after.

Supported Providers

Select a provider when creating the Mem0 instance:

const mem0 = createMem0({ provider: "anthropic" });
const { text } = await generateText({
  model: mem0("gpt-5-mini", { user_id: "alice" }),
  prompt: "Hello!",
});

How It Works Internally

Wrapped model flow

User prompt
  --> searchInternalMemories (POST /v3/memories/search/)
  --> memories injected as system message at start of prompt
  --> underlying LLM generates response (doGenerate or doStream)
  --> processMemories fires addMemories as fire-and-forget (no await)
  --> response returned to caller

Standalone flow

User controls each step:
  1. retrieveMemories / getMemories / searchMemories -> fetch memories
  2. inject into system prompt manually
  3. call generateText / streamText with any provider
  4. addMemories -> store new conversation to Mem0

Key Differences Between the 4 Utility Functions

All four accept LanguageModelV2Prompt | string as the first argument and optional Mem0ConfigSettings as the second.

Common Edge Cases and Tips

• Always provide `user_id` (or agent_id/app_id/run_id) for consistent memory retrieval. Without an entity identifier, memories cannot be scoped.
• Standalone utilities require explicit API key: pass mem0ApiKey in the config object, or set the MEM0_API_KEY environment variable.
• This uses Vercel AI SDK v5 (LanguageModelV2 / ProviderV2 interfaces). It is not compatible with AI SDK v3 or v4.
• `processMemories` fires `addMemories` as fire-and-forget (.then() without await). Memory storage happens asynchronously and does not block the LLM response.
• The `"gemini"` alias exists in the provider switch but is NOT in the supportedProviders list. Use "google" instead.
• Custom host: set host in the config to point to a different Mem0 API endpoint (default: https://api.mem0.ai).

References

Related Mem0 Skills

Mem0 Vercel AI SDK Skill for Claude

Add persistent memory to any Vercel AI SDK application using @mem0/vercel-ai-provider.

What This Skill Does

When installed, Claude can:

• Set up `@mem0/vercel-ai-provider` in your TypeScript or Next.js project
• Generate working code using the wrapped model (createMem0) or standalone utilities (retrieveMemories, addMemories, etc.)
• Configure multi-provider setups (OpenAI, Anthropic, Google, Groq, Cohere)
• Integrate memory into streaming responses, structured output, and API routes

Installation

CLI (Claude Code, OpenCode, OpenClaw, or any tool that supports skills)

npx skills add https://github.com/mem0ai/mem0 --skill mem0-vercel-ai-sdk

Claude.ai

1. Download this skills/mem0-vercel-ai-sdk folder as a ZIP 2. Go to Settings > Capabilities > Skills 3. Click Upload skill and select the ZIP

Claude API (Skills API)

curl -X POST https://api.anthropic.com/v1/skills \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "mem0-vercel-ai-sdk", "source": "https://github.com/mem0ai/mem0/tree/main/skills/mem0-vercel-ai-sdk"}'

Prerequisites

• Node.js 18+
• Vercel AI SDK v5 (ai package version 5.x)
• A Mem0 Platform API key (Get one here)
• An LLM provider API key (OpenAI, Anthropic, Google, Groq, or Cohere)
• Set environment variables:

  export MEM0_API_KEY="m0-xxx"
  export OPENAI_API_KEY="sk-xxx"  # or your chosen provider's key

Quick Start

After installing, just ask Claude:

• "Add memory to my Vercel AI SDK app"
• "Set up mem0 with streamText in my Next.js API route"
• "Use retrieveMemories with Anthropic instead of the wrapped model"
• "Show me how to use graph memories with the Vercel AI provider"
• "Help me store conversation history with addMemories"

What's Inside

skills/mem0-vercel-ai-sdk/
├── SKILL.md                          # Skill definition and instructions
├── README.md                         # This file
├── LICENSE                           # Apache-2.0
└── references/                       # Documentation (loaded on demand)
    ├── provider-api.md               # createMem0, Mem0Provider, types, config
    ├── memory-utilities.md           # addMemories, retrieveMemories, getMemories, searchMemories
    └── usage-patterns.md             # Working examples: streaming, Next.js, multi-provider, graph

Links

• Mem0 Platform Dashboard
• Mem0 Documentation
• Mem0 GitHub
• @mem0/vercel-ai-provider on npm
• Vercel AI SDK Documentation

Skill Graph

This skill is part of the Mem0 skill graph. The three Mem0 skills (mem0, mem0-cli, mem0-vercel-ai-sdk) each cover a different interface to the same Mem0 Platform API.

License

Apache-2.0

Memory Utilities Reference

Complete reference for standalone utility functions exported from @mem0/vercel-ai-provider. These functions give you manual control over memory retrieval and storage, independent of the wrapped model pattern.

Source: integrations/vercel-ai-sdk/src/mem0-utils.ts

addMemories(messages, config?)

Stores messages to Mem0 as new memories.

import { addMemories } from "@mem0/vercel-ai-provider";

await addMemories(
  [
    { role: "user", content: [{ type: "text", text: "I love Italian food" }] },
    { role: "assistant", content: [{ type: "text", text: "Noted! I'll remember that." }] },
  ],
  { user_id: "alice", mem0ApiKey: "m0-xxx" }
);

Signature:

async function addMemories(
  messages: LanguageModelV2Prompt | string,
  config?: Mem0ConfigSettings
): Promise<any>;

Parameters:

Behavior: 1. If messages is a string, wraps it as a single user message 2. Otherwise, converts LanguageModelV2Prompt to Mem0 format via convertToMem0Format (handles multimodal content) 3. Calls POST /v1/memories/ with the converted messages and config

Returns: The API response from Mem0 (memory operation result).

---

retrieveMemories(prompt, config?)

Retrieves memories and returns a formatted system prompt string ready to inject into a system parameter.

import { retrieveMemories } from "@mem0/vercel-ai-provider";

const systemPrompt = await retrieveMemories("What restaurants do I like?", {
  user_id: "alice",
  mem0ApiKey: "m0-xxx",
});
// Returns: "System Message: These are the memories I have stored... Memory: User loves Italian food\n\n ..."

Signature:

async function retrieveMemories(
  prompt: LanguageModelV2Prompt | string,
  config?: Mem0ConfigSettings
): Promise<string>;

Parameters:

Behavior: 1. Flattens the prompt to a plain string (extracts text from LanguageModelV2Prompt parts) 2. Calls searchInternalMemories (POST /v2/memories/search/) 3. Formats each memory as "Memory: {memory.memory}\n\n" 4. Wraps everything in a system prompt preamble

Returns: A string containing the formatted system prompt with embedded memories. Returns "" (empty string) if no memories found.

Output format:

System Message: 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 System prompt starts after text System Message:

Memory: User loves Italian food

Memory: User is vegetarian

---

getMemories(prompt, config?)

Retrieves memories and returns the raw memory array.

import { getMemories } from "@mem0/vercel-ai-provider";

const memories = await getMemories("What are my preferences?", {
  user_id: "alice",
  mem0ApiKey: "m0-xxx",
});
// Returns: [{ memory: "User loves Italian food", id: "...", ... }, ...]

Signature:

async function getMemories(
  prompt: LanguageModelV2Prompt | string,
  config?: Mem0ConfigSettings
): Promise<any>;

Parameters:

Behavior: 1. Flattens the prompt to a plain string 2. Calls searchInternalMemories (POST /v2/memories/search/) 3. Returns memories.results (the array of memory objects)

Returns: Memory object array.

---

searchMemories(prompt, config?)

Retrieves the full search API response including results, relations, scores, and metadata.

import { searchMemories } from "@mem0/vercel-ai-provider";

const response = await searchMemories("cooking preferences", {
  user_id: "alice",
  mem0ApiKey: "m0-xxx",
});
// Returns: { results: [{ memory: "...", score: 0.95, ... }], relations: [...] }

Signature:

async function searchMemories(
  prompt: LanguageModelV2Prompt | string,
  config?: Mem0ConfigSettings
): Promise<any>;

Parameters:

Behavior: 1. Flattens the prompt to a plain string 2. Calls searchInternalMemories (POST /v2/memories/search/) 3. Returns the full response without any filtering

Returns: The complete API response object. On error, returns [].

Note: Unlike getMemories, this always returns the full response.

---

When to Use Which Function

Internal: searchInternalMemories(query, config?, top_k?)

Not exported. Used by all retrieval functions.

async function searchInternalMemories(
  query: string,
  config?: Mem0ConfigSettings,
  top_k: number = 5
): Promise<any>;

Behavior: 1. Builds a filters object from entity identifiers (user_id, app_id, agent_id, run_id) 2. Resolves entity identifiers 3. Loads the API key from config.mem0ApiKey or MEM0_API_KEY env var 4. Calls POST {host}/v2/memories/search/ with:

• query: the search string
• filters: the filter object with entity identifiers
• top_k: from config or default 5
• All other config fields spread into the request body

Default host: https://api.mem0.ai

Internal: convertToMem0Format(messages)

Not exported. Used by addMemories to convert LanguageModelV2Prompt messages to Mem0's format.

Multimodal content mapping:

The function handles three message content shapes: 1. String content: passed through directly 2. Array content: each element mapped individually, nulls filtered out 3. Single object content: mapped as a single element

Internal: flattenPrompt(prompt)

Not exported. Extracts plain text from LanguageModelV2Prompt for use as a search query.

• Iterates over prompt parts, extracting text from user role messages
• For text type content: extracts .text
• For file type content: returns descriptive placeholders ([PDF document], [Markdown document], [Image], [File attachment])
• For other content types: returns [multimodal content]
• Joins all parts with spaces

Mem0ConfigSettings Fields Reference

All fields are optional. Used across all utility functions.

Provider API Reference

Complete reference for the @mem0/vercel-ai-provider provider layer. Source: integrations/vercel-ai-sdk/src/.

createMem0(options?)

Factory function that creates a Mem0Provider instance. This is the primary entry point for the wrapped model approach.

import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0();                           // defaults: provider "openai"
const mem0 = createMem0({ provider: "anthropic" });  // use Anthropic as LLM backend

Signature:

function createMem0(options?: Mem0ProviderSettings): Mem0Provider;

When called with no arguments, defaults to { provider: "openai" }.

Returns: Mem0Provider -- a callable function that also exposes .chat(), .completion(), and .languageModel() methods.

Mem0Provider Interface

Implements ProviderV2 from @ai-sdk/provider.

interface Mem0Provider extends ProviderV2 {
  // Call directly as a function
  (modelId: Mem0ChatModelId, settings?: Mem0ChatSettings): LanguageModelV2;

  // Or use named methods
  chat(modelId: Mem0ChatModelId, settings?: Mem0ChatSettings): LanguageModelV2;
  completion(modelId: Mem0ChatModelId, settings?: Mem0ChatSettings): LanguageModelV2;
  languageModel(modelId: Mem0ChatModelId, settings?: Mem0ChatSettings): LanguageModelV2;
}

• Direct call (mem0("gpt-5-mini", {...})): creates a generic language model (neither chat nor completion mode forced).
• `chat()`: creates a model with modelType: "chat" (note: in the current source, the chat constructor sets modelType: "completion" -- this appears to be a bug; functionally equivalent to completion() at present).
• `completion()`: creates a model with modelType: "completion".
• `languageModel()`: alias for the generic model (same as direct call).

All three return a Mem0GenericLanguageModel instance implementing LanguageModelV2.

Mem0ProviderSettings Interface

Configuration passed to createMem0().

interface Mem0ProviderSettings {
  baseURL?: string;            // Base URL for the LLM provider (default: "http://api.openai.com")
  headers?: Record<string, string>;  // Custom headers for LLM requests
  provider?: string;           // LLM provider name (default: "openai")
  mem0ApiKey?: string;         // Mem0 Platform API key (or use MEM0_API_KEY env var)
  apiKey?: string;             // LLM provider API key (e.g., OpenAI key)
  mem0Config?: Mem0Config;     // Default Mem0 config (user_id, etc.) applied to all calls
  config?: LLMProviderSettings; // Provider-specific settings (OpenAI, Anthropic, etc.)
  fetch?: typeof fetch;        // Custom fetch implementation (for testing/middleware)
  generateId?: () => string;   // Custom ID generator (internal use)
  name?: string;               // Provider instance name
  modelType?: "completion" | "chat";  // Force model type
}

Key fields explained

mem0 Singleton

A pre-configured instance using default settings (OpenAI provider, no API keys set -- relies on env vars).

import { mem0 } from "@mem0/vercel-ai-provider";

const { text } = await generateText({
  model: mem0("gpt-5-mini", { user_id: "alice" }),
  prompt: "Hello",
});

Equivalent to createMem0() with no arguments.

Mem0ConfigSettings Interface

Configuration for memory operations. Used as Mem0ChatSettings (per-call) or Mem0Config (provider-level default). All fields are optional.

interface Mem0ConfigSettings {
  user_id?: string;              // Scope memories to a specific user
  app_id?: string;               // Scope memories to an application
  agent_id?: string;             // Scope memories to an agent
  run_id?: string;               // Scope memories to a specific run/session
  metadata?: Record<string, any>; // Custom metadata attached to memories
  filters?: Record<string, any>; // Custom filters for memory search
  infer?: boolean;               // Enable inference during memory operations
  page?: number;                 // Pagination: page number
  page_size?: number;            // Pagination: results per page
  mem0ApiKey?: string;           // Mem0 API key (overrides provider-level key)
  top_k?: number;                // Number of memories to retrieve (default: 5)
  threshold?: number;            // Minimum similarity score for retrieval (default: 0.1)
  rerank?: boolean;              // Enable re-ranking of search results (default: false)
  host?: string;                 // Custom Mem0 API host (default: "https://api.mem0.ai")
}

Mem0ChatConfig Type

Combined type used internally by the language model. Merges memory config with provider config.

interface Mem0ChatConfig extends Mem0ConfigSettings, Mem0ProviderSettings {}

This means a Mem0ChatConfig has all fields from both Mem0ConfigSettings and Mem0ProviderSettings.

Mem0ChatSettings Type

Alias for Mem0ConfigSettings. Passed as the second argument when creating a model:

mem0("gpt-5-mini", { user_id: "alice" })
//                   ^^^^^^^^^^^^^^^^^^
//                   This object is Mem0ChatSettings

LLMProviderSettings Type

Union of provider-specific settings. Extends all supported provider setting interfaces:

interface LLMProviderSettings extends
  OpenAIProviderSettings,
  AnthropicProviderSettings,
  CohereProviderSettings,
  GroqProviderSettings {}

Pass via the config field of Mem0ProviderSettings to forward settings to the underlying LLM provider SDK.

Provider Selection: Mem0ClassSelector

Internal class that maps the provider string to the correct AI SDK provider.

class Mem0ClassSelector {
  static supportedProviders = ["openai", "anthropic", "cohere", "groq", "google"];
  // ...
}

Important: The "gemini" alias exists in the provider switch statement (maps to createGoogleGenerativeAI) but is NOT in the supportedProviders list. The constructor validates against supportedProviders, so using "gemini" will throw "Model not supported: gemini". Use "google" instead.

Provider mapping

Mem0 Facade Class

An alternative exported class that creates models directly without the callable-function pattern.

import { Mem0 } from "@mem0/vercel-ai-provider";

const mem0 = new Mem0({ provider: "openai" });
const chatModel = mem0.chat("gpt-5-mini", { user_id: "alice" });
const completionModel = mem0.completion("gpt-5-mini");

The facade defaults its base URL to "http://127.0.0.1:11434/api" (Ollama-style) rather than "http://api.openai.com". It always uses "openai" as the provider for created models.

Methods:

• chat(modelId, settings?) -- creates a model with modelType: "chat"
• completion(modelId, settings?) -- creates a model with modelType: "completion"

Mem0GenericLanguageModel Class

The core class implementing LanguageModelV2. Created by createMem0 or the Mem0 facade.

class Mem0GenericLanguageModel implements LanguageModelV2 {
  readonly specificationVersion = "v2";
  readonly defaultObjectGenerationMode = "json";
  readonly supportsImageUrls = false;
  readonly supportedUrls: Record<string, RegExp[]> = { '*': [/.*/] };

  provider: string;   // e.g., "openai"
  modelId: string;    // e.g., "gpt-5-mini"
  settings: Mem0ChatSettings;
  config: Mem0ChatConfig;

  async doGenerate(options: LanguageModelV2CallOptions): Promise<...>;
  async doStream(options: LanguageModelV2CallOptions): Promise<...>;
}

Both doGenerate and doStream follow the same internal flow:

1. Build Mem0ConfigSettings from config.mem0Config merged with settings 2. Call processMemories:

• Fire addMemories as fire-and-forget (no await, .then().catch())
• Await getMemories to retrieve relevant memories
• Format memories as a system message and prepend to the prompt

3. Create the underlying LLM model via Mem0ClassSelector 4. Delegate to the underlying model's doGenerate or doStream 5. Return the result

Note: Entity identifier fields use snake_case (user_id, app_id, agent_id, run_id) to match the Mem0 API.

Type: Mem0ChatModelId

type Mem0ChatModelId = string & NonNullable<unknown>;

Any non-null string. The model ID is passed through to the underlying provider (e.g., "gpt-5-mini", "gemini-pro").

Usage Patterns and Examples

Working examples for @mem0/vercel-ai-provider. All examples assume environment variables MEM0_API_KEY and the relevant LLM provider API key are set.

1. Wrapped Model with generateText (Basic)

The simplest way to add memory to any LLM call.

import { generateText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0();

const { text } = await generateText({
  model: mem0("gpt-5-mini", { user_id: "alice" }),
  prompt: "Recommend a restaurant based on my preferences",
});

console.log(text);

Memories are automatically retrieved before the call and stored after.

2. Wrapped Model with streamText (Streaming)

Stream responses with automatic memory augmentation.

import { streamText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0();

const result = streamText({
  model: mem0("gpt-5-mini", { user_id: "alice" }),
  prompt: "What should I cook for dinner tonight?",
});

for await (const chunk of result.textStream) {
  process.stdout.write(chunk);
}

Memory retrieval happens before streaming begins. The conversation is stored to Mem0 as a fire-and-forget call (non-blocking).

3. Standalone Utilities with OpenAI

Full control over the memory lifecycle using standalone functions with OpenAI.

import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";
import { retrieveMemories, addMemories } from "@mem0/vercel-ai-provider";

const user_id = "alice";
const prompt = "Suggest a weekend trip";

// Step 1: Retrieve memories as a formatted system prompt
const memories = await retrieveMemories(prompt, {
  user_id: user_id,
});

// Step 2: Generate with the memories injected as system context
const { text } = await generateText({
  model: openai("gpt-5-mini"),
  prompt,
  system: memories,
});

console.log(text);

// Step 3: Store the conversation as new memories
await addMemories(
  [
    { role: "user", content: [{ type: "text", text: prompt }] },
    { role: "assistant", content: [{ type: "text", text }] },
  ],
  { user_id: user_id }
);

4. Standalone Utilities with Anthropic

Same pattern, different LLM provider.

import { anthropic } from "@ai-sdk/anthropic";
import { generateText } from "ai";
import { retrieveMemories, addMemories } from "@mem0/vercel-ai-provider";

const prompt = "Help me plan my exercise routine";
const config = { user_id: "bob" };

const memories = await retrieveMemories(prompt, config);

const { text } = await generateText({
  model: anthropic("claude-sonnet-4-20250514"),
  prompt,
  system: memories,
});

await addMemories(
  [
    { role: "user", content: [{ type: "text", text: prompt }] },
    { role: "assistant", content: [{ type: "text", text }] },
  ],
  config
);

5. Structured Output with generateObject

Use with generateObject for typed, structured responses enriched with memory.

import { generateObject } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";
import { z } from "zod";

const mem0 = createMem0();

const { object } = await generateObject({
  model: mem0("gpt-5-mini", { user_id: "alice" }),
  prompt: "Suggest a meal plan for today",
  schema: z.object({
    breakfast: z.string(),
    lunch: z.string(),
    dinner: z.string(),
    snacks: z.array(z.string()),
    notes: z.string().describe("Personalization notes based on known preferences"),
  }),
});

console.log(object);
// { breakfast: "Avocado toast (you mentioned loving it)", lunch: "...", ... }

The defaultObjectGenerationMode is "json", so structured output works out of the box.

6. Multi-Provider Setup

Configure different LLM providers with the wrapped model.

OpenAI (default)

import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0(); // defaults to "openai"
const model = mem0("gpt-5-mini", { user_id: "alice" });

Anthropic

const mem0 = createMem0({ provider: "anthropic" });
const model = mem0("claude-sonnet-4-20250514", { user_id: "alice" });

Google

const mem0 = createMem0({ provider: "google" });
const model = mem0("gemini-2.0-flash", { user_id: "alice" });

Groq

const mem0 = createMem0({ provider: "groq" });
const model = mem0("llama-3.3-70b-versatile", { user_id: "alice" });

Cohere

const mem0 = createMem0({ provider: "cohere" });
const model = mem0("command-r-plus", { user_id: "alice" });

With explicit API keys (no env vars)

const mem0 = createMem0({
  provider: "openai",
  apiKey: "sk-xxx",       // OpenAI API key
  mem0ApiKey: "m0-xxx",   // Mem0 API key
});

7. Next.js API Route Integration

A POST handler that uses the wrapped model in a Next.js App Router API route.

// app/api/chat/route.ts
import { streamText } from "ai";
import { createMem0 } from "@mem0/vercel-ai-provider";

const mem0 = createMem0();

export async function POST(req: Request) {
  const { messages, user_id } = await req.json();

  const lastMessage = messages[messages.length - 1];

  const result = streamText({
    model: mem0("gpt-5-mini", { user_id }),
    prompt: lastMessage.content,
  });

  return result.toDataStreamResponse();
}

With standalone utilities for more control

// app/api/chat/route.ts
import { openai } from "@ai-sdk/openai";
import { streamText } from "ai";
import { retrieveMemories, addMemories } from "@mem0/vercel-ai-provider";

export async function POST(req: Request) {
  const { messages, user_id } = await req.json();
  const lastMessage = messages[messages.length - 1];

  // Retrieve relevant memories
  const memories = await retrieveMemories(lastMessage.content, {
    user_id,
  });

  // Stream the response
  const result = streamText({
    model: openai("gpt-5-mini"),
    prompt: lastMessage.content,
    system: memories,
  });

  // Store conversation in the background (fire-and-forget)
  result.text.then(async (text) => {
    await addMemories(
      [
        { role: "user", content: [{ type: "text", text: lastMessage.content }] },
        { role: "assistant", content: [{ type: "text", text }] },
      ],
      { user_id }
    );
  });

  return result.toDataStreamResponse();
}

8. How Memory Processing Works Internally

Wrapped model flow (doGenerate / doStream)

1. doGenerate(options) or doStream(options) is called
2. processMemories(messagesPrompts, mem0Config):
   a. addMemories(messagesPrompts, mem0Config)
      --> fire-and-forget: .then().catch(), NO await
      --> POST /v3/memories/add/ with converted messages
   b. await getMemories(messagesPrompts, mem0Config)
      --> POST /v3/memories/search/ with flattened prompt
      --> returns memory array
   c. Format memories into system message string
   d. Prepend system message to messagesPrompts array
   e. Return { memories, messagesPrompts }
3. Create underlying LLM via Mem0ClassSelector.createProvider()
4. Call model.doGenerate(updatedOptions) or model.doStream(updatedOptions)
5. Return result

Critical detail: The addMemories call in step 2a is NON-BLOCKING. It uses .then().catch() without await, meaning:

• Memory storage happens asynchronously in the background
• The LLM response is not delayed by the memory write
• If the memory write fails, it logs an error but does not affect the response
• There is a brief window where the latest conversation is not yet stored

Memory injection format

The memories are injected as a system message at position 0 of the prompt array:

{
  role: "system",
  content: "System Message: 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 System prompt starts after text System Message: \n\n Memory: ... \n\n Memory: ... \n\n"
}

9. Custom Configuration

Custom Mem0 API host

const mem0 = createMem0({
  mem0Config: {
    host: "https://my-mem0-instance.example.com",
  },
});

Or with standalone utilities:

const memories = await retrieveMemories(prompt, {
  user_id: "alice",
  host: "https://my-mem0-instance.example.com",
});

Memory filtering and ranking

const mem0 = createMem0();
const model = mem0("gpt-5-mini", {
  user_id: "alice",
  top_k: 10,          // retrieve up to 10 memories (default: 5)
  threshold: 0.8,     // only memories with score >= 0.8
  rerank: true,       // enable re-ranking of results
});

Provider-specific configuration

Pass SDK-specific settings via the config field:

const mem0 = createMem0({
  provider: "openai",
  config: {
    organization: "org-xxx",
    project: "proj-xxx",
  },
});

Default Mem0 config for all calls

Set defaults at the provider level that apply to every model created:

const mem0 = createMem0({
  mem0Config: {
    user_id: "alice",
    top_k: 10,
  },
});

// These calls inherit user_id and top_k from mem0Config
const { text } = await generateText({
  model: mem0("gpt-5-mini"),
  prompt: "Hello",
});

Per-call settings (passed as the second argument to mem0()) are merged on top of mem0Config, so you can override specific fields:

// Override user_id for this specific call
const model = mem0("gpt-5-mini", { user_id: "bob" });

The merge order is: config.mem0Config (provider defaults) < settings (per-call overrides).