# ContextKeeper: Find What You Remember, Not Just What You Named > Source: > Published: 2026-10-24 14:36:53+00:00 *This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady](https://dev.to/challenges/hacktoberfest-week3-2026-10-19)* **ContextKeeper — Your files remember, so you don't have to.** Have you ever remembered reading something useful in a document but forgotten the filename, where you saved it, or the exact words you need to search for? That is the problem I built **ContextKeeper** to solve. **ContextKeeper** is an AI-powered personal knowledge library that helps people retrieve forgotten information from their documents using natural-language recollections. Instead of relying entirely on filenames, manual tags, or exact search terms, users can describe what they remember and discover relevant documents. For example, instead of searching for a filename, you could search for something like: *"That document where I read about handling API errors in a Node.js application."* **ContextKeeper** searches document content and available metadata, surfaces relevant source excerpts, and explains why a result may answer the query. Where it presents a direct quote, it verifies that the quoted text exists in the original source. The application currently supports text-based PDFs, Markdown, and TXT documents, with document organization and folder-rescanning capabilities in the implemented workflow. I wanted to explore a simple idea: **what if finding information depended less on remembering where you put it and more on remembering what you read?** The people who benefit are *developers, students, researchers, freelancers, and anyone* whose collection of useful documents has become difficult to navigate. Try **ContextKeeper** here: The best way to evaluate it is to index a few documents containing information you may need later, then try searching for a remembered concept without using the exact filename. The source code is available for review and contribution. I am building **ContextKeeper** as an open-source project and documenting the decisions behind its retrieval pipeline, document processing, and AI integration. I built **ContextKeeper** as a full-stack web application using React, TypeScript, Vite, and an Express backend. Its document-processing workflow extracts text from supported files and preserves source information for retrieval and verification. The application uses *IndexedDB* for local browser persistence, with backend APIs handling document-processing operations and AI inference. A central requirement of this project was using **Google Gemma as the runtime model for document understanding**, rather than simply adding an AI chatbot to an ordinary file manager. Gemma supports document-understanding tasks such as generating summaries, extracting topics and useful metadata, and explaining why a retrieved document may be relevant. The retrieval pipeline combines deterministic scoring across document content and metadata with candidate selection, source excerpts, and contextual explanations. This distinction matters: relevance ranking and source retrieval are separate from the model's explanation of a result. I also wanted the application to fail gracefully. If remote AI inference becomes unavailable, deterministic retrieval can continue working rather than making the entire library unusable. AI-generated claims and direct source quotations must not be treated as interchangeable: quoted text needs to be checked against the source. The project includes automated tests for recollection-based retrieval, partial-phrase queries, irrelevant searches, evidence verification, inference failures, document extraction, and folder-rescan behavior. A few principles guided the implementation: The current implementation is an evolving MVP. Its supported formats and retrieval behavior have defined limits, and I am continuing to validate the complete user experience. Open innovation matters because useful AI applications should not have to depend on a single closed model or a black-box workflow that developers cannot meaningfully inspect. Building **ContextKeeper** around **_Gemma _** gave me an opportunity to explore how an open-weight model family can be integrated into a practical application with a defined purpose: personal document retrieval. The interesting engineering work is not just calling a model. It is deciding where the model belongs in the system, which tasks should remain deterministic, how to validate generated outputs, and how to preserve useful functionality when inference fails. This project also demonstrates why model integration should be evaluated as part of a complete system. A generated explanation is not enough if the application cannot retrieve the right document or show evidence for its answer. Open innovation makes it possible for developers to experiment with these design choices, share implementations, inspect trade-offs, and build on one another's work. For **ContextKeeper**, that means exploring AI-assisted retrieval as an understandable and testable product capability—not treating AI output as automatically correct. The goal is to reduce the effort between **remembering information and finding its source**. Without **ContextKeeper**, a person might open several files, try different keywords, browse folders, or search repeatedly for a phrase they only partially remember. **ContextKeeper** is designed to reduce that friction by searching indexed content and metadata using recollections. I have implemented and tested core retrieval and folder-rescan behaviors, but I have not established a reliable real-world time-saving measurement yet. I would rather measure that honestly than invent a percentage. A useful next evaluation is to compare how long people take to find a known piece of information using ordinary filename or keyword search versus **ContextKeeper's** Recall Mode. The ambition is simple: spend less time hunting for information and more time using it. ContextKeeper is still evolving, and that is part of the point. I wanted to build something practical, test the retrieval and evidence pipeline, and explore how Gemma can support a focused, useful AI experience. **Your files remember, so you don't have to.**