DEV Community: Ronit Solanki

Ofrenda: A Local AI Altar That Keeps Your Loved Ones’ Memories Alive

Ronit Solanki — Fri, 30 Oct 2026 18:46:08 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Ofrenda is a private, local altar for the people you remember.

In Día de los Muertos, an ofrenda is an altar built from the things a person loved: their favorite food, their songs, the objects they kept close, the stories people tell about them. I wanted to build a digital version, one that keeps those memories alive and can be talked to.

You add a person, then place "offerings" on their altar: a food, a song, a story, or an object. Then you can:

Ask the Keeper. A chat that answers only from the memories you placed. Ask "What did she love to cook?" and it tells you what you wrote, in a gentle voice.
Write a remembrance. A short tribute written from the memories.
Write a calaverita. A playful rhyming verse in the Mexican tradition of teasing Death while celebrating the person.

I interpreted "Ghost in the Machine" in a gentler way than haunting. The ghost isn't a fake version of your loved one. It's their memory, kept safe by a machine. That's why the Keeper is deliberately not allowed to speak as the person. It's a storyteller who looks after the memories, speaks about them in the third person, and says "that story isn't on the ofrenda yet" instead of making something up.

Demo

Code

ronitsolanki-01 / Ofrenda

Ofrenda: a private, local altar for people you remember. Place foods, songs & stories, then ask a Keeper that answers only from your memories, or get a calaverita. Spring Boot, Next.js, Spring AI, llama3.1:8b & nomic-embed-text via Ollama. Nothing leaves your laptop.

Ofrenda

A private, local altar for people you remember. Place foods, songs, stories and objects on it. Memories are embedded with nomic-embed-text into a Spring AI vector store. The "Keeper" (llama3.1:8b) answers using retrieval (RAG) from those memories only, and can write a remembrance or a playful calaverita.

Run

ollama pull llama3.1:8b && ollama pull nomic-embed-text (Ollama running on :11434)
Backend (Java 21): cd backend && mvn spring-boot:run → http://localhost:8080
Frontend: cd frontend && npm install && npm run dev → http://localhost:3000

Data is saved to backend/data/ofrenda.json and re-embedded on every startup.

View on GitHub

How I Built It

Everything runs on my own machine with open-weight models.

Layer	Tech
Chat model	`llama3.1:8b` via Ollama
Embeddings	`nomic-embed-text` via Ollama
AI framework	Spring AI 1.0 (`ChatClient`, `VectorStore`, `EmbeddingModel`)
Backend	Spring Boot 3.4, Java 21
Frontend	Next.js 15 (App Router, TypeScript)

The core idea is RAG (retrieval-augmented generation), kept small and honest:

When you place an offering, the backend embeds the text with nomic-embed-text and stores it in Spring AI's SimpleVectorStore, tagged with the person's id.
When you ask the Keeper a question, the backend runs a similarity search filtered to that person's memories and pulls the top 5.
Those memories go into the system prompt for llama3.1:8b, with strict rules: use only these memories, invent nothing, never pretend to be the person.
Memories are saved to a small JSON file and re-embedded on startup, so the altar survives restarts without needing a database.

The calaverita and the remembrance use the same approach: all of a person's memories go into the prompt, and the model is told which style to write.

The design comes from the subject itself: a papel picado banner across the top, and a marigold, pink and teal palette on deep plum, like candlelight against a night sky.

Why Does Open Innovation Matter?

Grief is private. The things people write about someone they've lost, such as a grandmother's recipes, a father's songs and the story from the hospital, are some of the most personal data a person owns.

With a closed API, every one of those memories would have to leave my machine and pass through someone else's servers. With open-weight models and local inference, nothing leaves the laptop. There's no account, no API key, no usage bill and no terms of service sitting between you and your own memories.

Open tooling also let me build exactly what I wanted. Spring AI let me plug Ollama into a normal Spring Boot backend, and I could swap models, tune the prompts and filter retrieval per person. Because the project is open too, someone else can fork it, translate it, or point it at a different model.

The Spirit of It

The goal isn't to bring anyone back. It's to make sure that the small, specific things that made a person who they were don't get lost.

*Built for Hacktoberfest 2026 with open-weight models.

SlothDigest: Let a Local 4B AI Read Your 400 Unread WhatsApp Messages While You Sleep

