Memori

https://memorilabs.ai/docs
Admin
Memori is an open-source, SQL-native system that provides AI agents with a structured, persistent...
Tokens:44,073
Snippets:610
Trust Score:6.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install LLM Provider SDK (Python)

Source: https://memorilabs.ai/docs/memori-cloud/getting-started/installation

Install the Python SDK for your chosen LLM provider. Example shown for OpenAI.

```bash
pip install openai
```

--------------------------------

### Memori Quick Start with SQLite and OpenAI

Source: https://memorilabs.ai/docs/memori-byodb

This snippet shows a basic setup for Memori using SQLite as the database and OpenAI's client. It configures Memori, registers the OpenAI client, builds the storage schema, and attributes a conversation to a specific user and process. The example then makes a chat completion call, with Memori automatically persisting and recalling conversations.

```python
import os
import sqlite3
from memori import Memori
from openai import OpenAI

# Requires OPENAI_API_KEY in your environment
def get_sqlite_connection():
    return sqlite3.connect("memori.db")

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori(conn=get_sqlite_connection).llm.register(client)

# Track conversations by user and process
mem.config.storage.build()
mem.attribution(entity_id="user_123", process_id="support_agent")

# All conversations automatically persisted and recalled
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "My favorite color is blue."}]
)

```

--------------------------------

### Install LLM Provider SDK (TypeScript)

Source: https://memorilabs.ai/docs/memori-cloud/getting-started/installation

Install the TypeScript SDK for your LLM provider. Example shown for OpenAI.

```bash
npm install openai
```

--------------------------------

### Register ChatOpenAI with Memori

Source: https://memorilabs.ai/docs/memori-byodb/llm/langchain

Quick start example demonstrating how to register a ChatOpenAI client with Memori and perform an attribution. Ensure LangChain and Memori are installed.

```python
from langchain_openai import ChatOpenAI
from memori import Memori
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

client = ChatOpenAI(model="gpt-4o-mini")
mem = Memori(conn=SessionLocal).llm.register(chatopenai=client)
mem.config.storage.build()
mem.attribution(entity_id="user_123", process_id="langchain_agent")

response = client.invoke("Hello!")
print(response.content)
```

--------------------------------

### Quick Start: LangChain OpenAI Integration

Source: https://memorilabs.ai/docs/memori-cloud/llm/langchain

Demonstrates basic integration with LangChain's ChatOpenAI model and Memori. Ensure the `langchain-openai` package is installed.

```python
from langchain_openai import ChatOpenAI
from memori import Memori

client = ChatOpenAI(model="gpt-4o-mini")

mem = Memori().llm.register(chatopenai=client)
mem.attribution(entity_id="user_123", process_id="langchain_agent")

response = client.invoke("Hello!")
print(response.content)
```

--------------------------------

### Install Memori and Requirements

Source: https://memorilabs.ai/docs/memori-byodb/contribute/development-setup

Alternative installation method if the project uses a requirements-dev.txt file. Installs Memori in editable mode and then installs development requirements.

```bash
pip install -e .
pip install -r requirements-dev.txt
```

--------------------------------

### Complete Example with Oracle Database and OpenAI

Source: https://memorilabs.ai/docs/memori-byodb/databases/oracle

A comprehensive example demonstrating connection pooling, LLM integration with OpenAI, and Memori's recall functionality.

```python
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import OpenAI

engine = create_engine(
    "oracle+oracledb://memori_user:password@oracle-host:1521/ORCL",
    pool_pre_ping=True,
    pool_size=5,
    max_overflow=10,
    pool_recycle=300
)
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori(conn=SessionLocal).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")
mem.config.storage.build()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Our quarterly review is on March 15."}]
)
print(response.choices[0].message.content)

mem.augmentation.wait()
facts = mem.recall("quarterly review date")
print(facts)
```

--------------------------------

### DeepSeek Quick Start with Memori

Source: https://memorilabs.ai/docs/memori-byodb/llm/deepseek

Connect to DeepSeek using the `openai` package and register it with Memori. Ensure your DEEPSEEK_API_KEY is set in the environment. This example demonstrates synchronous chat completion.

```python
import os
from memori import Memori
from openai import OpenAI
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(
    base_url="https://api.deepseek.com",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
)

mem = Memori(conn=SessionLocal).llm.register(client)
mem.config.storage.build()
mem.attribution(entity_id="user_123", process_id="deepseek_assistant")

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

```

