The Inspiration

I hope you found the front-facing chat system cool.

I know I did when I first heard about the idea from my coworker and mentor, @Vonshlovens. The basic concept immediately stuck with me: a personal blog that does not just sit there as a list of posts, but has a built-in chat interface that can answer questions from the author’s own writing.

That felt genuinely interesting to me.

Not because it replaces the posts. I still think the notes themselves matter. But because it creates another way into them. Instead of expecting someone to click through a bunch of titles, skim around, and guess where the relevant thought might be, they can just ask the site a question.

That small shift felt surprisingly important.

A blog usually asks you to browse chronologically. You start with the newest thing and work backward. That works fine for updates, but it does not always work well for ideas. I do not usually remember my own notes by date. I remember them by problem, tool, pattern, frustration, or half-formed opinion. I remember the thing I was trying to figure out.

So the idea of a site that could respond through the writing itself felt like something worth building.

I can shamelessly say that this entire idea was stolen from him, which he gave me explicit consent to do. And if I remember correctly, he also stole, borrowed, or was inspired by the idea from someone else. So really, this is part of a proud lineage of people seeing something cool and immediately thinking: “I want to make my own version of that.”

Which, honestly, is one of the better ways projects start.

The part that stuck with me

The chatbot part is obviously the most visible feature. It is the thing you notice first. It is also probably the easiest part to describe to someone else.

“Here is my blog, and you can chat with it.”

That sounds neat.

But the more interesting part to me is what has to happen underneath for that to work. The site needs some way to turn a pile of writing into something searchable, retrievable, and useful to a language model. It needs to treat notes less like static pages and more like a small knowledge base.

That was the part that made me want to build this.

I have always liked the idea of personal knowledge systems, but a lot of them stay private. They live in folders, notes apps, markdown vaults, half-finished documents, and random project directories. Glass Atlas is partly an attempt to make some of that thinking public, but without turning it into a polished portfolio or a tutorial factory.

I wanted a place for field notes.

Notes about GIS, automation, maps, tooling, software, design decisions, failed experiments, weird debugging sessions, and whatever else I happen to be thinking through. Not every note needs to be definitive. Some of them can just be snapshots of how I understood something at the time.

The chat interface adds another layer to that. It gives the notes a way to be queried later.

That is the part I find compelling: not just publishing thoughts, but making them easier to return to.

The technical version

The technical version of the idea is fairly simple, even if the words around it can make it sound heavier than it is.

Each note gets broken into smaller chunks. Those chunks are passed through an embedding model, which turns the text into a numerical representation of what it is about. In this case, I am using OpenRouter with OpenAI’s text-embedding-3-small model. Those embeddings are then stored in a Neon-connected Postgres database using pgvector.

That setup allows the site to do semantic search.

In plain terms, semantic search means the system is not only looking for exact matching words. It is trying to find sections of writing that are close in meaning to the question being asked.

So when someone asks the chat a question, the system takes that question, creates an embedding for it, compares it against the stored note chunks, and retrieves the sections that seem most relevant. Those sections are then passed into one of the language models used by the site so it can answer with the notes as context.

The practical result is this:

The chatbot is not just floating there as a generic AI assistant. It is looking through a database of things I have actually written, pulling forward relevant pieces, summarizing them, and answering from that material.

At least, that is the goal.

I am sure there will be rough edges. Retrieval can miss things. Models can over-summarize. Some notes will probably be too vague to be useful. Some chunks might not contain enough context on their own. There are a lot of small design decisions hidden inside a system like this.

But that is also what makes it interesting.

Why build it this way?

Part of the reason I wanted to build Glass Atlas this way is because I like the idea of a personal site being more than a display surface.

A lot of websites are organized around presentation. Here is the homepage. Here are the posts. Here are the projects. Here is the about page. Everything has its place.

That structure is useful, but it can also make writing feel more finished than it really is.

I wanted this site to feel more like a working atlas: a place where ideas can be mapped, revisited, connected, and occasionally contradicted. Some notes might be practical. Some might be reflective. Some might just be me trying to explain why a certain workflow bothered me for longer than it should have.

The chat interface fits into that because it gives the site another form of navigation.

Instead of only moving through categories, tags, and dates, someone can move through questions. They can ask what I have written about a tool, a process, a design choice, or a recurring pattern. If the system works well, it should be able to point them toward the relevant notes and explain how they connect.

That feels closer to how I actually think.

Not perfectly ordered. Not completely random either. More like a set of connected fragments that become useful when the right question is asked.

What I want this to become

This first note is partly an introduction and partly a seed.

If the system works the way I want it to, this post will eventually become one of the things the assistant can retrieve when someone asks why Glass Atlas exists. That feels like the right place to start: with the borrowed idea, the small technical obsession behind it, and the hope that a personal site can be more than a list of posts.

I do not want Glass Atlas to be a portfolio.

I do not want it to become a content machine.

I mostly want it to be a place where I can think in public, document what I am learning, and build a small archive that is useful both to me and to anyone else who finds it interesting.

Some posts will be technical. Some will be more reflective. Some will probably read like cleaned-up rants. That is fine with me. I would rather the notes feel personal and specific than overly polished and generic.

The point is not to sound like I have everything figured out.

The point is to leave a trail of how I am figuring things out.

And, hopefully, to make that trail searchable enough that the site can answer back.