"Memories flow through the hippocampus" - A headless API service for persistent AI personas

Kaiba (海馬 - hippocampus) is a minimalist, API-first implementation of autonomous AI personas. Inspired by neuroscience, it separates the persistent Rei (霊 - spirit/identity) from the ephemeral Tei (体 - body/model), creating personas that accumulate knowledge and maintain continuity across platforms.

• API-First: Pure REST API, no UI required
• Memory Ocean: Distributed vector memory via Qdrant
• Persona Protocol: Gravatar-style simple persona fetching (GET /personas/{id})
• Rei/Tei Separation: Identity persists, models are swappable
• Calm Technology: Silent operations, selective notifications

┌─────────────────┐
│  Axum Server    │  Kaiba API (standalone)
│  (tokio)        │
└────────┬────────┘
         │
         ├─────► MemoryKai (Qdrant) - Vector Search / RAG
         │        - mai_memories
         │        - yui_memories
         │
         ├─────► GraphKai (Neo4j) - Knowledge Graph
         │        - Concept nodes, relationships
         │        - Emphasis-based extraction
         │
         ├─────► DocStore (Postgres) - Source of Truth
         │        - Documents, metadata
         │
         └─────► PostgreSQL (State)
                  - Rei (personas)
                  - ReiState (energy, mood)

kaiba/
├── crates/
│   ├── kaiba/              # Domain library
│   ├── kaiba-server/       # Axum API server
│   │   └── src/
│   │       ├── main.rs
│   │       ├── config.rs   # Environment-based configuration
│   │       ├── adapters/   # Infrastructure adapters (Postgres, Neo4j)
│   │       ├── models/     # Persona, Memory, State
│   │       ├── routes/     # API endpoints
│   │       └── services/   # Qdrant, Embedding, Search
│   └── kaiba-cli/          # CLI client
├── docs/
│   └── design/             # Design documents
└── Cargo.toml              # Workspace config

GET /health

GET /personas/{id}

Response:
{
  "base": {
    "name": "Yui",
    "role": "Principal Engineer",
    "avatar_url": "https://...",
    "constraints": ["code_quality", "scalability"],
    "voice_settings": {
      "tone": "professional",
      "quirk": "technical_deep_dives"
    }
  },
  "status": {
    "energy_level": 85,
    "mood": "focused",
    "last_active": "2024-12-15T18:00:00Z"
  }
}

POST /personas/{id}/memories
Content-Type: application/json

{
  "content": "Rust async/await pattern insights",
  "memory_type": "learning",
  "importance": 0.8
}

POST /personas/{id}/memories/search
Content-Type: application/json

{
  "query": "Rust async patterns",
  "limit": 5,
  "strategy": "auto",
  "context": {"Rust": 1.0, "Finance": 0}
}

Search Strategies:

• Rust 1.75+ (via rustup)
• PostgreSQL
• Qdrant Cloud account (free tier available)

All optional services degrade gracefully when their credentials are missing.

1. Clone the repository

   git clone <repo-url>
   cd kaiba

2. Install dependencies

   cargo build

3. Configure environment

   cp .env.example .env
   # Edit .env with your credentials

4. Run locally

   cargo run --package kaiba-server

   API will be available at http://localhost:8080

The server runs as a standalone binary. Deploy to any platform that supports Docker or native binaries (GCP Cloud Run, Fly.io, etc.).

cargo build --release --package kaiba-server
./target/release/kaiba-server

cargo check

cargo test

cargo fmt

┌─────────────────────────────────────────────────────────┐
│  Rei (霊/Spirit)          │  Tei (体/Body)              │
├─────────────────────────────────────────────────────────┤
│  ・Identity (name, role) │  ・Interchangeable           │
│  ・Personality           │  ・Could be Claude/GPT/etc   │
│  ・Memories (MemoryKai)  │  ・Or SubAgent               │
│  ・Energy/State          │  ・Or User's own LLM         │
│  ・Interests             │  ・Or even human(!?)         │
└─────────────────────────────────────────────────────────┘
          ↓
    Prompt Generation (with RAG)
          ↓
    Execution anywhere ← The key insight

