Circle: A Private AI Memory for the People Who Matter

Navaneedan S — Sun, 04 Oct 2026 16:03:40 +0000

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.

DEV Community: Navaneedan S