### Quick Start

Source: https://github.com/remembra-ai/remembra/blob/main/site/guides/javascript-sdk/index.html

A quick guide to get started with the Remembra client, demonstrating how to initialize the client, store a memory, recall information, and forget a memory.

```APIDOC
## Quick Start

```typescript
import { Remembra } from '@remembra/client';

const memory = new Remembra({
  url: 'http://localhost:8787',
  apiKey: 'rem_xxx',     // optional for self-hosted
  userId: 'user_123',    // optional
  project: 'my_app',     // optional
});

// Store
const stored = await memory.store('Alice is the CTO of Acme Corp');
console.log(stored.extracted_facts);
// → ["Alice is the CTO of Acme Corp."]

// Recall
const result = await memory.recall('Who leads Acme?');
console.log(result.context);
// → "Alice is the CTO of Acme Corp."

// Forget
await memory.forget({ memoryId: stored.id });
```
```

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

### Server Installation and Execution

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/installation.md

Installs the server dependencies and starts the Remembra server.

```bash
pip install "remembra[server]"
```

```bash
export OPENAI_API_KEY=sk-your-key
python -m remembra.server
```

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

### Quick Start

Source: https://github.com/remembra-ai/remembra/blob/main/site/guides/python-sdk/index.html

A quick guide to get started with the Remembra Python SDK, including initializing the Memory class and performing basic store and recall operations.

```APIDOC
## Quick Start

### Description
Initialize the Memory class and perform basic store and recall operations.

### Method
Python

### Endpoint
N/A

### Request Example
```python
from remembra import Memory

memory = Memory(
    base_url="http://localhost:8787",
    user_id="user_123",
    project="my_app"  # Optional namespace
)

# Store a memory
memory.store("User prefers dark mode")

# Recall memories
context = memory.recall("What are user preferences?")
```

### Response Example
```python
# Example response from recall (depends on stored data)
# ['User prefers dark mode']
```
```

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

### Install Remembra via Quickstart Script

Source: https://github.com/remembra-ai/remembra/blob/main/README.md

Executes the automated installation script to set up Remembra, Qdrant, and Ollama locally.

```bash
curl -sSL https://raw.githubusercontent.com/remembra-ai/remembra/main/quickstart.sh | bash
```

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

### Install and Initialize Remembra

Source: https://github.com/remembra-ai/remembra/blob/main/landing/changelog/v0.10.1.html

Installation commands for setting up Remembra via pip, Docker, or the quick start utility.

```bash
# Via pip
pip install remembra==0.10.1

# Via Docker
docker pull remembra/remembra:0.10.1

# Quick start
remembra-install --all
```

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

### Start Remembra Server from Source

Source: https://github.com/remembra-ai/remembra/blob/main/docs/index.md

Install Remembra from source by cloning the repository, installing dependencies, and running the server command. This method is suitable for development or custom builds.

```bash
git clone https://github.com/remembra-ai/remembra
cd remembra
pip install -e ".[server]"
remembra-server
```

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

### Clone and Set Up Remembra Development Environment

Source: https://github.com/remembra-ai/remembra/blob/main/CONTRIBUTING.md

Clone the repository, set up a virtual environment, install development dependencies, and run tests. This is the initial setup for contributing.

```bash
git clone https://github.com/YOUR_USERNAME/remembra
cd remembra

python -m venv .venv
source .venv/bin/activate

pip install -e ".[dev]"

pytest

ruff check .
ruff format .

remembra-server --reload
```

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

### Start Remembra with Docker and Install SDK

Source: https://github.com/remembra-ai/remembra/blob/main/README-polished.md

Use Docker to run the Remembra server and install the Python SDK for integration.

```bash
# Start the server
docker run -d -p 8787:8787 remembra/remembra

# Install SDK
pip install remembra

# Done. That's it.
```

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

### Deploy Remembra with Docker Compose

Source: https://github.com/remembra-ai/remembra/blob/main/README.md

Clones the repository and starts the services using the provided quickstart configuration.

```bash
git clone https://github.com/remembra-ai/remembra && cd remembra
docker compose -f docker-compose.quickstart.yml up -d
```

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

### Install Remembra with All Agents

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/multi-agent-shared-memory.md

Installs the Remembra package and configures all installed agents with the provided API key and project ID. Recommended for a quick setup.

```bash
pip install remembra
remembra-install --all --api-key rem_xxx --project my-project
```

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

### Remembra AI Installation and Setup

Source: https://github.com/remembra-ai/remembra/blob/main/site/integrations/mcp-server/index.html

Instructions for installing Remembra AI and configuring it for various AI tools.

