Memory for every agent.

⟩ Quick start

Get started in seconds

Install extras for your stack, open a configured Astrocyte, then either call memory from your own code or wire the same instance into an agent framework adapter — LangGraph, CrewAI, MCP, OpenAI/Claude agent SDKs, and others. Optionally add MIP (Memory Intent Protocol) to declare routing rules — Astrocyte decides which bank, tags, and compliance policies to apply, with zero routing code in your app.

pip

pip install astrocyte astrocyte-pgvector

uv

uv pip install astrocyte astrocyte-pgvector

In a uv-managed project, use uv add astrocyte astrocyte-pgvector to record dependencies in pyproject.toml.

MIP routing

MIP (Memory Intent Protocol) lets you declare routing rules in mip.yaml and reference it from astrocyte.yaml with mip_config_path: ./mip.yaml. Astrocyte routes automatically — no routing code in your app.

mip.yaml

version: "1.0"
banks:
  - id: "student-{student_id}"
    description: Per-student academic memory
    compliance: pdpa
rules:
  - name: pii-lockdown
    priority: 1
    override: true          # compliance — intent layer cannot override
    match:
      pii_detected: true
    action:
      bank: private-encrypted
      tags: [pii, compliance]
      retain_policy: redact_before_store
  - name: student-answer
    priority: 10
    match:
      all:
        - content_type: student_answer
        - metadata.student_id: present
    action:
      bank: "student-{metadata.student_id}"
      tags: ["{metadata.topic}"]

astrocyte.yaml

profile: personal

provider_tier: storage
vector_store: pgvector
vector_store_config:
  connection_url: postgresql://localhost:5432/memories

llm_provider: anthropic
llm_provider_config:
  api_key: ${ANTHROPIC_API_KEY}
  model: claude-sonnet-4-20250514

# PII detection — country-specific + LLM fallback
compliance_profile: pdpa
barriers:
  pii:
    mode: rules_then_llm
    countries: [SG, IN]

# Point to MIP routing policy
mip_config_path: ./mip.yaml

lifecycle:
  enabled: true
  ttl:
    archive_after_days: 90
    delete_after_days: 365

Python

from astrocyte import Astrocyte

brain = Astrocyte.from_config("astrocyte.yaml")

# MIP routes to bank "student-stu-42" with tag "algebra"
await brain.retain(
    "The quadratic formula solves second degree equations",
    bank_id="default",  # MIP overrides this
    metadata={"student_id": "stu-42", "topic": "algebra"},
    content_type="student_answer",
)

hits = await brain.recall("quadratic formula", bank_id="student-stu-42")

Direct API

No mip.yaml needed — without mip_config_path, content goes straight to the bank you specify.

astrocyte.yaml

profile: personal

# Tier 1: bring your own database
provider_tier: storage
vector_store: pgvector
vector_store_config:
  connection_url: postgresql://localhost:5432/memories

# LLM for embedding + reflect
llm_provider: anthropic
llm_provider_config:
  api_key: ${ANTHROPIC_API_KEY}
  model: claude-sonnet-4-20250514

Python

from astrocyte import Astrocyte

brain = Astrocyte.from_config("astrocyte.yaml")

await brain.retain("Calvin prefers dark mode", bank_id="user-123")

hits = await brain.recall("What are Calvin's preferences?", bank_id="user-123")

LangGraph / LangChain

Add langgraph (or your chain stack) when you compile a graph. Same brain backs every framework adapter — see agent framework middleware.

from astrocyte import Astrocyte
from astrocyte.integrations.langgraph import AstrocyteMemory

brain = Astrocyte.from_config("astrocyte.yaml")
memory = AstrocyteMemory(brain, bank_id="user-123")

await memory.save_context(
    inputs={"question": "Theme preference?"},
    outputs={"answer": "Calvin prefers dark mode."},
    thread_id="thread-abc",
)

prompt_vars = await memory.load_memory_variables({})
# → inject prompt_vars["memory"] into the next model message

⟩ What it does

Three operations, any backend

Retain, recall, and reflect — with pipelines and policies that stay valid when you swap storage or engines.

Retain

Store memories with automatic chunking, entity extraction, and embedding. PII scanning and content validation happen before anything reaches your backend.

Recall

Multi-strategy retrieval — semantic, graph, keyword, temporal — fused with reciprocal rank fusion and reranked. Token budgets enforced automatically.

