AI and My Notes: When Technology Betrays Memory

The Initial Challenge: Dispersed Notes

Three weeks after diving into machine learning, I encountered an unexpected obstacle. It wasn't the complexity of the models or the mathematics that posed a problem, but the management of my notes. I had taken care to write my thoughts in my own words, creating analogies that resonated with me and jotting down questions to explore later. However, the structure of my notes left much to be desired.

My notes were scattered across several applications and formats. Some were in Notion, others in Google Docs, and a few in random text files. This lack of coherence forced me to spend the first twenty minutes of each study session piecing together the context. What had I already understood? Where had I left off? Which explanation had been the most enlightening? I felt like I had to relearn my own thoughts before I could make any progress.

In a moment of frustration, I tried an approach that seemed obvious. I opened a conversation with an AI, pasted my notes, and asked for help studying. Against all odds, it worked better than expected. The AI's responses aligned with my way of thinking, and I finally felt like I had a tool that adapted to me, rather than the other way around.

For the first time, my learning felt fluid and continuous, rather than fragmented.

The Emergence of Initial Problems

At first, the system seemed to work smoothly. The AI used my notes to explain concepts in an understandable way, saving me time. Everything seemed in order.

Then, inconsistencies began to appear. Sometimes, the AI used an example I didn't recognize. Other times, it omitted details I was sure I had noted. These errors weren't glaring, but they were sufficiently off to be noticed if one paid attention.

I initially thought it was my fault. Perhaps I hadn't formulated my notes clearly. Maybe I had forgotten what I had written.

Then, a response from the AI made me pause. I had asked for an explanation of a concept based on my notes, a concept I already understood well. The AI provided a clear and structured answer, but it cited a formula that it claimed came from my notes.

I stopped, knowing that this formula was not in my notes. I checked, and it wasn't hidden somewhere I had forgotten. It simply did not exist.

That's when the problem became impossible to ignore. The answer wasn't blatantly wrong; it even seemed correct. If I hadn't been attentive, I would have likely accepted this response without questioning it.

This type of error is insidious. It's not something you can detect immediately, but it can silently distort your understanding without you realizing it.

Revisiting Note Organization

Before correcting the AI, it was essential to revisit my notes. Until that moment, I had perceived the problem as external. The AI was inconsistent, so I assumed the issue lay with its responses. But upon examining my setup, it became clear that I wasn't providing the AI with a reliable foundation.

My notes lacked coherent structure. Some were written in paragraphs, others in bullet points. Some contained analogies, others did not. Even when two notes addressed similar topics, they were formatted completely differently. It made sense that I struggled to navigate my own notes. Expecting an AI system to interpret them coherently was even more unrealistic.

I decided to transfer everything to Markdown. Not because it’s a powerful tool, but because it enforces simplicity. Plain text, light formatting, and just enough structure to make things predictable.

Each note now followed the same pattern: a concept at the top, a short explanation, a personal analogy, and a section for points still unclear. It wasn't perfect, but it was consistent. And that consistency was more valuable than anything else.

What surprised me was how much this improved things, even before reintroducing the AI. The notes became easier to browse, revisit, and develop. I no longer wasted time reinterpreting my own writings.

I also added metadata at the top of each file, such as the topic and difficulty level. This didn't change how I directly used the notes, but it made them easier to organize once I considered them as a collection rather than isolated fragments.

In retrospect, this was the first real change. The system didn't start with the AI. It began by making the input structured enough to be usable.

Beyond the Chat Interface

Up to this point, I was still using the AI through a chat interface. This worked for quick interactions, but the limitations soon became evident. Every time I wanted to ask a question, I had to paste my notes again or rely on the remaining context in the conversation.

It didn't feel like a system. It was like starting over each time.

I wanted a more coherent system, where my notes were already part of the setup, rather than something I had to reintroduce each session. This pushed me to move beyond chat and use the API.

In simple terms, this meant writing a small script that sends my notes and questions directly to the model and receives responses in return. No chat window, no manual copy-pasting, just a structured request and a structured response.

The change itself wasn't as complicated as it seemed, but it altered how I thought about the interaction. Instead of viewing the AI as a conversational partner, it became a component around which I could build.

There were a few practical elements to consider quickly. The API key behaves like a password, so it must be handled carefully. And since usage is billed per request, it’s easy to underestimate how quickly costs can accumulate if you're not careful.

Once everything was set up, I adopted the simplest approach possible. I loaded all my notes, sent them with each question, and let the model respond.

For a while, the system worked exactly as I expected.

Then it started to deteriorate again.

The Limits of the System

As my notes accumulated, the system began to show signs of inconsistency again.

I would ask the same question and receive slightly different answers. Sometimes, details I knew were in my notes simply didn't appear. It wasn't obvious at first, but the pattern became hard to ignore. The more notes I added, the less reliable the responses seemed.

That's when I discovered the concept of the context window.

The model can only process a limited amount of text at a time. Everything you send—your notes, your question, and even parts of the previous conversation—must fit within this limit. If it doesn't, part of it is simply ignored.

There’s no warning when this happens. The model doesn’t tell you it missed something. It simply responds based on the portion it was able to read.

Once I understood this, the inconsistencies made sense. The model wasn't ignoring my notes. It simply couldn't see them all.

The limit itself is measured in tokens, not words. Tokens are smaller pieces of text, and they accumulate faster than you think, especially with technical material. A few pages of notes can quickly turn into thousands of tokens.

This means that sending all my notes with each question wasn't just inefficient. It was ultimately going to fail, no matter what.

This realization shifted the problem. It was no longer about making the AI "better." It was about working within a constraint I hadn't understood before.

The real question became: how can I ensure the model sees the right information without trying to show it everything?

A More Targeted Approach

Once I understood that the model couldn't see everything at once, the problem became clearer. I didn't need it to read all my notes every time. I just needed it to read the right parts.

Until that moment, my approach had been simple: send everything and let the model figure it out. This worked when the notes were small, but it failed as soon as they exceeded what the system could handle.

So I flipped the approach.

Instead of sending all my notes, I started by searching them first. When I asked a question, the system would look for the most relevant sections, extract them, and send only that smaller, targeted context to the model.

This small change made a noticeable difference.

The responses became more consistent, and more importantly, they began to resemble my notes again. The explanations reflected the way I had written things, including the analogies that had made sense to me when I first learned them.

This approach is often called retrieval-augmented generation, but the idea itself is simple. You first retrieve the relevant information, then generate a response based on it.

What struck me was that the method didn't make the model smarter. It just made it more grounded. Instead of relying on what it "knew," it was now anchored in what I had actually written.

This distinction mattered more than I had anticipated.

The Moment of Revelation

Even after correcting the retrieval, there was still something that didn’t seem quite right.

In general, the responses were anchored in my notes. They reflected my explanations, my analogies, and the way I had built my understanding. But occasionally, something slipped through that didn’t belong.

One response made this evident.

I had asked the system to explain backpropagation using my notes. It started well, walking through the idea in a way that matched how I had written it. Then, halfway through, it introduced a detailed mathematical formula.

I stopped immediately. I had...