```APIDOC
## Installation

`pip install remembra`

This installs the SDK, MCP server (`remembra-mcp`), and CLI tools (`remembra-install`, `remembra-doctor`, `remembra-bridge`).

## Quick Setup

Configure all your AI tools with one command:

`pip install remembra`
`remembra-install --all --api-key YOUR_API_KEY`

This auto-detects and configures: Claude Desktop, Claude Code, Codex, Cursor, Gemini, and Windsurf.

**Verify setup:**

`remembra-doctor all`

## Manual Setup Guides

Step-by-step setup instructions for each AI tool:

*   **Claude Code**: [Setup guide](../claude-code/) — `claude mcp add remembra ...`
*   **Claude Desktop**: [Setup guide](../claude-desktop/) — JSON config
*   **Cursor**: [Setup guide](../cursor/) — `.cursor/mcp.json`
*   **Windsurf**: [Setup guide](../windsurf/) — `mcp_config.json`
*   **Zed**: [Setup guide](../zed/) — `context_servers` in settings
*   **OpenAI Codex**: [Setup guide](../codex/) — `codex mcp add remembra ...`
*   **VS Code + Copilot**: [Setup guide](../vscode/) — `.vscode/mcp.json`
*   **JetBrains IDEs**: [Setup guide](../jetbrains/) — Settings → AI Assistant → MCP
*   **Any MCP client**: [Generic guide](../any-mcp-client/) — stdio, SSE, HTTP
```

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

### Source Installation and Development

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/installation.md

Clones the repository and installs dependencies for development.

```bash
# Clone the repo
git clone https://github.com/remembra-ai/remembra
cd remembra

# Install with uv (recommended)
uv sync --all-extras

# Or with pip
pip install -e ".[server,rerank,dev]"

# Run tests
pytest

# Start the server
python -m remembra.server
```

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

### Troubleshoot installation and connection

Source: https://github.com/remembra-ai/remembra/blob/main/docs/integrations/codex.md

Commands to verify installation path and server health.

```bash
pip install remembra[mcp]
which remembra-mcp
```

```toml
[mcp_servers.remembra]
command = "/Users/you/.local/bin/remembra-mcp"
```

```bash
curl http://localhost:8787/health
# If this fails:
docker compose up -d
```

```toml
[mcp_servers.remembra]
command = "remembra-mcp"
startup_timeout_sec = 30
```

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

### Universal Installer Script (Bash)

Source: https://github.com/remembra-ai/remembra/blob/main/docs/case-studies/multi-agent-collaboration.md

This script is designed for universal installation, automatically detecting and configuring for 6 different AI tools. It's part of the effort to simplify agent setup.

```bash
curl https://remembra.dev/install.sh | bash
```

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

### Initialize and Use Memory

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/python-sdk.md

Quick start guide for initializing the Memory class and performing basic store and recall operations.

```python
from remembra import Memory

memory = Memory(
    base_url="http://localhost:8787",
    user_id="user_123",
    project="my_app"  # Optional namespace
)

# Store a memory
memory.store("User prefers dark mode")

# Recall memories
context = memory.recall("What are user preferences?")
```

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

### Start Qdrant Service on macOS

Source: https://github.com/remembra-ai/remembra/blob/main/site/DEPLOYMENT/index.html

If you are on macOS and have Homebrew installed, you can start the Qdrant service using brew services.

```bash
brew services start qdrant
```

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

### Remembra CLI Universal Setup Command

Source: https://github.com/remembra-ai/remembra/blob/main/docs/case-studies/multi-agent-collaboration.md

The `npx remembra setup` command provides a one-click installation and configuration for Remembra, simplifying the process for users and ensuring all agents can connect to shared memory.

```bash
npx remembra setup
```

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

### Install Remembra from Source

Source: https://github.com/remembra-ai/remembra/blob/main/site/getting-started/quickstart/index.html

Clone the repository and install the server dependencies to run locally.

```bash
git clone https://github.com/remembra-ai/remembra
cd remembra
pip install -e ".[server]"

export OPENAI_API_KEY=sk-your-key
python -m remembra.server
```

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

### Start Remembra Service

Source: https://github.com/remembra-ai/remembra/blob/main/benchmarks/README.md

Start the Remembra service using Docker Compose. Ensure Docker is installed and running.

```bash
docker compose up -d
```

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

### Store Memory Examples

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/python-sdk.md

Practical examples for storing memories with various configurations.

```python
# Basic store
memory.store("User's name is John")

# With metadata
memory.store(
    "User prefers morning meetings",
    metadata={"category": "preferences", "confidence": "high"}
)

# With TTL (expires in 30 days)

# With explicit expiry (v0.12.0)
from datetime import datetime, timedelta
memory.store(
    "Conference call tomorrow at 3pm",
    expires_at=datetime.now() + timedelta(hours=36)
)
# With TTL (expires in 30 days)
memory.store(
    "Meeting scheduled for March 15",
    ttl="30d"
)
```

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

### Enable and Start Remembra Service

Source: https://github.com/remembra-ai/remembra/blob/main/site/DEPLOYMENT/index.html

