EchoVault AI

The problem

ChatGPT stores conversations as tokens. Notion stores them as pages. Neither understands them. Most AI tools forget you the moment a session ends, and the few that don't (ChatGPT Memory, custom GPTs) hold at most ~2KB of summarized strings — a notepad, not a memory system. Meanwhile, your private archive grows: thousands of WhatsApp messages, journal entries, voice notes — emotional context that becomes impossible to revisit meaningfully without an AI that actually understands what those moments meant.

What I built

EchoVault is an emotional memory intelligence platform. It ingests your private archive, chunks it by emotional continuity (not tokens), embeds it into a per-user vector space, and answers questions about your past as a grounded analytical companion that cites every claim back to a real memory chunk.

The IP — Temporal Emotional Chunker

Most RAG systems chunk by tokens. EchoVault chunks by feeling.

TIME_GAP_MINUTES = 30
MIN_CHUNK_SIZE = 3
MAX_CHUNK_SIZE = 50

def chunk(messages):
    chunks = []
    current = [messages[0]]
    for prev, msg in pairwise(messages):
        gap = msg.timestamp - prev.timestamp
        boundary_reason = None
        if gap > timedelta(minutes=TIME_GAP_MINUTES):
            boundary_reason = "time_gap"
        elif len(current) >= MAX_CHUNK_SIZE:
            boundary_reason = "size_limit"
        elif emotional_shift_detected(prev, msg):
            boundary_reason = "emotional_shift"
        if boundary_reason and len(current) >= MIN_CHUNK_SIZE:
            chunks.append(_finalize(current, boundary_reason))
            current = [msg]
        else:
            current.append(msg)
    if current:
        chunks.append(_finalize(current, "end_of_stream"))
    return chunks

Standard RAG splits text into 512-token windows — a brute-force approximation that breaks emotional context constantly. EchoVault's Temporal Emotional Chunker groups messages by two real-world signals: emotional continuity and time proximity. A grief conversation from June 2 stays one chunk even if it's 7 messages spanning 14 seconds. A topic shift from anxiety to celebration breaks the chunk, even if those messages are 30 seconds apart. Time gaps over 30 minutes always create boundaries, and a maximum of 50 messages prevents runaway chunks. Combined with a Grounding Validator that drops any claim below 0.7 confidence, the result is an AI that refuses to hallucinate about your past.

Architecture

WhatsApp .txt   ─┐
journal entries ─┼─→ Parser → Temporal Chunker → Emotional Enricher
voice note      ─┘                                 │ (Groq · LLaMA-3)
                                                   ↓
                              Embedder (BGE-small-en-v1.5, 384-dim)
                                                   ↓
                              Qdrant vector store + SQLite metadata
                                                   ↓
user query ──────→ Hybrid retrieval ──→ Reflection Engine
                                                   ↓
                                       Grounding Validator
                                       (drops claims < 0.7 confidence)
                                                   ↓
                                  answer + cited memory chunks

— End-to-end pipeline runs in ~1.91 seconds for a 5MB WhatsApp export. Every reflection cites every claim.

By the numbers

Where it's going

The MVP is live. The product roadmap is six phases:

1. 01

   Identity foundation — Clerk auth, JWT-based session, per-user Qdrant collections, managed Postgres on Neon.

2. 02

   Knowledge graph layer — entity linking, relationship strength, temporal edges, graph reranking on top of vector search.

3. 03

   Multi-agent orchestration — replace the single reflector with 8 specialist agents (orchestrator, retrieval, reflection, timeline, emotional analysis, grounding, memory curator, safety).

4. 04

   Event-driven backend — Celery + Redis workers, async fan-out, streaming uploads, background summarization.

5. 05

   Multi-source ingestion — Telegram, iMessage, plain markdown, audio files via Whisper transcription.

6. 06

   Real-time chat + observability — SSE streaming reflection, conversation history, Sentry, structured logs, evaluation suite (hallucination rate, grounding precision, latency budgets).

Currently building Phase 1 — auth and per-user namespaces.

Links