Ronit Solanki — Sun, 25 Oct 2026 19:22:00 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

SlothDigest is an asynchronous, local-first group chat summarizer built for people who refuse to wake up and scroll through 400 unread WhatsApp messages just to find out whether a meeting moved by 15 minutes.

Instead of reading noisy group threads in real time, you upload your exported .txt chat logs into SlothDigest before going to bed (or trigger a manual digest anytime). At 3:00 AM, a scheduled Spring Boot batch job wakes up, parses the raw chat transcripts, and feeds them through a local open-weight LLM (qwen3.5:4b running on Ollama).

When you open the React (Vite) dashboard with your morning coffee, every chaotic group chat is already distilled into three clean sections:

A 2-Line Summary: Two short, factual sentences explaining what actually happened in the thread.
Action Items: Concrete tasks, decisions, and deadlines extracted from the noise (including who is responsible and when it is due).
Direct Mentions: A personalized list of messages that addressed or mentioned you by name (e.g., "Sam asked if you can bring the projector"), so you never miss a ping buried under 50 memes.

Busy students, developers in hackathon coordination threads, and anyone trapped in high-volume WhatsApp project groups get to be unapologetically lazier every morning without missing a single task or ping.

Demo

Code

ronitsolanki-01 / slothdigest

You upload or forward your group chat exports (e.g. WhatsApp .txt files) and a scheduled job summarizes them overnight. In the morning you open the app and find a 2-line summary per chat, plus action items and anything that mentions you. You never have to scroll through 400 messages.

SlothDigest

Upload your group-chat exports, go to sleep, and read a two-line summary per chat in the morning (plus action items and anything that mentions you). It runs on an open-weight model through Ollama so your chats never leave your machine.

Backend: Spring Boot 4.0, Spring AI 2.0 (Ollama), Spring Security 7 (JWT), JPA + H2, @Scheduled job Frontend: React + Vite + Tailwind

Prerequisites

Java 17+ (21 recommended), Maven 3.9+
Node 18+
Ollama running locally, with the model pulled: ollama pull qwen3.5:4b (change the model in application.properties; thinking is turned off in DigestAi.java)

Run

# 1. backend (http://localhost:8080)
cd backend
mvn spring-boot:run

# 2. frontend (http://localhost:5173), in another terminal
cd frontend
npm install
npm run dev

Try it

