# Circle: A Private AI Memory for the People Who Matter > Source: > Published: 2026-10-04 16:03:40+00:00 *This is a submission for the [Hacktoberfest Weekend Challenge: Build for a Friend](https://dev.to/challenges/hacktoberfest-weekend-2026-10-01).* I built **Circle** for a friend who wanted an easier way to remember the small details that matter in their relationships. Meaningful conversations were scattered across chat exports, emails, calendars, notes, documents, and voice recordings. The information existed, but finding the right context at the right time was difficult. Circle turns that scattered information into a **private, searchable memory layer around the people who matter**. Instead of searching through several different applications, a user can select a person and ask questions such as: Circle retrieves relevant records from the user’s own archive and generates an answer using a local AI model. Each answer includes the sources used to produce it, so the user can verify the context instead of blindly trusting a generated summary. The idea came from one question: **What should I remember before I talk to this person?** Circle is not designed to replace human relationships or guess how someone feels. It is designed to help someone remember the details that matter so they can show up more thoughtfully for the people they care about. **Project page:** [https://circle-dh51.onrender.com/](https://circle-dh51.onrender.com/) **Source code:** [https://github.com/navaneedan07/circle](https://github.com/navaneedan07/circle) The public project page is hosted on Render. The actual Circle application runs locally as an Electron desktop app, keeping the private archive and AI processing on the user’s device. The demo shows: The most important part of the demo is not just the generated answer. It is the path from the answer back to the original evidence. **GitHub repository:** [https://github.com/navaneedan07/circle](https://github.com/navaneedan07/circle) Circle is built as a local-first Electron application. The current shipped architecture is: ``` ┌─────────────────────────────────────┐ │ Electron Desktop Application │ │ │ │ React + TypeScript renderer │ │ │ │ │ ▼ │ │ Local Node.js / Express API │ │ │ │ │ ┌───────┼────────────┐ │ │ ▼ ▼ ▼ │ │ SQLite Ollama Folder Watcher │ │ FTS5 Gemma │ │ Embeddings │ │ │ │ Local archive, retrieval, and AI │ │ processing remain on the device. │ └─────────────────────────────────────┘ ``` The application uses: The core of Circle is **Gemma 3:4B**, an open-weight model served locally through **Ollama**. I chose local inference because Circle works with highly personal information. The system should be useful without requiring a user to upload their entire personal archive to a third-party AI provider. Circle watches a folder selected by the user. It does not scrape websites, automate social-media logins, or ask for account passwords. Users can provide their own exports and files, including: When a file is detected, Circle processes it locally and adds the normalized records to the archive. The watcher is read-only with respect to the user’s source folder. Circle does not move, rename, or delete the files it imports. A WhatsApp export, email, calendar entry, note, and voice recording all have different formats. Circle normalizes them into a common memory representation containing information such as: This allows the application to search across different kinds of personal data consistently. The same person may appear under different names, usernames, phone numbers, or email addresses. Circle uses deterministic signals such as: Potential matches are treated carefully. Uncertain identities are surfaced as suggestions instead of being silently merged. Circle does not send the entire archive to Gemma for every question. When a question is asked, Circle first retrieves relevant evidence using: The retrieval flow is: ``` User Question │ ▼ Identify relevant person or time range │ ▼ Keyword search + vector search │ ▼ Fuse and rank evidence │ ▼ Limit the evidence budget │ ▼ Send only relevant records to local Gemma │ ▼ Answer with validated citations ``` This makes the system more efficient and reduces the chance of an answer being based on unrelated records. Gemma is used for tasks that benefit from language understanding, including: The application handles exact calculations directly. For example, questions such as “Who do I talk to most?” and “How many messages did I send last week?” are answered using database aggregates rather than asking a language model to count records. This is faster and avoids a common failure mode where a model mistakes a number mentioned inside a conversation for the answer. Circle does not treat the generated answer as the only output. Each answer can include: The goal is to make the AI useful while keeping the user in control of verification. Circle can also process voice recordings that are explicitly provided by the user. The voice workflow is: ``` Voice Recording │ ▼ Local transcription │ ▼ Searchable transcript │ ▼ Person association │ ▼ Evidence in the relationship archive ``` Circle never activates a microphone or records calls. A recording must be explicitly provided by the user. Open innovation is central to Circle because the application deals with extremely personal information. Conversations, plans, memories, emails, and voice recordings are not ordinary application data. They belong to the people who created them. A closed AI API could make the first prototype faster, but it would require sending private context to a service outside the user’s control. For this project, that would undermine the reason for building it. With **Gemma and Ollama**, Circle can perform its core AI processing locally. That makes several things possible: The open model is not just an implementation detail. It changes the product’s boundaries. **Open-weight AI allows Circle to make privacy part of the architecture rather than merely a promise in the user interface.** That matters especially here because the people being remembered did not necessarily choose to participate in an AI product. Keeping the archive local gives the user more control over those memories and conversations. Circle was built for a real friend who wanted a better way to remember relationship context without searching through years of scattered conversations. Circle uses **Gemma 3:4B** through **Ollama** as its local reasoning model for evidence-grounded questions, summaries, topic analysis, relationship context, and conversation preparation. The public Circle project and download page is hosted on **Render**. The privacy-sensitive archive, retrieval pipeline, and AI processing remain local in the desktop application. Circle was developed with GitHub Copilot as part of the engineering workflow, including code exploration, implementation support, debugging, and refinement. Circle started with a friend, not a market segment. The first question was not: “What AI application should I build?” It was: **“What would actually make my friend’s life a little easier?”** The answer was helping them remember. Because sometimes remembering one small thing about someone is enough to make them feel remembered.