Vercel AI SDK Integration

Copyexport function createMem0(
  options: Mem0ProviderSettings = {
    provider: "openai",
  }
): Mem0Provider {
  const baseURL =
    withoutTrailingSlash(options.baseURL) ?? "https://api.openai.com";
  const getHeaders = () => ({
    ...options.headers,
  });
 
  const createGenericModel = (
    modelId: Mem0ChatModelId,
    settings: Mem0ChatSettings = {}
  ) =>
    new Mem0GenericLanguageModel(
      modelId,
      settings,
      {
        baseURL,
        fetch: options.fetch,
        headers: getHeaders(),
        provider: options.provider || "openai",
        name: options.name,
        mem0ApiKey: options.mem0ApiKey,
        apiKey: options.apiKey,
        mem0Config: options.mem0Config,
      },
      options.config
    );
 
  const createCompletionModel = (
    modelId: Mem0ChatModelId,
    settings: Mem0ChatSettings = {}
  ) =>
    new Mem0GenericLanguageModel(
      modelId,
      settings,
      {
        baseURL,
        fetch: options.fetch,
        headers: getHeaders(),
        provider: options.provider || "openai",
        name: options.name,
        mem0ApiKey: options.mem0ApiKey,
        apiKey: options.apiKey,
        mem0Config: options.mem0Config,
        modelType: "completion",
      },
      options.config
    );
 
  const createChatModel = (
    modelId: Mem0ChatModelId,
    settings: Mem0ChatSettings = {}
  ) =>
    new Mem0GenericLanguageModel(
      modelId,
      settings,
      {
        baseURL,
        fetch: options.fetch,
        headers: getHeaders(),
        provider: options.provider || "openai",
        name: options.name,
        mem0ApiKey: options.mem0ApiKey,
        apiKey: options.apiKey,
        mem0Config: options.mem0Config,
        modelType: "chat",
      },
      options.config
    );
 
  const provider = function (
    modelId: Mem0ChatModelId,
    settings: Mem0ChatSettings = {}
  ) {
    if (new.target) {
      throw new Error(
        "The Mem0 model function cannot be called with the new keyword."

Copyexport class Mem0 {
  readonly baseURL: string
  readonly headers?: any
 
  constructor(options: Mem0ProviderSettings = {
    provider: 'openai',
  }) {
    this.baseURL =
      withoutTrailingSlash(options.baseURL) ?? 'https://api.openai.com'
 
    this.headers = options.headers
  }
 
  private get baseConfig() {
    return {
      baseURL: this.baseURL,
      headers: this.headers,
    }
  }
 
  chat(modelId: Mem0ChatModelId, settings: Mem0ChatSettings = {}) {
    return new Mem0GenericLanguageModel(modelId, settings, {
      provider: 'openai',
      modelType: 'chat',
      ...this.baseConfig,
    })
  }
 
  completion(modelId: Mem0ChatModelId, settings: Mem0ChatSettings = {}) {
    return new Mem0GenericLanguageModel(modelId, settings, {
      provider: 'openai',
      modelType: 'completion',
      ...this.baseConfig,
    })
  }
}

Copyexport class Mem0GenericLanguageModel implements LanguageModelV3 {
  readonly specificationVersion = "v3";
  readonly supportedUrls: Record<string, RegExp[]> = {
    '*': [/.*/]
  };
 
  constructor(
    public readonly modelId: Mem0ChatModelId,
    public readonly settings: Mem0ChatSettings,
    public readonly config: Mem0ChatConfig,
    public readonly provider_config?: Mem0ProviderSettings
  ) {
    this.provider = config.provider ?? "openai";
  }
 
  provider: string;

Copyprivate async processMemories(messagesPrompts: LanguageModelV3Message[], mem0Config: Mem0ConfigSettings) {
  try {
    // Add new memories — await to ensure writes complete before returning
    try {
      await addMemories(messagesPrompts, mem0Config);
    } catch (e) {
      console.error("Error while adding memories");
    }
 
    // Get memories (always returns an array since graph support is removed)
    const memories: any[] = await getMemories(messagesPrompts, mem0Config) ?? [];
 
    const mySystemPrompt = "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";
 
    let memoriesText = "";
    try {
      memoriesText = memories
        ?.map((memory: any) => `Memory: ${memory?.memory}\n\n`)
        .join("\n\n");
    } catch (e) {
      console.error("Error while parsing memories");
    }
 
    const memoriesPrompt = `System Message: ${mySystemPrompt} ${memoriesText} `;
 
    // Clone the prompt array to avoid mutating the caller's reference on retries
    const updatedPrompts = [...messagesPrompts];
 
    if (memories?.length > 0) {
      const systemPrompt: LanguageModelV3Message = {
        role: "system",
        content: memoriesPrompt
      };
      updatedPrompts.unshift(systemPrompt);
    }
 
    return { memories, messagesPrompts: updatedPrompts };
  } catch (e) {
    console.error("Error while processing memories");
    return { memories: [], messagesPrompts: [...messagesPrompts] };
  }
}

Copy  if (!memories || memories?.length === 0) {
    return ans;
  }
 
  const mem0Source: LanguageModelV3Source = {
    type: "source",
    sourceType: "url",
    id: "mem0-" + generateRandomId(),
    url: "https://app.mem0.ai?utm_source=oss&utm_medium=vercel-ai-sdk-src",
    title: "Mem0 Memories",
    providerMetadata: {
      mem0: {
        memories: memories,
        memoriesText: memories
          ?.map((memory: any) => memory?.memory)
          .join("\n\n"),
      },
    },
  };
 
  return {
    ...ans,
    content: [...(ans.content ?? []), mem0Source],
  };
}

Copyasync doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult> {
  try {
    const provider = this.config.provider;
    const mem0_api_key = this.config.mem0ApiKey;
 
    const settings: Mem0ProviderSettings = {
      provider: provider,
      mem0ApiKey: mem0_api_key,
      apiKey: this.config.apiKey,
      modelType: this.config.modelType,
    }
 
    const mem0Config: Mem0ConfigSettings = {
      mem0ApiKey: mem0_api_key,
      ...this.config.mem0Config,
      ...this.settings,
    }
 
    const selector = new Mem0ClassSelector(this.modelId, settings, this.provider_config);
 
    const { messagesPrompts: updatedPrompts } = await this.processMemories(options.prompt, mem0Config);
 
    const baseModel = selector.createProvider();
 
    const streamResponse = await baseModel.doStream({
      ...options,
      prompt: updatedPrompts,
    });
 
    // Return the full stream response, preserving all V3 fields (warnings, etc.)
    return streamResponse;
  } catch (error) {
    console.error("Error in doStream:", error);
    throw new Error("Streaming failed or method not implemented.");
  }
}

Copyclass Mem0ClassSelector {
    modelId: string;
    provider_wrapper: string;
    config: Mem0ProviderSettings;
    provider_config?: ProviderSettings;
    static supportedProviders = ["openai", "anthropic", "cohere", "groq", "google", "gemini"];
 
    constructor(modelId: string, config: Mem0ProviderSettings, provider_config?: ProviderSettings) {
        this.modelId = modelId;
        this.provider_wrapper = config.provider || "openai";
        this.provider_config = provider_config;
        if(config) this.config = config;
        else this.config = {
            provider: this.provider_wrapper,
        };
 
        // Check if provider_wrapper is supported
        if (!Mem0ClassSelector.supportedProviders.includes(this.provider_wrapper)) {
            throw new Error(`Model not supported: ${this.provider_wrapper}`);
        }
    }
 
    createProvider(): LanguageModelV3 {
        return new Mem0AITextGenerator(this.modelId, this.config , this.provider_config || {});
    }
}

Copyclass Mem0AITextGenerator implements LanguageModelV3 {
    readonly specificationVersion = "v3";
    readonly modelId: string;
    readonly provider = "mem0";
    readonly supportedUrls: Record<string, RegExp[]> = {
        '*': [/.*/]
    };
    private languageModel: any; // Use any type to avoid version conflicts
 
    constructor(modelId: string, config: Mem0ProviderSettings, provider_config: ProviderSettings) {
        this.modelId = modelId;
 
        switch (config.provider) {
            case "openai":
                if(config?.modelType === "completion"){
                    this.languageModel = createOpenAI({
                        apiKey: config?.apiKey,
                        ...provider_config as OpenAIProviderSettings,
                    }).completion(modelId);
                } else if(config?.modelType === "chat"){
                    this.languageModel = createOpenAI({
                        apiKey: config?.apiKey,
                        ...provider_config as OpenAIProviderSettings,
                    }).chat(modelId);
                } else {
                    this.languageModel = createOpenAI({
                        apiKey: config?.apiKey,
                        ...provider_config as OpenAIProviderSettings,
                    }).languageModel(modelId);
                }
                break;
            case "cohere":
                this.languageModel = createCohere({
                    apiKey: config?.apiKey,
                    ...provider_config as CohereProviderSettings,
                })(modelId);
                break;
            case "anthropic":
                this.languageModel = createAnthropic({
                    apiKey: config?.apiKey,
                    ...provider_config as AnthropicProviderSettings,
                }).languageModel(modelId);
                break;
            case "groq":
                this.languageModel = createGroq({
                    apiKey: config?.apiKey,
                    ...provider_config as GroqProviderSettings,
                })(modelId);
                break;
            case "google":
            case "gemini":
                this.languageModel = createGoogleGenerativeAI({
                    apiKey: config?.apiKey,
                    ...provider_config as GoogleGenerativeAIProviderSettings,
                })(modelId);
                break;
            default:
                throw new Error("Invalid provider");
        }
    }

Copy    async doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult> {
        const result = await this.languageModel.doGenerate(options);
        return result as LanguageModelV3GenerateResult;
    }
 
    async doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult> {
        const result = await this.languageModel.doStream(options);
        return result as LanguageModelV3StreamResult;
    }
}

Copyconst flattenPrompt = (prompt: LanguageModelV3Prompt) => {
    try {
        return prompt.map((part) => {
            if (part.role === "user") {
                if (typeof part.content === 'string') {
                    return part.content;
                } else if (Array.isArray(part.content)) {
                    return part.content
                        .filter((obj) => obj.type === 'text')
                        .map((obj) => obj.text)
                        .join(" ");
                } else if (part.content && typeof part.content === 'object' && 'type' in part.content) {
                    const content = part.content as any;
                    if (content.type === 'text' && content.text) {
                        return content.text;
                    } else if (content.type === 'file') {
                        if (content.mediaType === 'application/pdf') {
                            return '[PDF document]';
                        } else if (content.mediaType === 'text/markdown' || content.mediaType === 'application/mdx') {
                            return '[Markdown document]';
                        } else if (content.mediaType && content.mediaType.startsWith('image/')) {
                            return '[Image]';
                        } else {
                            return '[File attachment]';
                        }
                    }
                }
                return "[multimodal content]";
            }
            return "";
        }).join(" ");
    } catch (error) {
        console.error("Error in flattenPrompt:", error);
        return "";
    }
}

Copyconst convertToMem0Format = (messages: LanguageModelV3Prompt) => {
    try {
        return messages.flatMap((message: any) => {
            try {
                if (typeof message.content === 'string') {
                    return {
                        role: message.role,
                        content: message.content,
                    };
                }
                else if (Array.isArray(message.content)) {
                    return message.content.map((obj: any) => {
                        try {
                            if (obj.type === "text") {
                                return {
                                    role: message.role,
                                    content: obj.text,
                                };
                            } else if (obj.type === "file") {
                                if (obj.mediaType === "application/pdf") {
                                    return {
                                        role: message.role,
                                        content: {
                                            type: "pdf_url",
                                            pdf_url: {
                                                url: obj.data
                                            }
                                        }
                                    };
                                } else if (obj.mediaType === "text/markdown" || obj.mediaType === "application/mdx") {
                                    return {
                                        role: message.role,
                                        content: {
                                            type: "mdx_url",
                                            mdx_url: {
                                                url: obj.data
                                            }
                                        }
                                    };
                                } else if (obj.mediaType && obj.mediaType.startsWith("image/")) {
                                    return {
                                        role: message.role,
                                        content: {
                                            type: "image_url",
                                            image_url: {
                                                url: obj.data
                                            }
                                        }
                                    };
                                }
                            } else if (obj.type === "image_url" || obj.type === "image") {
                                return {
                                    role: message.role,
                                    content: {
                                        type: "image_url",
                                        image_url: {
                                            url: obj.image_url?.url || obj.image?.url || obj.url
                                        }
                                    }
                                };
                            } else if (obj.type === "mdx_url" || obj.type === "mdx") {
                                return {
                                    role: message.role,
                                    content: {
                                        type: "mdx_url",
                                        mdx_url: {
                                            url: obj.mdx_url?.url || obj.mdx?.url || obj.url
                                        }
                                    }
                                };
                            } else if (obj.type === "pdf_url" || obj.type === "pdf") {
                                return {
                                    role: message.role,
                                    content: {
                                        type: "pdf_url",
                                        pdf_url: {
                                            url: obj.pdf_url?.url || obj.pdf?.url || obj.url
                                        }
                                    }
                                };

Copyprivate async processMemories(messagesPrompts: LanguageModelV3Message[], mem0Config: Mem0ConfigSettings) {
  try {
    // Add new memories — await to ensure writes complete before returning
    try {
      await addMemories(messagesPrompts, mem0Config);
    } catch (e) {
      console.error("Error while adding memories");
    }
 
    // Get memories (always returns an array since graph support is removed)
    const memories: any[] = await getMemories(messagesPrompts, mem0Config) ?? [];
 
    const mySystemPrompt = "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";
 
    let memoriesText = "";
    try {
      memoriesText = memories
        ?.map((memory: any) => `Memory: ${memory?.memory}\n\n`)
        .join("\n\n");
    } catch (e) {
      console.error("Error while parsing memories");
    }
 
    const memoriesPrompt = `System Message: ${mySystemPrompt} ${memoriesText} `;
 
    // Clone the prompt array to avoid mutating the caller's reference on retries
    const updatedPrompts = [...messagesPrompts];
 
    if (memories?.length > 0) {
      const systemPrompt: LanguageModelV3Message = {
        role: "system",
        content: memoriesPrompt
      };
      updatedPrompts.unshift(systemPrompt);
    }
 
    return { memories, messagesPrompts: updatedPrompts };
  } catch (e) {
    console.error("Error while processing memories");
    return { memories: [], messagesPrompts: [...messagesPrompts] };
  }
}

Copy  await addMemories(messagesPrompts, mem0Config);
} catch (e) {
  console.error("Error while adding memories");
}
 
// Get memories (always returns an array since graph support is removed)
const memories: any[] = await getMemories(messagesPrompts, mem0Config) ?? [];
 
const mySystemPrompt = "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";
 
let memoriesText = "";
try {
  memoriesText = memories
    ?.map((memory: any) => `Memory: ${memory?.memory}\n\n`)
    .join("\n\n");
} catch (e) {
  console.error("Error while parsing memories");
}
 
const memoriesPrompt = `System Message: ${mySystemPrompt} ${memoriesText} `;
 
// Clone the prompt array to avoid mutating the caller's reference on retries
const updatedPrompts = [...messagesPrompts];
 
if (memories?.length > 0) {
  const systemPrompt: LanguageModelV3Message = {
    role: "system",
    content: memoriesPrompt
  };
  updatedPrompts.unshift(systemPrompt);
}

Copyconst retrieveMemories = async (prompt: LanguageModelV3Prompt | string, config?: Mem0ConfigSettings) => {
    try {
        const message = typeof prompt === 'string' ? prompt : flattenPrompt(prompt);
        const systemPrompt = "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";
 
        const data = await searchInternalMemories(message, config);
        // The API response may be a flat array or an object with a results key
        const memories: any[] = Array.isArray(data) ? data : (data?.results ?? []);
 
        if (memories.length === 0) {
            return "";
        }
 
        const memoriesText = memories
            .map((memory: any) => `Memory: ${memory.memory}\n\n`)
            .join("\n\n");
 
        return `System Message: ${systemPrompt} ${memoriesText}`;
    } catch (error) {
        console.error("Error in retrieveMemories:", error);
        throw error;
    }
}

Copyconst addMemories = async (messages: LanguageModelV3Prompt, config?: Mem0ConfigSettings) => {
    try {
        let finalMessages: Array<Message> = [];
        if (typeof messages === "string") {
            finalMessages = [{ role: "user", content: messages }];
        } else {
            finalMessages = convertToMem0Format(messages);
        }
        const response = await updateMemories(finalMessages, config);
        return response;
    } catch (error) {
        console.error("Error in addMemories:", error);
        throw error;
    }
}

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;
 

Copyconst 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),
};

Copydeclare const __MEM0_PROVIDER_VERSION__: string | undefined;
 
// Replaced at build time by tsup `define`. The fallback only applies when the
// source is run unbundled, such as in tests.
const PROVIDER_VERSION =
  typeof __MEM0_PROVIDER_VERSION__ !== "undefined" ? __MEM0_PROVIDER_VERSION__ : "dev";
 
…
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),
};

Copyasync function filterStream(originalStream: ReadableStream) {
    const reader = originalStream.getReader();
    const filteredStream = new ReadableStream({
        async start(controller) {
            while (true) {
                const { done, value } = await reader.read();
                if (done) {
                    controller.close();
                    break;
                }
                try {
                    const chunk = JSON.parse(value); 
                    if (chunk.type !== "step-finish") {
                        controller.enqueue(value);
                    }
                } catch (error) {
                    if (!(value.type==='step-finish')) {
                        controller.enqueue(value);
                    }
                }
            }
        }
    });
 
    return filteredStream;
}

Copytry {
    const chunk = JSON.parse(value); 
    if (chunk.type !== "step-finish") {
        controller.enqueue(value);
    }
} catch (error) {