←back to thread

111 points Manik_agg | 2 comments | | HN request time: 0.611s | source

I keep running in the same problem of each AI app “remembers” me in its own silo. ChatGPT knows my project details, Cursor forgets them, Claude starts from zero… so I end up re-explaining myself dozens of times a day across these apps.

The deeper problem

1. Not portable – context is vendor-locked; nothing travels across tools.

2. Not relational – most memory systems store only the latest fact (“sticky notes”) with no history or provenance.

3. Not yours – your AI memory is sensitive first-party data, yet you have no control over where it lives or how it’s queried.

Demo video: https://youtu.be/iANZ32dnK60

Repo: https://github.com/RedPlanetHQ/core

What we built

- CORE (Context Oriented Relational Engine): An open source, shareable knowledge graph (your memory vault) that lets any LLM (ChatGPT, Cursor, Claude, SOL, etc.) share and query the same persistent context.

- Temporal + relational: Every fact gets a full version history (who, when, why), and nothing is wiped out when you change it—just timestamped and retired.

- Local-first or hosted: Run it offline in Docker, or use our hosted instance. You choose which memories sync and which stay private.

Try it

- Hosted free tier (HN launch): https://core.heysol.ai

- Docs: https://docs.heysol.ai/core/overview

Show context
lukev ◴[] No.44438615[source]
So, this is cool and a per-user memory is obviously relevant for effective LLM use. And major props for the temporal focus.

However, keeping a tight, constrained context turns out to actually be pretty important for correct LLM results (https://www.dbreunig.com/2025/06/22/how-contexts-fail-and-ho...).

Do you have a take on how we reconcile the tension between these objectives? How to make sure the model has access to relevant info, while explicitly excluding irrelevant or confounding factors from the context?

replies(1): >>44439269 #
Manoj58 ◴[] No.44439269[source]
hey, thanks for the article reference. i read it.

that's the exact problem we've been solving! Context bloat vs. memory depth is the core challenge.

our approach tackles this by being selective, not comprehensive. We don't dump everything into context - instead, we:

- use graph structure to identify truly relevant facts (not just keyword matches) - leverage temporal tracking to prioritize current information and filter out outdated beliefs - structure memories as discrete statements that can be included/excluded individually the big advantage? Instead of retrieving entire conversations or documents, we can pull just the specific facts and relevant episodes needed for a given query.

it's like having a good assistant who knows when to remind you about something relevant without overwhelming you with every tangentially related memory.

the graph structure also gives users more transparency - they can see exactly which memories are influencing responses and why, rather than a black-box retrieval system.

ps: one of the authors of CORE

replies(2): >>44439939 #>>44471383 #
1. stingraycharles ◴[] No.44439939[source]
One of the challenges I was facing with other memory MCP servers is to get the LLM clients to actually use it to recall relevant information when they need it. Implementing to MCP tools is one thing, getting LLM clients to invoke them at the right time is another.

How do you solve that problem?

replies(1): >>44439985 #
2. harshithmul ◴[] No.44439985[source]
We faced the same challenge while building SOL (https://github.com/RedPlanetHQ/sol) — a personal assistant that relies heavily on memory for context and continuity.

Getting LLMs to invoke memory tools at the right time is definitely trickier than just wiring up MCP correctly. We're still refining it, but we've made good progress by explicitly guiding the assistant within the system prompt on when and how to use memory.

You can see an example of how we structure this in SOL here: Prompt instructions for memory usage (https://github.com/RedPlanetHQ/sol/blob/964ed23c885910e040bd...)

Using something on similar lines as rules in claude/cursor etc has been working better. It’s not perfect yet, but this combination of prompt engineering and structured tool exposure has been moving us in the right direction.

ps - one of the authors of CORE