--------------------------------

### Install Memori and OpenAI Libraries

Source: https://memorilabs.ai/docs/memori-cloud/getting-started/typescript-quickstart

Install the necessary libraries using npm, yarn, or pnpm.

```bash
npm install @memorilabs/memori openai

```

--------------------------------

### Run Python Quickstart Application

Source: https://memorilabs.ai/docs/memori-byodb/getting-started/python-quickstart

Execute the Python script from your terminal.

```bash
python quickstart.py

```

--------------------------------

### Install Memori SDK (Python)

Source: https://memorilabs.ai/docs/memori-cloud/getting-started/installation

Use this command to install the Memori Python SDK. Ensure pip is available.

```bash
pip install memori
```

--------------------------------

### Install Memori Prerequisites

Source: https://memorilabs.ai/docs/memori-byodb/support/troubleshooting

Before installing Memori, ensure you have the necessary binary dependencies like numpy and sentence-transformers installed.

```bash
pip install numpy>=1.24.0 sentence-transformers>=3.0.0 memori
```

--------------------------------

### Complete Example: Memori, OpenAI, and SQLite

Source: https://memorilabs.ai/docs/memori-byodb/databases/sqlite

A comprehensive example demonstrating Memori integration with OpenAI and SQLite. It sets up the database connection, registers the LLM client, performs an augmentation, and recalls facts.

```python
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import OpenAI

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori(conn=SessionLocal).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")
mem.config.storage.build()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "My favorite language is Python."}]
)
print(response.choices[0].message.content)

mem.augmentation.wait()
facts = mem.recall("favorite programming language")
print(facts)

```

--------------------------------

### Setup Memori Environment

Source: https://memorilabs.ai/docs/memori-byodb/concepts/cli-quickstart

Pre-download the embedding model for faster semantic search. If not run, the model downloads automatically on first use, which is slower.

```bash
python -m memori setup

```

--------------------------------

### xAI Grok Quick Start with Memori SDK

Source: https://memorilabs.ai/docs/memori-byodb/llm/xai-grok

Use this snippet to quickly integrate xAI Grok with the Memori SDK for LLM interactions. Ensure your XAI_API_KEY environment variable is set. This example demonstrates synchronous API usage.

```python
import os
from memori import Memori
from openai import OpenAI
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(
    base_url="https://api.x.ai/v1",
    api_key=os.getenv("XAI_API_KEY")
)

mem = Memori(conn=SessionLocal).llm.register(client)
mem.config.storage.build()
mem.attribution(entity_id="user_123", process_id="grok_assistant")

response = client.chat.completions.create(
    model="grok-2-latest",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

```

--------------------------------

### Set Up Virtual Environment

Source: https://memorilabs.ai/docs/memori-byodb/contribute/development-setup

Create and activate a Python virtual environment to manage project dependencies. This example uses the built-in venv module.

```bash
python -m venv .venv
source .venv/bin/activate    # macOS/Linux
# .venv\Scripts\activate     # Windows
```

--------------------------------

### Complete Memori and OpenAI Example with MongoDB

Source: https://memorilabs.ai/docs/memori-byodb/databases/mongodb

A comprehensive example demonstrating Memori integration with OpenAI for chat completions and memory recall, using MongoDB for storage. Includes API key setup and asynchronous memory augmentation.

```python
import os
from pymongo import MongoClient
from memori import Memori
from openai import OpenAI

mongo_client = MongoClient("mongodb://localhost:27017")

def get_db():
    return mongo_client["memori_db"]

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori(conn=get_db).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")
mem.config.storage.build()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "I love hiking in the Rockies."}]
)
print(response.choices[0].message.content)

mem.augmentation.wait()
facts = mem.recall("hobbies and outdoor activities")
print(facts)

```

--------------------------------

### Session Management Example

Source: https://memorilabs.ai/docs/memori-cloud/concepts/multi-user-support

Illustrates how to manage conversation sessions, including retrieving the current session ID, starting a new session, and restoring a previous one.

```Python
from memori import Memori
from openai import OpenAI

client = OpenAI()
mem = Memori().llm.register(client)
mem.attribution(entity_id="user_alice", process_id="support_bot")

# Get the current session ID
current_session = mem.config.session_id

# Start a new conversation group
mem.new_session()

# Or restore a previous session
mem.set_session(current_session)

```

