Memora

• 

• 

• 

Inspiration

We often remember important things in the moment, but forget them later: where we put something, who borrowed something from us, what we promised someone, or when we last did something.

Traditional note-taking apps require us to decide what to write, how to organize it, and where to find it later. We wanted to make remembering much more natural.

That led to Memora — a personal memory assistant where you can simply describe something in your own words and let AI understand what is worth remembering.

What it does

Memora turns natural-language statements into structured memories.

You can tell it things like:

"I gave David my charger and he said he'll return it tomorrow."

Memora understands that this is something borrowed, extracts useful information such as the person and item, resolves the relative date, and stores it as a searchable memory.

Memories are organized into different types, including Borrowed, Stored, Last Done, and Promised.

You can then browse your memories, filter and search them, open individual memories for more details, mark applicable memories as completed, or simply ask Memora questions such as:

"Who has my charger?"

or

"What did I promise Mum?"

Instead of returning only a list of database matches, Memora uses AI to turn the retrieved memories into a natural-language answer while still showing the relevant memories behind that answer.

How we built it

Memora is built with React and TypeScript on the frontend and NestJS, Prisma, and PostgreSQL on the backend.

The AI layer uses OpenRouter, allowing the underlying model to be changed through configuration rather than coupling the application to a specific provider or model.

We designed the AI integration around structured JSON outputs rather than allowing model responses to directly control the application. AI-generated interpretations pass through validation before they can reach the persistence layer.

The system also provides the AI with an explicit reference time so expressions such as "tomorrow", "yesterday", or "next Friday" can be resolved deterministically.

For natural-language questions, Memora separates the process into two stages: understanding the user's intent and query, then generating a concise answer from the memories retrieved from the database.

The frontend was deliberately kept simple: a focused Remember experience, a searchable Memories view, and an Ask interface for natural-language retrieval.

Challenges we ran into

One of the biggest challenges was making the AI reliable enough to be part of an application rather than just a chatbot.

Models sometimes produced outputs that were technically valid JSON but did not follow the expected structure. We therefore built validation boundaries around the AI layer and treated malformed or ambiguous interpretations separately from infrastructure failures.

Dates were another challenge. Natural-language expressions such as "Friday", "tomorrow", and "next Friday" can be surprisingly ambiguous. We added explicit rules around reference time and relative dates to make the interpretation more consistent.

We also had to distinguish between similar concepts. For example, "I gave David my laptop and he will return it Friday" represents something borrowed, while "I promised David I would call him Friday" represents a promise. Getting these distinctions right was important for making later questions useful.

Finally, we learned that a technically functional interface isn't necessarily a good product experience. We iterated on the UI to make information easier to scan without adding unnecessary complexity.

Accomplishments that we're proud of

We're proud that Memora can take an ordinary sentence and turn it into a structured memory without requiring the user to fill out forms or manually categorize anything.

We're also proud of the separation between the AI layer and the rest of the application. The system doesn't blindly trust model output; interpretations are validated before they are persisted.

Another accomplishment was building natural-language retrieval that goes beyond simply searching for matching words. Memora can understand questions such as "who has my charger?" and produce an answer based on the relevant memories.

Most importantly, we built the project around a simple interaction: say what you want to remember, and later ask for it naturally.

What we learned

We learned that integrating AI into an application is much more than sending prompts to an LLM.

Reliable AI features need clear contracts, validation, controlled inputs, deterministic application logic, and good handling of failure cases. We also learned that model output should be treated as untrusted input rather than application truth.

We learned how much natural-language date interpretation can affect the usefulness of a memory system, and how important it is to give models the right context instead of relying on their assumptions.

Finally, we learned that good UX doesn't necessarily mean adding more features. A small number of well-designed interactions can make an AI product feel much more natural and approachable.

What's next for Memora

The next step would be making Memora more useful as a long-term personal memory system.

Potential improvements include smarter memory organization, better handling of relationships between memories, more sophisticated retrieval across different types of memories, reminders for important upcoming commitments, and continued improvements to the AI's accuracy and consistency.

The architecture was intentionally designed so that the underlying AI model can also be changed as better models become available, without having to redesign the rest of the application.

Built With

• gpt
• nest.js
• node.js
• react
• typescript