Changelog

The June 2026 build wave.

2026-06-15#

• SDK parity: list & move memories — both SDKs gain list_memories/listMemories (page a collection's memories, newest first) and move (move a memory to another collection), closing the last gaps between the REST memory API and the SDKs.

2026-06-14#

• Fleet-wide memory health (operator) — GET /v1/memory/admin/memory-health rolls up knowledge hygiene across all collections: total, current, archived, stale, expired, supersessions and a single needs_attention. A SECURITY DEFINER cross-tenant aggregate (cheap COUNTs, RLS intact) — the operator companion to the per-collection /health, surfaced as a card on the admin analytics page and in both SDKs (admin_memory_health() / adminMemoryHealth()).
• MCP maintenance tools — the MCP server adds two hygiene tools so agents can keep the shared memory they collectively write to healthy: find_duplicates (surface near-duplicate clusters, read-only — deletes nothing) and archive_stale (soft-archive memories untouched for N days; reversible, dry_run by default). With these the access surface is store → recall → discover → summarize → maintain — ten MCP tools, all vendor-neutral.
• Guide: connect every agent to one shared memory — a new Connect Every Agent recipe shows agents from Claude, OpenAI/ChatGPT, Microsoft Copilot, and Gemini reading and writing the same collection — via MCP where the client supports it, REST/SDK everywhere else. One worked four-agent chain: one agent stores, another discovers, a third reports. Vendor-neutral by construction.
• Collection summary (board-report briefing) — GET /v1/memory/collections/{name}/summary rolls a collection into {summary, themes, based_on, generated_at} via one bounded, cached LLM call over its most important recent memories, noting notable supersession changes. The last link in the agent chain: one agent's observations become another's briefing. Also an MCP tool (summarize_collection) and summary() in both SDKs. Degrades to an extractive summary when no LLM is configured — never errors.
• Knowledge portability (export + import) — POST /v1/memory/admin/import is the round-trip companion to GET /admin/export: re-ingest a full knowledge-base dump into a tenant. Because an export carries text, not vectors, import re-embeds with the active model — so knowledge survives a move off any model, agent, or vendor. Collections are created as needed; into_collection can collapse everything into one. New Own Your Knowledge guide; export_account()/import_memories() in the Python SDK and exportAccount()/importMemories() in the JS SDK.
• MCP discovery tools — the MCP server now exposes three discovery primitives on top of store/search: related_memory (nearest neighbours of a memory), what_changed (where a newer fact superseded an older one), and collection_health (stale / expired / supersessions + a needs_attention roll-up). Any MCP-capable agent — Claude, ChatGPT, Copilot, Gemini — can now discover patterns in knowledge a different agent recorded, not just read and write. The access surface for a shared knowledge layer.
• Collection health snapshot — GET /v1/memory/collections/{name}/health returns a one-shot operator view of a collection: total, current, archived, pinned, stale (unpinned, not-archived, older than stale_days), expired, supersessions, a categories breakdown, and a single needs_attention roll-up — all cheap COUNT aggregates. Surfaced as per-collection badges on the dashboard and exposed in both SDKs (health() / health()).
• Benchmark: hybrid ranking-quality eval — a new reproducible eval scores recall@5 and MRR for vector / text / hybrid modes on a labeled set of semantic, lexical, and mixed queries: hybrid matches the best single arm on every query (MRR 1.00) while text-only drops to 0.50. Published on the eval page.
• Search cache hit-rate — the search-result cache now records hit/miss counters, surfaced under counters in GET /admin/metrics and as a hit-rate readout on the admin analytics page — so operators can see how often repeat queries are served from cache (one Redis GET) instead of a cold embed + vector round trip.
• Hybrid search: symmetric RRF fusion (lexical-only recall) — hybrid search now fuses its vector and full-text arms with a symmetric join, so a strong keyword-only match (a rare token, error code, id, or unusual name) surfaces even when it falls below the vector min_score or outside the vector candidate window. Previously the fusion was anchored on the vector arm and could drop such matches. A reproducible recall eval ships in evals/run_hybrid_recall_eval.py.
• SDK: connector fleet-health methods — the Python and JavaScript clients now expose connector_health()/connectorHealth() and connector_status()/connectorStatus() for the admin connector-sync endpoints, so operators can monitor the connector fleet programmatically (admin key required).
• Surface paused connectors — the admin analytics view now shows a status summary (active / error / paused) above the connector-sync table, with a clear "N connector(s) need attention" note, backed by a new GET /v1/memory/admin/connectors/status endpoint.
• Connector auto-pause — after 5 consecutive failed syncs a connection is paused so the scheduler stops hammering a broken source; a successful manual sync re-enables it. The dashboard shows the paused state with a fix-and-retry hint.
• Benchmark: intelligent-memory eval results — the public eval page now publishes the dedup (precision 1.00) and related (precision@3 1.00, coverage 1.00) numbers alongside the memory-vs-RAG results, with reproduce commands.
• Related-memory eval — a reproducible eval for related(): across 4 distinct topical clusters, every memory's top-3 neighbours came from its own topic (precision@3 and coverage both 1.00). evals/run_related_eval.py.
• Admin analytics: connector sync health — the analytics page now shows a per-provider connector-sync table (runs, errors, last run over the last 24h) alongside the funnel, usage, and latency panels.
• Operator: connector-sync metrics — GET /v1/memory/admin/connectors rolls up connector sync health across all tenants (per-provider runs, errors, last run over a window) via a SECURITY DEFINER aggregate — no tenant rows leave the function.
• Cookbook: intelligent memory in practice — a new recipe showing a shared-memory maintenance pass (preview + run dedup, pin, archive-stale) plus the related/contradictions recall helpers, all via the SDK.
• SDK: manage connectors — the Python and JS SDKs can now create, list, get, sync, inspect run history for, and delete managed connections — the whole connector workflow from code.
• SDK parity for intelligent memory — the Python and JS SDKs now expose related, dedup, contradictions, pin, archive, and archive_stale/archiveStale — the full intelligent-memory + related surface, no raw HTTP needed.
• Related memories — GET /v1/memory/collections/{name}/memories/{id}/related returns the nearest neighbours of a memory by its own embedding (excluding itself, archived, and superseded rows) — a one-call "more like this" recall primitive.
• Dedup eval — a reproducible precision/recall eval for the dedup op (evals/run_dedup_eval.py): across a threshold sweep, dedup kept precision at 1.00 (never deleted a distinct memory) while recall rose as the threshold loosened.
• Connector sync history — every connector sync is now recorded; see recent runs (status, items synced, errors) at GET /v1/memory/connections/{id}/runs or via the History button in the dashboard Connections panel.
• Managed connector: HubSpot — HubSpot CRM is now server-syncable: connect with a private-app token and RememberOS pulls contacts newest-modified first (name, title, company, lifecycle stage), incrementally. POST /v1/memory/connections with provider: "hubspot". That completes the managed set — only Postgres remains a self-host recipe.
• Managed connector: Gmail (via Google OAuth) — Gmail is now server-syncable: connect with OAuth (offline refresh) or a Google access token (gmail.readonly) and RememberOS pulls messages newest-first — subject, sender, and plain-text body — incrementally. POST /v1/memory/connections with provider: "gmail".
• Managed connector: Confluence — Confluence Cloud is now server-syncable: connect with your email + an API token and a base URL, and RememberOS pulls pages newest-modified first (storage-format bodies rendered to text), incrementally. POST /v1/memory/connections with provider: "confluence".
• Connectors overview on the site — the landing page now has a Connect everything section showing the managed connectors that sync server-side (Slack, Notion, Google Drive, Linear), one-click OAuth, the dashboard panel, and recipes for everything else.
• Google Drive via OAuth (offline) — connect Drive with one click: RememberOS runs the Google OAuth flow, stores a refresh token encrypted, and renews the access token automatically before each sync (no more pasting a token that expires in an hour). Enabled once the operator sets the Google OAuth app credentials. The dashboard now offers OAuth + Sync for Drive and Linear too.
• Managed connector: Linear — Linear is now server-syncable: connect with a Linear API key and RememberOS pulls issues newest-updated first via the GraphQL API (title, description, state, assignee, team, labels), incrementally. POST /v1/memory/connections with provider: "linear".
• Managed connector: Google Drive — Drive is now server-syncable: connect with a Google OAuth access token (optionally scope to a folder_id or query) and RememberOS pulls files newest-modified first, exporting native Google Docs to text, incrementally. POST /v1/memory/connections with provider: "gdrive".
• Connect with OAuth from the dashboard — the Connections panel now shows a Connect with OAuth button for Notion and Slack that runs the authorize flow and returns you to the dashboard with the connection ready (when the provider's OAuth app is configured).
• Connect connectors via OAuth — GET /v1/memory/connections/oauth/{provider}/start and /callback let a tenant authorize Notion or Slack with OAuth instead of pasting a token (the token is exchanged and stored encrypted server-side). Enabled per provider once its OAuth app credentials are set.
• Connections in the dashboard — the dashboard now has a Connections panel: add a managed connector, run a sync, see its status and last error, and remove it — no code required.
• Managed connector: Notion — Notion is now server-syncable like Slack: store a Notion integration token (optionally a database_id) and RememberOS pulls pages newest-edited first into the connection's collection, incrementally. POST /v1/memory/connections with provider: "notion".
• Intelligent memory: archive stale — POST /v1/memory/collections/{name}/memories/{id}/archive soft-archives (or restores) a memory, and POST /v1/memory/collections/{name}/archive-stale bulk-archives memories untouched for N days (skipping pinned). Archived memories drop out of default recall but stay restorable; pass include_archived to surface them. archived is now on every memory.
• Intelligent memory: pin/promote — POST /v1/memory/collections/{name}/memories/{id}/pin marks a memory important: pinned memories are always kept by dedup (never consolidated away) and rank first. pinned is now on every memory.

2026-06-13#

• Intelligent memory: contradictions — GET /v1/memory/collections/{name}/contradictions surfaces where the current truth changed: each newer fact alongside the older one it superseded (from graph supersession), making a shared collection's evolution visible.
• Intelligent memory: dedup — POST /v1/memory/collections/{name}/dedup finds near-identical memories (cosine over the recent 500) and consolidates each cluster to one keeper (dry-run by default). Shared memory that improves, not just grows.
• Shared-collection access control — collections are open to all a tenant's agents by default; add a grant (PUT …/collections/{name}/grants) and a collection becomes private to specific agents with per-agent read/write — disallowed agents get 403 and the collection drops out of their tenant-wide search. The "shared Support vs private Personal Memory" model.
• Agent identities & provenance — every memory now records which agent (API key) wrote it (created_by), so multiple agents can share a collection and you see who contributed what. New GET /v1/memory/agents lists a tenant's agent identities. First step toward shared, multi-agent memory.
• Managed connectors (beta) — connect an external source once and let RememberOS sync it server-side, no code: POST/GET/DELETE /v1/memory/connections + POST /v1/memory/connections/{id}/sync, credentials encrypted at rest and never returned. Slack syncs server-side today (incremental), and a background scheduler auto-syncs active connections (default hourly; config.sync_interval_minutes to tune). More providers rolling out. Distinct from the self-host recipes; reuses their mappers.
• SDK CRUD completeness — both SDKs gain get, delete, delete_collection/deleteCollection, and forget (semantic delete) — you can now read-one, delete, and forget from the SDKs, not just add/update/search.
• HubSpot connector recipe — sync your HubSpot CRM contacts into RememberOS with a ready-made dlt recipe (CRM as searchable memory for sales/support agents): name + key properties embedded, incremental on lastmodifieddate. Eighth connector. Source in connectors/hubspot/.
• Docs completeness pass — verified every endpoint, connector, and SDK method is documented and cross-linked; the bulk endpoint now shows its full per-item fields (incl. container_tag) and points to the SDK add_many helper.
• SDK bulk import + bulk container_tag fix — both SDKs gain add_many/addMany (strings or per-item dicts, chunked to 100/call with retries) for fast imports; the migration guide now uses it. Fixed the bulk API to persist container_tag (it was dropped on bulk insert), so bulk-imported memories keep their per-user scope.
• Eval: expiry scenario — added a 4th benchmark scenario for time-bound facts that expire and are replaced. Across 4 scenarios (33 queries) memory still ~2×s top-1 (51.5% vs 24.2%) and roughly halves contradictions (48.5% vs 90.9%) vs plain RAG; on the expiry scenario specifically, 80%/40% top-1.
• SDK auto-retry (Python + JS) — both the Python and JavaScript clients now retry transient failures (network errors + 429/5xx) with exponential backoff, honoring Retry-After; tunable via max_retries/backoff_base (maxRetries/ backoffBase in JS), 4xx never retried. Still zero-dependency.
• Migration guide — a provider-agnostic Migrate to RememberOS guide: how store/search/extract map to add/search/remember, and a bulk-import loop using the SDK or the connector recipes.
• Confluence connector recipe — sync your Confluence Cloud wiki into RememberOS with a ready-made dlt recipe: page bodies (storage XHTML) are stripped to text and embedded; incremental on the version timestamp, scoped by space. Source in connectors/confluence/.
• Linear connector recipe — sync your Linear issues into RememberOS with a ready-made dlt recipe over the GraphQL API: title, description, and fields are embedded; incremental on updatedAt, scoped by team. Source in connectors/linear/.
• Status page incidents — the status page now lists recent incidents derived from the health-probe history (start, recovery, duration), with an honest "no incidents in the last 7 days" state. Exposed on /v1/status.
• Docs search — the docs sidebar now has an instant client-side filter over page titles and descriptions (press / to focus it), with section hiding and a no-results state. No backend, no tracking.
• Gmail connector recipe — sync a mailbox into RememberOS with a ready-made dlt recipe: subject, sender, and plain-text body are embedded (base64url decoded), narrowed by any Gmail search query, incremental on internalDate. Source in connectors/gmail/.
• Postgres connector recipe — stream any Postgres table into RememberOS with a ready-made dlt recipe: pick the columns to embed, the rest is kept as metadata; server-side cursor + incremental on updated_at/id. Source in connectors/postgres/.
• Health alerting — the status probe pages ops on a Slack channel when the service goes down (after 2 consecutive failures, so deploy restarts don't page) and on recovery.
• Eval reconfirmed — re-ran the benchmark (2026-06-13); the memory-vs-RAG contradiction gap holds (~43% vs ~89%). Added a note that per-run numbers vary (LLM extraction).
• Comparison page — an honest RememberOS vs alternatives table (graph supersession is benchmark-backed; no FUD).
• Cookbook: infinite chat — added a memory-proxy recipe (point an OpenAI client at RememberOS; memories injected + turns remembered with zero glue).
• Card-free free signup — the free tier now issues a key with no Stripe and no card: enter an email, get your key by email. Public POST /v1/memory/signup.
• GEO/SEO hygiene — an expanded llms-full.txt for AI answer engines, image alt text, and heading-hierarchy cleanup.
• Docs quickstart polish — copy buttons on every code block; quickstart snippets verified live (store/search/remember).
• Social cards — every public page now has an OpenGraph/Twitter preview image so shared links render a branded card.
• Eval: 3rd scenario — the benchmark now adds a temporal/recency scenario (dated restatements; latest wins) alongside career and preference-conflict; memory still roughly halves contradictions vs plain RAG.
• SDKs at v0.2.0 — Python, JS/TS, LangChain, Vercel AI, and the dlt destination are version-synced, MIT-licensed, and release-ready (install-from-source; see RELEASING.md).
• API explorer — a full interactive reference at /api-explorer.html generated from the OpenAPI spec (/openapi.json), with enriched metadata + tags.
• Rate limiting — per-API-key request limits (fixed window) with standard RateLimit-Limit/Remaining/Reset headers and 429 + Retry-After when exceeded; fails open if the limiter is unavailable.
• API-key management — list, create, and revoke your own keys (with read-only support) from the dashboard or /v1/memory/keys; new keys are shown once. Read-only keys are now enforced on every write endpoint.
• Spend caps — set a monthly USD cap on platform LLM spend; over it, /remember still stores content but skips extraction (a runaway agent can't run up an unbounded bill). BYOK tenants are never gated.
• Eval v2 — the benchmark now runs two reproducible scenarios (career evolution + preference-conflict/multi-hop); memory supersession roughly halves contradictions vs plain RAG.
• Status page — a public status page and GET /v1/status with current health, 24h uptime, and recent checks.
• Consent-gated analytics — optional Google Analytics loads only after explicit opt-in via a cookie-consent banner; the cookieless first-party stats run regardless. Privacy policy and sub-processor list updated.
• SEO/GEO hardening — FAQPage schema on the landing pages, TechArticle + BreadcrumbList structured data on every docs page, and an explicit answer-engine allowlist in robots.txt (GPTBot, ClaudeBot, PerplexityBot, Google-Extended, ...).
• Framework adapters — RememberOS drops into LangChain (retriever + memory) and the Vercel AI SDK (memory injection + remember); see Framework Adapters.
• Latency profiling — per-stage p50/p95 (embed, cache_get, search, llm_extract) on GET /admin/metrics and the analytics page; see the new Performance page for live numbers.
• Audit log — every write and sensitive action (create/update/delete/bulk/ remember, webhook config) is recorded per tenant; view it at GET /admin/audit or the audit page.
• Connector recipes — ready-made dlt pipelines for Notion, Slack, and Google Drive (incremental, scoped), on top of the dlt destination.
• Memory eval — a transparent, reproducible eval showing memory supersession cuts contradictions from 100% to 33% vs a plain RAG store (source in evals/).
• GDPR self-service — full account export (GET /admin/export), irreversible erasure (POST /admin/delete-account), a real privacy policy (DE/EN) and a DPA template.
• SDK update() — both SDKs can now partially update a memory (PATCH; text changes re-embed).
• Webhooks — configure a URL and receive HMAC-signed memory.created/updated/deleted events; the signing secret is generated server-side and shown once.
• Search boosters — optional rewrite (LLM query expansion) and rerank (LLM re-ordering) parameters on search; off by default.
• Memory proxy — POST /v1/proxy/chat/completions: point an OpenAI client at RememberOS and chats get relevant memories injected automatically while new facts are remembered in the background ("infinite chat").
• Usage accounting — every LLM call (extraction, relate, profile, Whisper, vision) is recorded per tenant; the admin analytics page shows storage, tokens, and cost estimates per tenant.
• Analytics page — admin view of pageviews by day/path/referrer, signups by day, and the activation funnel; cookieless throughout. SEO: OpenGraph/Twitter/JSON-LD on the landing pages and docs.
• Vault — open a collection by link (/vault.html?c=name), load-more paging, search-mode toggle (hybrid/vector/text), per-memory details panel (metadata, source, dates).
• Dashboard — collections click through to the Vault; 7d/30d memory-growth counts.

2026-06-12#

• Docs site — this site: 27 pages, machine-verified API reference, cookbook.
• Unified design system — one dark theme + the memory-graph logo on every page.
• Presigned direct-to-S3 uploads — big drops PUT straight to storage; per-file failure isolation; folder drag-drop.
• JavaScript/TypeScript SDK — zero-dependency client (Node/Bun/Deno/browser/edge).
• Memory update — PATCH /memories/{id}, re-embeds on text change.
• BYO extraction — run graph extraction on your own OpenAI/Azure/Ollama endpoint; encrypted config with live self-test.
• Async graph extraction — remember returns 202 instantly; the worker extracts in the background.
• dlt destination — pipe any dlt source into memory.
• SharePoint connector — resumable Graph-API library importer.
• Container tags — per-end-user scoping inside collections.
• Cookieless analytics — first-party /v1/pulse beacon, no cookies, no consent banner needed.
• Ops — per-route metrics endpoint, uptime checker with email alerts, structured logs.

2026-06-11#

• Graph memory — fact extraction, updates/extends relationships with current-truth search, automatic expiry, user profiles.
• Python SDK — zero-dependency client.
• Named API keys — main + read-only keys, optional expiry, rotation.
• Secure welcome email — one-time reveal links; raw keys never emailed.
• llms.txt — agent-readable API summary at the site root.