Please excuse my noob-ish, naïve question, but to what extent is the business of getting the LLM to actually consult memory a model-dependent thing? Do you have to introduce the tool and guide models with different language for different model families?
Looking at your tool descriptions (as wit the ones on the original post) I wonder if this something perhaps only current frontier models will do, but the systems themselves seem like they'd be even more useful for open weights models with shorter working contexts.
Since you built something on OKF, how would you contrast it with knowledge graph implementations? How do you manage the ontology of what to keep knowledge about? Any cases where traversal would have helped?
I have seen the value of recording past sessions but I am more skeptical of the value in recording facts, which may soon become stale, about a constantly changing code base. Got benchmarks?
Well, do you see the value of writing notes for yourself occasionally, even though they might soon become stale in your constantly changing environment? Yes, right?
Same principle. It's a good idea to have a schedule to clean them up periodically - an idea you can also put into a note.
Cool idea. Why is this beneficial over just using markdown files and allowing agents to grep for whatever they need? I've tried various MCP things in the past and I've found they tend to slow down the agent and waste tokens more than they end up helping, but a better memory system is 100% needed for agents.
for one, the mcp-server architecture makes it usable from claude.ai and other surfaces where you have mcp but no filesystem. there are claude-specific workarounds (workspaces) but you lose portability across systems.
Hmm, ok. I guess I rarely use the web interface and everything that I have agents record as "memory" in markdown is always accessible locally. If I'm accessing something remotely, I use the ChatGPT app with remote which connects directly to the host computer.
The memories are stored as OKF (Open Knowledge Format), which is markdown + frontmatter (+ constraints/schema imposed thereon).
Having an inverted index (as with FTS5) is useful in that, for a basic single-term lookup, you reduce a sequential scan, O(N), down to O(log N). For small N, the performance difference might not be meaningful. Performance gap widens with more sophisticated queries (boolean operators, ranking, etc).
I'm not sure I follow. Are you suggesting that full text search systems are ultimately a convoluted way of performing O(N) regex searches? If not, I don't see how you arrive at the conclusion that this is "the same as grep in a memory/ directory".
agree there are a lot of these but they're all pretty simple (including mine [0]) so I think building your own and playing around with architecture is useful and fun.
For those looking for similar tools, there is also https://markbase.cloud/ as a hosted service. (Disclaimer: we built it for internal use first and would like to open source with the community help as we don’t have much experience in OSS maintenance)
rcarmo | 3 hours ago
dofm | 2 hours ago
Looking at your tool descriptions (as wit the ones on the original post) I wonder if this something perhaps only current frontier models will do, but the systems themselves seem like they'd be even more useful for open weights models with shorter working contexts.
ejp | 2 hours ago
esafak | 2 hours ago
sho | 2 hours ago
Same principle. It's a good idea to have a schedule to clean them up periodically - an idea you can also put into a note.
FitchApps | 2 hours ago
[OP] pcbmaker20 | 2 hours ago
clemens1010 | 2 hours ago
rgbrgb | an hour ago
I'm guessing having a portable memory that's comparable with first party memory is the goal.
jrflo | 2 hours ago
rgbrgb | an hour ago
jrflo | an hour ago
agentifysh | an hour ago
i can see for public facing deployments agent memory like this could result in faster roundtrips.
cstrahan | 28 minutes ago
Having an inverted index (as with FTS5) is useful in that, for a basic single-term lookup, you reduce a sequential scan, O(N), down to O(log N). For small N, the performance difference might not be meaningful. Performance gap widens with more sophisticated queries (boolean operators, ranking, etc).
bearjaws | 2 hours ago
cstrahan | 24 minutes ago
myshapeprotocol | 2 hours ago
healthycoder | an hour ago
rgbrgb | an hour ago
[0]: https://setoku.com
0c3ca83 | an hour ago
ksajadi | 57 minutes ago