Upskilling Your Tech Stack

Define a canonical document record with identifiers, source paths, checksums, media types, timestamps, and processing status.

Implement recursive discovery of supported PDFs and images without modifying their source files.

Validate file type and size using file contents rather than trusting filename extensions.

Use content hashes to detect duplicate files and make repeated ingestion idempotent.

Import validated files into a permission-restricted managed library with deterministic identifiers, then persist their canonical records in a local manifest.

Record ingestion failures in a structured manifest that supports safe retries.

Implement a parser runner that uses per-file temporary workspaces, canonical path validation, timeouts, and resource limits for untrusted documents.

Extract text and page boundaries from text-based PDFs with PyMuPDF.

Detect when a PDF page or image requires optical character recognition.

Apply local OCR to scanned PDF pages and images while retaining page-level provenance and confidence information.

Normalize extracted text while preserving dates, identifiers, monetary values, and source-page references.

Classify documents into an initial personal taxonomy using a rules-first approach with a local-model fallback, recording the method and uncertainty flags.

Extract and validate small metadata schemas for health records, receipts, and identity documents, linking each value to supporting source text.

Route low-confidence OCR, classification, and metadata results to a review queue.

Explain how embedding vectors and similarity metrics support semantic document retrieval.

Compare candidate local embedding models on representative health-record, receipt, and identity-document queries, then select one that fits the device's memory budget.

Split extracted documents into retrieval chunks while preserving overlap, document identity, page numbers, and section context.

Generate embeddings locally in batches and upsert them into a persistent Chroma collection using stable chunk identifiers.

Implement semantic top-k search with document-type and date metadata filters.

Add keyword retrieval for exact names, dates, amounts, and identification numbers.

Combine semantic and keyword scores into a hybrid ranking and inspect why each result was selected.

Transform a natural-language request into a validated search specification containing intent, query terms, filters, and target document types.

Retrieve whole-document candidates from chunk-level matches without losing source provenance.

Construct a context prompt that clearly separates system instructions, user requests, and retrieved document evidence.

Defend the retrieval pipeline against instructions embedded inside untrusted documents.

Generate a grounded response that cites the supporting file and page for each factual claim.

Return a clear insufficient-evidence response when retrieval does not support an answer.

Trace successful and failed queries end to end to locate errors in query parsing, retrieval, context construction, or citation mapping.

Enforce a canonical-path allowlist that prevents APIs and tools from reading files outside the managed library or following unsafe symbolic links.

Configure private local data directories with restrictive permissions, verify full-disk encryption coverage, and automate temporary-file cleanup.

Protect the local API with loopback-only binding, restrictive CORS rules, and explicit authorization for state-changing operations.

Redact sensitive values from application logs, errors, analytics, and debugging traces.

Audit application network requests to verify that document content, extracted text, and embeddings remain on the device.

Create and test an operation-safety policy for deletion, re-indexing, export, preview, and original-file opening.

Define typed tools for document search, metadata filtering, document preview, and policy-controlled file opening.

Represent workflow state with typed inputs, intermediate results, errors, and final outputs.

Implement a tool-calling loop with explicit termination, iteration, and timeout limits.

Build a single-controller workflow that parses a request, searches documents, verifies evidence, and formats a cited response.

Add retry and fallback behavior for malformed tool calls, local-model failures, and empty retrieval results.

Persist a privacy-conscious execution trace that omits document text and sensitive query values.

Decide when separate agents provide a measurable benefit over a single agent or deterministic function.

Specify non-overlapping responsibilities and input-output contracts for coordinator, retrieval, and verification agents.

Constrain each agent to the minimum tools and document data required for its responsibility.

Implement a LangGraph coordinator that routes work through retrieval and verification nodes.

Add conditional routing for direct lookup, multi-document comparison, and ambiguous requests.

Prevent infinite delegation with bounded transitions and explicit completion conditions.

Inspect a multi-agent trace to diagnose routing, retrieval, and verification failures.

Design a search interaction that distinguishes retrieved documents, generated summaries, and cited evidence.

Build a local import and indexing-status view for user-approved files or folders, including per-document processing results.

Implement prompt submission and streamed workflow updates in React against the local FastAPI service.

Render ranked document cards with safe metadata, ranking explanations, and page citations.

Build an in-app preview that opens the cited page without exposing unrestricted filesystem paths.

Add filters for document type, date range, and retrieval-score threshold.

Implement a human-review screen for uncertain OCR, classification, and metadata results.

Communicate empty results, processing failures, and model uncertainty without presenting fabricated answers.

Create a privacy-safe evaluation set covering exact lookup, semantic lookup, filtered search, comparison, ambiguity, and missing evidence.

Measure document recall, page-level retrieval accuracy, citation correctness, answer groundedness, and end-to-end latency.

Compare the single-controller and multi-agent paths to determine where orchestration improves quality enough to justify its cost.

Tune chunk size, overlap, retrieval depth, ranking weights, and prompt structure using recorded evaluation results.

Profile local inference and indexing on the M2 Mac and select settings that stay within 16 GB of unified memory.

Implement regression tests for ingestion, retrieval, access boundaries, and representative agent workflows.

Package the React client, FastAPI service, local model, index, and configuration into a repeatable local startup process.

Demonstrate the finished application by ingesting mixed PDFs and photos and retrieving the correct documents with verifiable citations.