After creating the service file, reload the systemd daemon, enable the service to start on boot, and then start the service.

```bash
sudo systemctl daemon-reload
sudo systemctl enable remembra
sudo systemctl start remembra
```

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

### Installation

Source: https://github.com/remembra-ai/remembra/blob/main/site/guides/javascript-sdk/index.html

Instructions for installing the Remembra client package using npm, yarn, or pnpm, and how to import it in Deno.

```APIDOC
## Installation

### npm
```bash
npm install @remembra/client
```

### yarn
```bash
yarn add @remembra/client
```

### pnpm
```bash
pnpm add @remembra/client
```

### Deno
```typescript
import { Remembra } from "npm:@remembra/client";
```
```

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

### Start Remembra Server with Docker

Source: https://github.com/remembra-ai/remembra/blob/main/docs/index.md

Run the Remembra server using Docker for a quick and recommended setup. Ensure the port 8787 is exposed.

```bash
docker run -d -p 8787:8787 remembra/remembra:0.12.0
```

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

### Installation

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/python-sdk.md

Install the Remembra Python SDK using pip.

```APIDOC
## Installation

```bash
pip install remembra
```
```

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

### Install Remembra SDK

Source: https://github.com/remembra-ai/remembra/blob/main/sdk/typescript/README.md

Use npm, yarn, or pnpm to install the package.

```bash
npm install remembra
# or
yarn add remembra
# or
pnpm add remembra
```

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

### Initialize and Start Docker Compose

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/docker.md

Creates the required .env file and starts the services in detached mode.

```bash
# Create .env file
echo "OPENAI_API_KEY=sk-your-key" > .env
echo "REMEMBRA_MASTER_KEY=$(openssl rand -hex 32)" >> .env

# Start services
docker-compose up -d
```

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

### Install Remembra with uv (Development)

Source: https://github.com/remembra-ai/remembra/blob/main/site/getting-started/installation/index.html

Install Remembra with all extras using `uv`, the recommended tool for development.

```bash
uv sync --all-extras
```

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

### Verify Remembra AI Setup

Source: https://github.com/remembra-ai/remembra/blob/main/README.md

Run this command to verify that Remembra AI is correctly installed and configured for all supported agents.

```bash
remembra-doctor all
```

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

### Install via PyPI

Source: https://github.com/remembra-ai/remembra/blob/main/RELEASE-NOTES-v0.10.1.md

Install the specific version of the Remembra package.

```bash
pip install remembra==0.10.1
```

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

### Install MCP Server for Remembra

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/multi-agent-shared-memory.md

Installs the Remembra MCP server using uv (recommended) or pip. Verify the installation by checking the command path.

```bash
# Using uv (recommended)
uv tool install "remembra[mcp]"

# Or using pip
pip install "remembra[mcp]"

# Verify installation
which remembra-mcp
# Should return: ~/.local/bin/remembra-mcp
```

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

### Install and Use Remembra Python SDK

Source: https://github.com/remembra-ai/remembra/blob/main/docs/index.md

Install the package via pip and initialize the Memory client to store and recall user context.

```bash
pip install remembra
```

```python
from remembra import Memory

memory = Memory(
    base_url="http://localhost:8787",
    user_id="user_123"
)

memory.store("User's name is John. He's a software engineer at Google.")
result = memory.recall("Who is the user?")
print(result.context)
# → "John is a software engineer at Google."
```

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

### Remembra CLI Setup Command

Source: https://github.com/remembra-ai/remembra/blob/main/docs/case-studies/multi-agent-collaboration.md

This command initiates the setup process for Remembra, allowing users to connect their agents to shared memory by providing an API key and project name. It's the primary command for multi-agent setup.

```bash
npx remembra setup --api-key YOUR_KEY --project my-project
```

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

### Consolidation Statistics Example (Python SDK)

Source: https://github.com/remembra-ai/remembra/blob/main/site/guides/sleep-time-compute/index.html

Example output of the report.stats object from the Python SDK, showing key metrics from the consolidation process.

```python
#ConsolidationStats( 
#     duplicates_merged=23,
#     entities_linked=8,
#     relationships_discovered=5,
#     ...
# )
```

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

### Remembra Installation Options

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/agent-setup.md

Various CLI commands for installing and configuring Remembra.

```bash
remembra-install --all
```

```bash
remembra-install --agent claude-code
remembra-install --agent codex
remembra-install --agent cursor
remembra-install --agent gemini
remembra-install --agent windsurf
```

```bash
remembra-install --detect
```

```bash
remembra-install --all --api-key rem_your_key_here
```

```bash
remembra-install --all --project my-project
```

```bash
remembra-install --all --user-id user_123
```

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

### Install Remembra Server

Source: https://github.com/remembra-ai/remembra/blob/main/site/getting-started/installation/index.html