--------------------------------

### Install OpenAI SDK

Source: https://memorilabs.ai/docs/memori-byodb/getting-started/installation

Install the Python SDK for the OpenAI API.

```bash
pip install openai

```

--------------------------------

### Multi-Agent System Setup

Source: https://memorilabs.ai/docs/memori-cloud/concepts/multi-user-support

Demonstrates how to set up multiple agents for a single user, where each agent has a unique process ID. Facts are shared across agents for the same entity.

```Python
from memori import Memori
from openai import OpenAI

def create_agent(user_id: str, agent_name: str):
    client = OpenAI()
    mem = Memori().llm.register(client)
    mem.attribution(entity_id=user_id, process_id=agent_name)
    return client

# Three agents, one user, shared facts
support = create_agent("user_alice", "support_agent")
sales = create_agent("user_alice", "sales_agent")
onboard = create_agent("user_alice", "onboarding_agent")

```

--------------------------------

### Complete Example: MySQL Integration with Memori and OpenAI

Source: https://memorilabs.ai/docs/memori-byodb/databases/mysql

A comprehensive example demonstrating how to configure Memori with a MySQL database, integrate with OpenAI for LLM capabilities, and perform data augmentation and recall. This includes advanced SQLAlchemy engine configurations for connection pooling.

```python
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import OpenAI

engine = create_engine(
    "mysql+pymysql://user:password@localhost:3306/memori_db"
    "?charset=utf8mb4",
    pool_pre_ping=True,
    pool_size=5,
    max_overflow=10,
    pool_recycle=1800
)
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori(conn=SessionLocal).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")
mem.config.storage.build()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "I work at Acme Corp as a designer."}]
)
print(response.choices[0].message.content)

mem.augmentation.wait()
facts = mem.recall("workplace")
print(facts)

```

--------------------------------

### Memori with OpenAI-Compatible Providers (Nebius Example)

Source: https://memorilabs.ai/docs/memori-byodb

This example demonstrates how to configure Memori to work with OpenAI-compatible providers, such as Nebius, by specifying a custom `base_url`. It sets up an OpenAI client with the provider's URL and API key, then registers this client with Memori, allowing it to leverage the compatible LLM service.

```python
import os
import sqlite3
from memori import Memori
from openai import OpenAI

def get_sqlite_connection():
    return sqlite3.connect("memori.db")

client = OpenAI(
    base_url="https://api.studio.nebius.com/v1/",
    api_key=os.getenv("NEBIUS_API_KEY"),
)

mem = Memori(conn=get_sqlite_connection).llm.register(client)

```

--------------------------------

### Install Cursor Skills

Source: https://memorilabs.ai/docs/memori-cloud/mcp/agent-skills

Create the directory and add the SKILL.md file for Cursor skills. Restart Cursor to apply changes.

```bash
mkdir -p .cursor/skills/memori-mcp
# Add SKILL.md content to .cursor/skills/memori-mcp/SKILL.md
```

--------------------------------

### Register Agno Model and Run Agent

Source: https://memorilabs.ai/docs/memori-cloud/llm/agno

Quick start example demonstrating how to register an Agno OpenAI model with Memori and use an Agno Agent for a synchronous run. Ensure the Agno model is correctly initialized and registered before use.

```python
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from memori import Memori

model = OpenAIChat(id="gpt-4o-mini")

mem = Memori().llm.register(openai_chat=model)
mem.attribution(entity_id="user_123", process_id="agno_agent")

agent = Agent(
    model=model,
    instructions=["Be helpful and concise"],
    markdown=True,
)

response = agent.run("Hello!", session_id="support-session")
print(response.content)
```

--------------------------------

### Install Memori and PyMongo

Source: https://memorilabs.ai/docs/memori-byodb/databases/mongodb

Install the necessary libraries for Memori and MongoDB integration.

```bash
pip install memori pymongo

```

--------------------------------

### Install Memori and OpenAI Packages

Source: https://memorilabs.ai/docs/memori-byodb/databases/sqlite

Install the necessary Python packages for Memori and OpenAI integration.

```bash
pip install memori openai

```

--------------------------------

### Complete Memori Example with PostgreSQL and OpenAI

