DEV Community: Saurabh Kumar

FamilyVault: An Offline-First AI Document Safe Built for My Parents

Saurabh Kumar — Sun, 04 Oct 2026 17:54:17 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built FamilyVault for my parents.

Like almost every household, my family has a chaotic physical drawer and a messy desktop folder filled with years of paperwork: health insurance cards, tax returns, hospital discharge summaries, birth certificates, and academic marksheets.

A few months ago, when my dad was dealing with an urgent insurance claim and a visa renewal around the same time, we hit two major headaches:

Finding the exact policy rider clause took hours of frantic digging through scanned PDFs.
A subtle typo in a date of birth between an old identity document and a newer certificate almost derailed an official application.

When I showed him cloud-based OCR tools and commercial AI assistants that could search through documents, his immediate reaction was: "I am not uploading our family's passports, tax files, and medical histories to some company's remote servers."

He was completely right. Organizing family documents shouldn't require surrendering your family's privacy.

Together with my teammate Rajnishant Kumar, I built FamilyVault—an offline-first, zero-cloud desktop digital safe for family documents. It runs multimodal AI and discrepancy detection directly on an ordinary laptop, ensuring not a single byte ever leaves the computer.

What it does for them:

Smart Drag-and-Drop Ingestion: When my parents drop in a scanned bill, ID, or PDF, local OCR and vision models automatically determine the document type, family member, issuing authority, and dates.
Cross-Document Contradiction Engine: It extracts atomic facts (legal names, dates of birth, policy numbers) across all files in the vault. If an Aadhaar card and a marksheet have conflicting date-of-birth spellings, FamilyVault flags it side-by-side with citations before an official government or visa application gets rejected.
Natural-Language Search with Exact Citations: My dad can ask questions like "What is the deductible on our ICICI health policy?" and get an answer backed by direct, clickable snippets from the original document.
Bank-Grade Local Security: Everything is locked on-disk with AES-256-GCM envelope encryption, Argon2id key derivation, and SQLCipher.

When I handed the build over to my dad and showed him the search and contradiction engine flagging a birthdate discrepancy entirely with the Wi-Fi turned off, his first words were: "Finally, something that actually respects where our data lives."

Demo

Live Download & Web Landing: https://hactober-fest-family-vault-download.vercel.app/

Code

The complete source code is public and open-source under the MIT license:

Dev-Saurabh-K / family-vault

FamilyVault

FamilyVault is a Windows desktop application for keeping family documents in a password-protected, portable vault. It stores original documents as encrypted objects, preserves document history, and provides local extraction, search, expiry tracking, and document-grounded assistance.

The vault is designed to remain usable independently of the installed application. FamilyVault is intended to work offline; optional model provisioning requires an internet connection to download the local AI runtime and model.

What it does

Creates, opens, locks, and restores password-protected .vault folders.
Imports PDF and image documents and stores originals encrypted.
Keeps document versions and an audit history; importing a newer version does not overwrite the prior one.
Extracts document text locally, proposes metadata for review, and tracks expiry dates.
Searches document metadata and text, with a separate semantic search mode.
Answers questions from retrieved document content using local inference when the local model is available, with citations where available.
Builds and…

View on GitHub

GitHub Repository: https://github.com/Dev-Saurabh-K/family-vault

How I Built It

FamilyVault is built with Electron, JavaScript, SQLite / SQLCipher, and open-weight AI runtimes:

1. Local Open-Source AI Architecture

Gemma 4 (Open-Weights Inference): We used Google's open-weight Gemma 4 (Gemma-4-E2B quantized GGUF) running locally on-device. The model is supervised via a local llama-server process bound exclusively to 127.0.0.1.
Grounded Document Q&A: We engineered a deterministic retrieval pipeline. Retrieved document chunks pass through our local embedding search, and Gemma 4 generates responses strictly constrained to cite document line numbers, eliminating hallucinations.
Local OCR: Text extraction is handled by Tesseract.js in background worker threads, allowing offline scanning without needing cloud OCR APIs or large Python runtime dependencies.

2. Contradiction & Verification Pipeline

Rather than blindly trusting an LLM with critical legal numbers, we treat AI extractions as untrusted suggestions. Extracted entities pass through deterministic regex and schema validators before entering SQLite. A discrepancy detection module then runs cross-record diffs across family profiles to highlight conflicting facts.

3. Sandboxing & Zero-Network Guarantee

The Electron frontend runs under a strict Content Security Policy (CSP) with remote network requests disabled. All database operations and cryptographic operations (Argon2id + AES-256-GCM) execute in isolated preload processes.

Why Does Open Innovation Matter?

For a project like FamilyVault, open-source AI wasn't just a technical preference—it was the only viable path.

True Privacy Requires Open Weights: Closed APIs (like commercial cloud LLMs) require streaming sensitive personal identifiers, bank statements, and health records over the wire to third-party data centers. Open weights allowed us to download the intelligence once and run it indefinitely inside a local sandbox.
Offline Resilience: Emergency hospital visits or international travel often involve spotty or nonexistent internet. Because open models run on-device, FamilyVault works 100% offline.
No Subscription or Token Tolls: Managing family paperwork is a lifelong chore. Families shouldn't have to worry about monthly API subscription bills or rate limits just to look up an old vaccination record or tax form.
Transparency & Auditability: In security-critical personal software, open source means anyone can audit the code to verify that documents are never phoned home.

My Agent Session

