Memora

Memora gives AI a secure, personalized memory, so it remembers your context across conversations.

Comment

Inspiration

I decided to build Memora because the longer I would use ChatGPT, the more I would have scattered conversations about the same topic everywhere. I would start a new conversation and It would remember the topic really well, but the different conversations had conflicting ideas, for example, I worked on a project where I had a specific conversation including a specific architecture and after months I decided to redo the entire project with a different architecture on a different conversation. The same problem kept happening where I would prompt ChatGPT in a new conversation and it references the old design. I wanted more control, whether I wanted to access the current design or look over my old one to analyze it. Going through the specific conversation was too daunting as well since the conversations where extremely long including a lot of debugging so a lot of it was me scrolling through an old conversation endlessly. So I decided to solve my problem, I wanted access to the most relevant information and control over the different versions of the same topic. This is why I created Memora, not a whole different LLM but a companion to use that helps me find what from my history actually matters for what I am trying to do right now.

What it does

Memora is a user controlled companion for ChatGPT. You write your prompt like normal, but before sending it, you can ask Memora to search through the conversation history and supported documents you chose to import. Instead of only returning similar messages, Memora:

  • retrieves relevant history
  • separates different subjects and projects into MemoryThreads
  • identifies useful MemoryFacts such as decisions, results, constraints, corrections, and current status
  • considers how information changed over time
  • turns the strongest information into concise MemoryBriefs
  • preserves provenance so the user can see where the information came from

The user stays in control. Memora never silently inserts or submits anything. The user reviews the results, selects Use This Context, reviews the updated draft, and sends the message manually.

How we built it

Memora has three main parts:

  • A Chrome Manifest V3 extension that works alongside ChatGPT
  • A local FastAPI backend that handles retrieval and memory processing
  • A local SQLite database that stores imported conversations, chunks, embeddings, documents, timestamps, and provenance

The retrieval pipeline is roughly:

query → semantic retrieval → hybrid reranking → MemoryThreads → MemoryFacts → temporal reasoning → MemoryBriefs → provenance

Memora also has Enhanced and Local processing modes, support for recoverable text PDFs and attachments, and a one-command Windows launcher that handles environment setup, dependencies, extension builds, authentication, and backend startup. Codex was used for code implementation, debugging, tests, security hardening, launcher work, and extension UX. GPT-5.6 was used as a reasoning partner especially in pointing out architectural mistakes, providing explanations on topics I was not comfortable with, and was a second reviewer to validate my review and catch any missed issues.

Challenges we ran into

The first challenge was honestly understanding the problem deeply enough to design the right architecture. I started from the idea of RAG and had to learn where basic retrieval falls short for personal memory. Finding similar text is useful, but it can still return outdated information, mix different projects together, or bring back something that is technically related but not actually important to the question. A big part of the challenge was taking that basic concept and building something more layered around it. That is where MemoryThreads, MemoryFacts, temporal reasoning, correction handling, and reranking came from.

The second major challenge was synthesis. I did not want Memora to just copy and paste old chat messages into a card. That would technically retrieve memory, but it would not make the memory useful. The harder problem was figuring out how to turn irrelevant conversation history into a new summary that gives the user the information they are looking for. For example, instead of returning things like "the user was building a project and kept debugging it," Memora should surface the actual decisions, problems, results, corrections, constraints, and current status that matter.

Accomplishments that we're proud of

I am most proud that I was able to take a problem I genuinely had, turn it into a product idea, and build something that actually solves it for me. I am also proud that I did not stop at implementing a basic retrieval system and putting a nice interface on top of it. I kept questioning the limitations of the architecture and building on top of it. The project grew from simple retrieval into a system with MemoryThreads, MemoryFacts, temporal reasoning, correction handling, synthesis, provenance, and explicit user control. Being able to take a concept like RAG, understand where it was not enough for the problem I wanted to solve, and develop a more complete architecture around it is probably what I am most proud of. Also building something that I would genuinely use personally, I managed to solve a problem I had faced numerous times and now I am extremely proud to have the solution and potentially help people who face the same problem by providing a solution.

What we learned

The biggest thing I learned was how to think about building a product from two perspectives at once: as the developer and as the user. Because Memora solves a problem I personally had, using it myself helped shape a lot of the product. Thinking like a user pushed me to make the memory more useful, the interface more interactive, and the setup and launching experience much simpler.

Technically, I also learned how to take the RAG concepts I had practiced in my courses and build a much more complete system around them, including retrieval, reranking, MemoryThreads, MemoryFacts, temporal reasoning, synthesis, a FastAPI backend, SQLite, and a Chrome extension.

What's next for Memora

The biggest next step for Memora would be making it something anyone can use, not just a local project that requires cloning a GitHub repository and running commands on a computer. I would like to move from a local only service toward a more accessible product while keeping the same focus on privacy and user control. I also want to make the setup experience much simpler where any ChatGPT user could download it and set it up with ease.

Built With

Share this project:

Updates