Source: https://memorilabs.ai/docs/memori-byodb/databases/postgres

A comprehensive example demonstrating Memori integration with PostgreSQL and OpenAI for LLM interactions, including configuration, data augmentation, and recall.

```python
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import OpenAI

engine = create_engine(
    os.getenv("DATABASE_URL"),
    pool_pre_ping=True,
    pool_size=10,
    max_overflow=20,
    pool_recycle=300
)
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori(conn=SessionLocal).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")
mem.config.storage.build()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "I'm a senior engineer at Google."}]
)
print(response.choices[0].message.content)

mem.augmentation.wait()
facts = mem.recall("job title and company")
print(facts)

```

--------------------------------

### Install Antigravity Skills

Source: https://memorilabs.ai/docs/memori-cloud/mcp/agent-skills

Create the directory and add the SKILL.md file for Antigravity skills.

```bash
mkdir -p .agent/skills/memori-mcp
# Add SKILL.md content to .agent/skills/memori-mcp/SKILL.md
```

--------------------------------

### Install Memori Package

Source: https://memorilabs.ai/docs/memori-byodb/getting-started/installation

Install the Memori Python package using pip.

```bash
pip install memori

```

--------------------------------

### Install Memori and psycopg2

Source: https://memorilabs.ai/docs/memori-byodb/databases/cockroachdb

Install the necessary Python packages for Memori and the CockroachDB psycopg2 driver.

```bash
pip install memori psycopg2-binary

```

--------------------------------

### Install Memori and PyMySQL Driver

Source: https://memorilabs.ai/docs/memori-byodb/databases/mysql

Install the necessary Python packages for Memori and the PyMySQL driver to connect to MySQL.

```bash
pip install memori pymysql

```

--------------------------------

### Install Memori SDK (TypeScript)

Source: https://memorilabs.ai/docs/memori-cloud/getting-started/installation

Use npm or yarn to install the Memori TypeScript SDK. This SDK is for Memori Cloud only.

```bash
npm install @memorilabs/memori
```

--------------------------------

### Install TiDB Driver

Source: https://memorilabs.ai/docs/memori-byodb/databases/tidb

Install the necessary Python packages for Memori, PyMySQL, SQLAlchemy, and certifi.

```bash
pip install memori pymysql sqlalchemy certifi

```

--------------------------------

### Install Oracle Driver for Memori

Source: https://memorilabs.ai/docs/memori-byodb/databases/oracle

Install the Memori library along with the recommended oracledb driver for Oracle Database integration.

```bash
pip install memori oracledb
```

--------------------------------

### Web Server Async Example with FastAPI

Source: https://memorilabs.ai/docs/memori-cloud/concepts/async-patterns

Shows how to integrate the Memori SDK with FastAPI for asynchronous API endpoints. This example uses `AsyncOpenAI` and sets attribution for each request.

```python
import os
from fastapi import FastAPI
from pydantic import BaseModel
from memori import Memori
from openai import AsyncOpenAI

app = FastAPI()

class ChatRequest(BaseModel):
    message: str

@app.post("/chat/{user_id}")
async def chat(user_id: str, req: ChatRequest):
    client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    mem = Memori().llm.register(client)
    mem.attribution(entity_id=user_id, process_id="fastapi_async")

    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": req.message}]
    )
    return {"response": response.choices[0].message.content}


```

--------------------------------

### Install Memori and PostgreSQL Driver

Source: https://memorilabs.ai/docs/memori-byodb/databases/postgres

Installs the necessary Python packages for Memori and PostgreSQL interaction.

```bash
pip install memori psycopg

```

--------------------------------

### Quick Start: Gemini Integration

Source: https://memorilabs.ai/docs/memori-byodb/llm/gemini

Initialize Memori with a Google Gemini GenerativeModel and configure attribution. Ensure GOOGLE_API_KEY is set in your environment.

```python
import os
from memori import Memori
import google.generativeai as genai
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
client = genai.GenerativeModel("gemini-2.0-flash-exp")

mem = Memori(conn=SessionLocal).llm.register(client)
mem.config.storage.build()
mem.attribution(entity_id="user_123", process_id="gemini_assistant")

response = client.generate_content("Hello!")
print(response.text)

```

--------------------------------

### Complete CockroachDB Example with OpenAI

