# RememberOS

> The organizational memory operating system for the AI era. Sovereign, European,
> self-hostable memory infrastructure for AI agents and the people they work with.
> Store text and files, search them semantically (vector + full-text hybrid), and let
> memory evolve over time (automatic fact extraction, updates/supersedes, forgetting).
> Bring your own model, memory, agents, and infrastructure — your organization's
> knowledge survives every model and vendor, and stays under your control. Multi-tenant
> with strict per-tenant isolation and per-collection access control.

Base URL: https://rememberos.ai
Full reference: https://rememberos.ai/llms-full.txt
Auth: every request sends `Authorization: Bearer mv_...` (your API key).
Content type: `application/json` unless uploading files.

## Core concepts

- **Collection**: a named namespace for memories (e.g. `strategy`, `people`, `docs`).
- **Memory**: a stored item (text, optionally with files/images) + metadata.
- **Search**: hybrid (vector + keyword) by default; also `vector` or `text` only.
- **Agent identity**: each API key is an agent that reads/writes the shared memory.
- **Access control**: per-collection read/write grants per agent — restrict a collection
  and only granted agents may access it (enforced on read, write, and search).
- **Graph memory**: `/remember` extracts atomic facts and links updates/supersedes,
  so the latest truth wins; old facts can expire and be forgotten automatically.

## Quickest start (Python SDK, zero dependencies)

```python
from rememberos import RememberOS       # pip install rememberos  (publish pending; see Source)
mem = RememberOS()                      # reads REMEMBEROS_API_KEY
mem.add("Acquisition target shortlisted", collection="strategy")
print(mem.search("what did we decide on M&A?"))
```

## Key endpoints

Store a memory:
```
POST /v1/memory/collections/{collection}/memories
{ "text": "Acquisition target shortlisted", "importance": 0.7, "category": "decision", "metadata": {} }
```

Search within a collection:
```
POST /v1/memory/collections/{collection}/search
{ "query": "what did we decide on M&A?", "limit": 5, "mode": "hybrid" }
```

Search across all collections (restricted collections you can't read are excluded):
```
POST /v1/memory/search
{ "query": "...", "limit": 5 }
```

Graph memory — extract + relate facts from free text:
```
POST /v1/memory/collections/{collection}/remember
{ "content": "Alex moved from Google to Stripe last month." }
```

Grant an agent access to a restricted collection:
```
PUT /v1/memory/collections/{collection}/grants
{ "agent_key_id": "<api key id>", "can_read": true, "can_write": false }
```

List collections:
```
GET /v1/memory/collections
```

## curl example

```
curl -s https://rememberos.ai/v1/memory/collections/strategy/search \
  -H "Authorization: Bearer $REMEMBEROS_API_KEY" -H "Content-Type: application/json" \
  -d '{"query":"what did we decide on M&A?","limit":5}'
```

## MCP (Model Context Protocol)

RememberOS speaks MCP at `POST /v1/mcp` (JSON-RPC) with tools `search_memory`,
`get_memory`, `store_memory`, `list_collections` — point any MCP-capable agent
(Claude, ChatGPT, Copilot, Gemini) at it with your bearer key so they share the same
governed organizational memory.

## One-prompt agent onboarding

Paste this into Claude Code or Cursor to wire memory into your project:

> Use the RememberOS memory API at https://rememberos.ai. Read the bearer key from the
> REMEMBEROS_API_KEY env var. Before answering, search relevant memory with
> `POST /v1/memory/search {"query": <user intent>}`. After learning a durable fact
> about the org or project, store it with
> `POST /v1/memory/collections/project/memories {"text": <fact>}`. Prefer the
> `rememberos` Python SDK if available.

## Links

- Docs: https://rememberos.ai/docs.html
- Source: https://github.com/11data/rememberos