Active Product

Sieve

AI knowledge and memory workspace

Sieve turns messy personal input into reviewable, searchable memory. Capture anything, ask Sieve what it knows, and review every proposed change before it becomes durable knowledge.

Read Case Study Case-study Repo
Sieve architecture diagram showing capture, semantic units, review packets, approved knowledge graph, and Ask Sieve retrieval.

What Sieve does

Sieve is an AI memory workspace that captures rough thoughts, Discord messages, files, links, and conversations, then turns them into reviewable memory records with source evidence intact.

How it works

The system combines a review-gated AI extraction pipeline, typed knowledge records, graph links, source provenance, generated API clients, and retrieval feedback so memory stays useful instead of becoming a pile of raw notes.

Tech stack

React Vite TypeScript Node OpenAPI Zod Supabase Postgres Drizzle pgvector OpenAI pnpm Vercel

Case Study

AI memory with review-gated data quality

Product problem

Personal knowledge tools usually fail in one of two ways: they store raw dumps that are hard to reuse, or they let AI rewrite memory too aggressively. Sieve aims for the middle path: preserve the original capture, propose useful memory changes, and make the user approve what becomes durable.

AI/data workflow

  1. Capture: accept rough input from notes, messages, links, files, or Discord DMs.
  2. Interpret: split the capture into semantic units before creating candidates.
  3. Review: present notes, work items, resources, reminders, tags, and links as a packet.
  4. Retrieve: answer later questions from approved knowledge with citations and evidence.

Architecture

Sieve uses a TypeScript web dashboard, a Node API service, an OpenAPI contract with generated clients, and Supabase/Postgres as the durable store. The AI layer enriches captures and retrieval, while the review workflow is the default safety boundary for memory mutation.

Stack detail

  • React and Vite dashboard
  • TypeScript and Node API service
  • OpenAPI, Zod, and generated React client package
  • Supabase/Postgres, Drizzle, row-level ownership hardening, and pgvector retrieval
  • OpenAI-backed extraction and retrieval helpers
  • pnpm workspace with Vercel deployment conventions

Data/API overview

The public-safe model is category-level: captures, review packets, review candidates, approved knowledge nodes, work items, derived project views, source documents, source evidence, graph links, retrieval events, feedback, settings, export/delete controls, and Discord pairing. The public case study intentionally avoids raw endpoint catalogs, table definitions, and policy text.

What I built

I shaped the product language and implementation around Capture, Review Packet, Review Candidate, WorkItem, Knowledge Link, Source Evidence, and Ask Sieve so the UI, API, and data model share the same mental model.

Verification

Verification spans model tests for candidate policy, API and dashboard tests for review behavior, generated contract checks, typechecking, source-level route assertions, and browser QA where authentication gates allow it.

Evidence model

Public proof comes from architecture diagrams, schema/API category summaries, verification notes, safe screenshots or videos, and interview walkthroughs rather than public source code.

Trade-offs

  • Review-first memory is slower than silent auto-save, but it preserves trust.
  • Postgres plus graph-style records is simpler to operate than adding a separate graph database.
  • Collapsed source evidence keeps the main UI usable while preserving debuggability.

Current rough edges

  • Ask Sieve is still moving from retrieval inspection toward a more conversational answer surface.
  • Review needs more grouping so users see what will change before seeing classifier details.
  • Public demo media uses synthetic data so private captures and active source stay private.

Roadmap

  1. Unify capture for notes, files, source imports, and Discord DMs.
  2. Turn retrieval into an Ask Sieve chatbot with citations and evidence controls.
  3. Simplify review around what will change in memory.
  4. Make knowledge detail, graph, and source evidence contextual rather than primary destinations.
  5. Add evaluation coverage for capture quality, review usefulness, and grounded retrieval answers.

Media

Product Demo

This product demo shows the AI-native memory loop: capture, semantic ingestion, AI extraction, review packet approval, and source-grounded recall.

Demo with synthetic data.