Source: https://memorilabs.ai/docs/memori-byodb/databases/cockroachdb

A comprehensive example demonstrating Memori integration with CockroachDB and OpenAI. It sets up the database connection, registers an OpenAI client, performs an LLM call, and recalls augmented facts.

```python
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import OpenAI

engine = create_engine(
    os.getenv("COCKROACHDB_URL"),
    pool_pre_ping=True,
    pool_size=10,
    max_overflow=20,
    pool_recycle=300
)
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori(conn=SessionLocal).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")
mem.config.storage.build()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "I manage a distributed systems team."}]
)
print(response.choices[0].message.content)

mem.augmentation.wait()
facts = mem.recall("job role")
print(facts)

```

--------------------------------

### Quick Start OpenAI Integration (Python)

Source: https://memorilabs.ai/docs/memori-cloud/llm/openai

Initialize Memori with an OpenAI client for basic chat completions. Ensure the OpenAI client is properly configured.

```Python
from memori import Memori
from openai import OpenAI

client = OpenAI()

mem = Memori().llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)
```

--------------------------------

### Quick Start Oracle Connection with oracledb

Source: https://memorilabs.ai/docs/memori-byodb/databases/oracle

Establish a connection to your Oracle Database using the modern oracledb driver and initialize Memori.

```python
from memori import Memori
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine(
    "oracle+oracledb://user:password@hostname:1521/service_name"
)
SessionLocal = sessionmaker(bind=engine)

mem = Memori(conn=SessionLocal)
mem.config.storage.build()
```

--------------------------------

### Complete TiDB Example

Source: https://memorilabs.ai/docs/memori-byodb/databases/tidb

A comprehensive example demonstrating TiDB connection with TLS, LLM integration, data augmentation, and recall operations. It uses environment variables for sensitive information like database connection strings and API keys.

```python
import os
import certifi
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import OpenAI

engine = create_engine(
    os.getenv("DATABASE_CONNECTION_STRING"),
    connect_args={"ssl": {"ca": certifi.where()}} if os.getenv("DATABASE_USE_TLS") else {},
    pool_pre_ping=True,
    pool_recycle=1800,
)
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori(conn=SessionLocal).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")
mem.config.storage.build()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "I work on distributed systems."}]
)
print(response.choices[0].message.content)

mem.augmentation.wait()
facts = mem.recall("distributed systems")
print(facts)

```

--------------------------------

### Quick Start AWS Bedrock Integration

Source: https://memorilabs.ai/docs/memori-cloud/llm/aws-bedrock

Initialize ChatBedrock with a specific model ID and region, then register it with Memori. Finally, invoke the client and print the response content.

```python
from langchain_aws import ChatBedrock
from memori import Memori

client = ChatBedrock(
    model_id="anthropic.claude-sonnet-4-5-20250929",
    region_name="us-east-1"
)

mem = Memori().llm.register(chatbedrock=client)
mem.attribution(entity_id="user_123", process_id="bedrock_agent")

response = client.invoke("Hello!")
print(response.content)
```

--------------------------------

### Multi-Process Isolation Example

Source: https://memorilabs.ai/docs/memori-cloud/concepts/multi-user-support

Shows how the same user can have isolated contexts across different processes. Facts are shared across processes for the same entity.

```Python
from memori import Memori
from openai import OpenAI

client = OpenAI()
mem = Memori().llm.register(client)

# Same user, different processes
mem.attribution(entity_id="user_alice", process_id="support_bot")
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "I use PostgreSQL for my databases"}
    ]
)

# Switch to a different process for the same user
mem.attribution(entity_id="user_alice", process_id="sales_bot")
# The sales bot can recall Alice's facts (like "uses PostgreSQL")
# because facts are shared across processes for the same entity.
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "What databases do I use?"}
    ]
)

```

--------------------------------

### Install Warp Agent Rules

Source: https://memorilabs.ai/docs/memori-cloud/mcp/agent-skills

Create the directory and add the SKILL.md content to your Warp rules configuration file. Restart Warp for the rules to take effect.

```bash
mkdir -p .warp/rules
# Add SKILL.md content to .warp/rules/memori-mcp.md
```

--------------------------------

### Anthropic Quick Start with Memori (Python)

Source: https://memorilabs.ai/docs/memori-cloud/llm/anthropic

