What If Your Notes Could Talk to Each Other?

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built
CoralMind is a personal knowledge dashboard that lets you query all your scattered data — Notion notes, PDFs, CSV reading lists, Markdown files — in one place using natural language and SQL.
The idea came from a frustrating reality: knowledge lives in too many places. You write notes in Notion, save papers as PDFs, track reading in spreadsheets, and when you need to connect ideas across them, you're opening five tabs and searching manually. CoralMind solves that with a single query box.
Ask "What did I write about transformer architecture, and which papers back it up?" — and the dashboard streams back an answer that cites your Notion notes and your PDF index simultaneously. That's a cross-source join, powered by Coral's SQL interface, surfaced in plain English.

The core features:
Natural language queries across all connected sources with streaming AI responses
Source citations on every answer — you always know where the information came from
SQL Explorer with a live editor, cross-source JOIN examples, and auto-generated queries from every AI answer
Add new sources on the fly by pasting any content — immediately queryable, no rebuild needed
Query history, source filtering chips, and a stats panel tracking cache hits

Built entirely as a single HTML file — no npm install, no build step, no server. Open it in a browser and it works.

Demo
Working: https://youtu.be/SO3g0_2FQKI
Repo: https://github.com/JNAbhishek27/CoralMind
follow whats given in ReadMe file
Walkthrough:
Three sources come pre-loaded — Notion research notes, academic PDFs, and a reading stats CSV
Type any question and hit ⌘↵ — the answer streams in real time with [Source Name] citations
Open the SQL Explorer tab to see the Coral cross-source JOIN query auto-generated from your question
Click + Add source, paste your own notes or CSV content, and it's instantly queryable alongside existing sources

The Comeback Story
CoralMind started as a rough idea scribbled during the Coral Hackathon — a concept with no code behind it, just a judging rubric and the question "what would actually win this?"
Where it started: A blank file and a list of features I wasn't sure I could build. The SQL Explorer felt too ambitious. Streaming responses felt like it would require a backend. Cross-source joins felt like hand-waving without Coral's actual infrastructure.

What changed:
The biggest unlock was deciding to keep it a single HTML file. No framework, no build toolchain, no deployment complexity. That constraint forced every feature to be lean and every interaction to be immediate — which turned out to be a strength, not a limitation.
The streaming implementation was the hardest part to finish. The Groq API returns server-sent events, and parsing the stream cleanly while updating the DOM in real time required getting the reader/decoder loop exactly right. That was the piece that sat half-broken the longest.
The SQL auto-generation — where every AI answer produces the equivalent Coral SQL query below it — was added late and ended up being the feature that ties the whole project together. It makes the Coral connection tangible and educational.
What got finished:

Streaming AI responses with proper SSE parsing
Cross-source context bundling with per-source citations
SQL Explorer with syntax highlighting and runnable example queries
Live source indexing via the Add Source modal
Full GitHub repo with README, .gitignore, .env.example, and MIT license

The project went from concept → working demo → documented, shareable repo. That arc is what the Finish-Up-A-Thon is about.

My Experience with GitHub Copilot
Copilot was most useful in the places where I knew what I wanted but not exactly how to write it.
The SQL syntax highlighter is a good example. I knew I wanted keywords like SELECT, JOIN, and UNION ALL to render in a different colour inside a

 block. Writing the regex replacements for every keyword by hand would have been tedious and error-prone. Copilot autocompleted the keyword array and the replace chain from the first two lines — saving probably 20 minutes of lookup and testing.

The same happened with the SSE stream parser. Once I wrote the reader.read() loop and the first if (line.startsWith('data: ')) check, Copilot filled in the [DONE] guard, the try/catch around JSON.parse, and the delta extraction — all the boilerplate that surrounds the one line that actually matters.

Where Copilot didn't help — and wasn't supposed to — was in the product decisions. Which features to cut, how to structure the judging-criteria story, what the SQL Explorer tab should actually do. Those required thinking through the problem, not autocompleting it.

The honest summary: Copilot handled the mechanical parts so I could stay focused on the parts that required actual judgment. For a solo hackathon build where time is the constraint, that trade-off is exactly right.

This is a Solo project

Thank You