Install Remembra with the server component for running your own Remembra instance.

```bash
pip install "remembra[server]"
```

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

### Install Remembra Agents

Source: https://github.com/remembra-ai/remembra/blob/main/RELEASE-NOTES-v0.10.1.md

Configure AI tools using the universal installer command.

```bash
pip install remembra
remembra-install --all --url http://localhost:8787
```

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

### Start Remembra Server

Source: https://github.com/remembra-ai/remembra/blob/main/site/getting-started/installation/index.html

Set your OpenAI API key and start the Remembra server using the Python module.

```bash
export OPENAI_API_KEY=sk-your-key
python -m remembra.server
```

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

### Quick Start

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/python-sdk.md

A brief introduction to initializing the Memory class and performing basic operations.

```APIDOC
## Quick Start

```python
from remembra import Memory

memory = Memory(
    base_url="http://localhost:8787",
    user_id="user_123",
    project="my_app"  # Optional namespace
)

# Store a memory
memory.store("User prefers dark mode")

# Recall memories
context = memory.recall("What are user preferences?")
```
```

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

### Clone and Install Remembra

Source: https://github.com/remembra-ai/remembra/blob/main/README.md

Clone the Remembra repository, install development dependencies, and set up the project for local development.

```bash
git clone https://github.com/remembra-ai/remembra
cd remembra
pip install -e ".[dev]"
```

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

### Configure Environment Variables

Source: https://github.com/remembra-ai/remembra/blob/main/DOCKER.md

Initialize the configuration file from the provided example.

```bash
cp .env.example .env
```

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

### Deploy on VPS

Source: https://github.com/remembra-ai/remembra/blob/main/landing/blog/self-hosting-ai-memory.html

Manual installation steps for a standard Linux server environment.

```bash
# SSH to your server
ssh user@your-server

# Install Docker if needed
curl -fsSL https://get.docker.com | sh

# Run Remembra
docker run -d \
  --name remembra \
  --restart unless-stopped \
  -p 8787:8787 \
  -v /opt/remembra:/data \
  remembra/remembra
```

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

### Install and Configure Remembra

Source: https://github.com/remembra-ai/remembra/blob/main/docs/integrations/mcp-server.md

Use these commands to install the package and automatically configure supported AI tools with your API key.

```bash
pip install remembra
remembra-install --all --api-key YOUR_API_KEY
```

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

### Install and Use Remembra JavaScript Client

Source: https://github.com/remembra-ai/remembra/blob/main/docs/index.md

Install the client via npm and use the Remembra class to manage memory with async/await.

```bash
npm install @remembra/client
```

```typescript
import { Remembra } from '@remembra/client';

const memory = new Remembra({
  url: 'http://localhost:8787',
  userId: 'user_123',
});

await memory.store("User's name is John. He's a software engineer at Google.");
const result = await memory.recall('Who is the user?');
console.log(result.context);
// → "John is a software engineer at Google."
```

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

### Install Benchmark Dependencies

Source: https://github.com/remembra-ai/remembra/blob/main/benchmarks/README.md

Install the necessary Python dependencies for running the LOCOMO benchmark. This includes httpx, openai, and nltk.

```bash
pip install httpx openai nltk
```

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

### Plugin Status Response Example

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/plugins.md

Example JSON response showing the status of various plugins, including their health, enabled state, and processed events.

```json
{
  "plugins": [
    {
      "name": "auto_tagger",
      "enabled": true,
      "healthy": true,
      "events_processed": 1523
    },
    {
      "name": "sentiment",
      "enabled": true,
      "healthy": true,
      "events_processed": 1523,
      "avg_latency_ms": 45
    }
  ]
}
```

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

### Test MCP Server Installation

Source: https://github.com/remembra-ai/remembra/blob/main/site/guides/multi-agent-shared-memory/index.html

Shell script to test the installation and basic functionality of the remembra-mcp server by starting it, waiting, and then stopping it.

```shell
# Should start without errors
REMEMBRA_URL="https://api.remembra.dev" \
REMEMBRA_API_KEY="rem_YOUR_KEY" \
remembra-mcp &
sleep 2
kill %1
echo "MCP server works!"
```

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

### Get User Profile API Example

Source: https://github.com/remembra-ai/remembra/blob/main/landing/changelog/v0.12.0.html

Example cURL command to fetch a user's profile data from the Remembra API.

```bash
curl -H "Authorization: Bearer rem_xxx" \
  https://api.remembra.dev/api/v1/users/user_123/profile
```

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

### SDK Usage Example

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/installation.md

Initializes the Remembra Memory client.

```python
from remembra import Memory

memory = Memory(
    base_url="http://localhost:8787",
    user_id="test"
)
```

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

### Install Agents Pointing to Local Bridge

Source: https://github.com/remembra-ai/remembra/blob/main/site/getting-started/agent-setup/index.html

