Recall

Inspiration

Most agent "memory" today is a vendor-locked vector dump you can't query, audit, or export. We wanted an agent's long-term memory to be something you own — portable, inspectable, durable across sessions and frameworks. So we modeled memory the way cognition does: fast episodic capture, then an offline "dreaming" pass that consolidates raw episodes into durable knowledge.

What it does

Recall is portable, SQL-native long-term memory for AI agents, exposed over MCP (store_memory / recall / consolidate / forget) so any framework — Strands, LangGraph, Claude Code, custom — can use it.

• Episodic tier: every interaction is a row in CockroachDB, embedded with Bedrock Titan v2 and indexed by CockroachDB's native distributed vector index.
• Semantic tier: a scheduled consolidation ("dreaming") loop has Bedrock Claude distill recent episodes into durable facts, preferences, and skills — each with a confidence score and provenance back to source episodes.
• Hybrid recall: vector similarity AND SQL metadata filters (agent, subject, time, tier) in a single query — because the memory is just SQL: queryable, auditable, exportable, portable.

How we built it

• CockroachDB Serverless as the memory substrate (3 CockroachDB touchpoints: MCP server + distributed vector index + ccloud CLI).
• AWS (6+ services): Bedrock (Titan v2 embeddings + Claude consolidation), Lambda (MCP server + consolidation worker), AgentCore (Runtime/Gateway/Observability), EventBridge (scheduled dreaming), S3, API Gateway (public MCP endpoint).
• MCP JSON-RPC 2.0 over streamable HTTP; idempotent stores keyed on content hash; consolidation runs async off EventBridge. Everything is IaC via AWS SAM, deployed through GitHub Actions OIDC.

Challenges we ran into

Making recall genuinely hybrid — combining ANN vector search with arbitrary SQL predicates in one query without a second store — and keeping the consolidation loop idempotent so repeated "dreaming" runs converge instead of duplicating semantic memories.

Accomplishments that we're proud of

A live, functional demo where a brand-new session answers a question it was never told in that session, in the user's preferred language, purely from consolidated memory — and the agent's entire "brain" is inspectable with a single SELECT.

What we learned

Modeling agent memory as two SQL tiers (episodic + semantic) with a scheduled consolidation job gives durability, auditability, and zero vendor lock-in — the opposite of a black-box vector store.

What's next for Recall

Richer Cedar-policy enforcement via AgentCore Gateway (e.g. forget requires an elevated principal), multi-agent shared memory, and export/import tooling for full memory portability.

Judging axes

• Agentic Memory Design — episodic + semantic tiers with a consolidation "dreaming" loop and provenance links.
• Technical Implementation — 3 CockroachDB tools + 6 AWS services, MCP JSON-RPC 2.0, IaC, OIDC CI.
• Real-World Impact — SQL memory you own: portable across frameworks, auditable for compliance, no lock-in.
• Production Readiness — IaC (SAM), AgentCore Observability → CloudWatch/X-Ray, Cedar policy, idempotency, unit tests, live endpoint.
• Creativity — offline "dreaming" consolidation mirroring biological memory; the whole brain is one SELECT away.

Repo: https://github.com/OpsAgentsAI/recall-agentic-memory (MIT) · Live demo: https://mafjgoryw8.execute-api.us-east-1.amazonaws.com/mcp

Built With

• amazon-api-gateway
• amazon-bedrock
• amazon-eventbridge
• amazon-web-services
• aws-agentcore
• aws-lambda
• claude
• cockroachdb
• mcp
• python
• sql
• titan-embeddings
• vector-search