A dedicated LLM-powered memory management service that maintains a persistent Cognitive Nexus (Knowledge Graph) on behalf of business AI agents via KIP (Knowledge Interaction Protocol).

Business agents interact entirely through natural language and a REST API — no KIP knowledge required.

Anda Brain is designed to be self-hosted (the hosted cloud service has been discontinued). For a complete agent built on Anda Brain, see Anda Bot.

┌─────────────────────┐
│   Business Agent    │  ← Focuses on business logic & user interaction
│  (No KIP knowledge) │    Only speaks natural language
└────────┬────────────┘
         │ Natural Language / REST API
         ▼
┌─────────────────────┐
│      Brain          │  ← The ONLY layer that understands KIP
│   (LLM + KIP)       │    Three agents: Formation / Recall / Maintenance
└────────┬────────────┘
         │ KIP (KQL / KML / META)
         ▼
┌─────────────────────┐
│  Cognitive Nexus    │  ← Persistent Knowledge Graph (backed by AndaDB)
│  (Knowledge Graph)  │
└─────────────────────┘

• Zero KIP knowledge required — Business agents interact through natural language and a simple REST API.
• Persistent, structured memory — Facts, preferences, relationships, events, and patterns encoded into a knowledge graph.
• Three operational modes — Formation (encoding), Recall (retrieval), and Maintenance (consolidation & pruning).
• Multi-space isolation — Each space has its own independent database, knowledge graph, and conversation history.
• Triple serialization — Supports JSON, CBOR, and Markdown for request/response payloads (negotiated via Content-Type / Accept headers).
• Pluggable storage backends — Local filesystem, AWS S3, or in-memory (for development/testing).

Receives conversation messages and encodes them into structured memory within the Cognitive Nexus via KIP.

System prompt: BrainFormation.md

Processing pipeline:

1. Receives FormationInput (messages + optional context + timestamp).
2. Creates a tracked Conversation record (status: Submitted → Working → Completed | Failed).
3. LLM analyzes messages, extracting three types of memory:
   • Episodic memory — Events with timestamps, participants, outcomes
   • Semantic memory — Stable facts, preferences, relationships, domain knowledge
   • Cognitive memory — Behavioral patterns, decision criteria, communication style
4. Deduplicates against existing knowledge (SEARCH before CREATE).
5. Encodes structured memory into the Cognitive Nexus via execute_kip tool.

Key behaviors:

• Sequential processing with automatic queue draining — new conversations are picked up after the current one completes.
• Atomic single-conversation processing via processing_conversation flag.
• Schema auto-evolution — defines new concept types/predicates when needed.

Translates natural language queries into knowledge graph lookups and returns synthesized answers.

System prompt: BrainRecall.md

Processing pipeline:

1. Receives RecallInput (query + optional context).
2. Analyzes query intent (entity lookup, relationship traversal, attribute query, event recall, pattern detection, etc.).
3. Grounds entities to actual graph nodes (resolves ambiguity).
4. Executes structured KQL queries via read-only memory tools + conversation search.
5. Iterative deepening — follows up with additional queries if needed (max 5 rounds).
6. Synthesizes results into a coherent natural language answer.

Available tools:

• MemoryReadonly — Read-only access to the knowledge graph

Consolidates, prunes, and optimizes the knowledge graph during scheduled or on-demand cycles.

System prompt: BrainMaintenance.md

Processing phases (full scope):

1. Assessment — Audit memory health (read-only): DESCRIBE PRIMER, pending SleepTasks, unsorted items, orphans, stale events.
2. SleepTask Processing — Handle queued actions: consolidate_to_semantic, archive, merge_duplicates, reclassify, review.
3. Unsorted Inbox — Reclassify items to appropriate topic domains.
4. Stale Event Consolidation — Extract semantic knowledge from old events (configurable threshold), create linked Preference/Fact nodes.
5. Duplicate Merging — Find and merge similar concepts, updating all propositions.
6. Orphan Cleanup — Assign domain-less concepts to appropriate domains.
7. Confidence Decay — Age facts by reducing confidence scores (confidence * decay_factor).

Key behaviors:

• Single-execution guard — only one maintenance cycle can run at a time per space.
• Non-destructive principle — archives before deleting, decays confidence rather than removing.
• Async execution — returns immediately with conversation ID; actual processing in background.

Detailed API docs (with TypeScript request/response types):

• English: API.md
• 中文: API_cn.md
• Agent Skill: SKILL.md

Triple serialization via Content-Type / Accept headers:

• application/json — JSON (default)
• application/cbor — CBOR (binary, more compact)
• text/markdown — Markdown (human-readable text)

All responses use an RPC envelope:

{"result": { ... }, "error": null}