After starting the Remembra bridge, use this command in a second terminal to install agents that will communicate through the bridge.

```bash
# Terminal 2: Install agents pointing to bridge
remembra-install --all --url http://localhost:8766
```

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

### Install Remembra with API Key

Source: https://github.com/remembra-ai/remembra/blob/main/site/getting-started/agent-setup/index.html

Initializes the CLI and saves the provided API key to the local credentials file.

```bash
remembra-install --all --api-key rem_your_key_here
```

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

### Run Setup Diagnostics

Source: https://github.com/remembra-ai/remembra/blob/main/RELEASE-NOTES-v0.10.1.md

Troubleshoot connectivity and configuration issues for specific agents.

```bash
remembra-doctor all
remembra-doctor claude-code
remembra-doctor codex
```

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

### One-Command Codex Installer Script

Source: https://github.com/remembra-ai/remembra/blob/main/site/feedback/remembra-codex-feedback-2026-03-15/index.html

This bash script automates the installation and setup of Remembra AI's Codex. It installs dependencies, configures environment variables, and creates necessary executable scripts. Ensure REMEMBRA_CLOUD_URL, REMEMBRA_API_KEY, REMEMBRA_PROJECT, and REMEMBRA_USER_ID are set before running.

```bash
#!/usr/bin/env bash
set -euo pipefail

REMEMBRA_CLOUD_URL="${REMEMBRA_CLOUD_URL:-https://api.remembra.dev}"
REMEMBRA_API_KEY="${REMEMBRA_API_KEY:?REMEMBRA_API_KEY is required}"
REMEMBRA_PROJECT="${REMEMBRA_PROJECT:?REMEMBRA_PROJECT is required}"
REMEMBRA_USER_ID="${REMEMBRA_USER_ID:?REMEMBRA_USER_ID is required}"
REMEMBRA_HOST_IP="${REMEMBRA_HOST_IP:-}"

command -v uv >/dev/null 2>&1 || curl -LsSf https://astral.sh/uv/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"

uv tool install --upgrade "remembra[mcp]"

mkdir -p "$HOME/.local/bin" "$HOME/.remembra" "$HOME/.codex"

cat > "$HOME/.remembra/bridge.env" <<EOF
REMEMBRA_URL=$REMEMBRA_CLOUD_URL
REMEMBRA_API_KEY=$REMEMBRA_API_KEY
REMEMBRA_PROJECT=$REMEMBRA_PROJECT
REMEMBRA_USER_ID=$REMEMBRA_USER_ID
REMEMBRA_HOST_IP=$REMEMBRA_HOST_IP
EOF

cat > "$HOME/.local/bin/remembra-bridge" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
set -a
. "$HOME/.remembra/bridge.env"
set +a
exec python3 "$HOME/.remembra/remembra_bridge.py"
EOF
chmod +x "$HOME/.local/bin/remembra-bridge"

cat > "$HOME/.local/bin/remembra-codex-mcp" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
export REMEMBRA_URL="${REMEMBRA_URL:-http://127.0.0.1:8765}"
export REMEMBRA_PROJECT="${REMEMBRA_PROJECT:?REMEMBRA_PROJECT is required}"
export REMEMBRA_USER_ID="${REMEMBRA_USER_ID:?REMEMBRA_USER_ID is required}"
exec "$HOME/.local/bin/remembra-mcp" "$@"
EOF
chmod +x "$HOME/.local/bin/remembra-codex-mcp"

cat > "$HOME/.remembra/remembra_bridge.py" <<'EOF'
#!/usr/bin/env python3
import os
import socket
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

import httpx

UPSTREAM = os.environ["REMEMBRA_URL"].rstrip("/")
API_KEY = os.environ["REMEMBRA_API_KEY"]
FORCE_IP = os.environ.get("REMEMBRA_HOST_IP", "").strip()

if FORCE_IP:
    real_getaddrinfo = socket.getaddrinfo

    def patched_getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
        if host == "api.remembra.dev":
            host = FORCE_IP
        return real_getaddrinfo(host, port, family, type, proto, flags)

    socket.getaddrinfo = patched_getaddrinfo

client = httpx.Client(
    base_url=UPSTREAM,
    headers={"X-API-Key": API_KEY},
    timeout=30.0,
)

class Proxy(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def _forward(self):
        length = int(self.headers.get("content-length", "0"))
        body = self.rfile.read(length) if length else None
        headers = {}
        content_type = self.headers.get("content-type")
        if content_type:
            headers["content-type"] = content_type

        response = client.request(
            method=self.command,
            url=self.path,
            content=body,
            headers=headers,
        )

        payload = response.content

```

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

### Python SDK Usage

Source: https://github.com/remembra-ai/remembra/blob/main/ARCHITECTURE.md

Demonstrates initializing the client for self-hosted or cloud environments, storing data, and recalling information.