Open http://localhost:5173 and create an account. Use the name your friends call you as display name, because that is how mentions of you are found.
Upload sample-chat.txt (WhatsApp…

View on GitHub

How I Built It

SlothDigest is built as a full-stack application with a React (Vite) frontend and a Java Spring Boot backend, orchestrated around local open-source AI inference via Spring AI 2.x and Ollama.

Tech Stack

Frontend: React + Vite organized into three focused screens: a Login / Register page, a Chat Export Upload page, and a Morning Digest Feed.
Backend: Java & Spring Boot with Spring Security + stateless JWT authentication (app.jwt.secret) supporting multi-user accounts, where each user's display name is dynamically injected into the prompt to detect direct mentions.
Database: File-based H2 database (jdbc:h2:file:./data/slothdigest) with Spring Data JPA / Hibernate for zero-setup local persistence (easily swappable to PostgreSQL in production).
Open-Source AI & Local Inference: Ollama serving the open-weight qwen3.5:4b model locally (plus nomic-embed-text configured for future semantic search/RAG features), integrated via Spring AI 2.x.

Architecture & Workflow

Chat-Export Parser: Raw exported .txt chat logs are uploaded (up to 10MB multipart uploads), cleaned, and normalized into a compact Sender: text line-by-line format. To protect local memory and keep inference snappy on laptop hardware, the parser keeps the most recent 12,000 characters (app.digest.max-chars=12000) within an 8,192-token context window (num-ctx=8192).
Slow-and-Steady Overnight Batch Job (@Scheduled): Rather than making the user stare at a loading spinner, a Spring @Scheduled cron job (0 0 3 * * *) runs every night at 3:00 AM to digest all pending chat exports in the background.
Schema-Enforced Structured Output (BeanOutputConverter): Small local models can sometimes wrap JSON in markdown fences or drift off-schema. In DigestAi.java, I paired Spring AI's BeanOutputConverter<DigestResult> with OllamaChatOptions to enforce the exact JSON schema at the Ollama inference layer while disabling chain-of-thought reasoning traces (disableThinking()) and setting a low temperature (0.2) for fast, deterministic extraction:

java
public DigestResult summarize(String chatName, String readerName, String transcript) {
OllamaChatOptions options = OllamaChatOptions.builder()
.model(this.model) // qwen3.5:4b
.disableThinking() // no reasoning trace: faster, cleaner JSON
.outputSchema(converter.getJsonSchema()) // Ollama enforces this JSON schema
.build();

Prompt prompt = new Prompt(List.of(
        new SystemMessage(SYSTEM),
        new UserMessage(USER.formatted(chatName, readerName, transcript))),
        options);

String json = chatModel.call(prompt).getResult().getOutput().getText();
return converter.convert(json);

}

Why Does Open Innovation Matter?

Group chat exports contain deeply personal, unfiltered conversations—phone numbers, internal project updates, deadlines, and candid banter among friends or teammates. Uploading private group chat logs to a closed, third-party cloud API is a non-starter for privacy.

Open innovation made SlothDigest possible in three ways that a closed API couldn't match:

VaultExam AI: Mock Tests from Your Notes, Without Uploading Them Anywhere

Ronit Solanki — Sat, 17 Oct 2026 23:40:09 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

VaultExam AI is a 100% local, privacy-first tool that turns a chapter (In any format) into a ready-to-print question paper + answer key and lets you ask questions of the same document with page-cited answers.

Who would pay for it: independent coaching institutes, test-prep tutors, university professors and corporate trainers. Their curated notes and question banks are their intellectual property, and they don't want to upload them to a cloud API. They also spend hours every week typing up mock tests, DPPs and Set A/B variations by hand.

What it does:

Upload Notes in any format. It is chunked and embedded locally, and the file is deleted from disk straight after ingestion.
Ask the document: answers come only from your notes, with Page citations.
Generate an exam: choose the institute name, exam type (Coaching Mock Test, University Mid-Sem, Corporate SOP Quiz), difficulty (Recall, Application, Analytical/Edge Cases) and the number of MCQs, short answers and long answers.
Set A/B/C: each set draws on different parts of the document and avoids repeating earlier questions.
Answer key included: MCQ answers with explanations, model answers for short and long questions, marking-scheme key points, and the source page for every question so a teacher can verify it.
Print or save as PDF straight from the browser.

Demo

Code

https://github.com/ronitsolanki-01/VaultExam.git

How I Built It

Everything runs on the user's own machine. No cloud calls, no per-token fees.

Backend: Java 21, Spring Boot 4.1.1 and Spring AI 2.0.1
LLM: an open-weight model (qwen3.5:4b) served by local Ollama
Embeddings: nomic-embed-text via Ollama
Vector store: PostgreSQL with PGVector (pgvector/pgvector:pg16 via Docker Compose), with metadata filtering by document_id
Ingestion: Spring AI's TikaDocumentReader and PagePdfDocumentReader keeps page number on every chunk, then TokenTextSplitter chunks it
Frontend: one Next.js page (TypeScript, Tailwind), with window.print() for output

How the exam generator works: it retrieves a sample of chunks from the document, asks the model for MCQs, short answers and long answers in separate structured-output calls, then validates each result (question count, exactly four options, valid answer index) and retries if the local model returns bad JSON. Each set uses a different seeded sample of the document, plus a "don't repeat these questions" list.

Things that bit me on a small local model:

Reasoning models like qwen3.5 can spend their whole token budget "thinking" and return an empty answer, which breaks JSON parsing. I fixed it by disabling thinking in the Ollama options.
Ollama's default context window silently truncates long RAG prompts, so I set a larger num-ctx and tuned how many chunks each call retrieves.
Small models sometimes return a bare JSON array instead of an object, so the parsing and validation code handles that and retries.

Why Does Open Innovation Matter?

A closed API would have made this product impossible to sell to its target customers. A coaching institute's notes are its business, and "send your question bank to a third party" is a dealbreaker.

Open-weight models let the whole pipeline run inside the customer's own machine. That also changes the economics: generating a hundred papers costs electricity, not tokens, so a tutor can regenerate Set B at 11pm without watching a bill. And because the stack is open, institutes can swap the model for a bigger one as their hardware allows.