We leveraged Antigravity and DevRelay during our hacking session to architect the cryptographic envelope, refine the local llama-server process lifecycle, and verify unit test suites.

Prize Categories

Featured Prize Category: Best Use of Gemma ($200)

FamilyVault uses Google Gemma 4 as the core intelligence engine for on-device document understanding and grounded natural-language querying. By bundling a quantized Gemma 4 model via local llama-server, we achieved sub-second inference on ordinary consumer laptops with zero data leaving the machine, proving that modern generative AI can be brought directly to private family data without cloud compromise.

Team Members

Saurabh Kumar (@dev-saurabh-k)
Rajnishant Kumar (Teammate)

Built GitOCX — an AI-powered GitHub repository analysis platform.

Saurabh Kumar — Thu, 01 Oct 2026 06:17:02 +0000

What I Built

I built GitOCX, an AI-powered developer tool that analyzes GitHub repositories to help developers understand how a project evolves and how development knowledge is distributed across a codebase.

GitOCX analyzes repository commit history and uses AI to group related commits into meaningful features. It then provides insights into contributor activity and the areas of the project different contributors have worked on.

The idea came from a simple problem: a GitHub repository can contain hundreds or thousands of commits, but the commit history alone doesn't always provide a clear picture of how the project evolved.

We wanted to transform that raw history into something more meaningful — showing what features were developed, who contributed to them, and where development knowledge is concentrated within the project.

One of our biggest challenges was the cost of AI processing. Analyzing large repositories can require significant token usage, and repeatedly sending the same repository data to an AI service is both expensive and inefficient.

To address this, we implemented caching for analyzed repository data, allowing us to reuse previous results instead of unnecessarily processing the same information again.

Building GitOCX gave me practical experience with GitHub APIs, AI-powered analysis, backend architecture, caching, data processing, and building developer-focused tools.

🔗 GitOCX: https://explorers-wheat.vercel.app/

💻 Source Code: https://github.com/Dev-Saurabh-K/Explorers

Demo

Explore the deployed version of GitOCX:

🔗 https://explorers-wheat.vercel.app/

Partner Technologies

GitOCX uses AI as a core part of its repository-analysis workflow.

We use AI to analyze commit information and categorize related commits into meaningful features. This allows GitOCX to move beyond simply displaying a repository's commit history and instead extract higher-level information from it.

One of the main engineering challenges was controlling AI usage and keeping the system efficient. Since processing repository data can require many tokens, we introduced caching to avoid repeatedly sending the same information for analysis.

This gave us hands-on experience designing an application where AI is integrated into a larger backend system rather than being treated as a standalone feature.

Hackathon Experience

The hackathon was an opportunity to take an idea from a rough concept to a working product within a limited amount of time.

One of my biggest takeaways was the importance of planning before implementation. GitOCX required multiple pieces to work together — GitHub APIs, backend services, AI processing, caching, and the frontend. Thinking through the architecture and workflow before implementation helped us avoid unnecessary rework later.

We also faced the realities of building under a deadline: debugging unexpected issues, changing our approach when something didn't work, and working late to get the project into a usable state.

Beyond the technical experience, the project taught me a lot about team management, dividing work effectively, communicating ideas, and turning a complex idea into something that can actually be built.

The most valuable part was seeing a real GitHub repository go through our system and come out as structured, understandable information instead of just a long list of commits.

GitOCX started as an idea about understanding repository history, but building it gave us a much deeper understanding of AI engineering, backend systems, caching, collaboration, and product development under constraints.

GitOcx

Saurabh Kumar — Wed, 30 Sep 2026 09:42:37 +0000

GitOcx

AI-powered GitHub documentation and knowledge analysis for development teams.

Inspiration

As our projects grow, we often face a problem: one developer builds a feature, but other developers need to spend a lot of time understanding how it works before they can use or extend it.

This becomes even harder when a developer leaves the team.

We wanted to build a tool that could automatically understand a codebase and make its knowledge easier to share.

What it does

GitOcx connects to a GitHub repository and analyzes its commit history.

It uses AI to:

Group related commits into individual features
Generate documentation for each feature
Explain how features work and how they can be integrated
Identify features where knowledge is highly concentrated around one developer
Highlight features that may be at risk if a key developer becomes unavailable

For example, GitOcx can turn multiple commits into a "Payment Integration" feature, then generate documentation that helps another developer understand and use it.

How we built it

We built GitOcx with React.js and FastAPI.

PyGithub is used to retrieve GitHub repository data. LangChain and Gemini power the AI analysis.

We use SQLite for storing project data and deployed the application using a VM and Vultr.

Because AI analysis can be expensive and difficult to scale, we also added repository caching to reduce repeated AI processing.

Challenges

One of our biggest challenges was the cost of repeated AI calls.

Large repositories can contain a lot of commits and information, so sending the same data to an AI model again and again is expensive.

We solved part of this problem by caching analyzed repository data.

What we learned

We learned that understanding a large codebase is not only about reading code. A project also contains knowledge about how its features work and how those features connect.

We also learned the importance of planning before execution, proper research, documentation, and teamwork during a 36-hour hackathon.

What's next

We want to improve the quality of the generated documentation and explore job sequencing to help identify suitable developers who could take over a feature when a core team member is unavailable.

Built With

React.js, FastAPI, SQLite, PyGithub, LangChain, Gemini, VM, Vultr

Links

Demo: https://explorers-wheat.vercel.app/

GitHub: https://github.com/Dev-Saurabh-K/Explorers