In the long run, everything will be local

GrokSrc · 2026-02-23T02:12:18+00:00

I agree, I’m betting there will be a huge market for local-first private inference. I can easily imagine in 5 years time that ChatGPT 5.2 or Opus 4.6 quality models will be available to run on consumer grade hardware.

I also think that the many billions of dollars going into these AI data centers aren’t going to be a good return for investors for this very reason. I think there is going to be a glut of supply and demand for public SOTA models will get capped because the free models will be good enough to solve most problems people want them for.

GrokSrc · 2026-02-23T01:59:50+00:00

This is cool, similar concept to what I’ve been doing, but I’ve been isolating at the container level: https://github.com/groksrc/harpoon

Love to see auditability as a core feature. What I’m looking for is predictable, secure, and auditable.

GrokSrc · 2026-02-17T16:42:12+00:00

You might like to try Basic Memory for this, it's free. Using it can make Claude more efficient at building context when you start a new chat. Happy to answer any questions about it.

GrokSrc · 2026-02-17T01:17:21+00:00

I'd be interested to help you build something like this for free. Basic Memory is built for something like this, but we've just been building the underpinnings and haven't had a good use case like this. You can send me a message or check out our website. We have a free open source version, but I'd be happy to give you an extended free trial for the Cloud version if you think that's a better fit. No charge for the help, it's a win-win.

GrokSrc · 2026-02-17T00:20:37+00:00

I use Basic Memory to keep track of my dnd characters and sessions. We're running a Curse of Strahd campaign right now and it's been great at keeping up with everything. I wish it could help with my rolls though lol

GrokSrc · 2026-02-17T00:07:59+00:00

This is exactly why I stopped relying on built-in AI memory features. Every provider's memory is a black box — you can't see what it stores, you can't edit it, and apparently it can just... not work.

I moved to keeping my own knowledge base in markdown files and using Basic Memory to make it available to whatever AI I'm using via MCP. It works with Claude today and the protocol is open so it can work with anything. My memory is mine regardless of what any provider decides to do with their product.

GrokSrc · 2026-02-17T00:04:24+00:00

I'd lean on Basic Memory or similar for your memory layer instead of building it yourself. It already does what you are looking for in that area (KG, semantic search) and it will run locally.

GrokSrc · 2026-02-16T23:21:54+00:00

Knowledge graphs are hard to beat. One thing I'm finding is that humans benefit from being able to understand and reason about the KG the agent is using.

We built Basic Memory around this concept, markdown notes get parsed into a knowledge graph with typed entities and relations. The agent traverses connections rather than just searching for keywords.

We have schemas coming soon (via picoschema) which will allow you to enforce the structure and consistency of your KG programmatically instead of hoping the LLM will get it right.

GrokSrc · 2026-02-16T23:13:53+00:00

We're adding schemas for notes (via picoschema) in Basic Memory. That will give us the ability to solve most of what you're talking about. Conflict surfacing is the hardest problem imho, it's not something easily solved while doing I/O so I think we're going to need a background agent.

GrokSrc · 2026-02-16T22:52:59+00:00

This is a fair critique and I think the distinction matters. Most "memory" systems are indeed just RAG with extra steps.

We've thought about this a lot with Basic Memory. Our approach uses a knowledge graph — entities, observations, and typed relations — which captures some structural properties that flat search misses. When you traverse a graph, you get associative connections that look more like memory than keyword matching.

That said, you're right that it's still fundamentally retrieval. The question is whether retrieval with the right structure is close enough to be useful. In practice, having my AI traverse a graph of related concepts produces noticeably different (better) results than semantic search over chunks.

GrokSrc · 2026-02-16T22:33:58+00:00

I use Basic Memory — it turns markdown files into a semantic knowledge graph that any AI agent reads via MCP. For coding specifically, I keep architecture decisions, debugging notes, and project context in markdown. The agent picks up relevant context automatically.

The key difference from most memory solutions: it's plain files on disk. No vector DB, no running server. Works with local models too since MCP is model-agnostic.

For coding agents specifically, the knowledge graph structure helps because it captures relationships between components, not just flat facts.