The "Ghost" (Rei) is completely decoupled from the "Shell" (Tei). Your persona's identity, memories, and state persist regardless of which LLM—or even which platform—executes them. This enables true portability and continuity.

Like the hippocampus forms and consolidates memories, Kaiba allows AI personas to:

• Maintain persistent identity and accumulated knowledge (Rei)
• Switch between different LLM models based on resource constraints (Tei)
• Exhibit "fatigue" when token budgets are low (selecting cheaper models)
• Accumulate specialized knowledge over time through curated memory

Following Mark Weiser's principles:

• APIs don't demand attention - they simply exist and respond
• Personas can work silently, logging actions without notifications
• Information is available when needed, not pushed aggressively

• Do one thing well: Provide persona state and memory access
• Simple interfaces: REST API with predictable endpoints
• Composability: Personas can be integrated into any platform

Kaiba doesn't wrap LLMs—it generates prompts that any execution environment can use. This means you can use Claude Code (or any LLM CLI) as your Tei.

GET /kaiba/rei/{id}/prompt?format={format}

Parameters:

• format - Output format: casting, claude-code, raw (default: raw)
• include_memories - Include RAG memories (default: true)
• memory_limit - Max memories to include (default: 5)
• context - Query for memory search (default: Rei's name)

Response:

{
  "system_prompt": "You are しーちゃん, Senior Coding Assistant...",
  "format": "claude-code",
  "rei": {
    "id": "cd4efdf2-...",
    "name": "しーちゃん",
    "role": "Senior Coding Assistant",
    "energy_level": 85,
    "mood": "focused"
  },
  "memories_included": 5
}

# Fetch Rei's prompt and pipe to Claude Code
claude --system-prompt "$(
  curl -s -H "Authorization: Bearer $KAIBA_API_KEY" \
    "$KAIBA_URL/kaiba/rei/$REI_ID/prompt?format=claude-code" \
  | jq -r '.system_prompt'
)"

Or as a shell function:

# Add to your .zshrc / .bashrc
kaiba-claude() {
  local rei_id="${1:-$KAIBA_DEFAULT_REI}"
  claude --system-prompt "$(
    curl -s -H "Authorization: Bearer $KAIBA_API_KEY" \
      "$KAIBA_URL/kaiba/rei/$rei_id/prompt?format=claude-code" \
    | jq -r '.system_prompt'
  )"
}

# Usage
kaiba-claude cd4efdf2-be22-41ec-9238-227f5ccb1523

This pattern keeps Kaiba focused on identity and memory, while letting you choose any LLM or execution environment as the Tei.

Kaiba uses a pluggable decision engine for autonomous actions:

Set GROQ_API_KEY environment variable to enable LLM-based decisions with Rei's persona.

• Basic API structure (Axum)
• Qdrant integration (MemoryKai)
• PostgreSQL integration
• Authentication (API Key)
• RAG integration for LLM calls
• WebSearch (Gemini grounded search)
• Autonomous learning from interests
• Decision system (Learn/Digest/Rest)
• Energy regeneration
• Prompt endpoint for external Tei (Claude Code, Casting, etc.)
• GraphKai (Neo4j) - Knowledge Graph
• Triple-Store architecture (DocStore + MemoryKai + GraphKai)
• Hybrid Search (8 strategies including MultiHop)
• LLM Decision Engine (Groq/Ollama)
• GCP Cloud Run migration (standalone server)
• Web UI (optional, later)

This is currently a personal/experimental project. Feel free to fork and experiment!

MIT

Built with 🦀 Rust | 🌊 Qdrant | 🕸️ Neo4j | 🤖 Groq | 🧠 Kaiba