Initialize Memori with an Anthropic client and make a basic message creation call. The `max_tokens` parameter is required.

```python
from anthropic import Anthropic
from memori import Memori

client = Anthropic()

mem = Memori().llm.register(client)
mem.attribution(entity_id="user_123", process_id="claude_assistant")

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.content[0].text)
```

--------------------------------

### Install OpenAI Codex Skills

Source: https://memorilabs.ai/docs/memori-cloud/mcp/agent-skills

Create the directory and add the SKILL.md file for OpenAI Codex skills. Restart Codex if changes are not picked up automatically.

```bash
mkdir -p .agents/skills/memori-mcp
# Add SKILL.md content to .agents/skills/memori-mcp/SKILL.md
```

--------------------------------

### Install Claude Code Skills

Source: https://memorilabs.ai/docs/memori-cloud/mcp/agent-skills

Create the directory and add the SKILL.md file for Claude Code skills. Restart Claude Code or reload the session.

```bash
mkdir -p .claude/skills/memori-mcp
# Add SKILL.md content to .claude/skills/memori-mcp/SKILL.md
```

--------------------------------

### Integrate OpenAI-Compatible Providers with Memori

Source: https://memorilabs.ai/docs/memori-byodb/llm/overview

Connect to any provider with an OpenAI-compatible API by setting a custom `base_url`. This example demonstrates integration with Nebius AI Studio.

```python
import os
from memori import Memori
from openai import OpenAI
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(
    base_url="https://api.studio.nebius.com/v1/",
    api_key=os.getenv("NEBIUS_API_KEY"),
)
mem = Memori(conn=SessionLocal).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")

response = client.chat.completions.create(
    model="meta-llama/Llama-3.3-70B-Instruct",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

```

--------------------------------

### Basic Async Setup in Python

Source: https://memorilabs.ai/docs/memori-cloud/concepts/async-patterns

Demonstrates setting up and using the Memori SDK with an asynchronous OpenAI client in Python. Ensure you import `AsyncOpenAI` and use `asyncio.run()` to execute the async function.

```python
import asyncio
from memori import Memori
from openai import AsyncOpenAI

client = AsyncOpenAI()

mem = Memori().llm.register(client)
mem.attribution(entity_id="user_123", process_id="async_agent")

async def main():
    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": "I prefer async Python."}]
    )
    print(response.choices[0].message.content)

asyncio.run(main())

```

--------------------------------

### Quick Start Gemini Integration (Python)

Source: https://memorilabs.ai/docs/memori-cloud/llm/gemini

Register a GenerativeModel instance with Memori to automatically capture generate_content calls. Ensure the GOOGLE_API_KEY environment variable is set.

```python
import os
from memori import Memori
import google.generativeai as genai

genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
client = genai.GenerativeModel("gemini-2.0-flash-exp")  # Use any Gemini model

mem = Memori().llm.register(client)
mem.attribution(entity_id="user_123", process_id="gemini_assistant")

response = client.generate_content("Hello!")
print(response.text)

```

--------------------------------

### Basic Async Setup with Memori and OpenAI

Source: https://memorilabs.ai/docs/memori-byodb/concepts/async-patterns

Demonstrates initializing Memori with an async OpenAI client and performing a chat completion. Ensure your OpenAI API key is set in the environment. The `mem.augmentation.wait()` call is crucial for ensuring all async operations are completed before exiting.

```python
import os
import asyncio
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import AsyncOpenAI

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

async def main():
    client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    mem = Memori(conn=SessionLocal).llm.register(client)
    mem.attribution(entity_id="user_123", process_id="async_agent")
    mem.config.storage.build()

    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": "I prefer async Python."}]
    )
    print(response.choices[0].message.content)
    mem.augmentation.wait()

asyncio.run(main())
```

--------------------------------

### Quick Start: Pydantic AI Agent with Memori

Source: https://memorilabs.ai/docs/memori-cloud/llm/pydantic-ai

Register a Pydantic AI agent with Memori for synchronous execution. Ensure Memori and pydantic-ai are installed.

```python
from memori import Memori
from pydantic_ai import Agent

agent = Agent("openai:gpt-4o-mini")

mem = Memori().llm.register(agent)
mem.attribution(entity_id="user_123", process_id="pydantic_agent")

result = agent.run_sync("Hello!")
print(result.output)

```

