Recall

Find the right things, fast.

Recall is a retrieval engine and knowledge base for LLMs and agents. It gives AI grounded, ranked evidence from your own data — so it retrieves before it reasons.

Doctrine

Core belief

Don't be smart. Be correct first.

Most AI apps: generate → hallucinate → maybe fetch. Recall: fetch → rank → then let the LLM reason on real data.

What Recall is

• A retrieval engine and knowledge base that plugs into LLMs and agents
• Stores, indexes, and ranks items — the source of truth behind every AI response
• A tool where ranking quality is the product

What Recall is not

• A standalone chatbot
• A memory system that replaces retrieval
• An LLM wrapper that happens to search

Core Concepts

Items

The core object is an item — a source of truth.

Examples: a saved article, an email thread, a local file, a note.

Everything revolves around: storing items, indexing items, ranking items.

Ranked Evidence

Output is a ranked list of relevant items with source attribution and snippet previews. The LLM reasons over this evidence — it doesn't generate from nothing.

Ranking Signals (v1)

| Signal | Weight | Notes | |---|---|---| | Title match | Strong (1.5) | Title FTS scored separately from body — strongest signal | | Body match | Strong (1.0) | Chunk-level FTS (ts_rank_cd) | | Recency | Medium (0.3) | By publish date, not ingest date | | User intent | Light (0.2) | Explicitly saved → boost (not auto-saved on ingest) | | Source type | Light (0.1) | Scaffolding for when more source types are added |

Semantic match (vector embeddings) will be added later as a ranking signal via pgvector.

Ingestion Philosophy

High signal (manual) first. Low signal (passive) later.

v1 — Manual

• Save URL (Chrome extension + CLI)
• Ingest local file

v1.5 — Personal knowledge

• Notion (pages + databases)
• Local notes directory (Obsidian, markdown folders)

Later — Passive

• GitHub repos and issues
• Gmail
• Browser bookmarks/history

Ranking reflects signal quality. Manual saves rank higher than passive ingestion.

Search UX

The interface is search-first:

1. Search bar — the entry point
2. Results list — ranked, with source type labels (link / file, more later)
3. Preview pane — snippet and context

Optional: "Generate answer from these results" button. Not default. Not prominent.

How Agents Use Recall

Recall is an API that agents call. Not a chat interface.

Agent → POST /search { q: "database migration strategies", limit: 5 }

Recall → {
  results: [
    {
      id: "...",
      title: "Zero-Downtime Migrations at Scale",
      url: "https://blog.example.com/migrations",
      source_type: "url",
      snippet: "...use **migration** shadow tables to avoid locking...",
      best_chunk: 2,
      fts_score: 0.42,
      final_score: 0.89,
      tags: ["postgres", "devops"]
    },
    ...
  ]
}

Agent → uses ranked evidence to reason, cite sources, not hallucinate

The agent gets grounded evidence. Recall never generates answers — it retrieves them.

See Architecture for full technical details (schema, query, ingestion pipeline, performance).

Where Distilled Memory Fits (Later)

Memory is never the primary source of truth. When added, it serves ranking:

• Tags and entity extraction
• Summaries for preview
• Ranking signal boosts

But the item — the original source — is always what gets returned.

Guiding Principles

1. Reliable over smart. Reliable systems get used. Smart-but-wrong systems get abandoned.
2. Retrieval over generation. Ground the LLM in real data before it reasons.
3. Evidence over answers. The LLM cites sources, not "trust me."
4. Simple over clever. Build the minimum that works, then iterate.
5. Manual over passive. High-signal inputs first. Scale ingestion later.

Inspirations & Alternatives

Projects we studied, learned from, and differentiate against.

Retrieval-first (closest in philosophy)

| Project | What it does | What we take | Where we differ | |---|---|---|---| | Khoj | Self-hosted AI second brain. Started as search, added chat. | Search-first philosophy. | Python/Django stack. We're TypeScript, leaner, agent-focused. | | R2R | Production RAG with Postgres + pgvector, REST API. | Architecture pattern — closest to our target stack. | Python, heavier. Includes features we intentionally defer. | | Onyx (Danswer) | Enterprise QA with 40+ source connectors. | Connector architecture — normalize everything to a common schema. | Enterprise-focused, complex. We're personal-first. |

Chat-first (different philosophy)

| Project | What it does | Why it's different | |---|---|---| | Quivr | "Second brain" with RAG and chat UI. | Chat-first, not retrieval-first. | | mem0 | Memory layer for LLMs — extracts facts from conversations. | Memory-first, not retrieval-first. Interesting for later (distilled memory). | | LightRAG | Lightweight graph-enhanced RAG. | Graph + embeddings focus. Useful reference when we add knowledge graph. |

Postgres-native (technique inspiration)

| Project | What it does | What we take | |---|---|---| | Korvus | Entire RAG pipeline in a single SQL query. | "Retrieval lives in Postgres" philosophy. JS/TS bindings. | | ParadeDB | BM25 scoring + hybrid search as Postgres extensions. | Future: better scoring than ts_rank when we need it. |

Key differentiation

Most of these projects are either:

• Chat-first — build a chatbot that sometimes searches
• Enterprise-first — 40+ connectors, teams, permissions
• Python-first — heavier stack, ML-oriented

Recall is:

• Retrieval-first — search is the product, chat is optional
• Personal-first — single user, minimal infra
• TypeScript + Postgres — thin API layer, retrieval logic lives in SQL
• Agent-native — built to be consumed by LLMs/agents via API, not just humans via UI

Author

Aman Kumar — amankumar.ai