Reflect

Synthesize answers from memory. Native engine reflect or automatic fallback via LLM. Disposition-aware personality for support, coding, or research agents.

⟩ Where it sits

Harness, memory, context, LLM

Your agent stack runs the loop; Astrocyte is the governed memory boundary before context and completions. What you paste into the next turn is still your context-engineering choice — Astrocyte makes the evidence consistent and auditable. Read the architecture note →

Harness

Orchestration, tools, MCP — when to call memory and how the loop runs.

Astrocyte

Retain, recall, reflect — hybrid retrieval, policies, token budgets on the memory path.

Context

Prompt layout and snippets — your app turns hits into system/user messages for the model.

LLMs

Completions and tool calls — any provider or gateway (OpenAI, Anthropic, LiteLLM, OpenRouter, and similar).

⟩ Agent frameworks

Supports all AI agent frameworks

One memory integration for every framework. Each links to a dedicated guide with install, usage, and API reference.

LangGraphCrewAIClaude Agent SDKOpenAI Agents SDKGoogle ADKAutoGen / AG2Semantic KernelMS Agent FrameworkSmolagentsDSPyStrands AgentsLlamaIndexHaystackCAMEL-AIBeeAI (IBM)LiveKit AgentsPydantic AIMCP Server

⟩ Works with everything

Pluggable storage and engines

Bring your own database or plug in a full memory engine — Astrocyte keeps governance and observability consistent.

pgvectorPineconeQdrantNeo4jMCPLangGraphLiteLLMOpenRouterPortkeyMem0Zep

Tier 1: Retrieval backends

Use your existing databases. pgvector, Pinecone, Qdrant, Neo4j, Memgraph — the built-in pipeline handles embedding, extraction, fusion, and synthesis on top.

Tier 2: Memory engines

Full-stack engines that own the pipeline. Mystique, Mem0, Zep, Letta, Cognee — Astrocyte adds governance, observability, and portability.

⟩ Governance

Built-in governance

Neuroscience-inspired policies that protect every operation — regardless of backend.

PII barriers

Regex, NER, or LLM-based scanning with country-specific patterns (SG, IN, UK, EU, AU, CA, JP, CN). Per-type actions, DLP output scanning, and compliance profiles (GDPR, HIPAA, PDPA).

Rate limits & budgets

Token bucket rate limiting, daily quotas, and per-operation token budgets. Prevent runaway agents.

Circuit breakers

Automatic degraded mode when backends go down. Empty recall, error, or cache — with controlled recovery.

Observability

OpenTelemetry spans and Prometheus metrics on every operation. Switch providers without rebuilding dashboards.

Access control

Per-bank read/write/forget/admin permissions. Principals, grants, and audit trails built in.

Data governance

Classification levels, compliance profiles (GDPR, HIPAA, PDPA), data residency, encryption, and DLP.

⟩ Integrations

Agents, frameworks, models

One framework, every agent stack.

MCP Server

Any MCP-capable agent (Claude Code, Cursor, Windsurf) gets memory via astrocyte-mcp. Zero code integration.

Memory Intent Protocol (MIP)

Declarative memory routing — mechanical rules resolve deterministically, LLM judgment only when needed. One mip.yaml governs bank routing, compliance enforcement, and escalation across all agents.

Agent Frameworks

LangGraph, CrewAI, Pydantic AI, OpenAI Agents SDK, AG2 — thin middleware wires Astrocyte into each framework’s memory abstraction.

LLM Providers

Multi-provider gateways (e.g. LiteLLM, Portkey, OpenRouter, Vercel AI Gateway) or direct SDKs — OpenAI, Anthropic, Bedrock, Azure, Vertex, Ollama — or bring your own via the LLM SPI.

Memory Portability

Export and import memories between providers using Astrocyte Memory Archive (AMA), a portable newline-delimited JSON (JSONL) format. No vendor lock-in.

⟩ Documentation

Explore the docs

Quick Start Install, configure, and run your first retain/recall in minutes.

Provider SPI Build a storage adapter or engine provider for Astrocyte.

Architecture Two-tier model, layer boundaries, and design principles.

Memory Intent Protocol Declarative routing — mechanical rules + LLM intent for multi-agent memory.

100 Agents in 100 Days Daily tutorials for building AI agents with persistent memory.