```python
from remembra import Memory

# Initialize (self-hosted)
memory = Memory(
    base_url="http://localhost:8787",
    user_id="user_123",
    project="my_app"
)

# Initialize (cloud - future)
memory = Memory(
    api_key="rem_xxx",
    user_id="user_123"
)

# Store
result = memory.store("John is the CTO at Acme Corp")
print(result.id)  # "01HQXYZ..."
print(result.extracted_facts)  # ["John is the CTO at Acme Corp."]

# Recall
result = memory.recall("Who is John?")
print(result.context)  # "John is the CTO at Acme Corp."
print(result.memories)  # [Memory(...)]
```

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

### Entity Introduction Best Practices

Source: https://github.com/remembra-ai/remembra/blob/main/site/concepts/entity-graph/index.html

Examples demonstrating the importance of providing full context versus vague references when storing memories.

```python
# ✅ Good - Full context 
memory.store("John Smith joined as VP of Engineering at Google") 

# ❌ Vague - Hard to resolve 
memory.store("He joined the company")
```

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

### Self-Hosted Setup

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/agent-setup.md

Commands for configuring Remembra with a self-hosted instance.

```bash
remembra-install --all --url http://localhost:8787
```

```bash
remembra-install --all --url http://localhost:8787 --api-key your-key
```

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

### LangChain Conversational Chain Usage

Source: https://github.com/remembra-ai/remembra/blob/main/site/examples/rag-pipeline/index.html

Example of integrating the custom `RemembraMemory` into a LangChain `ConversationalRetrievalChain`. Ensure `langchain`, `chromadb`, and `openai` libraries are installed.

```python
from langchain.chains import ConversationalRetrievalChain
from langchain.vectorstores import Chroma
from langchain.llms import ChatOpenAI

chain = ConversationalRetrievalChain.from_llm(
    llm=ChatOpenAI(model="gpt-4o"),
    retriever=chroma_db.as_retriever(),
    memory=RemembraMemory(user_id="user_123")
)
```

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

### SDKs - Python

Source: https://github.com/remembra-ai/remembra/blob/main/site/reference/api/index.html

Instructions for installing and using the Python SDK.

```APIDOC
## SDKs - Python

Install:
`pip install remembra`

Usage:
```python
from remembra import Memory
memory = Memory(base_url="...", user_id="...")
```
```

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

### Run Remembra with Docker

Source: https://github.com/remembra-ai/remembra/blob/main/landing/blog/self-hosting-ai-memory.html

The fastest way to get self-hosted AI memory running. This command starts a Remembra container in detached mode, maps port 8787, and mounts a volume for persistent data.

```docker
docker run -d \
  --name remembra \
  -p 8787:8787 \
  -v remembra-data:/data \
  remembra/remembra
```

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

### Get Authentication Token for Remembra API

Source: https://github.com/remembra-ai/remembra/blob/main/site/TROUBLESHOOTING/index.html

Use this script to obtain an access token for authenticating with the Remembra API. Replace placeholders with your actual API URL, email, and password. Ensure jq is installed for JSON parsing.

```bash
# Set your API URL and get a token
API="https://your-remembra-instance.com/api/v1"
TOKEN=$(curl -s -X POST "$API/auth/login" \
  -H "Content-Type: application/json" \
  -d '{"email":"your@email.com","password":"yourpassword"}' | jq -r '.access_token')
```

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

### Example .env File Configuration

Source: https://github.com/remembra-ai/remembra/blob/main/docs/reference/configuration.md

This is an example .env file showing required and optional configuration variables for Remembra AI. It covers API keys, server and database settings, security options, extraction and retrieval parameters, and temporal configurations.

```bash
# Required
OPENAI_API_KEY=sk-your-key-here

# Server
REMEMBRA_HOST=0.0.0.0
REMEMBRA_PORT=8787

# Database
REMEMBRA_DATABASE_PATH=/app/data/remembra.db
QDRANT_HOST=qdrant
QDRANT_PORT=6333

# Security (enable in production!)
REMEMBRA_AUTH_ENABLED=true
REMEMBRA_AUTH_MASTER_KEY=your-secure-master-key
REMEMBRA_RATE_LIMIT_ENABLED=true

# Extraction
REMEMBRA_SMART_EXTRACTION_ENABLED=true
REMEMBRA_EXTRACTION_MODEL=gpt-4o-mini

# Retrieval
REMEMBRA_HYBRID_SEARCH_ENABLED=true
REMEMBRA_RERANK_ENABLED=false
REMEMBRA_DEFAULT_MAX_TOKENS=4000

# Temporal
REMEMBRA_DEFAULT_TTL_DAYS=365
REMEMBRA_DECAY_ENABLED=true
```

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

### Query memories chronologically with timeline tool

