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

docs: navigation (#5900)

Browse Source
This commit is contained in:
Kartik
2026-07-01 22:48:23 +05:30
committed by GitHub
parent f2532f072f
commit 207f65deda
107 changed files with 951 additions and 1296 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/open-source/configuration.mdx
+80 -87
View File
@@ -1,63 +1,47 @@
---
title: "Configure the OSS Stack"
description: "Wire up Mem0 OSS with your preferred LLM, vector store, embedder, and reranker."
description: "Configure Mem0 OSS in Python or TypeScript with your own LLM, embedder, and vector store."
icon: "sliders"
---
# Configure Mem0 OSS Components
Mem0 OSS works out of the box with OpenAI defaults. Point it at your own LLM, embedder, and vector store by passing a config when you create `Memory`. The Python SDK also supports a reranker and graph memory.
<Info>
**Prerequisites**
- Python 3.10+ with `pip` available
- Running vector database (e.g., Qdrant, Postgres + pgvector) or access credentials for a managed store
- API keys for your chosen LLM, embedder, and reranker providers
- Python 3.10+ (`pip`) or Node.js 18+ (`npm`)
- A running vector store such as Qdrant or Postgres + pgvector (Python's default Qdrant and Node's in-memory store need nothing extra)
- API keys for your chosen LLM and embedder providers
</Info>
<Tip>
Start from the <Link href="/open-source/python-quickstart">Python quickstart</Link> if you still need the base CLI and repository.
New to Mem0 OSS? Run the <Link href="/open-source/python-quickstart">Python</Link> or <Link href="/open-source/node-quickstart">Node.js</Link> quickstart first, then come back to swap in your own providers.
</Tip>
## Install dependencies
<Tabs>
<Tab title="Python">
<Steps>
<Step title="Install Mem0 OSS">
```bash
<CodeGroup>
```bash pip
pip install mem0ai
```
</Step>
<Step title="Add provider SDKs (example: Qdrant + OpenAI)">
```bash
pip install qdrant-client openai
```bash npm
npm install mem0ai
```
</Step>
</Steps>
</Tab>
<Tab title="Docker Compose">
<Steps>
<Step title="Clone the repo and copy the compose file">
</CodeGroup>
Using Qdrant as your vector store? Install its Python client (the Node SDK talks to Qdrant over REST) and run the server locally:
```bash
git clone https://github.com/mem0ai/mem0.git
cd mem0/examples/docker-compose
pip install qdrant-client # Python only
docker run -p 6333:6333 qdrant/qdrant
```
</Step>
<Step title="Install dependencies for local overrides">
```bash
pip install -r requirements.txt
```
</Step>
</Steps>
</Tab>
</Tabs>
## Define your configuration
<Tabs>
<Tab title="Python">
<Steps>
<Step title="Create a configuration dictionary">
```python
Each component takes a `provider` and a `config`. Keys are `snake_case` in Python and `camelCase` in TypeScript. Pass the config when you create `Memory`:
<CodeGroup>
```python Python
from mem0 import Memory
config = {
@@ -67,11 +51,11 @@ config = {
},
"llm": {
"provider": "openai",
"config": {"model": "gpt-4.1-mini", "temperature": 0.1},
"config": {"model": "gpt-5-mini", "temperature": 0.1},
},
"embedder": {
"provider": "vertexai",
"config": {"model": "textembedding-gecko@003"},
"provider": "openai",
"config": {"model": "text-embedding-3-small"},
},
"reranker": {
"provider": "cohere",
@@ -81,86 +65,95 @@ config = {
memory = Memory.from_config(config)
```
</Step>
<Step title="Store secrets as environment variables">
```ts Node.js
import { Memory } from "mem0ai/oss";
const memory = new Memory({
llm: {
provider: "openai",
config: { apiKey: process.env.OPENAI_API_KEY || "", model: "gpt-5-mini", temperature: 0.1 },
},
embedder: {
provider: "openai",
config: { apiKey: process.env.OPENAI_API_KEY || "", model: "text-embedding-3-small" },
},
vectorStore: {
provider: "qdrant",
config: { host: "localhost", port: 6333, collectionName: "memories" },
},
});
```
</CodeGroup>
Set your provider keys as environment variables:
```bash
export QDRANT_API_KEY="..."
export OPENAI_API_KEY="..."
export COHERE_API_KEY="..."
export COHERE_API_KEY="..." # Python reranker only
```
</Step>
</Steps>
</Tab>
<Tab title="config.yaml">
<Steps>
<Step title="Create a `config.yaml` file">
```yaml
vector_store:
provider: qdrant
config:
host: localhost
port: 6333
llm:
provider: azure_openai
config:
api_key: ${AZURE_OPENAI_KEY}
deployment_name: gpt-4.1-mini
<Note>
The TypeScript OSS SDK configures the LLM, embedder, vector store, and history store. Reranker and graph memory are Python-only today.
</Note>
embedder:
provider: ollama
config:
model: nomic-embed-text
Prefer a config file? Load YAML into Python's `from_config`:
reranker:
provider: zero_entropy
config:
api_key: ${ZERO_ENTROPY_KEY}
```
</Step>
<Step title="Load the config file at runtime">
```python
import yaml
from mem0 import Memory
memory = Memory.from_config_file("config.yaml")
with open("config.yaml") as f:
config = yaml.safe_load(f)
memory = Memory.from_config(config)
```
</Step>
</Steps>
</Tab>
</Tabs>
<Info icon="check">
Run `memory.add("Remember my favorite cafe in Tokyo.", user_id="alex")` and then `memory.search("favorite cafe", filters={"user_id": "alex"})`. You should see the Qdrant collection populate and the reranker mark the memory as a top hit.
Verify it works: add a memory and search it back. `memory.add(...)` followed by `memory.search(...)` should populate your vector store and return the memory as a top hit.
</Info>
## Available providers
Change the `provider` string to switch backends. The most common options:
| Component | Python | TypeScript |
| --- | --- | --- |
| LLM | `openai`, `anthropic`, `gemini`, `groq`, `ollama`, `aws_bedrock`, `azure_openai`, `litellm` | `openai`, `anthropic`, `gemini`, `groq`, `ollama`, `azure_openai`, `mistral`, `deepseek` |
| Embedder | `openai`, `gemini`, `azure_openai`, `ollama`, `huggingface`, `vertexai`, `aws_bedrock` | `openai`, `gemini`, `azure_openai`, `ollama` |
| Vector store | `qdrant`, `pgvector`, `chroma`, `pinecone`, `redis`, `weaviate`, `milvus`, `elasticsearch` | `memory`, `qdrant`, `pgvector`, `redis`, `supabase`, `azure-ai-search`, `vectorize` |
See the full catalog in <Link href="/components/llms/overview">Components</Link>.
## Tune component settings
<AccordionGroup>
<Accordion title="Vector store collections">
Name collections explicitly in production (`collection_name`) to isolate tenants and enable per-tenant retention policies.
Name collections explicitly in production (`collection_name` / `collectionName`) to isolate tenants and enable per-tenant retention policies.
</Accordion>
<Accordion title="LLM extraction temperature">
Keep extraction temperatures ≤0.2 so advanced memories stay deterministic. Raise it only when you see missing facts.
Keep extraction temperature at or below 0.2 so memories stay deterministic. Raise it only when you see facts being missed.
</Accordion>
<Accordion title="Reranker depth">
Limit `top_k` to 10–20 results; sending more adds latency without meaningful gains.
<Accordion title="Reranker depth (Python)">
Limit `top_k` to 10 to 20 results. Sending more adds latency without meaningful gains.
</Accordion>
</AccordionGroup>
<Warning>
Mixing managed and self-hosted components? Make sure every outbound provider call happens through a secure network path. Managed rerankers often require outbound internet even if your vector store is on-prem.
Mixing managed and self-hosted components? Make sure every outbound provider call has a secure network path. Managed rerankers and embedders often require outbound internet even if your vector store is on-prem.
</Warning>
## Quick recovery
- Qdrant connection errors → confirm port `6333` is exposed and API key (if set) matches.
- Empty search results → verify the embedder model name; a mismatch causes dimension errors.
- `Unknown reranker` → update the SDK (`pip install --upgrade mem0ai`) to load the latest provider registry.
- Qdrant connection errors: confirm port `6333` is exposed and the API key (if set) matches.
- Empty search results: verify the embedder model name. A mismatch causes dimension errors.
- `Unknown reranker` (Python): upgrade the SDK with `pip install --upgrade mem0ai` to load the latest provider registry.
- `Cannot find module` (Node): import from the OSS entry point, `import { Memory } from "mem0ai/oss"`, not `"mem0ai"`.
<CardGroup cols={2}>
<Card
title="Pick Providers"
description="Review the LLM, vector store, embedder, and reranker catalogs."
description="Browse the LLM, vector store, embedder, and reranker catalogs."
icon="sitemap"
href="/components/llms/overview"
/>
docs/open-source/node-quickstart.mdx
+18 -191
View File
@@ -4,7 +4,7 @@ description: "Store and search Mem0 memories from a TypeScript or JavaScript app
icon: "js"
---
Spin up Mem0 with the Node SDK in just a few steps. You’ll install the package, initialize the client, add a memory, and confirm retrieval with a single search.
Spin up Mem0 with the Node SDK in just a few steps. You'll install the package, initialize the client, add a memory, and confirm retrieval with a single search.
## Prerequisites
@@ -67,218 +67,45 @@ console.log(results);
</Steps>
<Note>
By default the Node SDK uses local-friendly settings (OpenAI `gpt-5-mini`, `text-embedding-3-small`, in-memory vector store, and SQLite history). Swap components by passing a config as shown below.
By default the Node SDK uses local-friendly settings (OpenAI `gpt-5-mini`, `text-embedding-3-small`, in-memory vector store, and SQLite history). Pass a config to swap any of them.
</Note>
## Configure for production
## Configure providers
Pass a config object to `new Memory()` to use your own LLM, embedder, and vector store:
```ts
import { Memory } from "mem0ai/oss";
const memory = new Memory({
llm: {
provider: "openai",
config: { apiKey: process.env.OPENAI_API_KEY || "", model: "gpt-4-turbo-preview" }
},
embedder: {
provider: "openai",
config: {
apiKey: process.env.OPENAI_API_KEY || "",
model: "text-embedding-3-small"
}
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"
}
},
historyDbPath: "memory.db"
});
```
## Manage memories (optional)
<CodeGroup>
```ts Get all memories
const allMemories = await memory.getAll({ filters: { userId: "alice" } });
console.log(allMemories);
```
```ts Get one memory
const singleMemory = await memory.get("892db2ae-06d9-49e5-8b3e-585ef9b85b8e");
console.log(singleMemory);
```
```ts Search memories
const result = await memory.search("What do you know about me?", { filters: { userId: "alice" } });
console.log(result);
```
```ts Update a memory
const updateResult = await memory.update(
"892db2ae-06d9-49e5-8b3e-585ef9b85b8e",
"I love India, it is my favorite country."
);
console.log(updateResult);
```
</CodeGroup>
```ts
// Audit history
const history = await memory.history("892db2ae-06d9-49e5-8b3e-585ef9b85b8e");
console.log(history);
// Delete specific or scoped memories
await memory.delete("892db2ae-06d9-49e5-8b3e-585ef9b85b8e");
await memory.deleteAll({ userId: "alice" });
// Reset everything
await memory.reset();
```
## Use a custom history store
The Node SDK supports Supabase (or other providers) when you need serverless-friendly history storage.
<CodeGroup>
```ts Supabase provider
import { Memory } from "mem0ai/oss";
const memory = new Memory({
historyStore: {
provider: "supabase",
config: {
supabaseUrl: process.env.SUPABASE_URL || "",
supabaseKey: process.env.SUPABASE_KEY || "",
tableName: "memory_history"
}
config: { collectionName: "memories", dimension: 1536 }
}
});
```
```ts Disable history
import { Memory } from "mem0ai/oss";
const memory = new Memory({
disableHistory: true
});
```
</CodeGroup>
Create the Supabase table with:
```sql
create table memory_history (
id text primary key,
memory_id text not null,
previous_value text,
new_value text,
action text not null,
created_at timestamp with time zone default timezone('utc', now()),
updated_at timestamp with time zone,
is_deleted integer default 0
);
```
## Configuration parameters
Mem0 offers granular configuration across vector stores, LLMs, embedders, and history stores.
<AccordionGroup>
<Accordion title="Vector store">
| Parameter | Description | Default |
| --- | --- | --- |
| `provider` | Vector store provider (e.g., `"memory"`) | `"memory"` |
| `host` | Host address | `"localhost"` |
| `port` | Port number | `undefined` |
</Accordion>
<Accordion title="LLM">
| Parameter | Description | Provider |
| --- | --- | --- |
| `provider` | LLM provider (e.g., `"openai"`, `"anthropic"`) | All |
| `model` | Model to use | All |
| `temperature` | Temperature value | All |
| `apiKey` | API key | All |
| `maxTokens` | Max tokens to generate | All |
| `topP` | Probability threshold | All |
| `topK` | Token count to keep | All |
| `openaiBaseUrl` | Base URL override | OpenAI |
</Accordion>
<Accordion title="Embedder">
| Parameter | Description | Default |
| --- | --- | --- |
| `provider` | Embedding provider | `"openai"` |
| `model` | Embedding model | `"text-embedding-3-small"` |
| `apiKey` | API key | `undefined` |
</Accordion>
<Accordion title="General">
| Parameter | Description | Default |
| --- | --- | --- |
| `historyDbPath` | Path to history database | `"{mem0_dir}/history.db"` |
| `customInstructions` | Custom processing prompt | `undefined` |
</Accordion>
<Accordion title="History store">
| Parameter | Description | Default |
| --- | --- | --- |
| `provider` | History provider | `"sqlite"` |
| `config` | Provider configuration | `undefined` |
| `disableHistory` | Disable history store | `false` |
</Accordion>
<Accordion title="Complete config example">
```ts
const config = {
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"
}
},
historyStore: {
provider: "supabase",
config: {
supabaseUrl: process.env.SUPABASE_URL || "",
supabaseKey: process.env.SUPABASE_KEY || "",
tableName: "memories"
}
},
disableHistory: false,
customInstructions: "I'm a virtual assistant. I'm here to help you with your queries."
};
```
</Accordion>
</AccordionGroup>
For the full provider catalog, history stores, and every config option, see [Configuration](/open-source/configuration).
## What's next?
<CardGroup cols={3}>
<Card title="Explore Memory Operations" icon="database" href="/core-concepts/memory-operations/add">
Review CRUD patterns, filters, and advanced retrieval across the OSS stack.
<Card title="Memory operations" icon="database" href="/core-concepts/memory-operations/add">
Search, update, and manage memories with the full CRUD API.
</Card>
<Card title="Customize Configuration" icon="sliders" href="/open-source/configuration">
Swap in your preferred LLM, vector store, and history provider for production use.
<Card title="Configure for production" icon="sliders" href="/open-source/configuration">
Swap in your own LLM, embedder, and vector store.
</Card>
<Card title="Automate Node Workflows" icon="plug" href="/cookbooks/integrations/openai-tool-calls">
See a full Node-based workflow that layers Mem0 memories onto tool-calling agents.
<Card title="Add to your framework" icon="plug" href="/integrations">
Wire Mem0 into LangChain, CrewAI, LangGraph, and 20+ more.
</Card>
</CardGroup>
docs/open-source/overview.mdx
+37 -68
View File
@@ -4,43 +4,38 @@ description: "Self-host Mem0 with full control over your infrastructure and data
icon: "house"
---
# Mem0 Open Source Overview
Mem0 Open Source is the same memory engine as the Platform, running on your own infrastructure. You own the stack, the data, and every component, and you choose where each one runs.
Mem0 Open Source delivers the same adaptive memory engine as the platform, but packaged for teams that need to run everything on their own infrastructure. You own the stack, the data, and the customizations.
Run it two ways:
## What Mem0 OSS provides
- **As a library** in your app. `pip install mem0ai` (or `npm install mem0ai`), call `Memory()`, and you have memory in a few lines.
- **As a self-hosted server.** A Docker stack with a dashboard, per-user API keys, and a request audit log.
- **Full control**: Tune every component, from LLMs to vector stores, inside your environment.
- **Offline ready**: Keep memory on your own network when compliance or privacy demands it.
- **Extendable codebase**: Fork the repo, add providers, and ship custom automations.
<Info>
Two ways to run Mem0 OSS: as a **library** inside your app (Python or Node), or as a **self-hosted server** with a dashboard, per-user API keys, and a request audit log.
</Info>
## Choose your path
## Get started
<CardGroup cols={3}>
<Card title="Self-hosted setup" icon="rocket-launch" href="/open-source/setup">
Run `make bootstrap` to launch the server + dashboard, create an admin, and issue your first API key.
</Card>
<Card title="Python Quickstart" icon="python" href="/open-source/python-quickstart">
Bootstrap CLI and verify add/search loop.
Install the SDK and verify the add/search loop in a few lines.
</Card>
<Card title="Node.js Quickstart" icon="node" href="/open-source/node-quickstart">
Install TypeScript SDK and run starter script.
Install the TypeScript SDK and run the starter script.
</Card>
<Card title="Self-hosted server" icon="rocket-launch" href="/open-source/setup">
Run `make bootstrap` to launch the server, dashboard, and your first API key.
</Card>
</CardGroup>
## Go further
<CardGroup cols={3}>
<Card title="Configure Components" icon="sliders" href="/open-source/configuration">
LLM, embedder, vector store, reranker setup.
<Card title="Configure components" icon="sliders" href="/open-source/configuration">
Set your LLM, embedder, vector store, and reranker.
</Card>
<Card title="Tune Retrieval & Rerankers" icon="sparkles" href="/open-source/features/reranker-search">
Hybrid retrieval and reranker controls.
<Card title="Self-hosting features" icon="server" href="/open-source/features/overview">
Async memory, metadata filters, reranker search, multimodal, and more.
</Card>
<Card title="Memory Evaluation" icon="chart-line" href="/core-concepts/memory-evaluation">
Benchmarks and how Mem0 is tested.
<Card title="Build with cookbooks" icon="book-open" href="/cookbooks/overview">
End-to-end examples: companions, agents, and integrations.
</Card>
</CardGroup>
@@ -48,55 +43,29 @@ Mem0 Open Source delivers the same adaptive memory engine as the platform, but p
Need a managed alternative? Compare hosting models in the <Link href="/platform/platform-vs-oss">Platform vs OSS guide</Link> or switch tabs to the Platform documentation.
</Tip>
<AccordionGroup>
<Accordion title="What you get with Mem0 OSS" icon="code-branch">
| Benefit | What you get |
| --- | --- |
| Full infrastructure control | Host on your own servers with complete access to configuration and deployment. |
| Complete customization | Modify the implementation, extend functionality, and tailor it to your stack. |
| Local development | Perfect for development, testing, and offline environments. |
| No vendor lock-in | Keep ownership of your data, providers, and pipelines. |
| Community driven | Contribute improvements and tap into a growing ecosystem. |
</Accordion>
</AccordionGroup>
## Default components
<Note>
**Library defaults** (when you `import` Mem0 and call `Memory()` directly):
- LLM: OpenAI `gpt-5-mini` (via `OPENAI_API_KEY`)
- Embeddings: OpenAI `text-embedding-3-small`
- Vector store: Local Qdrant at `/tmp/qdrant`
- History store: SQLite at `~/.mem0/history.db`
- Reranker: Disabled until configured
Mem0 runs out of the box with the defaults below. Override any of them through [configuration](/open-source/configuration).
Override any component with <Link href="/open-source/configuration">`Memory.from_config`</Link>.
</Note>
**As a library** (you `import` Mem0 and call `Memory()`):
<Note>
**Self-hosted server defaults** (the `server/` Docker Compose stack):
- LLM: OpenAI `gpt-4.1-nano-2025-04-14` (override with `MEM0_DEFAULT_LLM_MODEL`)
- Embeddings: OpenAI `text-embedding-3-small` (override with `MEM0_DEFAULT_EMBEDDER_MODEL`)
- Vector store: Postgres + pgvector
- Bundled providers: `openai`, `anthropic`, `gemini`: switch from the Configuration page
| Component | Default |
|---|---|
| LLM | OpenAI `gpt-5-mini` (set `OPENAI_API_KEY`) |
| Embeddings | OpenAI `text-embedding-3-small` |
| Vector store | Local Qdrant at `/tmp/qdrant` |
| History store | SQLite at `~/.mem0/history.db` |
| Reranker | Disabled until configured |
See <Link href="/open-source/setup#supported-providers">Self-Hosted Setup</Link> for the full provider list and how to extend it.
</Note>
Override any component with [`Memory.from_config`](/open-source/configuration).
## Keep going
**As a self-hosted server** (the `server/` Docker Compose stack):
<CardGroup cols={2}>
<Card
title="Review Platform vs OSS"
description="Confirm whether managed infrastructure or self-hosting better suits your workload."
icon="arrows-left-right"
href="/platform/platform-vs-oss"
/>
<Card
title="Run the Python Quickstart"
description="Clone the repo, install dependencies, and persist your first local memory."
icon="terminal"
href="/open-source/python-quickstart"
/>
</CardGroup>
| Component | Default |
|---|---|
| LLM | OpenAI `gpt-5-mini` (override with `MEM0_DEFAULT_LLM_MODEL`) |
| Embeddings | OpenAI `text-embedding-3-small` (override with `MEM0_DEFAULT_EMBEDDER_MODEL`) |
| Vector store | Postgres + pgvector |
| Bundled providers | `openai`, `anthropic`, `gemini` (switch on the Configuration page) |
See [Self-Hosted Setup](/open-source/setup#supported-providers) for the full provider list and how to extend it.
docs/open-source/python-quickstart.mdx
+9 -11
View File
@@ -86,24 +86,22 @@ By default `Memory()` wires up:
- No reranker (add one in the config when you need it)
</Note>
## What's Next?
## What's next?
<CardGroup cols={3}>
<Card title="Memory Operations" icon="database" href="/core-concepts/memory-operations/add">
Learn how to search, update, and manage memories with full CRUD operations
<Card title="Memory operations" icon="database" href="/core-concepts/memory-operations/add">
Search, update, and manage memories with the full CRUD API.
</Card>
<Card title="Configuration" icon="sliders" href="/open-source/configuration">
Customize Mem0 with different LLMs, vector stores, and embedders for production use
<Card title="Configure for production" icon="sliders" href="/open-source/configuration">
Swap in your own LLM, embedder, and vector store.
</Card>
<Card title="Advanced Features" icon="sparkles" href="/open-source/features/async-memory">
Explore async support and multi-agent memory organization
<Card title="Add to your framework" icon="plug" href="/integrations">
Wire Mem0 into LangChain, CrewAI, LangGraph, and 20+ more.
</Card>
</CardGroup>
## Additional Resources
If you have any questions, please feel free to reach out:
- **[OpenAI Compatibility](/open-source/features/openai_compatibility)** - Use Mem0 with OpenAI-compatible chat completions
- **[Contributing Guide](/contributing/development)** - Learn how to contribute to Mem0
- **[Examples](/cookbooks/companions/local-companion-ollama)** - See Mem0 in action with Ollama and other integrations
<Snippet file="get-help.mdx" />
docs/open-source/setup.mdx
+11 -10
View File
@@ -1,5 +1,6 @@
---
title: "Self-Hosted Setup"
sidebarTitle: "Self-Hosted Server"
description: "Stand up the Mem0 REST server and dashboard in a few minutes, with an admin account, API keys, and a live audit log included."
icon: "rocket-launch"
---
@@ -22,7 +23,7 @@ The self-hosted bundle ships the REST API and a web dashboard together. Configur
## Prerequisites
- Docker and Docker Compose (the reference path).
- An `OPENAI_API_KEY` (or equivalent: the server reads the same component config as the library).
- An `OPENAI_API_KEY` or another provider key; the server reads the same component config as the library.
- A free port `8888` for the API and `3000` for the dashboard.
---
@@ -70,7 +71,7 @@ cd server
make bootstrap
```
`make bootstrap` starts the same containers, then automatically creates the admin account and generates the first API key via the CLI. The admin credentials and API key are printed to your terminal: no browser required.
`make bootstrap` starts the same containers, then automatically creates the admin account and generates the first API key via the CLI. The CLI prints the admin credentials and API key in your terminal. No browser required.
You can override the generated credentials:
@@ -89,16 +90,16 @@ Because `make bootstrap` already creates the admin, the setup wizard is skipped.
## Run the setup wizard
<Info>
This section applies to the **browser-first** path (`make up`). If you used `make bootstrap`, the admin and API key were already created: skip ahead to [What the dashboard gives you](#what-the-dashboard-gives-you).
This section applies to the **browser-first** path (`make up`). If you used `make bootstrap`, the admin and API key were already created, so skip ahead to [What the dashboard gives you](#what-the-dashboard-gives-you).
</Info>
On a fresh install the dashboard redirects to `/setup`. Each step submits on Enter.
**1. Create the admin account.** Name, email, password. This account becomes the first admin. Registration closes after the first admin is created; additional accounts are provisioned by the existing admin.
**2. Review the effective config.** Read-only display of the LLM and embedder the server is running with, sourced from your environment. If anything is wrong here, stop the stack, fix the `.env`, and restart: the dashboard intentionally does not let you change provider secrets at runtime.
**2. Review the effective config.** Read-only display of the LLM and embedder the server is running with, sourced from your environment. If anything is wrong here, stop the stack, fix the `.env`, and restart. The dashboard intentionally does not let you change provider secrets at runtime.
**3. Generate your first API key.** The full `m0sk_...` value is shown **once**. Copy it immediately: the server only stores the prefix and a bcrypt hash.
**3. Generate your first API key.** The full `m0sk_...` value is shown **once**. Copy it immediately. The server stores only the prefix and a bcrypt hash.
**4. Tell us your use case.** Pick a preset or describe your use case in a few words. Mem0 generates custom instructions that tell the memory system what to prioritize. You can edit the instructions before saving, or skip this step entirely.
@@ -125,8 +126,8 @@ For the underlying endpoints (including `/auth/*`, `/api-keys`, `/requests`, `/e
The shipped container bundles the Python packages for:
- **LLMs**: `openai`, `anthropic`, `gemini`
- **Embedders**: `openai`, `gemini`
- **LLMs:** `openai`, `anthropic`, `gemini`
- **Embedders:** `openai`, `gemini`
The Configuration page and `POST /configure` only accept providers from these lists. Anything else returns a 400 up front instead of failing at the first memory write.
@@ -146,9 +147,9 @@ Heavy providers (`sentence-transformers` pulls in PyTorch, ~2 GB) are intentiona
Previous self-hosted builds allowed open access when `ADMIN_API_KEY` was unset. This build enables auth by default. After pulling the new image, pick **one**:
1. **Fastest, zero client changes**: set `ADMIN_API_KEY` to a long random value (16+ characters). Existing clients that send `X-API-Key: <your-key>` keep working unchanged.
2. **Recommended for teams**: visit `http://<host>:3000`, run the setup wizard, and switch clients to per-user API keys. You get the audit log and revocation for free.
3. **Local development only**: set `AUTH_DISABLED=true`. The server logs a warning on every boot. Never use this in production.
1. **Fastest, zero client changes:** set `ADMIN_API_KEY` to a long random value (16+ characters). Existing clients that send `X-API-Key: <your-key>` keep working unchanged.
2. **Recommended for teams:** visit `http://<host>:3000`, run the setup wizard, and switch clients to per-user API keys. You get the audit log and revocation for free.
3. **Local development only:** set `AUTH_DISABLED=true`. The server logs a warning on every boot. Never use this in production.
The server prints an unmissable startup banner when it detects the "upgraded but not configured" state so you know exactly which option to pick.