This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend
What I Built
There is usually one person in every household or friend group who somehow knows everything.
Not everything in a dramatic way.
Just the oddly specific things everyone eventually asks them:
“Where is the spare key?”
“Who fixed the washing machine last time?”
“What do I do when the Wi-Fi stops working?”
“When is the purifier due for service?”
“Which plumber should I call?”
The problem is that this knowledge rarely lives in one place.
Some of it is in WhatsApp messages.
Some is in screenshots.
Some is buried in PDFs and receipts.
Some exists as voice notes.
And some of it only exists in that one person's memory.
That person was the inspiration for RELAY.
RELAY is a personal knowledge handoff system that turns scattered information into a temporary, evidence-backed handoff that someone else can actually use.
Instead of asking the person who "knows everything" to sit down and manually explain it all, RELAY reconstructs the important context and organizes it into:
- What you need to know
- Who you need to contact
- What needs attention
- What changed recently
- What is uncertain
- Where each important fact came from
The key design principle is simple:
RELAY should never sound more certain than the evidence allows.
For example, if an old message contains a Wi-Fi password but a newer message says the password was changed, RELAY doesn't guess the new one.
It says:
I don't know the current Wi-Fi password.
An older password exists, but a later source says it was changed. No replacement was found.
That behaviour is intentional.
I wanted to build something that doesn't just remember information, but understands when information is old, conflicting, or incomplete.
Demo
Demo Video: https://youtu.be/5DhEMq-5jpc
The most important interaction is not the answer itself.
It is being able to ask:
“Why do you think that?”
and see the source that supports it.
Code
GitHub Repository: https://github.com/Tanishaaaaaaa/relay-ai-handoff/tree/main
How I Built It
The architecture is deliberately split into two parts:
reconstruction and handoff.
The first stage takes messy information and turns it into structured facts.
The second stage decides what belongs in the actual handoff.
Messages / PDFs / Images / Voice Notes
↓
Ingestion
↓
Open-weight AI / extraction
↓
Structured facts
↓
┌──────────┼──────────┐
↓ ↓ ↓
Sources Timeline Relations
└──────────┼──────────┘
↓
Conflict + freshness checks
↓
Evidence-backed state
↓
Handoff Builder
↓
Temporary handoff
Open-source AI
RELAY is designed around Gemma, an open-weight model that can be run locally through Ollama.
The repository includes an Ollama adapter in:
server/ollama.js
The model is instructed to answer only from the supplied reconstructed context and to explicitly say when the available evidence is insufficient.
The system can therefore work in two modes:
Demo/evidence-engine mode
Useful for running the project immediately without requiring local model inference.
Local Gemma mode
The /api/ask endpoint can route questions through a locally running Gemma model via Ollama.
For example:
User question
↓
RELAY API
↓
Local Gemma
↓
Evidence-grounded answer
The model is not treated as the permanent source of truth.
Instead, the application keeps the evidence and provenance separate from the model layer.
That makes the model replaceable and the reasoning workflow inspectable.
Backend
The backend is a Node.js + Express API.
It exposes endpoints including:
GET /api/health
GET /api/handoff
GET /api/facts
GET /api/conflicts
GET /api/sources
POST /api/ask
POST /api/handoff/build
POST /api/ingest
Evidence and conflict handling
One of the most important parts of RELAY is that facts carry context around them.
A fact isn't just:
{
"value": "Suresh"
}
It also has information such as:
{
"value": "Suresh",
"source": "maintenance-chat.txt",
"updated": "2026-09-02",
"confidence": 0.89
}
This lets RELAY surface situations like:
Plumber contact changed
Older: Rakesh
Newer: Suresh
Reason: A newer message explicitly replaces the older contact.
Or:
Wi-Fi password is stale
Older password: Found
New password: Unknown
Reason: A later message says the password changed, but the replacement was not found.
That is much more useful than simply retrieving every matching message.
Why Does Open Innovation Matter?
The information RELAY is designed to work with can be extremely personal.
It can include:
- private conversations
- phone numbers
- receipts
- addresses
- photographs
- household routines
- personal notes
- voice recordings
I didn't want the product to require all of that information to be sent to a remote black-box AI service just to answer a simple question.
Using an open-weight model gives me another option:
Run the intelligence closer to the data.
With a local Gemma + Ollama setup, the model can run on the user's own machine.
That matters for this project for three reasons.
Privacy
Sensitive personal information can stay local.
Control
The model can be swapped, tested, evaluated, or replaced without redesigning the whole application.
Transparency
The AI layer doesn't have to be the only place where reasoning happens. RELAY can keep evidence, source provenance, and conflict information as first-class parts of the system.
For this particular problem, open AI isn't just a checkbox.
The privacy requirement is part of the product itself.
Prize Categories
Best Use of Gemma
RELAY is designed around Gemma as the open-weight model layer, with local inference supported through Ollama.
The idea behind RELAY started with something very ordinary:
There is always someone everyone depends on because they remember the little things.
The goal wasn't to make that person remember more.
It was to make it easier for them to hand over what they already know.
And maybe that is a better way to think about AI memory:
Not keeping everything forever.
Keeping the right context until somebody else can carry it.
){kind=link}
Top comments (0)