Chronicle | History by date

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built Chronicle | History by Dates, a local-first history revision application for a friend who is preparing for competitive exams.

One of the problems my friend struggles with is remembering important historical dates and the chronological order of events. There are hundreds of dates to remember while preparing for competitive exams, and repeatedly reading the same information doesn't always make it easier to recall.

So I built Chronicle around a simple idea:

Make history easier to remember by organizing it around dates and using AI to create useful memory aids.

Chronicle allows my friend to explore historical events by date and use AI to generate explanations and memory aids for difficult events.

Rather than building another general-purpose AI chatbot, I wanted to build something focused on a real problem faced by one particular person.

And there's one more important part:

Chronicle runs locally and can work offline.

After the initial setup and download of the AI model, the application doesn't need an internet connection to use its AI features.

The demo shows Chronicle running locally, including the AI functionality with the internet disconnected.

Demo

Code

GitHub: https://github.com/aLok-1105/chronicle

How I Built It

Chronicle is a lightweight web application built using:

• Node.js — application runtime
• Express.js — backend/server
• HTML, CSS and JavaScript — frontend
• Docker Compose — running the application and AI infrastructure
• Ollama — local AI inference
• Qwen2.5 0.5B — open-weight language model

The AI model I currently use is Qwen2.5 0.5B, which is only around 397 MB and can run locally on a regular laptop without a dedicated GPU.

The architecture looks like this:

┌───────────────────────────────┐
│        HTML / CSS / JS        │
│           Chronicle           │
└───────────────┬───────────────┘
                │
                ▼
┌───────────────────────────────┐
│          Express.js           │
│            Node.js            │
└───────────────┬───────────────┘
                │
                ▼
┌───────────────────────────────┐
│          Docker Compose       │
│                               │
│  ┌─────────────────────────┐  │
│  │         Ollama          │  │
│  │                         │  │
│  │    Qwen2.5 0.5B         │  │
│  └─────────────────────────┘  │
└───────────────────────────────┘

The user interacts with the normal web interface, while the Express backend communicates with the locally running Ollama instance.

There is no requirement to send the user's questions to a remote AI API.

Offline Mode

The first setup requires downloading the Docker images and the Qwen model.

After that, the complete application can run locally:

Internet
   │
   ✕
   │
   ▼
┌─────────────────────────────┐
│       Chronicle             │
│                             │
│ HTML/CSS/JS                 │
│      ↓                      │
│ Express                     │
│      ↓                      │
│ Ollama                      │
│      ↓                      │
│ Qwen2.5 0.5B                │
└─────────────────────────────┘

This means the AI functionality can continue working without an internet connection after the initial installation and model download.

Why Does Open Innovation Matter?

Open innovation is important to Chronicle because the project is designed around local AI rather than a closed cloud AI API.

I wanted to see how much could be built with a very small open-weight model running on an ordinary laptop.

Using Qwen2.5 0.5B with Ollama gives Chronicle several advantages:

• Works offline after the initial setup
• No AI API key required
• No per-request API cost
• User interactions can stay on the local machine
• The model can be replaced with another open-weight model
• I can customize prompts and AI behavior for competitive-exam preparation
• The application isn't tied to a single cloud AI provider

The offline capability is particularly important to me.

A student shouldn't need a constant internet connection just to use an AI-powered study tool. With Chronicle, the model is downloaded once and can then run locally.

The project also demonstrates that local AI doesn't necessarily require an expensive GPU or a huge model.

I'm currently using a 397 MB Qwen2.5 0.5B model on a regular laptop with no dedicated GPU.

That makes experimentation much more accessible.

Instead of:

Student
   ↓
Internet
   ↓
Cloud AI API
   ↓
Answer

Chronicle can work like this:

Student
   ↓
Chronicle
   ↓
Local Qwen model
   ↓
Answer

For me, that's the biggest reason open innovation matters here: I have control over the model, the data flow, and the application.

Built for a Friend

Chronicle started with a simple conversation with my friend.

He's preparing for competitive exams and was having trouble remembering historical dates and putting events in the correct chronological order.

Instead of building a generic AI application and looking for a problem to solve, I started with his problem.

I wanted to build something small that he could actually use while studying.

The result is Chronicle:

History organized by dates, with a local AI companion to help make those dates easier to remember.

And because it runs locally, he can even use it when he's offline.

That's what made this project meaningful to me—not just building something with AI, but building something for someone I know and care about.