Golden Lines

Golden Lines: A Personal Knowledge Graph That Remembers What Matters

This is my submission for the "Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle" (https://dev.to/challenges/hacktoberfest-week2-2026-10-12).

What I Built

Golden Lines is a personal knowledge system for capturing, connecting, and retrieving the sentences worth remembering.

We consume ideas from books, podcasts, conversations, articles, and people we admire. But most of those ideas end up scattered across notes, bookmarks, and documents. Even when we remember an idea, we often forget where it came from or how it connects to something else.

I built Golden Lines to solve that problem.

Instead of storing everything in an unstructured pile of notes, Golden Lines treats each meaningful sentence as an individual piece of knowledge. Every line can be connected to its speaker, topics, and source. I can then ask questions in natural language and let an AI agent retrieve relevant lines from my personal knowledge base.

For example, I can ask, "What did I save about discipline?" or "Who said this, and what else do I know about them?" The system combines semantic search, structured relationships, and an AI agent to find relevant information.

The most important design decision is that my knowledge belongs to me, not to the AI or the database.

Golden Lines are stored as plain Markdown files. PostgreSQL, entity relationships, and vector embeddings are derived indexes that can be rebuilt from those files. The AI can search and reason over my knowledge, but it doesn't write or rewrite my canonical notes.

Golden Lines is currently a personal knowledge system, but I see potential for researchers, writers, students, creators, and knowledge workers who want to build a searchable, reusable library of ideas.

A future product could serve people who are willing to pay for a private, portable knowledge system that helps them retrieve and connect what they've learned over time.

Demo

The project currently runs through a CLI and an authenticated HTTP API.

• Capture a golden line from the command line.
• Index Markdown files into PostgreSQL.
• Ask questions in natural language through an AI agent.
• Browse saved lines and entities through the API.

I haven't published a hosted demo yet, so the repository is the best place to explore the implementation and setup instructions.

Code

GitHub repository: https://github.com/tanishbhongade/golden-lines

The project is built in Python and organized into distinct layers:

• "app/capture/" — captures new golden lines.
• "app/indexer/" — parses Markdown, resolves entities, generates embeddings, and updates the database.
• "app/retrieval/" — handles semantic search, entity resolution, and relationship queries.
• "app/tools/" — exposes retrieval functions to the AI agent.
• "app/graph/" — orchestrates the agent using LangGraph.
• "app/api/" — provides authenticated HTTP endpoints using FastAPI.

The database uses PostgreSQL with pgvector for semantic search and "pg_trgm" for similarity-based entity resolution.

How I Built It

I wanted to build something where AI adds intelligence without becoming the owner of the underlying data.

The system uses a combination of traditional software engineering and AI-powered retrieval.

The knowledge layer

Every golden line is a Markdown file with YAML frontmatter containing metadata such as its title, speaker, topics, and source. These files are the canonical records, making the knowledge base human-readable, portable, and version-control friendly.

The indexing layer

A deterministic Python pipeline parses the files, extracts entity references, resolves them against existing entities, and generates embeddings. PostgreSQL stores the resulting structured relationships and vector representations.

The retrieval layer

The application combines vector similarity with relational queries. This allows it to search by meaning while also answering questions about specific people, topics, and their associated lines.

The AI agent

I used LangGraph to orchestrate an agent that can call retrieval tools, inspect the results, and answer questions grounded in the available knowledge. The model decides which tools to use; the tools perform the actual data retrieval.

For the model layer, I used AWS Bedrock with configurable model identifiers. The documented defaults are Amazon Titan Text Embeddings V2 for embeddings and DeepSeek V3 for language-model reasoning.

I deliberately kept the agent's access to canonical knowledge read-only. Capturing new knowledge is an explicit user action, while the database and embeddings remain rebuildable projections.

This separation means I can change the database or model implementation without losing the underlying knowledge.

Why Does Open Innovation Matter?

Open innovation matters because a personal knowledge system should not require a permanent commitment to one AI provider, database, or proprietary note-taking platform.

Golden Lines is built on open-source frameworks and portable data formats. Python, FastAPI, LangGraph, PostgreSQL, pgvector, and Markdown each play a distinct role in the system.

That combination made it possible to experiment with AI-powered retrieval while retaining control over the data model and application architecture.

It also makes the project easier to inspect, adapt, and extend. Someone could replace the embedding model, change the language model, build a different interface, or reuse the indexing pipeline without having to rebuild the entire system from scratch.

I use configurable model identifiers so that changing models doesn't require rewriting the application around a particular provider's API.

There is an important distinction here: the application and its core architecture are built with open-source technologies, while the currently configured models are accessed through AWS Bedrock. The system is designed to make model substitution easier, although switching to local or open-weight inference would still require configuring a compatible inference backend.

For me, open innovation is about retaining the freedom to experiment, learn from existing work, and build something that remains useful even as the AI ecosystem changes.