JDSS/mem0
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update Docs (#2277)

Browse Source
This commit is contained in:
Saket Aryan
2025-02-28 16:37:05 -08:00
committed by GitHub
parent c1aba35884
commit 5606c3ffb8
30 changed files with 437 additions and 877 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/open-source-typescript/components/embedders/config.mdx
-56
View File
@@ -1,56 +0,0 @@
---
title: Configurations
icon: "gear"
iconType: "solid"
---
Config in Mem0 is a dictionary that specifies the settings for your embedding models. It allows you to customize the behavior and connection details of your chosen embedder.
## How to define configurations?
The config is defined as a TypeScript object with two main keys:
- `embedder`: Specifies the embedder provider and its configuration
- `provider`: The name of the embedder (e.g., "openai", "ollama")
- `config`: A nested object containing provider-specific settings
## How to use configurations?
Here's a general example of how to use the config with Mem0:
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
embedder: {
provider: 'openai',
config: {
apiKey: 'your-openai-api-key',
model: 'text-embedding-3-small',
},
},
};
const memory = new Memory(config);
await memory.add("Your text here", { userId: "user", metadata: { category: "example" } });
```
## Why is Config Needed?
Config is essential for:
1. Specifying which embedding model to use.
2. Providing necessary connection details (e.g., model, api_key, embedding_dims).
3. Ensuring proper initialization and connection to your chosen embedder.
## Master List of All Params in Config
Here's a comprehensive list of all parameters that can be used across different embedders:
| Parameter | Description |
|------------------------|--------------------------------------------------|
| `model` | Embedding model to use |
| `apiKey` | API key of the provider |
| `embeddingDims` | Dimensions of the embedding model |
## Supported Embedding Models
For detailed information on configuring specific embedders, please visit the [Embedding Models](./models) section. There you'll find information for each supported embedder with provider-specific usage examples and configuration details.
docs/open-source-typescript/components/embedders/models/openai.mdx
-36
View File
@@ -1,36 +0,0 @@
---
title: OpenAI
---
To use OpenAI embedding models, you need to provide the API key directly in your configuration. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).
### Usage
Here's how to configure OpenAI embedding models in your application:
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
embedder: {
provider: 'openai',
config: {
apiKey: 'your-openai-api-key',
model: 'text-embedding-3-large',
},
},
};
const memory = new Memory(config);
await memory.add("I'm visiting Paris", { userId: "john" });
```
### Config
Here are the parameters available for configuring the OpenAI embedder:
| Parameter | Description | Default Value |
|------------------------|--------------------------------------------------|---------------|
| `model` | The name of the embedding model to use | `text-embedding-3-small` |
| `embedding_dims` | Dimensions of the embedding model | `1536` |
| `api_key` | The OpenAI API key | `None` |
docs/open-source-typescript/components/embedders/overview.mdx
-21
View File
@@ -1,21 +0,0 @@
---
title: Overview
icon: "info"
iconType: "solid"
---
Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs.
## Supported Embedders
See the list of supported embedders below.
<CardGroup cols={1}>
<Card title="OpenAI" href="/components/embedders/models/openai"></Card>
</CardGroup>
## Usage
To utilize a embedder, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the embedder.
For a comprehensive list of available parameters for embedder configuration, please refer to [Config](./config).
docs/open-source-typescript/components/llms/config.mdx
-85
View File
@@ -1,85 +0,0 @@
---
title: Configurations
icon: "gear"
iconType: "solid"
---
## How to define configurations?
The `config` is defined as a TypeScript object with two main keys:
- `llm`: Specifies the LLM provider and its configuration
- `provider`: The name of the LLM (e.g., "openai", "groq")
- `config`: A nested object containing provider-specific settings
### Config Values Precedence
Config values are applied in the following order of precedence (from highest to lowest):
1. Values explicitly set in the `config` object
2. Environment variables (e.g., `OPENAI_API_KEY`, `OPENAI_API_BASE`)
3. Default values defined in the LLM implementation
This means that values specified in the `config` object will override corresponding environment variables, which in turn override default values.
## How to Use Config
Here's a general example of how to use the config with Mem0:
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
llm: {
provider: 'openai',
config: {
apiKey: process.env.OPENAI_API_KEY || '',
model: 'gpt-4-turbo-preview',
temperature: 0.2,
maxTokens: 1500,
},
},
embedder: {
provider: 'openai',
config: {
apiKey: process.env.OPENAI_API_KEY || '',
model: 'text-embedding-3-small',
},
},
vectorStore: {
provider: 'memory',
config: {
collectionName: 'memories',
dimension: 1536,
},
},
historyDbPath: 'memory.db',
};
const memory = new Memory(config);
memory.add("Your text here", { userId: "user123", metadata: { category: "example" } });
```
## Why is Config Needed?
Config is essential for:
1. Specifying which LLM to use.
2. Providing necessary connection details (e.g., model, api_key, temperature).
3. Ensuring proper initialization and connection to your chosen LLM.
## Master List of All Params in Config
Here's a comprehensive list of all parameters that can be used across different LLMs:
| Parameter | Description | Provider |
|----------------------|-----------------------------------------------|-------------------|
| `model` | Embedding model to use | All |
| `temperature` | Temperature of the model | All |
| `apiKey` | API key to use | All |
| `maxTokens` | Tokens to generate | All |
| `topP` | Probability threshold for nucleus sampling | All |
| `topK` | Number of highest probability tokens to keep | All |
| `openaiBaseUrl` | Base URL for OpenAI API | OpenAI |
## Supported LLMs
For detailed information on configuring specific LLMs, please visit the [LLMs](./models) section. There you'll find information for each supported LLM with provider-specific usage examples and configuration details.
docs/open-source-typescript/components/llms/models/anthropic.mdx
-30
View File
@@ -1,30 +0,0 @@
---
title: Anthropic
---
To use Anthropic's models, please set the `ANTHROPIC_API_KEY`, which you can find on their [Account Settings Page](https://console.anthropic.com/account/keys).
## Usage
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
llm: {
provider: 'anthropic',
config: {
apiKey: process.env.ANTHROPIC_API_KEY || '',
model: 'claude-3-7-sonnet-latest',
temperature: 0.1,
maxTokens: 2000,
},
},
};
const memory = new Memory(config);
await memory.add("Likes to play cricket on weekends", { userId: "alice", metadata: { category: "hobbies" } });
```
## Config
All available parameters for the `anthropic` config are present in the [Master List of All Params in Config](../config).
docs/open-source-typescript/components/llms/models/groq.mdx
-32
View File
@@ -1,32 +0,0 @@
---
title: Groq
---
[Groq](https://groq.com/) is the creator of the world's first Language Processing Unit (LPU), providing exceptional speed performance for AI workloads running on their LPU Inference Engine.
In order to use LLMs from Groq, go to their [platform](https://console.groq.com/keys) and get the API key. Set the API key as `GROQ_API_KEY` environment variable to use the model as given below in the example.
## Usage
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
llm: {
provider: 'groq',
config: {
apiKey: process.env.GROQ_API_KEY || '',
model: 'mixtral-8x7b-32768',
temperature: 0.1,
maxTokens: 1000,
},
},
};
const memory = new Memory(config);
await memory.add("Likes to play cricket on weekends", { userId: "alice", metadata: { category: "hobbies" } });
```
## Config
All available parameters for the `groq` config are present in the [Master List of All Params in Config](../config).
docs/open-source-typescript/components/llms/models/openai.mdx
-30
View File
@@ -1,30 +0,0 @@
---
title: OpenAI
---
To use OpenAI LLM models, you need to set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).
## Usage
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
llm: {
provider: 'openai',
config: {
apiKey: process.env.OPENAI_API_KEY || '',
model: 'gpt-4-turbo-preview',
temperature: 0.2,
maxTokens: 1500,
},
},
};
const memory = new Memory(config);
await memory.add("Likes to play cricket on weekends", { userId: "alice", metadata: { category: "hobbies" } });
```
## Config
All available parameters for the `openai` config are present in the [Master List of All Params in Config](../config).
docs/open-source-typescript/components/llms/overview.mdx
-45
View File
@@ -1,45 +0,0 @@
---
title: Overview
icon: "info"
iconType: "solid"
---
Mem0 includes built-in support for various popular large language models. Memory can utilize the LLM provided by the user, ensuring efficient use for specific needs.
## Usage
To use a llm, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `OpenAI` will be used as the llm.
For a comprehensive list of available parameters for llm configuration, please refer to [Config](./config).
To view all supported llms, visit the [Supported LLMs](./models).
<CardGroup cols={3}>
<Card title="OpenAI" href="/open-source-typescript/components/llms/models/openai"></Card>
<Card title="Anthropic" href="/open-source-typescript/components/llms/models/anthropic"></Card>
<Card title="Groq" href="/open-source-typescript/components/llms/models/groq"></Card>
</CardGroup>
## Structured vs Unstructured Outputs
Mem0 supports two types of OpenAI LLM formats, each with its own strengths and use cases:
### Structured Outputs
Structured outputs are LLMs that align with OpenAI's structured outputs model:
- **Optimized for:** Returning structured responses (e.g., JSON objects)
- **Benefits:** Precise, easily parseable data
- **Ideal for:** Data extraction, form filling, API responses
- **Learn more:** [OpenAI Structured Outputs Guide](https://platform.openai.com/docs/guides/structured-outputs/introduction)
### Unstructured Outputs
Unstructured outputs correspond to OpenAI's standard, free-form text model:
- **Flexibility:** Returns open-ended, natural language responses
- **Customization:** Use the `response_format` parameter to guide output
- **Trade-off:** Less efficient than structured outputs for specific data needs
- **Best for:** Creative writing, explanations, general conversation
Choose the format that best suits your application's requirements for optimal performance and usability.
docs/open-source-typescript/components/vectordbs/config.mdx
-100
View File
@@ -1,100 +0,0 @@
---
title: Configurations
icon: "gear"
iconType: "solid"
---
## How to define configurations?
The `config` is defined as a TypeScript object with two main keys:
- `vectorStore`: Specifies the vector database provider and its configuration
- `provider`: The name of the vector database (e.g., "chroma", "pgvector", "qdrant", "milvus", "azure_ai_search", "redis", "memory")
- `config`: A nested object containing provider-specific settings
## In-Memory Storage Option
We also support an in-memory storage option for the vector store, which is useful for reduced overhead and faster access times. Here's how to configure it:
### Example for In-Memory Storage
```typescript
const configMemory = {
vector_store: {
provider: 'memory',
config: {
collectionName: 'memories',
dimension: 1536,
},
},
};
const memory = new Memory(configMemory);
await memory.add("Your text here", { userId: "user", metadata: { category: "example" } });
```
## How to Use Config
Here's a general example of how to use the config with Mem0:
### Example for qdrant
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
vector_store: {
provider: 'qdrant',
config: {
collectionName: 'memories',
embeddingModelDims: 1536,
host: 'localhost',
port: 6333,
url: 'https://your-qdrant-url.com',
apiKey: 'your-qdrant-api-key',
onDisk: true,
},
},
};
const memory = new Memory(config);
await memory.add("Your text here", { userId: "user", metadata: { category: "example" } });
```
## Why is Config Needed?
Config is essential for:
1. Specifying which vector database to use.
2. Providing necessary connection details (e.g., host, port, credentials).
3. Customizing database-specific settings (e.g., collection name, path).
4. Ensuring proper initialization and connection to your chosen vector store.
## Master List of All Params in Config
Here's a comprehensive list of all parameters that can be used across different vector databases:
| Parameter | Description |
|------------------------|--------------------------------------|
| `collectionName` | Name of the collection |
| `dimension` | Dimensions of the embedding model |
| `host` | Host where the server is running |
| `port` | Port where the server is running |
| `embeddingModelDims` | Dimensions of the embedding model |
| `url` | URL for the Qdrant server |
| `apiKey` | API key for the Qdrant server |
| `path` | Path for the Qdrant server |
| `onDisk` | Enable persistent storage (for Qdrant) |
| `redisUrl` | URL for the Redis server |
| `username` | Username for Redis connection |
| `password` | Password for Redis connection |
## Customizing Config
Each vector database has its own specific configuration requirements. To customize the config for your chosen vector store:
1. Identify the vector database you want to use from [supported vector databases](./dbs).
2. Refer to the `Config` section in the respective vector database's documentation.
3. Include only the relevant parameters for your chosen database in the `config` object.
## Supported Vector Databases
For detailed information on configuring specific vector databases, please visit the [Supported Vector Databases](./dbs) section. There you'll find individual pages for each supported vector store with provider-specific usage examples and configuration details.
docs/open-source-typescript/components/vectordbs/dbs/pgvector.mdx
-44
View File
@@ -1,44 +0,0 @@
[pgvector](https://github.com/pgvector/pgvector) is open-source vector similarity search for Postgres. After connecting with Postgres, run `CREATE EXTENSION IF NOT EXISTS vector;` to create the vector extension.
### Usage
Here's how to configure pgvector in your application:
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
vector_store: {
provider: 'pgvector',
config: {
collectionName: 'memories',
dimension: 1536,
dbname: 'vectordb',
user: 'postgres',
password: 'postgres',
host: 'localhost',
port: 5432,
embeddingModelDims: 1536,
hnsw: true,
},
},
};
const memory = new Memory(config);
await memory.add("Likes to play cricket on weekends", { userId: "alice", metadata: { category: "hobbies" } });
```
### Config
Here's the parameters available for configuring pgvector:
| Parameter | Description | Default Value |
|------------------------|--------------------------------------------------|---------------|
| `dbname` | The name of the database | `postgres` |
| `collectionName` | The name of the collection | `mem0` |
| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
| `user` | Username to connect to the database | `None` |
| `password` | Password to connect to the database | `None` |
| `host` | The host where the Postgres server is running | `None` |
| `port` | The port where the Postgres server is running | `None` |
| `hnsw` | Enable HNSW indexing | `False` |
docs/open-source-typescript/components/vectordbs/dbs/qdrant.mdx
-42
View File
@@ -1,42 +0,0 @@
[Qdrant](https://qdrant.tech/) is an open-source vector search engine. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data.
### Usage
Here's how to configure Qdrant in your application:
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
vector_store: {
provider: 'qdrant',
config: {
collectionName: 'memories',
embeddingModelDims: 1536,
host: 'localhost',
port: 6333,
url: 'https://your-qdrant-url.com',
apiKey: 'your-qdrant-api-key',
onDisk: true,
},
},
};
const memory = new Memory(config);
await memory.add("Likes to play cricket on weekends", { userId: "alice", metadata: { category: "hobbies" } });
```
### Config
Let's see the available parameters for the `qdrant` config:
| Parameter | Description | Default Value |
|------------------------|--------------------------------------------------|---------------|
| `collectionName` | The name of the collection to store the vectors | `mem0` |
| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
| `host` | The host where the Qdrant server is running | `None` |
| `port` | The port where the Qdrant server is running | `None` |
| `path` | Path for the Qdrant database | `/tmp/qdrant` |
| `url` | Full URL for the Qdrant server | `None` |
| `apiKey` | API key for the Qdrant server | `None` |
| `onDisk` | For enabling persistent storage | `False` |
docs/open-source-typescript/components/vectordbs/dbs/redis.mdx
-47
View File
@@ -1,47 +0,0 @@
[Redis](https://redis.io/) is a scalable, real-time database that can store, search, and analyze vector data.
### Installation
```bash
pip install redis redisvl
```
Redis Stack using Docker:
```bash
docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
```
### Usage
Here's how to configure Redis in your application:
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
vector_store: {
provider: 'redis',
config: {
collectionName: 'memories',
embeddingModelDims: 1536,
redisUrl: 'redis://localhost:6379',
username: 'your-redis-username',
password: 'your-redis-password',
},
},
};
const memoryRedis = new Memory(config);
await memoryRedis.add("Likes to play cricket on weekends", { userId: "alice", metadata: { category: "hobbies" } });
```
### Config
Let's see the available parameters for the `redis` config:
| Parameter | Description | Default Value |
|------------------------|--------------------------------------------------|---------------|
| `collectionName` | The name of the collection to store the vectors | `mem0` |
| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
| `redisUrl` | The URL of the Redis server | `None` |
| `username` | Username for Redis connection | `None` |
| `password` | Password for Redis connection | `None` |
docs/open-source-typescript/components/vectordbs/overview.mdx
-36
View File
@@ -1,36 +0,0 @@
---
title: Overview
icon: "info"
iconType: "solid"
---
Mem0 includes built-in support for various popular databases. Memory can utilize the database provided by the user, ensuring efficient use for specific needs.
## Supported Vector Databases
See the list of supported vector databases below.
<CardGroup cols={2}>
<Card title="Memory" href="/components/vectordbs/dbs/memory"></Card>
<Card title="Qdrant" href="/components/vectordbs/dbs/qdrant"></Card>
<Card title="Redis" href="/components/vectordbs/dbs/redis"></Card>
<Card title="Pgvector" href="/components/vectordbs/dbs/pgvector"></Card>
</CardGroup>
## Usage
To utilize a vector database, you must provide a configuration to customize its usage. If no configuration is supplied, a default configuration will be applied, and `Memory` will be used as the vector database.
For a comprehensive list of available parameters for vector database configuration, please refer to [Config](./config).
## Common issues
### Using model with different dimensions
If you are using customized model, which is having different dimensions other than 1536
for example 768, you may encounter below error:
`ValueError: shapes (0,1536) and (768,) not aligned: 1536 (dim 1) != 768 (dim 0)`
you could add `"embedding_model_dims": 768,` to the config of the vector_store to overcome this issue.
docs/open-source-typescript/features/custom-prompts.mdx
-141
View File
@@ -1,141 +0,0 @@
---
title: Custom Prompts
description: 'Enhance your product experience by adding custom prompts tailored to your needs'
icon: "pencil"
iconType: "solid"
---
## Introduction to Custom Prompts
Custom prompts allow you to tailor the behavior of your Mem0 instance to specific use cases or domains.
By defining a custom prompt, you can control how information is extracted, processed, and stored in your memory system.
To create an effective custom prompt:
1. Be specific about the information to extract.
2. Provide few-shot examples to guide the LLM.
3. Ensure examples follow the format shown below.
Example of a custom prompt:
```typescript
const customPrompt = `
Please only extract entities containing customer support information, order details, and user information.
Here are some few shot examples:
Input: Hi.
Output: {"facts" : []}
Input: The weather is nice today.
Output: {"facts" : []}
Input: My order #12345 hasn't arrived yet.
Output: {"facts" : ["Order #12345 not received"]}
Input: I'm John Doe, and I'd like to return the shoes I bought last week.
Output: {"facts" : ["Customer name: John Doe", "Wants to return shoes", "Purchase made last week"]}
Input: I ordered a red shirt, size medium, but received a blue one instead.
Output: {"facts" : ["Ordered red shirt, size medium", "Received blue shirt instead"]}
Return the facts and customer information in a json format as shown above.
`;
```
Here we initialize the custom prompt in the config:
```typescript
import { Memory } from 'mem0ai/oss';
const config = {
version: 'v1.1',
embedder: {
provider: 'openai',
config: {
apiKey: process.env.OPENAI_API_KEY || '',
model: 'text-embedding-3-small',
},
},
vectorStore: {
provider: 'memory',
config: {
collectionName: 'memories',
dimension: 1536,
},
},
llm: {
provider: 'openai',
config: {
apiKey: process.env.OPENAI_API_KEY || '',
model: 'gpt-4-turbo-preview',
temperature: 0.2,
maxTokens: 1500,
},
},
customPrompt: customPrompt,
historyDbPath: 'memory.db',
};
const memory = new Memory(config);
```
### Example 1
In this example, we are adding a memory of a user ordering a laptop. As seen in the output, the custom prompt is used to extract the relevant information from the user's message.
<CodeGroup>
```typescript Code
await memory.add('Yesterday, I ordered a laptop, the order id is 12345', { userId: "user123" });
```
```json Output
{
"results": [
{
"id": "c03c9045-df76-4949-bbc5-d5dc1932aa5c",
"memory": "Ordered a laptop",
"metadata": {}
},
{
"id": "cbb1fe73-0bf1-4067-8c1f-63aa53e7b1a4",
"memory": "Order ID: 12345",
"metadata": {}
},
{
"id": "e5f2a012-3b45-4c67-9d8e-123456789abc",
"memory": "Order placed yesterday",
"metadata": {}
}
]
}
```
</CodeGroup>
### Example 2
In this example, we are adding a memory of a user liking to go on hikes. This add message is not specific to the use-case mentioned in the custom prompt.
Hence, the memory is not added.
<CodeGroup>
```typescript Code
await memory.add('I like going to hikes', { userId: "user123" });
```
```json Output
{
"results": []
}
```
</CodeGroup>
You can also use custom prompts with chat messages:
```typescript
const messages = [
{ role: 'user', content: 'Hi, I ordered item #54321 last week but haven\'t received it yet.' },
{ role: 'assistant', content: 'I understand you\'re concerned about your order #54321. Let me help track that for you.' }
];
await memory.add(messages, { userId: "user123" });
```
The custom prompt will process both the user and assistant messages to extract relevant information according to the defined format.
docs/open-source-typescript/quickstart.mdx
+1 -1
View File
@@ -1,5 +1,5 @@
---
title: Node.js Guide
title: Node SDK
description: 'Get started with Mem0 quickly!'
icon: "node"
iconType: "solid"