All endpoints (except /, /info and /SKILL.md) require a Bearer token:

Authorization: Bearer <base64_encoded_cose_sign1_token>

If ED25519_PUBKEYS is not provided (empty), authentication is effectively disabled: API requests are accepted without signature verification.

Token format: COSE Sign1 message signed with Ed25519 keys, containing CWT claims:

Create a new isolated memory space. Requires manager principal.

Request:

{
  "user": "<owner_principal_id>",
  "space_id": "my_space_001",
  "tier": 0
}

Response:

{
  "result": {
    "space_id": "my_space_001",
    "owner": "owner_principal_id",
    ...
  }
}

Submit conversation messages for memory encoding. Processing is asynchronous — returns immediately while encoding continues in the background.

Request:

{
  "messages": [
    {
      "role": "user",
      "content": "I prefer dark mode. My timezone is UTC+8.",
      "name": "Alice"
    },
    {
      "role": "assistant",
      "content": "Got it! I've noted your preferences."
    }
  ],
  "context": {
    "counterparty": "alice_principal_id",
    "agent": "customer_bot_001",
    "source": "source_123",
    "topic": "settings"
  },
  "timestamp": "2026-03-09T10:30:00Z"
}

Response:

{
  "result": {
    "conversation": 1,
    ...
  }
}

Query memory with natural language. Returns a synthesized answer from the knowledge graph and conversation history.

Request:

{
  "query": "What are Alice's preferences?",
  "context": {
    "counterparty": "alice_principal_id",
    "topic": "settings"
  }
}

Response:

{
  "result": {
    "content": "Alice prefers dark mode and operates in UTC+8 timezone.",
    ...
  }
}

Trigger a memory maintenance cycle. Runs asynchronously with single-execution guard.

Request:

{
  "trigger": "on_demand",
  "scope": "daydream",
  "timestamp": "2026-03-10T03:00:00Z",
  "parameters": {
    "stale_event_threshold_days": 7,
    "confidence_decay_factor": 0.95,
    "unsorted_max_backlog": 20,
    "orphan_max_count": 10
  }
}

Response:

{
  "result": {
    "conversation": 8,
    ...
  }
}

Get space statistics and health information.

Response:

{
  "result": {
    "space_id": "my_space_001",
    "owner": "principal_id",
    "db_stats": { "total_items": 150, "total_bytes": 524288 },
    "concepts": 85,
    "propositions": 120,
    "conversations": 12,
    ...
  }
}

Business agents can register the Recall endpoint as an LLM tool/function call. See RecallFunctionDefinition.json for the OpenAI function-calling format.

1. Creates a new AndaDB instance.
2. Initializes CognitiveNexus (knowledge graph).
3. Loads bootstrap KIP definitions ($self, $system, core meta-types).
4. Stores creator/owner principal IDs.

• Spaces are lazy-loaded on first access via OnceCell.
• In-memory cache with access tracking.
• 5-minute interval: Flush active spaces to storage.
• 9-minute idle timeout: Evict unused spaces from cache (skipped while a space is pinned, processing, or still referenced by requests).
• Graceful shutdown: Close all space databases before exit.

The schema is self-describing — all type definitions are stored as nodes within the graph itself. Types can be defined on-the-fly by the Formation agent as needed.

CORS_ORIGINS examples:

• "" (empty): CORS disabled
• "*": allow all origins
• "https://app.example.com,https://admin.example.com": allow specific origins

# Development (in-memory storage)
cargo run -p anda_brain

# Local filesystem storage
cargo run -p anda_brain -- local --db ./data

# AWS S3 storage
cargo run -p anda_brain -- aws --bucket my-bucket --region us-east-1

# Pull image
docker pull ghcr.io/ldclabs/anda_brain_amd64:latest

# Run with ENV (in-memory by default)
docker run --rm -p 8042:8042 \
  -e LISTEN_ADDR=0.0.0.0:8042 \
  -e MODEL_API_KEY=your_key \
  ghcr.io/ldclabs/anda_brain_amd64:latest

# Override startup args (example: local storage)
docker run --rm -p 8042:8042 \
  -v $(pwd)/data:/data \
  ghcr.io/ldclabs/anda_brain_amd64:latest local --db /data

# Override startup args (example: AWS S3 storage)
docker run --rm -p 8042:8042 \
  -e AWS_ACCESS_KEY_ID=your_ak \
  -e AWS_SECRET_ACCESS_KEY=your_sk \
  ghcr.io/ldclabs/anda_brain_amd64:latest aws --bucket my-bucket --region us-east-1

Key crates from the Anda ecosystem:

Copyright © LDC Labs

Licensed under the Apache License, Version 2.0.