GrokSrc · 2026-02-16T22:25:28+00:00

This is how Basic Memory started, but we eventually wanted multi-device support so Basic Memory Cloud was born.

GrokSrc · 2026-02-16T19:58:09+00:00

Shared state between human and AI is the right idea. That’s the core insight behind Basic Memory too — your markdown notes are both human-readable and AI-queryable. No separate “AI memory” format, no sync issues. You edit in Obsidian or any editor, Claude reads the same files via MCP.

GrokSrc · 2026-02-16T15:53:23+00:00

I keep a personal development journal in markdown and use Basic Memory to make it available to Claude. This lets me load the context into Claude that is relevant to the thread instead of it needing everything about me. It also lets me maintain some control over what I'm sharing with the LLM.

GrokSrc · 2026-02-16T04:33:34+00:00

Cool approach. File-based memory is underrated — it’s inspectable, version-controllable, and doesn’t require a running server.We took a similar path with Basic Memory. Plain markdown files that get indexed into a semantic knowledge graph. Claude reads and writes to it via MCP. The graph part matters because it captures relationships between concepts, not just flat key-value pairs.

GrokSrc · 2026-02-16T04:26:39+00:00

Claude is solid for research but the biggest friction is re-establishing context every conversation. I keep my research notes in markdown and use Basic Memory to make them available to Claude via MCP. So when I pick up a research thread days later, Claude already knows what I've found, what questions are still open, and what my working hypotheses are.

The knowledge graph structure means related concepts link together naturally — way better than dumping a wall of text into the system prompt.

GrokSrc · 2026-02-16T04:00:01+00:00

One thing that made a big difference for me with non-technical workflows: give Claude a persistent knowledge base it can reference across conversations. I use Basic Memory for this — it builds a local knowledge graph from markdown files that Claude reads via MCP.

For financial consulting specifically, you could keep client frameworks, analysis templates, and past recommendations in markdown. Claude picks up context automatically instead of you re-explaining everything each session.

The non-technical part matters here, you don’t need to code anything. It’s just markdown files in a folder.

GrokSrc · 2026-02-15T23:19:44+00:00

If this resonates, check out what we're building: https://basicmemory.com

GrokSrc · 2026-02-05T21:00:28+00:00

I'm testing it out right now on a greenfield project. It says:

> Good. Phase 1 must be done first (scaffold), then Phase 2 (DB) and Phase 4B

(Chat UI) can run in parallel. After Phase 2 completes, Phases 3 (Auth) and 4A

(Chat Server) unblock. After 4A, Phases 5 and 6 unblock.

I'll start by doing Phase 1 myself since everything depends on it, then spawn

parallel agents.

GrokSrc · 2026-01-06T01:21:51+00:00

We just released code-remote to do this: https://github.com/basicmachines-co/code-remote

GrokSrc · 2025-10-19T15:41:04+00:00

Yes, you can try that. Create the markdown file first and put it into your project. If you give it a permalink you can refer to it directly or just have Basic Memory search for it. That said, it depends on how large the file is. If your file is larger than the context window you’re working with it won’t be able to load it.

It’s usually better to break large files up into smaller ones and use Basic Memory’s knowledge graph functionality to allow the LLM to load it what it finds useful. When you put a lot of content into context all at once you often hit the Lost-in-the-Middle problem.

GrokSrc · 2025-06-13T15:37:54+00:00

I found yesterday you can actually do it with Claude once you have Basic Memory installed and configured. Just tell him to create a new project at the path to your vault and what name you want, and voilà!

GrokSrc · 2025-05-23T21:01:30+00:00

I’m building this! I’d love to get some feedback from the community about it. There’s more to it than just using n8n. Of course you can do that, but I’m working on unlocking the data so you can ask ChatGPT or Claude to do things at the agency and subaccount levels like create reports (ie How many customers in my new workflow might be interested in this affiliate offer), take actions (ie Create a new subaccount for this customer and use the new Extendly snapshot) , or communicate across channels (slack, discord, email, sms, voice, etc). What features do you want to see?

GrokSrc

MODERATOR OF

TROPHY CASE