--------------------------------

### FastAPI Async Endpoint with Memori

Source: https://memorilabs.ai/docs/memori-byodb/concepts/async-patterns

An example of integrating Memori with FastAPI to handle asynchronous chat requests. This setup requires `check_same_thread=False` for SQLite in async contexts. Ensure your OpenAI API key is available in the environment.

```python
import os
from fastapi import FastAPI
from pydantic import BaseModel
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import AsyncOpenAI

app = FastAPI()
engine = create_engine("sqlite:///memori.db", connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(bind=engine)
Memori(conn=SessionLocal).config.storage.build()

class ChatRequest(BaseModel):
    message: str

@app.post("/chat/{user_id}")
async def chat(user_id: str, req: ChatRequest):
    client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    mem = Memori(conn=SessionLocal).llm.register(client)
    mem.attribution(entity_id=user_id, process_id="fastapi_async")

    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": req.message}]
    )
    return {"response": response.choices[0].message.content}
```

--------------------------------

### Configure Memori with Database and LLM

Source: https://memorilabs.ai/docs/memori-byodb/concepts/architecture

Sets up Memori by establishing a database connection, registering an LLM client, defining attribution, and building the storage schema. Requires importing necessary modules and initializing the Memori client.

```python
import sqlite3
from memori import Memori
from openai import OpenAI

def get_connection():
    return sqlite3.connect("memori.db")

client = OpenAI()
mem = Memori(conn=get_connection).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")
mem.config.storage.build()

```

--------------------------------

### DeepSeek Quick Start with Memori

Source: https://memorilabs.ai/docs/memori-cloud/llm/deepseek

Initialize the OpenAI client with DeepSeek's base URL and API key. Register the client with Memori and set attribution for tracking. Then, make a chat completion request.

```python
import os
from memori import Memori
from openai import OpenAI

client = OpenAI(
    base_url="https://api.deepseek.com",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
)

mem = Memori().llm.register(client)
mem.attribution(entity_id="user_123", process_id="deepseek_assistant")

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

```

--------------------------------

### Verify Memori Installation

Source: https://memorilabs.ai/docs/memori-byodb/getting-started/installation

Confirm that the Memori package has been successfully installed by checking its details in your terminal.

```bash
pip show memori

```

--------------------------------

### Initialize Memori with MongoDB Connection

Source: https://memorilabs.ai/docs/memori-byodb/databases/mongodb

Set up a MongoDB client and initialize Memori with a database connection. Ensure the database and collections are built.

```python
from memori import Memori
from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017")

def get_db():
    return client["memori_db"]

mem = Memori(conn=get_db)
mem.config.storage.build()

```

--------------------------------

### Initialize Memori and OpenAI Client

Source: https://memorilabs.ai/docs/memori-cloud/getting-started/python-quickstart

Import necessary libraries, initialize the OpenAI client, and then register it with Memori. Memori automatically reads the API key from the environment. Use attribution to link memories to a specific user and process.

```python
import os
from memori import Memori
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori().llm.register(client)
mem.attribution(entity_id="user_123", process_id="test-ai-agent")

```

--------------------------------

### Install and Enable Memori Plugin for OpenClaw

Source: https://memorilabs.ai/docs/memori-cloud/openclaw/quickstart

Install the Memori plugin using npm and then enable it within your OpenClaw workspace.

```bash
openclaw plugins install @memorilabs/openclaw-memori
```

```bash
openclaw plugins enable openclaw-memori
```

--------------------------------

### Initialize Memori with SQLite and OpenAI

Source: https://memorilabs.ai/docs/memori-byodb/getting-started/python-quickstart

Set up a SQLite database connection and register the OpenAI client with Memori. This configures Memori for memory capture and storage. Ensure the database schema is built.

```python
import os
import sqlite3
from memori import Memori
from openai import OpenAI

def get_sqlite_connection():
    return sqlite3.connect("memori.db")

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
mem = Memori(conn=get_sqlite_connection).llm.register(client)
mem.attribution(entity_id="user_123", process_id="test-ai-agent")
mem.config.storage.build()

```

--------------------------------

### Initialize and Use ChatBedrock Client

Source: https://memorilabs.ai/docs/memori-byodb/llm/aws-bedrock

Set up the ChatBedrock client with a specific model ID and region. Register the client with Memori and configure storage before making an invocation.

