refactor: consolidate agent/editor plugins under integrations/ (#5491)
Co-authored-by: Claude <noreply@anthropic.com>
This commit is contained in:
Kartik
@@ -0,0 +1,2 @@
|
||||
# Auto detect text files and perform LF normalization
|
||||
* text=auto
|
||||
@@ -0,0 +1,10 @@
|
||||
**/.env
|
||||
**/node_modules
|
||||
**/.DS_Store
|
||||
|
||||
# Ignore test-related files
|
||||
**/coverage.data
|
||||
**/coverage/
|
||||
|
||||
# Build files
|
||||
**/dist
|
||||
@@ -0,0 +1,234 @@
|
||||
# Mem0 AI SDK Provider
|
||||
|
||||
The **Mem0 AI SDK Provider** is a community-maintained library developed by [Mem0](https://mem0.ai/) to integrate with the Vercel AI SDK. This library brings enhanced AI interaction capabilities to your applications by introducing persistent memory functionality. With Mem0, language model conversations gain memory, enabling more contextualized and personalized responses based on past interactions.
|
||||
|
||||
Discover more of **Mem0** on [GitHub](https://github.com/mem0ai).
|
||||
Explore the [Mem0 Documentation](https://docs.mem0.ai/overview) to gain deeper control and flexibility in managing your memories.
|
||||
|
||||
For detailed information on using the Vercel AI SDK, refer to Vercel’s [API Reference](https://sdk.vercel.ai/docs/reference) and [Documentation](https://sdk.vercel.ai/docs).
|
||||
|
||||
## Features
|
||||
|
||||
- 🧠 Persistent memory storage for AI conversations
|
||||
- 🔄 Seamless integration with Vercel AI SDK
|
||||
- 🚀 Support for multiple LLM providers
|
||||
- 📝 Rich message format support
|
||||
- ⚡ Streaming capabilities
|
||||
- 🔍 Context-aware responses
|
||||
|
||||
## Installation
|
||||
|
||||
```bash
|
||||
npm install @mem0/vercel-ai-provider
|
||||
```
|
||||
|
||||
## Before We Begin
|
||||
|
||||
### Setting Up Mem0
|
||||
|
||||
1. Obtain your [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys?utm_source=oss&utm_medium=vercel-ai-sdk-readme) from the Mem0 dashboard.
|
||||
|
||||
2. Initialize the Mem0 Client:
|
||||
|
||||
```typescript
|
||||
import { createMem0 } from "@mem0/vercel-ai-provider";
|
||||
|
||||
const mem0 = createMem0({
|
||||
provider: "openai",
|
||||
mem0ApiKey: "m0-xxx",
|
||||
apiKey: "openai-api-key",
|
||||
config: {
|
||||
compatibility: "strict",
|
||||
// Additional model-specific configuration options can be added here.
|
||||
},
|
||||
});
|
||||
```
|
||||
|
||||
### Note
|
||||
By default, the `openai` provider is used, so specifying it is optional:
|
||||
```typescript
|
||||
const mem0 = createMem0();
|
||||
```
|
||||
For better security, consider setting `MEM0_API_KEY` and `OPENAI_API_KEY` as environment variables.
|
||||
|
||||
3. Add Memories to Enhance Context:
|
||||
|
||||
```typescript
|
||||
import { LanguageModelV1Prompt } from "ai";
|
||||
import { addMemories } from "@mem0/vercel-ai-provider";
|
||||
|
||||
const messages: LanguageModelV1Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "I love red cars." },
|
||||
{ type: "text", text: "I like Toyota Cars." },
|
||||
{ type: "text", text: "I prefer SUVs." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
await addMemories(messages, { user_id: "borat" });
|
||||
```
|
||||
|
||||
These memories are now stored in your profile. You can view and manage them on the [Mem0 Dashboard](https://app.mem0.ai/dashboard/users?utm_source=oss&utm_medium=vercel-ai-sdk-readme).
|
||||
|
||||
### Note:
|
||||
|
||||
For standalone features, such as `addMemories` and `retrieveMemories`,
|
||||
you must either set `MEM0_API_KEY` as an environment variable or pass it directly in the function call.
|
||||
|
||||
Example:
|
||||
|
||||
```typescript
|
||||
await addMemories(messages, { user_id: "borat", mem0ApiKey: "m0-xxx", org_id: "org_xx", project_id: "proj_xx" });
|
||||
await retrieveMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx", org_id: "org_xx", project_id: "proj_xx" });
|
||||
await getMemories(prompt, { user_id: "borat", mem0ApiKey: "m0-xxx", org_id: "org_xx", project_id: "proj_xx" });
|
||||
```
|
||||
|
||||
### Note:
|
||||
|
||||
`retrieveMemories` enriches the prompt with relevant memories from your profile, while `getMemories` returns the memories in array format which can be used for further processing.
|
||||
|
||||
## Usage Examples
|
||||
|
||||
### 1. Basic Text Generation with Memory Context
|
||||
|
||||
```typescript
|
||||
import { generateText } from "ai";
|
||||
import { createMem0 } from "@mem0/vercel-ai-provider";
|
||||
|
||||
const mem0 = createMem0();
|
||||
|
||||
const { text } = await generateText({
|
||||
model: mem0("gpt-4-turbo", {
|
||||
user_id: "borat",
|
||||
}),
|
||||
prompt: "Suggest me a good car to buy!",
|
||||
});
|
||||
```
|
||||
|
||||
### 2. Combining OpenAI Provider with Memory Utils
|
||||
|
||||
```typescript
|
||||
import { generateText } from "ai";
|
||||
import { openai } from "@ai-sdk/openai";
|
||||
import { retrieveMemories } from "@mem0/vercel-ai-provider";
|
||||
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
const memories = await retrieveMemories(prompt, { user_id: "borat" });
|
||||
|
||||
const { text } = await generateText({
|
||||
model: openai("gpt-4-turbo"),
|
||||
prompt: prompt,
|
||||
system: memories,
|
||||
});
|
||||
```
|
||||
|
||||
### 3. Structured Message Format with Memory
|
||||
|
||||
```typescript
|
||||
import { generateText } from "ai";
|
||||
import { createMem0 } from "@mem0/vercel-ai-provider";
|
||||
|
||||
const mem0 = createMem0();
|
||||
|
||||
const { text } = await generateText({
|
||||
model: mem0("gpt-4-turbo", {
|
||||
user_id: "borat",
|
||||
}),
|
||||
messages: [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: "Why is it better than the other cars for me?" },
|
||||
{ type: "text", text: "Give options for every price range." },
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
```
|
||||
|
||||
### 4. Advanced Memory Integration with OpenAI
|
||||
|
||||
```typescript
|
||||
import { generateText, LanguageModelV1Prompt } from "ai";
|
||||
import { openai } from "@ai-sdk/openai";
|
||||
import { retrieveMemories } from "@mem0/vercel-ai-provider";
|
||||
|
||||
// New format using system parameter for memory context
|
||||
const messages: LanguageModelV1Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: "Why is it better than the other cars for me?" },
|
||||
{ type: "text", text: "Give options for every price range." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
const memories = await retrieveMemories(messages, { user_id: "borat" });
|
||||
|
||||
const { text } = await generateText({
|
||||
model: openai("gpt-4-turbo"),
|
||||
messages: messages,
|
||||
system: memories,
|
||||
});
|
||||
```
|
||||
|
||||
### 5. Streaming Responses with Memory Context
|
||||
|
||||
```typescript
|
||||
import { streamText } from "ai";
|
||||
import { createMem0 } from "@mem0/vercel-ai-provider";
|
||||
|
||||
const mem0 = createMem0();
|
||||
|
||||
const { textStream } = await streamText({
|
||||
model: mem0("gpt-4-turbo", {
|
||||
user_id: "borat",
|
||||
}),
|
||||
prompt:
|
||||
"Suggest me a good car to buy! Why is it better than the other cars for me? Give options for every price range.",
|
||||
});
|
||||
|
||||
for await (const textPart of textStream) {
|
||||
process.stdout.write(textPart);
|
||||
}
|
||||
```
|
||||
|
||||
## Core Functions
|
||||
|
||||
- `createMem0()`: Initializes a new mem0 provider instance with optional configuration
|
||||
- `retrieveMemories()`: Enriches prompts with relevant memories
|
||||
- `addMemories()`: Add memories to your profile
|
||||
- `getMemories()`: Get memories from your profile in array format
|
||||
|
||||
## Configuration Options
|
||||
|
||||
```typescript
|
||||
const mem0 = createMem0({
|
||||
config: {
|
||||
...
|
||||
// Additional model-specific configuration options can be added here.
|
||||
},
|
||||
});
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **User Identification**: Always provide a unique `user_id` identifier for consistent memory retrieval
|
||||
2. **Context Management**: Use appropriate context window sizes to balance performance and memory
|
||||
3. **Error Handling**: Implement proper error handling for memory operations
|
||||
4. **Memory Cleanup**: Regularly clean up unused memory contexts to optimize performance
|
||||
|
||||
We also have support for `agent_id`, `app_id`, and `run_id`. Refer [Docs](https://docs.mem0.ai/api-reference/memory/add-memories).
|
||||
|
||||
## Notes
|
||||
|
||||
- Requires proper API key configuration for underlying providers (e.g., OpenAI)
|
||||
- Memory features depend on proper user identification via `user_id`
|
||||
- Supports both streaming and non-streaming responses
|
||||
- Compatible with all Vercel AI SDK features and patterns
|
||||
@@ -0,0 +1,105 @@
|
||||
import dotenv from "dotenv";
|
||||
import { createMem0 } from "../src";
|
||||
|
||||
dotenv.config();
|
||||
|
||||
export interface Provider {
|
||||
name: string;
|
||||
activeModel: string;
|
||||
apiKey: string | undefined;
|
||||
}
|
||||
|
||||
export const testConfig = {
|
||||
apiKey: process.env.MEM0_API_KEY,
|
||||
userId: "mem0-ai-sdk-test-user-1134774",
|
||||
deleteId: "",
|
||||
providers: [
|
||||
{
|
||||
name: "openai",
|
||||
activeModel: "gpt-4-turbo",
|
||||
apiKey: process.env.OPENAI_API_KEY,
|
||||
}
|
||||
,
|
||||
{
|
||||
name: "anthropic",
|
||||
activeModel: "claude-3-5-sonnet-20240620",
|
||||
apiKey: process.env.ANTHROPIC_API_KEY,
|
||||
},
|
||||
// {
|
||||
// name: "groq",
|
||||
// activeModel: "gemma2-9b-it",
|
||||
// apiKey: process.env.GROQ_API_KEY,
|
||||
// },
|
||||
{
|
||||
name: "cohere",
|
||||
activeModel: "command-r-plus",
|
||||
apiKey: process.env.COHERE_API_KEY,
|
||||
}
|
||||
],
|
||||
models: {
|
||||
openai: "gpt-4-turbo",
|
||||
anthropic: "claude-3-haiku-20240307",
|
||||
groq: "gemma2-9b-it",
|
||||
cohere: "command-r-plus"
|
||||
},
|
||||
apiKeys: {
|
||||
openai: process.env.OPENAI_API_KEY,
|
||||
anthropic: process.env.ANTHROPIC_API_KEY,
|
||||
groq: process.env.GROQ_API_KEY,
|
||||
cohere: process.env.COHERE_API_KEY,
|
||||
},
|
||||
|
||||
createTestClient: (provider: Provider) => {
|
||||
return createMem0({
|
||||
provider: provider.name,
|
||||
mem0ApiKey: process.env.MEM0_API_KEY,
|
||||
apiKey: provider.apiKey,
|
||||
});
|
||||
},
|
||||
fetchDeleteId: async function () {
|
||||
const options = {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
Authorization: `Token ${this.apiKey}`,
|
||||
},
|
||||
};
|
||||
|
||||
try {
|
||||
const response = await fetch('https://api.mem0.ai/v1/entities/', options);
|
||||
const data = await response.json();
|
||||
const entity = data.results.find((item: any) => item.name === this.userId);
|
||||
if (entity) {
|
||||
this.deleteId = entity.id;
|
||||
} else {
|
||||
console.error("No matching entity found for userId:", this.userId);
|
||||
}
|
||||
} catch (error) {
|
||||
console.error("Error fetching deleteId:", error);
|
||||
throw error;
|
||||
}
|
||||
},
|
||||
deleteUser: async function () {
|
||||
if (!this.deleteId) {
|
||||
console.error("deleteId is not set. Ensure fetchDeleteId is called first.");
|
||||
return;
|
||||
}
|
||||
|
||||
const options = {
|
||||
method: 'DELETE',
|
||||
headers: {
|
||||
Authorization: `Token ${this.apiKey}`,
|
||||
},
|
||||
};
|
||||
|
||||
try {
|
||||
const response = await fetch(`https://api.mem0.ai/v1/entities/user/${this.deleteId}/`, options);
|
||||
if (!response.ok) {
|
||||
throw new Error(`Failed to delete user: ${response.statusText}`);
|
||||
}
|
||||
await response.json();
|
||||
} catch (error) {
|
||||
console.error("Error deleting user:", error);
|
||||
throw error;
|
||||
}
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,6 @@
|
||||
module.exports = {
|
||||
preset: 'ts-jest',
|
||||
testEnvironment: 'node',
|
||||
globalTeardown: './teardown.ts',
|
||||
};
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
{
|
||||
"watch": ["src"],
|
||||
"ext": ".ts,.js",
|
||||
"exec": "ts-node ./example/index.ts"
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
{
|
||||
"name": "@mem0/vercel-ai-provider",
|
||||
"version": "3.0.0",
|
||||
"description": "Vercel AI Provider for providing memory to LLMs",
|
||||
"main": "./dist/index.js",
|
||||
"module": "./dist/index.mjs",
|
||||
"types": "./dist/index.d.ts",
|
||||
"files": [
|
||||
"dist/**/*"
|
||||
],
|
||||
"scripts": {
|
||||
"build": "tsup",
|
||||
"clean": "rm -rf dist",
|
||||
"dev": "nodemon",
|
||||
"lint": "eslint \"./**/*.ts*\"",
|
||||
"type-check": "tsc --noEmit",
|
||||
"prettier-check": "prettier --check \"./**/*.ts*\"",
|
||||
"test": "jest",
|
||||
"test:edge": "vitest --config vitest.edge.config.js --run",
|
||||
"test:node": "vitest --config vitest.node.config.js --run"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/mem0ai/mem0",
|
||||
"directory": "integrations/vercel-ai-sdk"
|
||||
},
|
||||
"keywords": [
|
||||
"ai",
|
||||
"vercel-ai"
|
||||
],
|
||||
"author": "Saket Aryan <saketaryan2002@gmail.com>",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
"@ai-sdk/anthropic": "^3.0.82",
|
||||
"@ai-sdk/cohere": "^3.0.36",
|
||||
"@ai-sdk/google": "^3.0.80",
|
||||
"@ai-sdk/groq": "^3.0.39",
|
||||
"@ai-sdk/openai": "^3.0.69",
|
||||
"@ai-sdk/provider": "^3.0.10",
|
||||
"@ai-sdk/provider-utils": "^4.0.27",
|
||||
"ai": "^6.0.199",
|
||||
"dotenv": "^16.6.1",
|
||||
"partial-json": "0.1.7",
|
||||
"zod": "^3.25.76"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@edge-runtime/vm": "^3.2.0",
|
||||
"@types/jest": "^29.5.14",
|
||||
"@types/node": "^18.19.130",
|
||||
"jest": "^29.7.0",
|
||||
"nodemon": "^3.1.14",
|
||||
"ts-jest": "^29.4.11",
|
||||
"ts-node": "^10.9.2",
|
||||
"tsup": "^8.5.1",
|
||||
"typescript": "^5.9.3"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"zod": "^3.0.0"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"zod": {
|
||||
"optional": true
|
||||
}
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=18"
|
||||
},
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"directories": {
|
||||
"example": "example",
|
||||
"test": "tests"
|
||||
},
|
||||
"packageManager": "pnpm@10.5.2+sha512.da9dc28cd3ff40d0592188235ab25d3202add8a207afbedc682220e4a0029ffbff4562102b9e6e46b4e3f9e8bd53e6d05de48544b0c57d4b0179e22c76d1199b",
|
||||
"pnpm": {
|
||||
"onlyBuiltDependencies": [
|
||||
"esbuild",
|
||||
"sqlite3"
|
||||
],
|
||||
"overrides": {
|
||||
"glob@>=10.2.0 <10.5.0": "^10.5.0",
|
||||
"minimatch@<3.1.3": "^3.1.3",
|
||||
"minimatch@>=5.0.0 <5.1.8": "^5.1.8",
|
||||
"minimatch@>=9.0.0 <9.0.7": "^9.0.7",
|
||||
"picomatch@<2.3.2": "^2.3.2",
|
||||
"rollup@>=4.0.0 <4.59.0": "^4.59.0"
|
||||
}
|
||||
}
|
||||
}
|
||||
+3854
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,14 @@
|
||||
packages:
|
||||
- '.'
|
||||
|
||||
onlyBuiltDependencies:
|
||||
- esbuild
|
||||
- sqlite3
|
||||
|
||||
overrides:
|
||||
"glob@>=10.2.0 <10.5.0": "^10.5.0"
|
||||
"minimatch@<3.1.3": "^3.1.3"
|
||||
"minimatch@>=5.0.0 <5.1.8": "^5.1.8"
|
||||
"minimatch@>=9.0.0 <9.0.7": "^9.0.7"
|
||||
"picomatch@<2.3.2": "^2.3.2"
|
||||
"rollup@>=4.0.0 <4.59.0": "^4.59.0"
|
||||
@@ -0,0 +1,5 @@
|
||||
export * from './mem0-facade'
|
||||
export type { Mem0Provider, Mem0ProviderSettings } from './mem0-provider'
|
||||
export { createMem0, mem0 } from './mem0-provider'
|
||||
export type { Mem0ConfigSettings, Mem0ChatConfig, Mem0ChatSettings } from './mem0-types'
|
||||
export { addMemories, retrieveMemories, searchMemories, getMemories } from './mem0-utils'
|
||||
@@ -0,0 +1,42 @@
|
||||
import { withoutTrailingSlash } from '@ai-sdk/provider-utils'
|
||||
|
||||
import { Mem0GenericLanguageModel } from './mem0-generic-language-model'
|
||||
import { Mem0ChatModelId, Mem0ChatSettings } from './mem0-types'
|
||||
import { Mem0ProviderSettings } from './mem0-provider'
|
||||
|
||||
export 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,
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
/* eslint-disable camelcase */
|
||||
import {
|
||||
LanguageModelV3,
|
||||
LanguageModelV3CallOptions,
|
||||
LanguageModelV3GenerateResult,
|
||||
LanguageModelV3Message,
|
||||
LanguageModelV3Source,
|
||||
LanguageModelV3StreamResult,
|
||||
} from '@ai-sdk/provider';
|
||||
|
||||
import { Mem0ChatConfig, Mem0ChatModelId, Mem0ChatSettings, Mem0ConfigSettings } from "./mem0-types";
|
||||
import { Mem0ClassSelector } from "./mem0-provider-selector";
|
||||
import { Mem0ProviderSettings } from "./mem0-provider";
|
||||
import { addMemories, getMemories } from "./mem0-utils";
|
||||
|
||||
const generateRandomId = () => {
|
||||
return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
|
||||
}
|
||||
|
||||
export 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;
|
||||
|
||||
private 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] };
|
||||
}
|
||||
}
|
||||
|
||||
async doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult> {
|
||||
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 { memories, messagesPrompts: updatedPrompts } = await this.processMemories(options.prompt, mem0Config);
|
||||
|
||||
const model = selector.createProvider();
|
||||
|
||||
const ans = await model.doGenerate({
|
||||
...options,
|
||||
prompt: updatedPrompts,
|
||||
});
|
||||
|
||||
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],
|
||||
};
|
||||
}
|
||||
|
||||
async 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.");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
import { Mem0ProviderSettings } from "./mem0-provider";
|
||||
import Mem0AITextGenerator, { ProviderSettings } from "./provider-response-provider";
|
||||
import { LanguageModelV3 } from '@ai-sdk/provider';
|
||||
|
||||
class 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 || {});
|
||||
}
|
||||
}
|
||||
|
||||
export { Mem0ClassSelector };
|
||||
@@ -0,0 +1,142 @@
|
||||
import { ProviderV3 } from '@ai-sdk/provider';
|
||||
import { LanguageModelV3 } from '@ai-sdk/provider';
|
||||
import { withoutTrailingSlash } from "@ai-sdk/provider-utils";
|
||||
import { Mem0ChatModelId, Mem0ChatSettings, Mem0Config } from "./mem0-types";
|
||||
import { Mem0GenericLanguageModel } from "./mem0-generic-language-model";
|
||||
import { LLMProviderSettings } from "./mem0-types";
|
||||
|
||||
export interface Mem0Provider extends ProviderV3 {
|
||||
(modelId: Mem0ChatModelId, settings?: Mem0ChatSettings): LanguageModelV3;
|
||||
|
||||
chat(modelId: Mem0ChatModelId, settings?: Mem0ChatSettings): LanguageModelV3;
|
||||
completion(modelId: Mem0ChatModelId, settings?: Mem0ChatSettings): LanguageModelV3;
|
||||
|
||||
languageModel(
|
||||
modelId: Mem0ChatModelId,
|
||||
settings?: Mem0ChatSettings
|
||||
): LanguageModelV3;
|
||||
}
|
||||
|
||||
export interface Mem0ProviderSettings {
|
||||
baseURL?: string;
|
||||
/**
|
||||
* Custom fetch implementation. You can use it as a middleware to intercept
|
||||
* requests or to provide a custom fetch implementation for e.g. testing
|
||||
*/
|
||||
fetch?: typeof fetch;
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
generateId?: () => string;
|
||||
/**
|
||||
* Custom headers to include in the requests.
|
||||
*/
|
||||
headers?: Record<string, string | undefined>;
|
||||
name?: string;
|
||||
mem0ApiKey?: string;
|
||||
apiKey?: string;
|
||||
provider?: string;
|
||||
modelType?: "completion" | "chat";
|
||||
mem0Config?: Mem0Config;
|
||||
|
||||
/**
|
||||
* The configuration for the provider.
|
||||
*/
|
||||
config?: LLMProviderSettings ;
|
||||
}
|
||||
|
||||
export 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."
|
||||
);
|
||||
}
|
||||
|
||||
return createGenericModel(modelId, settings);
|
||||
};
|
||||
|
||||
provider.specificationVersion = 'v3';
|
||||
provider.languageModel = createGenericModel;
|
||||
provider.completion = createCompletionModel;
|
||||
provider.chat = createChatModel;
|
||||
|
||||
return provider as unknown as Mem0Provider;
|
||||
}
|
||||
|
||||
export const mem0 = createMem0();
|
||||
@@ -0,0 +1,32 @@
|
||||
import { Mem0ProviderSettings } from "./mem0-provider";
|
||||
import { OpenAIProviderSettings } from "@ai-sdk/openai";
|
||||
import { AnthropicProviderSettings } from "@ai-sdk/anthropic";
|
||||
import { CohereProviderSettings } from "@ai-sdk/cohere";
|
||||
import { GroqProviderSettings } from "@ai-sdk/groq";
|
||||
import { GoogleGenerativeAIProviderSettings } from "@ai-sdk/google";
|
||||
export type Mem0ChatModelId =
|
||||
| (string & NonNullable<unknown>);
|
||||
|
||||
export interface Mem0ConfigSettings {
|
||||
user_id?: string;
|
||||
app_id?: string;
|
||||
agent_id?: string;
|
||||
run_id?: string;
|
||||
metadata?: Record<string, any>;
|
||||
filters?: Record<string, any>;
|
||||
infer?: boolean;
|
||||
page?: number;
|
||||
page_size?: number;
|
||||
mem0ApiKey?: string;
|
||||
top_k?: number;
|
||||
threshold?: number;
|
||||
rerank?: boolean;
|
||||
host?: string;
|
||||
}
|
||||
|
||||
export interface Mem0ChatConfig extends Mem0ConfigSettings, Mem0ProviderSettings {}
|
||||
|
||||
export type LLMProviderSettings = OpenAIProviderSettings | AnthropicProviderSettings | CohereProviderSettings | GroqProviderSettings | GoogleGenerativeAIProviderSettings;
|
||||
|
||||
export interface Mem0Config extends Mem0ConfigSettings {}
|
||||
export interface Mem0ChatSettings extends Mem0ConfigSettings {}
|
||||
@@ -0,0 +1,399 @@
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { Mem0ConfigSettings } from './mem0-types';
|
||||
import { loadApiKey } from '@ai-sdk/provider-utils';
|
||||
interface MultimodalContent {
|
||||
type: 'text' | 'image_url' | 'mdx_url' | 'pdf_url';
|
||||
text?: string;
|
||||
image_url?: {
|
||||
url: string;
|
||||
};
|
||||
mdx_url?: {
|
||||
url: string;
|
||||
};
|
||||
pdf_url?: {
|
||||
url: string;
|
||||
};
|
||||
}
|
||||
|
||||
interface FileContent {
|
||||
type: 'file';
|
||||
data: string; // fileDataUrl
|
||||
mediaType: string; // e.g., 'application/pdf', 'text/markdown', 'image/jpeg'
|
||||
}
|
||||
|
||||
interface Message {
|
||||
role: string;
|
||||
content: string | MultimodalContent | Array<MultimodalContent>;
|
||||
}
|
||||
|
||||
const 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 "";
|
||||
}
|
||||
}
|
||||
|
||||
const 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
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
return null;
|
||||
} catch (error) {
|
||||
console.error("Error processing content object:", error);
|
||||
return null;
|
||||
}
|
||||
}).filter((item: null) => item !== null);
|
||||
} else {
|
||||
const obj = message.content;
|
||||
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
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
return null;
|
||||
}
|
||||
} catch (error) {
|
||||
console.error("Error processing message:", error);
|
||||
return [];
|
||||
}
|
||||
});
|
||||
} catch (error) {
|
||||
console.error("Error in convertToMem0Format:", error);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
const searchInternalMemories = async (query: string, config?: Mem0ConfigSettings, top_k: number = 10) => {
|
||||
try {
|
||||
// v3: entity IDs go inside the filters object, not as top-level params
|
||||
const filters: Record<string, any> = {
|
||||
...(config?.filters ?? {}),
|
||||
};
|
||||
if (config?.user_id) {
|
||||
filters.user_id = config.user_id;
|
||||
}
|
||||
if (config?.app_id) {
|
||||
filters.app_id = config.app_id;
|
||||
}
|
||||
if (config?.agent_id) {
|
||||
filters.agent_id = config.agent_id;
|
||||
}
|
||||
if (config?.run_id) {
|
||||
filters.run_id = config.run_id;
|
||||
}
|
||||
|
||||
const apiKey = loadApiKey({
|
||||
apiKey: config?.mem0ApiKey,
|
||||
environmentVariableName: "MEM0_API_KEY",
|
||||
description: "Mem0",
|
||||
});
|
||||
|
||||
const body: Record<string, any> = {
|
||||
query,
|
||||
filters,
|
||||
top_k: config?.top_k ?? top_k,
|
||||
};
|
||||
if (config?.threshold != null) {
|
||||
body.threshold = config.threshold;
|
||||
}
|
||||
if (config?.rerank != null) {
|
||||
body.rerank = config.rerank;
|
||||
}
|
||||
if (config?.metadata) {
|
||||
body.metadata = config.metadata;
|
||||
}
|
||||
|
||||
const options = {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
Authorization: `Token ${apiKey}`,
|
||||
'Content-Type': 'application/json'
|
||||
},
|
||||
body: JSON.stringify(body),
|
||||
};
|
||||
|
||||
const baseUrl = config?.host || 'https://api.mem0.ai';
|
||||
const response = await fetch(`${baseUrl}/v3/memories/search/`, 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 searchInternalMemories:", error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
const 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;
|
||||
}
|
||||
}
|
||||
|
||||
const 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'
|
||||
},
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
const 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;
|
||||
}
|
||||
}
|
||||
|
||||
const 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;
|
||||
}
|
||||
}
|
||||
|
||||
const searchMemories = async (prompt: LanguageModelV3Prompt | string, config?: Mem0ConfigSettings) => {
|
||||
try {
|
||||
const message = typeof prompt === 'string' ? prompt : flattenPrompt(prompt);
|
||||
const memories = await searchInternalMemories(message, config);
|
||||
return memories;
|
||||
} catch (error) {
|
||||
console.error("Error in searchMemories:", error);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
export {addMemories, updateMemories, retrieveMemories, flattenPrompt, searchMemories, getMemories};
|
||||
@@ -0,0 +1,83 @@
|
||||
import { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult } from "@ai-sdk/provider";
|
||||
import { Mem0ProviderSettings } from "./mem0-provider";
|
||||
import { createOpenAI, OpenAIProviderSettings } from "@ai-sdk/openai";
|
||||
import { CohereProviderSettings, createCohere } from "@ai-sdk/cohere";
|
||||
import { AnthropicProviderSettings, createAnthropic } from "@ai-sdk/anthropic";
|
||||
import { createGoogleGenerativeAI, GoogleGenerativeAIProviderSettings } from "@ai-sdk/google";
|
||||
import { createGroq, GroqProviderSettings } from "@ai-sdk/groq";
|
||||
|
||||
// Define a private provider field
|
||||
class 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");
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
export type ProviderSettings = OpenAIProviderSettings | CohereProviderSettings | AnthropicProviderSettings | GroqProviderSettings | GoogleGenerativeAIProviderSettings;
|
||||
export default Mem0AITextGenerator;
|
||||
@@ -0,0 +1,28 @@
|
||||
async 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;
|
||||
}
|
||||
|
||||
export { filterStream };
|
||||
@@ -0,0 +1,12 @@
|
||||
import { testConfig } from './config/test-config';
|
||||
|
||||
export default async function () {
|
||||
console.log("Running global teardown...");
|
||||
try {
|
||||
await testConfig.fetchDeleteId();
|
||||
await testConfig.deleteUser();
|
||||
console.log("User deleted successfully after all tests.");
|
||||
} catch (error) {
|
||||
console.error("Failed to delete user after all tests:", error);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
import { generateText, streamText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { simulateStreamingMiddleware, wrapLanguageModel } from 'ai';
|
||||
import { addMemories } from "../src";
|
||||
import { testConfig } from "../config/test-config";
|
||||
|
||||
interface Provider {
|
||||
name: string;
|
||||
activeModel: string;
|
||||
apiKey: string | undefined;
|
||||
}
|
||||
|
||||
describe.each(testConfig.providers)('TESTS: Generate/Stream Text with model %s', (provider: Provider) => {
|
||||
const { userId } = testConfig;
|
||||
let mem0: ReturnType<typeof testConfig.createTestClient>;
|
||||
jest.setTimeout(50000);
|
||||
|
||||
beforeEach(() => {
|
||||
mem0 = testConfig.createTestClient(provider);
|
||||
});
|
||||
|
||||
beforeAll(async () => {
|
||||
// Add some test memories before all tests
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "I love red cars." },
|
||||
{ type: "text", text: "I like Toyota Cars." },
|
||||
{ type: "text", text: "I prefer SUVs." },
|
||||
],
|
||||
}
|
||||
];
|
||||
await addMemories(messages, { user_id: userId });
|
||||
});
|
||||
|
||||
it("should generate text using mem0 model", async () => {
|
||||
const { text } = await generateText({
|
||||
model: mem0(provider.activeModel, {
|
||||
user_id: userId,
|
||||
}),
|
||||
prompt: "Suggest me a good car to buy!",
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using provider with memories", async () => {
|
||||
const { text } = await generateText({
|
||||
model: mem0(provider.activeModel, {
|
||||
user_id: userId,
|
||||
}),
|
||||
messages: [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: "Write only the car name and it's color." },
|
||||
]
|
||||
}
|
||||
],
|
||||
});
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should stream text using Mem0 provider with new streaming approach", async () => {
|
||||
// Create the base model
|
||||
const baseModel = mem0(provider.activeModel, {
|
||||
user_id: userId,
|
||||
});
|
||||
|
||||
// Wrap with streaming middleware using the new Vercel AI SDK 5.0 approach
|
||||
const model = wrapLanguageModel({
|
||||
model: baseModel,
|
||||
middleware: simulateStreamingMiddleware(),
|
||||
});
|
||||
|
||||
const { textStream } = streamText({
|
||||
model,
|
||||
prompt: "Suggest me a good car to buy! Write only the car name and it's color.",
|
||||
});
|
||||
|
||||
// Collect streamed text parts
|
||||
let streamedText = '';
|
||||
for await (const textPart of textStream) {
|
||||
streamedText += textPart;
|
||||
}
|
||||
|
||||
// Ensure the streamed text is a string
|
||||
expect(typeof streamedText).toBe('string');
|
||||
expect(streamedText.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
});
|
||||
@@ -0,0 +1,60 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { createMem0, retrieveMemories } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
import { createCohere } from "@ai-sdk/cohere";
|
||||
|
||||
describe("COHERE MEM0 Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
let mem0: any;
|
||||
|
||||
beforeEach(() => {
|
||||
mem0 = createMem0({
|
||||
provider: "cohere",
|
||||
apiKey: process.env.COHERE_API_KEY,
|
||||
mem0Config: {
|
||||
user_id: userId
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using COHERE provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: mem0("command-r-plus"),
|
||||
messages: messages
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using COHERE provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: mem0("command-r-plus"),
|
||||
prompt: prompt
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,59 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { createMem0 } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
|
||||
describe("GOOGLE MEM0 Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(50000);
|
||||
|
||||
let mem0: any;
|
||||
|
||||
beforeEach(() => {
|
||||
mem0 = createMem0({
|
||||
provider: "google",
|
||||
apiKey: process.env.GOOGLE_API_KEY,
|
||||
mem0Config: {
|
||||
user_id: userId
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using Google provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: mem0("gemini-1.5-flash"),
|
||||
messages: messages
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using Google provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: mem0("gemini-1.5-flash"),
|
||||
prompt: prompt
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,61 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { createMem0, retrieveMemories } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
import { createGroq } from "@ai-sdk/groq";
|
||||
|
||||
describe("GROQ MEM0 Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
|
||||
let mem0: any;
|
||||
|
||||
beforeEach(() => {
|
||||
mem0 = createMem0({
|
||||
provider: "groq",
|
||||
apiKey: process.env.GROQ_API_KEY,
|
||||
mem0Config: {
|
||||
user_id: userId
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using GROQ provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: mem0("llama3-8b-8192"),
|
||||
messages: messages
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using GROQ provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: mem0("llama3-8b-8192"),
|
||||
prompt: prompt
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
+120
@@ -0,0 +1,120 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { generateObject } from "ai";
|
||||
import { testConfig } from "../../config/test-config";
|
||||
import { z } from "zod";
|
||||
|
||||
interface Provider {
|
||||
name: string;
|
||||
activeModel: string;
|
||||
apiKey: string | undefined;
|
||||
}
|
||||
|
||||
const provider: Provider = {
|
||||
name: "openai",
|
||||
activeModel: "gpt-4o-mini",
|
||||
apiKey: process.env.OPENAI_API_KEY,
|
||||
}
|
||||
describe("OPENAI Structured Outputs", () => {
|
||||
const { userId } = testConfig;
|
||||
let mem0: ReturnType<typeof testConfig.createTestClient>;
|
||||
jest.setTimeout(30000);
|
||||
|
||||
beforeEach(() => {
|
||||
mem0 = testConfig.createTestClient(provider);
|
||||
});
|
||||
|
||||
describe("openai Object Generation Tests", () => {
|
||||
// Test 1: Generate a car preference object
|
||||
it("should generate a car preference object with name and steps", async () => {
|
||||
const { object } = await generateObject({
|
||||
model: mem0(provider.activeModel, {
|
||||
user_id: userId,
|
||||
}),
|
||||
schema: z.object({
|
||||
car: z.object({
|
||||
name: z.string(),
|
||||
steps: z.array(z.string()),
|
||||
}),
|
||||
}),
|
||||
prompt: "Which car would I like?",
|
||||
});
|
||||
|
||||
expect(object.car).toBeDefined();
|
||||
expect(typeof object.car.name).toBe("string");
|
||||
expect(Array.isArray(object.car.steps)).toBe(true);
|
||||
expect(object.car.steps.every((step) => typeof step === "string")).toBe(true);
|
||||
});
|
||||
|
||||
// Test 2: Generate an array of car objects
|
||||
it("should generate an array of three car objects with name, class, and description", async () => {
|
||||
const { object } = await generateObject({
|
||||
model: mem0(provider.activeModel, {
|
||||
user_id: userId,
|
||||
}),
|
||||
output: "array",
|
||||
schema: z.object({
|
||||
name: z.string(),
|
||||
class: z.string().describe('Cars should be "SUV", "Sedan", or "Hatchback"'),
|
||||
description: z.string(),
|
||||
}),
|
||||
prompt: "Write name of three cars that I would like.",
|
||||
});
|
||||
|
||||
expect(Array.isArray(object)).toBe(true);
|
||||
expect(object.length).toBe(3);
|
||||
object.forEach((car) => {
|
||||
expect(car).toHaveProperty("name");
|
||||
expect(typeof car.name).toBe("string");
|
||||
expect(car).toHaveProperty("class");
|
||||
expect(typeof car.class).toBe("string");
|
||||
expect(car).toHaveProperty("description");
|
||||
expect(typeof car.description).toBe("string");
|
||||
});
|
||||
});
|
||||
|
||||
// Test 3: Generate an enum for movie genre classification
|
||||
it("should classify the genre of a movie plot", async () => {
|
||||
const { object } = await generateObject({
|
||||
model: mem0(provider.activeModel, {
|
||||
user_id: userId,
|
||||
}),
|
||||
output: "enum",
|
||||
enum: ["action", "comedy", "drama", "horror", "sci-fi"],
|
||||
prompt: 'Classify the genre of this movie plot: "A group of astronauts travel through a wormhole in search of a new habitable planet for humanity."',
|
||||
});
|
||||
|
||||
expect(object).toBeDefined();
|
||||
expect(object).toBe("sci-fi");
|
||||
});
|
||||
|
||||
// Test 4: Generate an object of car names without schema
|
||||
it("should generate an object with car names", async () => {
|
||||
const { object } = await generateObject({
|
||||
model: mem0(provider.activeModel, {
|
||||
user_id: userId,
|
||||
}),
|
||||
output: "no-schema",
|
||||
prompt: "Write name of 3 cars that I would like in JSON format.",
|
||||
});
|
||||
|
||||
// The response structure might vary, so let's be more flexible
|
||||
expect(object).toBeDefined();
|
||||
expect(typeof object).toBe("object");
|
||||
|
||||
// Check if it has cars property or if it's an array
|
||||
if (object && typeof object === "object" && "cars" in object && Array.isArray((object as any).cars)) {
|
||||
const cars = (object as any).cars;
|
||||
expect(cars.length).toBe(3);
|
||||
expect(cars.every((car: any) => typeof car === "string")).toBe(true);
|
||||
} else if (object && Array.isArray(object)) {
|
||||
expect(object.length).toBe(3);
|
||||
expect(object.every((car: any) => typeof car === "string")).toBe(true);
|
||||
} else if (object && typeof object === "object") {
|
||||
// If it's a different structure, just check it's valid
|
||||
expect(Object.keys(object as object).length).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,56 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { createMem0 } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
|
||||
describe("OPENAI MEM0 Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
let mem0: any;
|
||||
|
||||
beforeEach(() => {
|
||||
mem0 = createMem0({
|
||||
provider: "openai",
|
||||
apiKey: process.env.OPENAI_API_KEY,
|
||||
mem0Config: {
|
||||
user_id: userId
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using Mem0 OpenAI provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
const { text } = await generateText({
|
||||
model: mem0("gpt-4-turbo"),
|
||||
messages: messages
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using openai provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
|
||||
const { text } = await generateText({
|
||||
model: mem0("gpt-4-turbo"),
|
||||
prompt: prompt
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,60 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { createMem0, retrieveMemories } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
import { createAnthropic } from "@ai-sdk/anthropic";
|
||||
|
||||
describe("ANTHROPIC MEM0 Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
|
||||
let mem0: any;
|
||||
|
||||
beforeEach(() => {
|
||||
mem0 = createMem0({
|
||||
provider: "anthropic",
|
||||
apiKey: process.env.ANTHROPIC_API_KEY,
|
||||
mem0Config: {
|
||||
user_id: userId
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using ANTHROPIC provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: mem0("claude-3-haiku-20240307"),
|
||||
messages: messages,
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using ANTHROPIC provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: mem0("claude-3-haiku-20240307"),
|
||||
prompt: prompt,
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,104 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { addMemories, createMem0 } from "../src";
|
||||
import { generateText, tool } from "ai";
|
||||
import { testConfig } from "../config/test-config";
|
||||
import { z } from "zod";
|
||||
|
||||
describe("Tool Calls Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
|
||||
beforeEach(async () => {
|
||||
await addMemories([{
|
||||
role: "user",
|
||||
content: [{ type: "text", text: "I live in Mumbai" }],
|
||||
}], { user_id: userId });
|
||||
});
|
||||
|
||||
it("should Execute a Tool Call Using OpenAI", async () => {
|
||||
const mem0OpenAI = createMem0({
|
||||
provider: "openai",
|
||||
apiKey: process.env.OPENAI_API_KEY,
|
||||
mem0Config: {
|
||||
user_id: userId,
|
||||
},
|
||||
});
|
||||
|
||||
const result = await generateText({
|
||||
model: mem0OpenAI("gpt-4o"),
|
||||
tools: {
|
||||
weather: tool({
|
||||
description: "Get the weather in a location",
|
||||
inputSchema: z.object({
|
||||
location: z.string().describe("The location to get the weather for"),
|
||||
}),
|
||||
execute: async ({ location }) => ({
|
||||
location,
|
||||
temperature: 72 + Math.floor(Math.random() * 21) - 10,
|
||||
}),
|
||||
}),
|
||||
},
|
||||
prompt: "What is the temperature in the city that I live in?",
|
||||
});
|
||||
|
||||
// Check if the response is valid
|
||||
expect(result).toHaveProperty('text');
|
||||
expect(typeof result.text).toBe("string");
|
||||
|
||||
// For tool calls, we should have either text response or tool call results
|
||||
if (result.text && result.text.length > 0) {
|
||||
expect(result.text.length).toBeGreaterThan(0);
|
||||
// Check if the response mentions weather or temperature
|
||||
expect(result.text.toLowerCase()).toMatch(/(weather|temperature|mumbai)/);
|
||||
} else {
|
||||
// If text is empty, check if there are tool call results
|
||||
expect(result).toHaveProperty('toolResults');
|
||||
expect(Array.isArray(result.toolResults)).toBe(true);
|
||||
expect(result.toolResults.length).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
|
||||
it("should Execute a Tool Call Using Anthropic", async () => {
|
||||
const mem0Anthropic = createMem0({
|
||||
provider: "anthropic",
|
||||
apiKey: process.env.ANTHROPIC_API_KEY,
|
||||
mem0Config: {
|
||||
user_id: userId,
|
||||
},
|
||||
});
|
||||
|
||||
const result = await generateText({
|
||||
model: mem0Anthropic("claude-3-haiku-20240307"),
|
||||
tools: {
|
||||
weather: tool({
|
||||
description: "Get the weather in a location",
|
||||
inputSchema: z.object({
|
||||
location: z.string().describe("The location to get the weather for"),
|
||||
}),
|
||||
execute: async ({ location }) => ({
|
||||
location,
|
||||
temperature: 72 + Math.floor(Math.random() * 21) - 10,
|
||||
}),
|
||||
}),
|
||||
},
|
||||
prompt: "What is the temperature in the city that I live in?",
|
||||
});
|
||||
|
||||
// Check if the response is valid
|
||||
expect(result).toHaveProperty('text');
|
||||
expect(typeof result.text).toBe("string");
|
||||
|
||||
if (result.text && result.text.length > 0) {
|
||||
expect(result.text.length).toBeGreaterThan(0);
|
||||
// Check if the response mentions weather or temperature
|
||||
expect(result.text.toLowerCase()).toMatch(/(weather|temperature|mumbai)/);
|
||||
} else {
|
||||
// If text is empty, check if there are tool call results
|
||||
expect(result).toHaveProperty('toolResults');
|
||||
expect(Array.isArray(result.toolResults)).toBe(true);
|
||||
expect(result.toolResults.length).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,75 @@
|
||||
import { addMemories, retrieveMemories } from "../src";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../config/test-config";
|
||||
|
||||
describe("Memory Core Functions", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(20000);
|
||||
|
||||
describe("addMemories", () => {
|
||||
it("should successfully add memories and return correct format", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "I love red cars." },
|
||||
{ type: "text", text: "I like Toyota Cars." },
|
||||
{ type: "text", text: "I prefer SUVs." },
|
||||
],
|
||||
}
|
||||
];
|
||||
|
||||
const response = await addMemories(messages, { user_id: userId });
|
||||
|
||||
expect(Array.isArray(response)).toBe(true);
|
||||
response.forEach((memory: { event: any; }) => {
|
||||
expect(memory).toHaveProperty('id');
|
||||
expect(memory).toHaveProperty('data');
|
||||
expect(memory).toHaveProperty('event');
|
||||
expect(memory.event).toBe('ADD');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("retrieveMemories", () => {
|
||||
beforeEach(async () => {
|
||||
// Add some test memories before each retrieval test
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "I love red cars." },
|
||||
{ type: "text", text: "I like Toyota Cars." },
|
||||
{ type: "text", text: "I prefer SUVs." },
|
||||
],
|
||||
}
|
||||
];
|
||||
await addMemories(messages, { user_id: userId });
|
||||
});
|
||||
|
||||
it("should retrieve memories with string prompt", async () => {
|
||||
const prompt = "Which car would I prefer?";
|
||||
const response = await retrieveMemories(prompt, { user_id: userId });
|
||||
|
||||
expect(typeof response).toBe('string');
|
||||
expect(response.match(/Memory:/g)?.length).toBeGreaterThan(2);
|
||||
});
|
||||
|
||||
it("should retrieve memories with array of prompts", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Which car would I prefer?" },
|
||||
{ type: "text", text: "Suggest me some cars" },
|
||||
],
|
||||
}
|
||||
];
|
||||
|
||||
const response = await retrieveMemories(messages, { user_id: userId });
|
||||
|
||||
expect(typeof response).toBe('string');
|
||||
expect(response.match(/Memory:/g)?.length).toBeGreaterThan(2);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,68 @@
|
||||
import { generateText, streamText } from "ai";
|
||||
import { testConfig } from "../config/test-config";
|
||||
|
||||
interface Provider {
|
||||
name: string;
|
||||
activeModel: string;
|
||||
apiKey: string | undefined;
|
||||
}
|
||||
|
||||
describe.each(testConfig.providers)('TEXT/STREAM PROPERTIES: Tests with model %s', (provider: Provider) => {
|
||||
const { userId } = testConfig;
|
||||
let mem0: ReturnType<typeof testConfig.createTestClient>;
|
||||
jest.setTimeout(50000);
|
||||
|
||||
beforeEach(() => {
|
||||
mem0 = testConfig.createTestClient(provider);
|
||||
});
|
||||
|
||||
it("should stream text with onChunk handler", async () => {
|
||||
const chunkTexts: string[] = [];
|
||||
const { textStream } = streamText({
|
||||
model: mem0(provider.activeModel, {
|
||||
user_id: userId, // Use the uniform userId
|
||||
}),
|
||||
prompt: "Write only the name of the car I prefer and its color.",
|
||||
});
|
||||
|
||||
// Wait for the stream to complete
|
||||
for await (const _ of textStream) {
|
||||
chunkTexts.push(_);
|
||||
}
|
||||
|
||||
// Ensure chunks are collected
|
||||
expect(chunkTexts.length).toBeGreaterThan(0);
|
||||
expect(chunkTexts.every((text) => typeof text === "string" || typeof text === "object")).toBe(true);
|
||||
});
|
||||
|
||||
it("should call onFinish handler without throwing an error", async () => {
|
||||
streamText({
|
||||
model: mem0(provider.activeModel, {
|
||||
user_id: userId, // Use the uniform userId
|
||||
}),
|
||||
prompt: "Write only the name of the car I prefer and its color.",
|
||||
});
|
||||
});
|
||||
|
||||
it("should generate fullStream with expected usage", async () => {
|
||||
const {
|
||||
text, // combined text
|
||||
usage, // combined usage of all steps
|
||||
} = await generateText({
|
||||
model: mem0.completion(provider.activeModel, {
|
||||
user_id: userId,
|
||||
}), // Ensure the model name is correct
|
||||
prompt:
|
||||
"Suggest me some good cars to buy. Each response MUST HAVE at least 200 words.",
|
||||
});
|
||||
|
||||
// Ensure text is a string
|
||||
expect(typeof text).toBe("string");
|
||||
|
||||
// Check usage
|
||||
expect(usage.inputTokens).toBeGreaterThanOrEqual(10);
|
||||
expect(usage.inputTokens).toBeLessThanOrEqual(500);
|
||||
expect(usage.outputTokens).toBeGreaterThanOrEqual(10);
|
||||
expect(usage.totalTokens).toBeGreaterThan(10);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,62 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { retrieveMemories } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
import { createAnthropic } from "@ai-sdk/anthropic";
|
||||
|
||||
describe("ANTHROPIC Integration Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
|
||||
let anthropic: any;
|
||||
|
||||
beforeEach(() => {
|
||||
anthropic = createAnthropic({
|
||||
apiKey: process.env.ANTHROPIC_API_KEY,
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using ANTHROPIC provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
// Retrieve memories based on previous messages
|
||||
const memories = await retrieveMemories(messages, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: anthropic("claude-3-haiku-20240307"),
|
||||
messages: messages,
|
||||
system: memories.length > 0 ? memories : "No Memories Found"
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using ANTHROPIC provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
const memories = await retrieveMemories(prompt, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: anthropic("claude-3-haiku-20240307"),
|
||||
prompt: prompt,
|
||||
system: memories.length > 0 ? memories : "No Memories Found"
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,61 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { retrieveMemories } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
import { createCohere } from "@ai-sdk/cohere";
|
||||
|
||||
describe("COHERE Integration Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
let cohere: any;
|
||||
|
||||
beforeEach(() => {
|
||||
cohere = createCohere({
|
||||
apiKey: process.env.COHERE_API_KEY,
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using COHERE provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
// Retrieve memories based on previous messages
|
||||
const memories = await retrieveMemories(messages, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: cohere("command-r-plus"),
|
||||
messages: messages,
|
||||
system: memories,
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using COHERE provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
const memories = await retrieveMemories(prompt, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: cohere("command-r-plus"),
|
||||
prompt: prompt,
|
||||
system: memories
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,59 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { retrieveMemories } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
import { createGoogleGenerativeAI } from "@ai-sdk/google";
|
||||
|
||||
describe("GOOGLE Integration Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
let google: any;
|
||||
|
||||
beforeEach(() => {
|
||||
google = createGoogleGenerativeAI({
|
||||
apiKey: process.env.GOOGLE_API_KEY,
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using Google provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
// Retrieve memories based on previous messages
|
||||
const memories = await retrieveMemories(messages, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
model: google("gemini-1.5-flash"),
|
||||
messages: messages,
|
||||
system: memories,
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using Google provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
const memories = await retrieveMemories(prompt, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
model: google("gemini-1.5-flash"),
|
||||
prompt: prompt,
|
||||
system: memories
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,62 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { retrieveMemories } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
import { createGroq } from "@ai-sdk/groq";
|
||||
|
||||
describe("GROQ Integration Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
|
||||
let groq: any;
|
||||
|
||||
beforeEach(() => {
|
||||
groq = createGroq({
|
||||
apiKey: process.env.GROQ_API_KEY,
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using GROQ provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
// Retrieve memories based on previous messages
|
||||
const memories = await retrieveMemories(messages, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: groq("llama3-8b-8192"),
|
||||
messages: messages,
|
||||
system: memories,
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using GROQ provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
const memories = await retrieveMemories(prompt, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
// @ts-ignore
|
||||
model: groq("llama3-8b-8192"),
|
||||
prompt: prompt,
|
||||
system: memories
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,59 @@
|
||||
import dotenv from "dotenv";
|
||||
dotenv.config();
|
||||
|
||||
import { retrieveMemories } from "../../src";
|
||||
import { generateText } from "ai";
|
||||
import { LanguageModelV3Prompt } from '@ai-sdk/provider';
|
||||
import { testConfig } from "../../config/test-config";
|
||||
import { createOpenAI } from "@ai-sdk/openai";
|
||||
|
||||
describe("OPENAI Integration Tests", () => {
|
||||
const { userId } = testConfig;
|
||||
jest.setTimeout(30000);
|
||||
let openai: any;
|
||||
|
||||
beforeEach(() => {
|
||||
openai = createOpenAI({
|
||||
apiKey: process.env.OPENAI_API_KEY,
|
||||
});
|
||||
});
|
||||
|
||||
it("should retrieve memories and generate text using OpenAI provider", async () => {
|
||||
const messages: LanguageModelV3Prompt = [
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
{ type: "text", text: "Suggest me a good car to buy." },
|
||||
{ type: "text", text: " Write only the car name and it's color." },
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
// Retrieve memories based on previous messages
|
||||
const memories = await retrieveMemories(messages, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
model: openai("gpt-4-turbo"),
|
||||
messages: messages,
|
||||
system: memories,
|
||||
});
|
||||
|
||||
// Expect text to be a string
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it("should generate text using openai provider with memories", async () => {
|
||||
const prompt = "Suggest me a good car to buy.";
|
||||
const memories = await retrieveMemories(prompt, { user_id: userId });
|
||||
|
||||
const { text } = await generateText({
|
||||
model: openai("gpt-4-turbo"),
|
||||
prompt: prompt,
|
||||
system: memories
|
||||
});
|
||||
|
||||
expect(typeof text).toBe('string');
|
||||
expect(text.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,486 @@
|
||||
import { createMem0, Mem0Provider } from "../src";
|
||||
import { Mem0GenericLanguageModel } from "../src/mem0-generic-language-model";
|
||||
import { Mem0ClassSelector } from "../src/mem0-provider-selector";
|
||||
import Mem0AITextGenerator from "../src/provider-response-provider";
|
||||
import { Mem0ConfigSettings } from "../src/mem0-types";
|
||||
|
||||
// Mock fetch globally for memory API tests
|
||||
const mockFetch = jest.fn();
|
||||
global.fetch = mockFetch;
|
||||
|
||||
describe("V3 Provider Contract", () => {
|
||||
beforeEach(() => {
|
||||
mockFetch.mockReset();
|
||||
});
|
||||
|
||||
describe("Mem0Provider factory", () => {
|
||||
let provider: Mem0Provider;
|
||||
|
||||
beforeEach(() => {
|
||||
provider = createMem0({
|
||||
provider: "openai",
|
||||
mem0ApiKey: "test-key",
|
||||
apiKey: "test-openai-key",
|
||||
});
|
||||
});
|
||||
|
||||
it("should have specificationVersion v3", () => {
|
||||
expect(provider.specificationVersion).toBe("v3");
|
||||
});
|
||||
|
||||
it("should expose languageModel, chat, and completion methods", () => {
|
||||
expect(typeof provider.languageModel).toBe("function");
|
||||
expect(typeof provider.chat).toBe("function");
|
||||
expect(typeof provider.completion).toBe("function");
|
||||
});
|
||||
|
||||
it("should be callable as a function", () => {
|
||||
const model = provider("gpt-4o");
|
||||
expect(model).toBeDefined();
|
||||
expect(model.specificationVersion).toBe("v3");
|
||||
});
|
||||
|
||||
it("should throw when called with new keyword", () => {
|
||||
expect(() => new (provider as any)("gpt-4o")).toThrow(
|
||||
"The Mem0 model function cannot be called with the new keyword."
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Mem0GenericLanguageModel V3 interface", () => {
|
||||
let model: Mem0GenericLanguageModel;
|
||||
|
||||
beforeEach(() => {
|
||||
model = new Mem0GenericLanguageModel(
|
||||
"gpt-4o",
|
||||
{ user_id: "test-user" },
|
||||
{
|
||||
provider: "openai",
|
||||
mem0ApiKey: "test-key",
|
||||
apiKey: "test-openai-key",
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
it("should implement specificationVersion v3", () => {
|
||||
expect(model.specificationVersion).toBe("v3");
|
||||
});
|
||||
|
||||
it("should not have deprecated V2 properties", () => {
|
||||
expect((model as any).defaultObjectGenerationMode).toBeUndefined();
|
||||
expect((model as any).supportsImageUrls).toBeUndefined();
|
||||
});
|
||||
|
||||
it("should have supportedUrls as a record", () => {
|
||||
expect(model.supportedUrls).toBeDefined();
|
||||
expect(typeof model.supportedUrls).toBe("object");
|
||||
expect(model.supportedUrls["*"]).toBeDefined();
|
||||
expect(Array.isArray(model.supportedUrls["*"])).toBe(true);
|
||||
});
|
||||
|
||||
it("should have doGenerate and doStream methods", () => {
|
||||
expect(typeof model.doGenerate).toBe("function");
|
||||
expect(typeof model.doStream).toBe("function");
|
||||
});
|
||||
|
||||
it("should have provider and modelId properties", () => {
|
||||
expect(model.provider).toBe("openai");
|
||||
expect(model.modelId).toBe("gpt-4o");
|
||||
});
|
||||
});
|
||||
|
||||
describe("Mem0ClassSelector", () => {
|
||||
const supportedProviders = ["openai", "anthropic", "cohere", "groq", "google", "gemini"];
|
||||
|
||||
it.each(supportedProviders)("should accept %s as a valid provider", (providerName) => {
|
||||
const selector = new Mem0ClassSelector(
|
||||
"test-model",
|
||||
{ provider: providerName, apiKey: "test-key" }
|
||||
);
|
||||
expect(selector).toBeDefined();
|
||||
});
|
||||
|
||||
it("should throw for unsupported provider", () => {
|
||||
expect(
|
||||
() => new Mem0ClassSelector("test-model", { provider: "invalid-provider" })
|
||||
).toThrow("Model not supported: invalid-provider");
|
||||
});
|
||||
|
||||
it("should create a V3 provider instance", () => {
|
||||
const selector = new Mem0ClassSelector(
|
||||
"gpt-4o",
|
||||
{ provider: "openai", apiKey: "test-key" }
|
||||
);
|
||||
const provider = selector.createProvider();
|
||||
expect(provider.specificationVersion).toBe("v3");
|
||||
expect(typeof provider.doGenerate).toBe("function");
|
||||
expect(typeof provider.doStream).toBe("function");
|
||||
});
|
||||
});
|
||||
|
||||
describe("Provider modelType routing", () => {
|
||||
it("should create chat model with chat modelType", () => {
|
||||
const provider = createMem0({
|
||||
provider: "openai",
|
||||
mem0ApiKey: "test-key",
|
||||
apiKey: "test-openai-key",
|
||||
});
|
||||
|
||||
const chatModel = provider.chat("gpt-4o");
|
||||
expect(chatModel).toBeDefined();
|
||||
expect(chatModel.specificationVersion).toBe("v3");
|
||||
expect((chatModel as any).config.modelType).toBe("chat");
|
||||
});
|
||||
|
||||
it("should create completion model with completion modelType", () => {
|
||||
const provider = createMem0({
|
||||
provider: "openai",
|
||||
mem0ApiKey: "test-key",
|
||||
apiKey: "test-openai-key",
|
||||
});
|
||||
|
||||
const completionModel = provider.completion("gpt-4o");
|
||||
expect(completionModel).toBeDefined();
|
||||
expect(completionModel.specificationVersion).toBe("v3");
|
||||
expect((completionModel as any).config.modelType).toBe("completion");
|
||||
});
|
||||
});
|
||||
|
||||
describe("Default baseURL", () => {
|
||||
it("should default to https, not http", () => {
|
||||
const provider = createMem0({
|
||||
provider: "openai",
|
||||
mem0ApiKey: "test-key",
|
||||
});
|
||||
const model = provider("gpt-4o") as Mem0GenericLanguageModel;
|
||||
expect((model as any).config.baseURL).toMatch(/^https:\/\//);
|
||||
});
|
||||
});
|
||||
|
||||
describe("google/gemini alias routing", () => {
|
||||
it("should route google and gemini to the same provider", () => {
|
||||
const googleModel = new Mem0AITextGenerator(
|
||||
"gemini-2.0-flash",
|
||||
{ provider: "google", apiKey: "test-key" },
|
||||
{}
|
||||
);
|
||||
const geminiModel = new Mem0AITextGenerator(
|
||||
"gemini-2.0-flash",
|
||||
{ provider: "gemini", apiKey: "test-key" },
|
||||
{}
|
||||
);
|
||||
expect(googleModel.specificationVersion).toBe("v3");
|
||||
expect(geminiModel.specificationVersion).toBe("v3");
|
||||
expect(googleModel.modelId).toBe(geminiModel.modelId);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Graph memory removal", () => {
|
||||
it("should not have enable_graph in Mem0ConfigSettings type", () => {
|
||||
const config: Mem0ConfigSettings = {
|
||||
user_id: "test-user",
|
||||
mem0ApiKey: "test-key",
|
||||
};
|
||||
expect((config as any).enable_graph).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe("processMemories prompt cloning", () => {
|
||||
it("should not mutate the original prompt array", async () => {
|
||||
const model = new Mem0GenericLanguageModel(
|
||||
"gpt-4o",
|
||||
{ user_id: "test-user" },
|
||||
{
|
||||
provider: "openai",
|
||||
mem0ApiKey: "test-key",
|
||||
apiKey: "test-openai-key",
|
||||
}
|
||||
);
|
||||
|
||||
const originalPrompt = [
|
||||
{ role: "user" as const, content: [{ type: "text" as const, text: "Hello" }] },
|
||||
];
|
||||
const originalLength = originalPrompt.length;
|
||||
|
||||
// Mock both Mem0 API calls — addMemories (POST /v3/memories/add/) and getMemories (POST /v3/memories/search/)
|
||||
mockFetch
|
||||
.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({ results: [] }),
|
||||
})
|
||||
.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [
|
||||
{ memory: "User likes TypeScript" },
|
||||
],
|
||||
});
|
||||
|
||||
// Access processMemories via reflection
|
||||
const processMemories = (model as any).processMemories.bind(model);
|
||||
await processMemories(originalPrompt, { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
|
||||
// Original prompt should NOT have been mutated
|
||||
expect(originalPrompt.length).toBe(originalLength);
|
||||
});
|
||||
});
|
||||
|
||||
describe("getMemories normalization", () => {
|
||||
it("should return a flat array when API returns a flat array", async () => {
|
||||
const { getMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [
|
||||
{ memory: "User prefers dark mode" },
|
||||
{ memory: "User likes React" },
|
||||
],
|
||||
});
|
||||
|
||||
const result = await getMemories("test query", { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
expect(Array.isArray(result)).toBe(true);
|
||||
expect(result).toHaveLength(2);
|
||||
expect(result[0].memory).toBe("User prefers dark mode");
|
||||
});
|
||||
|
||||
it("should return a flat array when API returns { results: [...] }", async () => {
|
||||
const { getMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
results: [
|
||||
{ memory: "User prefers dark mode" },
|
||||
],
|
||||
}),
|
||||
});
|
||||
|
||||
const result = await getMemories("test query", { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
expect(Array.isArray(result)).toBe(true);
|
||||
expect(result).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("should return empty array when API returns empty results", async () => {
|
||||
const { getMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [],
|
||||
});
|
||||
|
||||
const result = await getMemories("test query", { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
expect(Array.isArray(result)).toBe(true);
|
||||
expect(result).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("retrieveMemories normalization", () => {
|
||||
it("should return empty string when no memories exist", async () => {
|
||||
const { retrieveMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [],
|
||||
});
|
||||
|
||||
const result = await retrieveMemories("test query", { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
expect(result).toBe("");
|
||||
});
|
||||
|
||||
it("should return formatted string when memories exist as flat array", async () => {
|
||||
const { retrieveMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [
|
||||
{ memory: "User likes pizza" },
|
||||
],
|
||||
});
|
||||
|
||||
const result = await retrieveMemories("test query", { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
expect(result).toContain("System Message:");
|
||||
expect(result).toContain("User likes pizza");
|
||||
});
|
||||
|
||||
it("should return formatted string when memories come as { results: [...] }", async () => {
|
||||
const { retrieveMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
results: [{ memory: "User likes pizza" }],
|
||||
}),
|
||||
});
|
||||
|
||||
const result = await retrieveMemories("test query", { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
expect(result).toContain("System Message:");
|
||||
expect(result).toContain("User likes pizza");
|
||||
});
|
||||
});
|
||||
|
||||
describe("top_k zero handling", () => {
|
||||
it("should respect top_k: 0 and not fall back to default", async () => {
|
||||
const { searchMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [],
|
||||
});
|
||||
|
||||
await searchMemories("test query", {
|
||||
mem0ApiKey: "test-key",
|
||||
user_id: "test-user",
|
||||
top_k: 0,
|
||||
});
|
||||
|
||||
const body = JSON.parse(mockFetch.mock.calls[0][1].body);
|
||||
expect(body.top_k).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Mem0 v3 API migration", () => {
|
||||
it("should call /v3/memories/search/ endpoint for search", async () => {
|
||||
const { searchMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [],
|
||||
});
|
||||
|
||||
await searchMemories("test query", { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
|
||||
const url = mockFetch.mock.calls[0][0];
|
||||
expect(url).toBe("https://api.mem0.ai/v3/memories/search/");
|
||||
});
|
||||
|
||||
it("should call /v3/memories/add/ endpoint for add", async () => {
|
||||
const { addMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({ message: "ok", status: "PENDING", event_id: "test" }),
|
||||
});
|
||||
|
||||
await addMemories(
|
||||
[{ role: "user" as const, content: [{ type: "text" as const, text: "Hello" }] }],
|
||||
{ mem0ApiKey: "test-key", user_id: "test-user" }
|
||||
);
|
||||
|
||||
const url = mockFetch.mock.calls[0][0];
|
||||
expect(url).toBe("https://api.mem0.ai/v3/memories/add/");
|
||||
});
|
||||
|
||||
it("should put entity IDs inside filters for search (not top-level)", async () => {
|
||||
const { searchMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [],
|
||||
});
|
||||
|
||||
await searchMemories("test query", {
|
||||
mem0ApiKey: "test-key",
|
||||
user_id: "user-123",
|
||||
agent_id: "agent-456",
|
||||
});
|
||||
|
||||
const body = JSON.parse(mockFetch.mock.calls[0][1].body);
|
||||
expect(body.filters.user_id).toBe("user-123");
|
||||
expect(body.filters.agent_id).toBe("agent-456");
|
||||
// Should NOT be top-level
|
||||
expect(body.user_id).toBeUndefined();
|
||||
expect(body.agent_id).toBeUndefined();
|
||||
});
|
||||
|
||||
it("should not send deprecated v2 params (version, output_format, org_id, etc.)", async () => {
|
||||
const { searchMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [],
|
||||
});
|
||||
|
||||
await searchMemories("test query", { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
|
||||
const body = JSON.parse(mockFetch.mock.calls[0][1].body);
|
||||
expect(body.version).toBeUndefined();
|
||||
expect(body.output_format).toBeUndefined();
|
||||
expect(body.org_id).toBeUndefined();
|
||||
expect(body.project_id).toBeUndefined();
|
||||
expect(body.org_name).toBeUndefined();
|
||||
expect(body.project_name).toBeUndefined();
|
||||
});
|
||||
|
||||
it("should not send deprecated params in add body", async () => {
|
||||
const { addMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => ({ message: "ok", status: "PENDING", event_id: "test" }),
|
||||
});
|
||||
|
||||
await addMemories(
|
||||
[{ role: "user" as const, content: [{ type: "text" as const, text: "Hello" }] }],
|
||||
{ mem0ApiKey: "test-key", user_id: "test-user" }
|
||||
);
|
||||
|
||||
const body = JSON.parse(mockFetch.mock.calls[0][1].body);
|
||||
expect(body.version).toBeUndefined();
|
||||
expect(body.async_mode).toBeUndefined();
|
||||
expect(body.output_format).toBeUndefined();
|
||||
expect(body.enable_graph).toBeUndefined();
|
||||
expect(body.filter_memories).toBeUndefined();
|
||||
expect(body.org_id).toBeUndefined();
|
||||
expect(body.project_id).toBeUndefined();
|
||||
// Should have entity ID at top-level for add endpoint
|
||||
expect(body.user_id).toBe("test-user");
|
||||
});
|
||||
|
||||
it("should not have deprecated fields in Mem0ConfigSettings type", () => {
|
||||
const config: Mem0ConfigSettings = {
|
||||
user_id: "test-user",
|
||||
mem0ApiKey: "test-key",
|
||||
};
|
||||
expect((config as any).org_id).toBeUndefined();
|
||||
expect((config as any).project_id).toBeUndefined();
|
||||
expect((config as any).org_name).toBeUndefined();
|
||||
expect((config as any).project_name).toBeUndefined();
|
||||
expect((config as any).output_format).toBeUndefined();
|
||||
expect((config as any).filter_memories).toBeUndefined();
|
||||
expect((config as any).async_mode).toBeUndefined();
|
||||
expect((config as any).enable_graph).toBeUndefined();
|
||||
});
|
||||
|
||||
it("should default top_k to 10 (v3 default) when not provided", async () => {
|
||||
const { searchMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [],
|
||||
});
|
||||
|
||||
await searchMemories("test query", { mem0ApiKey: "test-key", user_id: "test-user" });
|
||||
|
||||
const body = JSON.parse(mockFetch.mock.calls[0][1].body);
|
||||
expect(body.top_k).toBe(10);
|
||||
});
|
||||
|
||||
it("should merge user-provided filters with entity ID filters", async () => {
|
||||
const { searchMemories } = require("../src/mem0-utils");
|
||||
|
||||
mockFetch.mockResolvedValueOnce({
|
||||
ok: true,
|
||||
json: async () => [],
|
||||
});
|
||||
|
||||
await searchMemories("test query", {
|
||||
mem0ApiKey: "test-key",
|
||||
user_id: "user-123",
|
||||
filters: { category: "preferences" },
|
||||
});
|
||||
|
||||
const body = JSON.parse(mockFetch.mock.calls[0][1].body);
|
||||
expect(body.filters.user_id).toBe("user-123");
|
||||
expect(body.filters.category).toBe("preferences");
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,29 @@
|
||||
{
|
||||
"$schema": "https://json.schemastore.org/tsconfig",
|
||||
"compilerOptions": {
|
||||
"composite": false,
|
||||
"declaration": true,
|
||||
"declarationMap": true,
|
||||
"esModuleInterop": true,
|
||||
"forceConsistentCasingInFileNames": true,
|
||||
"inlineSources": false,
|
||||
"isolatedModules": true,
|
||||
"moduleResolution": "node16",
|
||||
"noUnusedLocals": false,
|
||||
"noUnusedParameters": false,
|
||||
"preserveWatchOutput": true,
|
||||
"skipLibCheck": true,
|
||||
"strict": true,
|
||||
"types": ["@types/node", "jest"],
|
||||
"jsx": "react-jsx",
|
||||
"lib": ["dom", "ES2021"],
|
||||
"module": "Node16",
|
||||
"target": "ES2018",
|
||||
"stripInternal": true,
|
||||
"paths": {
|
||||
"@/*": ["./src/*"]
|
||||
}
|
||||
},
|
||||
"include": ["."],
|
||||
"exclude": ["dist", "build", "node_modules"]
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
import { defineConfig } from 'tsup'
|
||||
|
||||
export default defineConfig([
|
||||
{
|
||||
dts: true,
|
||||
entry: ['src/index.ts'],
|
||||
format: ['cjs', 'esm'],
|
||||
sourcemap: true,
|
||||
},
|
||||
])
|
||||
Reference in New Issue
Block a user