This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.
What I Built
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:
- “What have we been talking about recently?”
- “What did I promise them?”
- “When did we last discuss this?”
- “What should I remember before meeting them?”
- “What topics keep coming up between us?”
- “Prepare me for my next conversation with them.”
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.
Demo
Project page: https://circle-dh51.onrender.com/
Source code: 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:
- Opening the Circle desktop application
- Selecting a local folder containing personal exports
- Importing conversation and personal data
- Automatically detecting and processing imported files
- Resolving records to people
- Building relationship timelines and activity summaries
- Asking a natural-language question
- Retrieving relevant evidence with hybrid search
- Generating an answer with local Gemma
- Opening the cited source records behind the answer
- Importing a voice recording
- Transcribing it locally with the voice pipeline
- Searching the newly created memory
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.
Code
GitHub repository: 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:
- Electron for the desktop application
- React and TypeScript for the interface
- Node.js and Express for the local application API
- SQLite for the local archive
- SQLite FTS5 for keyword search
- Vector embeddings for semantic retrieval
- Ollama for local model serving
- Gemma 3:4B for local reasoning and answer generation
- nomic-embed-text for local embeddings
- A local folder watcher for importing user-provided files
How I Built It
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.
Local-first ingestion
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:
- WhatsApp exports
- Telegram exports
- Instagram exports
- X exports
- Email files
- Calendar files
- Contact files
- Notes
- Documents
- Generic chat exports
- Voice recordings
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 common memory model
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:
- The person involved
- The source
- The message or event text
- The timestamp
- The origin of the record
- Source file and citation information
This allows the application to search across different kinds of personal data consistently.
Identity resolution
The same person may appear under different names, usernames, phone numbers, or email addresses.
Circle uses deterministic signals such as:
- Email addresses
- Phone numbers
- Usernames
- Contact information
- Aliases
- Source metadata
Potential matches are treated carefully. Uncertain identities are surfaced as suggestions instead of being silently merged.
Hybrid retrieval
Circle does not send the entire archive to Gemma for every question.
When a question is asked, Circle first retrieves relevant evidence using:
- SQLite FTS5 keyword search
- Semantic vector search
- Person filtering
- Source filtering
- Time-window filtering
- Reciprocal-rank fusion
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.
Local AI
Gemma is used for tasks that benefit from language understanding, including:
- Natural-language questions
- Conversation summaries
- Cross-source synthesis
- Topic analysis
- Relationship context
- Conversation preparation
- Evidence-grounded responses
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.
Source-grounded answers
Circle does not treat the generated answer as the only output.
Each answer can include:
- The generated response
- The person it relates to
- The number of evidence records used
- Source labels
- Source snippets
- Timestamps
- Links back to the original archive records
The goal is to make the AI useful while keeping the user in control of verification.
Voice memories
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.
Why Does Open Innovation Matter?
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:
- Personal records can remain on the user’s device.
- The application can continue working after the models are installed, even without internet access.
- There is no per-message cloud inference cost.
- Users can choose a model that fits their hardware.
- The model can be replaced without redesigning the application.
- The retrieval pipeline can be inspected and modified.
- The archive can remain in a local SQLite database.
- AI responses can be checked against locally stored sources.
- The application is not locked into one provider’s API, pricing, or retention policy.
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.
Prize Categories
Main Hacktoberfest Weekend Challenge: Build for a Friend
Circle was built for a real friend who wanted a better way to remember relationship context without searching through years of scattered conversations.
Best Use of Gemma
Circle uses Gemma 3:4B through Ollama as its local reasoning model for evidence-grounded questions, summaries, topic analysis, relationship context, and conversation preparation.
Best Use of Render
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.
Best Use of GitHub Copilot
Circle was developed with GitHub Copilot as part of the engineering workflow, including code exploration, implementation support, debugging, and refinement.
Final Thought
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.
Top comments (0)