```python
from langchain_aws import ChatBedrock
from memori import Memori
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

client = ChatBedrock(
    model_id="anthropic.claude-3-5-sonnet-20241022-v2:0",
    region_name="us-east-1"
)

mem = Memori(conn=SessionLocal).llm.register(chatbedrock=client)
mem.config.storage.build()
mem.attribution(entity_id="user_123", process_id="bedrock_agent")

response = client.invoke("Hello!")
print(response.content)
```

--------------------------------

### Nebius AI Studio Quick Start with Memori

Source: https://memorilabs.ai/docs/memori-byodb/llm/nebius

This snippet demonstrates setting up the OpenAI client for Nebius AI Studio and using it with the Memori library for LLM interactions. Ensure your NEBIUS_API_KEY is set in your environment variables.

```python
import os
from memori import Memori
from openai import OpenAI
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

client = OpenAI(
    base_url="https://api.studio.nebius.com/v1/",
    api_key=os.getenv("NEBIUS_API_KEY"),
)

mem = Memori(conn=SessionLocal).llm.register(client)
mem.config.storage.build()
mem.attribution(entity_id="user_123", process_id="nebius_assistant")

response = client.chat.completions.create(
    model="meta-llama/Llama-3.3-70B-Instruct",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

```

--------------------------------

### Install Memori with Development Dependencies

Source: https://memorilabs.ai/docs/memori-byodb/contribute/development-setup

Install Memori in editable mode with development dependencies. This allows changes to the source code to be reflected immediately without reinstallation.

```bash
pip install -e ".[dev]"
```

--------------------------------

### Initialize Memori with OpenAI Client

Source: https://memorilabs.ai/docs/memori-cloud/dashboard/overview

This snippet shows how to initialize the Memori client using an OpenAI client and register it for use. It also demonstrates how to set attribution for a specific entity and process.

```python
import os
from memori import Memori
from openai import OpenAI

client = OpenAI()
mem = Memori().llm.register(client)
mem.attribution(entity_id="user_123", process_id="my-agent")

```

--------------------------------

### Initialize Memori and Register LLM Client

Source: https://memorilabs.ai/docs/memori-byodb/concepts/advanced-augmentation

Set up Memori with your database connection, register an LLM client, and configure attribution. The augmentation process starts automatically after the LLM call.

```python
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from memori import Memori
from openai import OpenAI

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

client = OpenAI()
mem = Memori(conn=SessionLocal).llm.register(client)
mem.attribution(entity_id="user_123", process_id="my_agent")
mem.config.storage.build()

# This returns immediately — no augmentation delay
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "I love hiking in the mountains."}
    ]
)
print(response.choices[0].message.content)

# Only needed in short-lived scripts
mem.augmentation.wait()
```

--------------------------------

### Setup and Configuration for Memori

Source: https://memorilabs.ai/docs/memori-cloud/getting-started/typescript-quickstart

Import libraries and initialize Memori with your API key and OpenAI client. Memori reads the API key from environment variables automatically. Use `llm.register()` to wrap your LLM client for automatic memory capture and `attribution()` to link memories to a specific user and process.

```typescript
import OpenAI from 'openai';
import { Memori } from '@memorilabs/memori';

const client = new OpenAI();
const mem = new Memori().llm.register(client);
mem.attribution('user_123', 'test-ai-agent');

```

--------------------------------

### Register ChatAnthropic with Memori

Source: https://memorilabs.ai/docs/memori-byodb/llm/langchain

Example for registering an Anthropic chat client with Memori. Requires the `langchain-anthropic` package.

```python
from langchain_anthropic import ChatAnthropic

client = ChatAnthropic(model="claude-3-5-sonnet-20241022")
mem = Memori(conn=SessionLocal).llm.register(chatopenai=client)
```

--------------------------------

### Initialize Memori with SQLAlchemy (SQLite)

Source: https://memorilabs.ai/docs/memori-byodb/databases/sqlite

Connect to a local SQLite database using SQLAlchemy and initialize the Memori instance. Ensure the storage is built.

```python
from memori import Memori
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine("sqlite:///memori.db")
SessionLocal = sessionmaker(bind=engine)

mem = Memori(conn=SessionLocal)
mem.config.storage.build()

```
Tokens:
Raw