Source: https://github.com/remembra-ai/remembra/blob/main/docs/integrations/mcp-server.md

Use the timeline tool to browse memories chronologically. Filter by entity name, start date, end date, and limit the number of results. The example shows filtering for 'Alice' between January and March 2026.

```tool_code
[Tool: timeline]
entity_name: "Alice"
start_date: "2026-01-01"
end_date: "2026-03-01"

Result:
{
  "status": "ok",
  "count": 3,
  "entity_filter": "Alice",
  "date_range": {"start": "2026-01-01", "end": "2026-03-01"},
  "memories": [
    {
      "id": "mem_001",
      "content": "Alice joined the engineering team",
      "created_at": "2026-01-15T10:00:00Z"
    },
    {
      "id": "mem_002",
      "content": "Alice completed the API redesign project",
      "created_at": "2026-02-20T14:30:00Z"
    }
  ]
}
```

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

### Start Remembra Server

Source: https://github.com/remembra-ai/remembra/blob/main/site/index.html

Commands to initialize the Remembra server using different deployment methods.

```bash
curl -sSL https://raw.githubusercontent.com/remembra-ai/remembra/main/quickstart.sh | bash
```

```bash
docker run -d -p 8787:8787 remembra/remembra
```

```bash
git clone https://github.com/remembra-ai/remembra
cd remembra
pip install -e ".[server]"
remembra-server
```

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

### Install Remembra MCP Server

Source: https://github.com/remembra-ai/remembra/blob/main/site/guides/multi-agent-shared-memory/index.html

Install the Remembra MCP server package. Use 'uv' for recommended installation or 'pip' as an alternative. Verify the installation by checking the command path.

```bash
uv tool install "remembra[mcp]"
```

```bash
pip install "remembra[mcp]"
```

```bash
which remembra-mcp
```

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

### Install Remembra with Encryption Support

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/security.md

Install the Remembra package with the necessary `cryptography` dependency for encryption at rest, or install `cryptography` separately.

```bash
pip install "remembra[encryption]"
# or
pip install cryptography
```

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

### Troubleshoot Server Not Starting

Source: https://github.com/remembra-ai/remembra/blob/main/site/DEPLOYMENT/index.html

Steps to diagnose issues when the Remembra server fails to start. This includes checking logs, verifying Qdrant status, and checking port usage.

```bash
tail -f /tmp/remembra.log
curl http://localhost:6333/health
lsof -i :8787
```

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

### Manual MCP Configuration

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/agent-setup.md

Manual configuration examples for different agents.

```json
{
  "mcpServers": {
    "remembra": {
      "command": "remembra-mcp",
      "env": {
        "REMEMBRA_URL": "https://api.remembra.dev",
        "REMEMBRA_API_KEY": "your-api-key"
      }
    }
  }
}
```

```json
{
  "mcpServers": {
    "remembra": {
      "command": "remembra-mcp",
      "env": {
        "REMEMBRA_URL": "https://api.remembra.dev",
        "REMEMBRA_API_KEY": "your-api-key"
      }
    }
  }
}
```

```toml
[mcp_servers.remembra]
command = "remembra-mcp"

[mcp_servers.remembra.env]
REMEMBRA_URL = "https://api.remembra.dev"
REMEMBRA_API_KEY = "your-api-key"
```

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

### Install Remembra for Custom Project

Source: https://github.com/remembra-ai/remembra/blob/main/site/getting-started/agent-setup/index.html

Configures the installation for a specific project identifier.

```bash
remembra-install --all --project my-project
```

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

### Remembra SDK Quick Start

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/javascript-sdk.md

Initialize the Remembra client and perform basic store, recall, and forget operations. Ensure the server is running locally on port 8787.

```typescript
import { Remembra } from '@remembra/client';

const memory = new Remembra({
  url: 'http://localhost:8787',
  apiKey: 'rem_xxx',     // optional for self-hosted
  userId: 'user_123',    // optional
  project: 'my_app',     // optional
});

// Store
const stored = await memory.store('Alice is the CTO of Acme Corp');
console.log(stored.extracted_facts);
// → ["Alice is the CTO of Acme Corp."]

// Recall
const result = await memory.recall('Who leads Acme?');
console.log(result.context);
// → "Alice is the CTO of Acme Corp."

// Forget
await memory.forget({ memoryId: stored.id });
```

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

### Start Remembra with Docker Compose

Source: https://github.com/remembra-ai/remembra/blob/main/DOCKER.md

Commands to clone the repository and initialize the service stack.

```bash
# Clone the repo
git clone https://github.com/remembra-ai/remembra.git
cd remembra

# Start all services
docker compose up -d

# Check status
docker compose ps
```

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

### Install Encryption Dependencies

Source: https://github.com/remembra-ai/remembra/blob/main/docs/reference/changelog.md

Install the optional cryptography dependency for field-level encryption.

```bash
pip install "remembra[encryption]"
```

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

### Initialize Memory with Scoped Keys

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/rbac.md

Demonstrates initializing the Memory client with different roles to control access levels.

```python
from remembra import Memory

# Editor key - can store and recall
memory = Memory(
    base_url="http://localhost:8787",
    api_key="rem_sk_live_editor_...",
    user_id="user_123"
)

memory.store("User feedback: Great product!")  # ✅ Works
memory.recall("feedback")  # ✅ Works
```

```python
# Viewer key - read only
memory = Memory(
    base_url="http://localhost:8787",
    api_key="rem_sk_live_viewer_...",
    user_id="user_123"
)

memory.recall("feedback")  # ✅ Works
memory.store("New data")  # ❌ 403 Forbidden
```

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

### Manage API Keys

Source: https://github.com/remembra-ai/remembra/blob/main/site/SETUP-CHECKLIST/index.html

Demonstrates API key management, including creating a new key with specified permissions and listing the total number of existing keys.

```bash
# Create an API key
curl -s -X POST "$API/keys" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "test-key", "permission": "editor"}' | jq '{id, key: .key[0:20]}'
# List keys
curl -s "$API/keys" \
  -H "Authorization: Bearer $TOKEN" | jq '.keys | length'
```

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

### Reranking Support Installation

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/installation.md

Installs server dependencies with CrossEncoder reranking support.

```bash
pip install "remembra[server,rerank]"
```

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

### Run Remembra Tests and Server

Source: https://github.com/remembra-ai/remembra/blob/main/README.md

Execute the project's tests and start the development server for Remembra.

```bash
pytest
remembra-server --reload
```

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

### List Installed Agents with Remembra

Source: https://github.com/remembra-ai/remembra/blob/main/landing/changelog/v0.10.0.html

This command lists all agents that have been detected and installed by Remembra.

```bash
remembra-install --detect
```

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

### Initialize Remembra SDK with API Key

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/security.md

Instantiate the Remembra SDK client by providing the base URL, user ID, and your API key for authenticated access.

```python
memory = Memory(
    base_url="http://localhost:8787",
    user_id="user_123",
    api_key="rem_abc123..."
)
```

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

### Install and Configure Remembra

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/agent-setup.md

Install the package and automatically configure all detected AI agents.

```bash
# Install Remembra
pip install remembra

# Configure all detected agents
remembra-install --all
```

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

### Install Remembra via pip

Source: https://github.com/remembra-ai/remembra/blob/main/demo/PRODUCTION_GUIDE.md

Use this command to install the Remembra package in your terminal.

```bash
$ pip install remembra
```

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

### Start Remembra Manually

Source: https://github.com/remembra-ai/remembra/blob/main/docs/getting-started/quickstart.md

Provides various methods to manually start the Remembra server.

```bash
docker run -d \
  -p 8787:8787 \
  -e OPENAI_API_KEY=sk-your-key \
  -v remembra-data:/app/data \
  remembra/remembra
```

```yaml
version: '3.8'
services:
  remembra:
    image: remembra/remembra
    ports:
      - "8787:8787"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
    volumes:
      - remembra-data:/app/data

volumes:
  remembra-data:
```

```bash
docker-compose up -d
```

```bash
git clone https://github.com/remembra-ai/remembra
cd remembra
pip install -e ".[server]"

export OPENAI_API_KEY=sk-your-key
python -m remembra.server
```

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

### Run Qdrant using Docker

Source: https://github.com/remembra-ai/remembra/blob/main/site/DEPLOYMENT/index.html

Easily set up and run Qdrant, a required dependency for Remembra, using Docker. This command ensures Qdrant starts automatically on boot.

```bash
docker run -d \
  --name qdrant \
  --restart=always \
  -p 6333:6333 \
  -v qdrant_data:/qdrant/storage \
  qdrant/qdrant
```

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

### Initialize Remembra Python Client

Source: https://github.com/remembra-ai/remembra/blob/main/docs/reference/api.md

Instantiate the Memory client with your base URL and user ID.

```python
from remembra import Memory
memory = Memory(base_url="...", user_id="...")
```

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

### Recall Logger Output Example

Source: https://github.com/remembra-ai/remembra/blob/main/docs/guides/plugins.md

Example JSONL log entry generated by the recall_logger.

```jsonl
{"timestamp": "2026-03-02T12:00:00Z", "user_id": "user_123", "query": "preferences", "results_count": 5, "latency_ms": 45}
```

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

### Perform Backups

Source: https://github.com/remembra-ai/remembra/blob/main/docs/concepts/durability.md

Commands for backing up SQLite databases and creating Qdrant snapshots.

```bash
# SQLite backup (safe during operation)
sqlite3 remembra.db ".backup backup.db"

# Qdrant snapshot
curl -X POST http://localhost:6333/collections/remembra/snapshots
```