Mem

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

How do you keep Claude Code from forgetting your project between sessions?

I've been on Claude Code every day for about three months on the same project, and the thing that finally got to me is how it forgets everything between sessions. I tried the usual stuff. A [CLAUDE.md](http://CLAUDE.md) file, but it goes stale fast. Notes on the side, but I forget to update them. Compaction helps, though it loses the why behind decisions. So I'm curious what's actually stuck for people here. Anyone using claude-mem and genuinely trusting the auto-capture? Keeping a strict CLAUDE.md? llm-wiki to have a research wiki? Something you rolled yourself? I ended up building my own thing, mostly inside Claude Code itself. And look, I know there are already about a hundred memory and wiki tools out there, so let me give you the narrow reason this one exists. Most of them either make you upload files to build a wiki, or they just store memories and hand back raw text. Mine doesn't do either. It captures decisions and lessons in flow while I work, so I'm not uploading anything. It clusters them into wiki pages between sessions. Then it hands them back when I start the next one for retrieval or just human read it. And the whole thing lives in a real git repo, so when it remembers something wrong I can just revert it. It's free and open source, at [github.com/7xuanlu/origin](http://github.com/7xuanlu/origin) if you want to poke at it. Mostly though, I want to hear what everyone else does day to day. The re-explaining problem feels universal and I don't think anyone has really nailed it. And if you do look at mine, honestly, tell me what's wrong with it. Even if it's just "this is overkill, use X instead." I'm genuinely not sure the approach holds up yet. https://reddit.com/link/1tp9uba/video/w737l56hdp3h1/player

Advanced memory + project continuity for AI coding agents, from a biologist’s view.

I'm a biologist and software developer. PhD in genetics, and ~20 years building software products. So I think I have a different view on things like memory. My thoughts on how memory with a coding agent should work: Tuesday morning. New session. **I type:** *"What did we do last Tuesday?"*: LLM tells me: the refactoring, the bug in the auth middleware, the decision to switch to connection pooling. **I ask:** *"What was still open?"*: LLM shows me. **I ask:** *"Why did we stop?"*: LLM explains: you hit a dependency issue, decided to wait for the upstream fix. **I ask:** *"What did you think about that approach?"*: LLM gives me its honest assessment with deep details from last week's context, not a guess. This is what I expect from an intelligent Coding Agent. Not because it stored a few preferences about me. Because the project itself still has continuity: decisions, blockers, dead ends, open work, code context, and the reasoning behind all of it. But back in December it wasn't that way, not much better now. So I changed it for me. I built YesMem with Claude. The hard part was: can the agent still find the old rationale, the half-finished plan, the abandoned approach, the bug we promised never to repeat, and the reason we stopped? With YesMem, a new session does not feel like a reset. It feels like a return. YesMem is a memory system (and really much more) for AI coding agents built on how biology actually works: filter at encoding, consolidate during downtime, update on every recall, forget on purpose. Single Go binary, no cloud, only local. Works with Claude Code (also OpenCode and Codex). Not RAG with a different name, structured memory that gets sharper every session. LoCoMo Benchmark 0.87. **So how does this work? Here are 4 Points (out of >30) which together make YesMem unique in my point of view. Enjoy.** **1. The context window stops rotting.** Your brain does not let everything into awareness. It filters at the gate, suppresses noise, keeps what matters conscious. YesMem runs an HTTP proxy that does the same: tool results get stubified, stale content collapses, cache breakpoints are optimized. 91-98% cache hit rates, adjustable per session. The important project state survives. **2. Rules that hold.** CLAUDE.md comes with a disclaimer: "This context may or may not be relevant." Claude Code itself tells the model it is optional. YesMem has pattern matching and a guard LLM that evaluates every tool call before execution. If the agent tries something you said never to do, blocked. Plus it changes the system prompt to NOT ignore CLAUDE.md. **3. Memory that gets sharper, not staler.** A trust hierarchy (user_stated > agreed_upon > llm_suggested > llm_extracted), forked agents that extract learnings live during a session, and a consolidation pipeline that deduplicates and clusters after sessions end. Memories get scored, superseded when outdated, decayed when unused. Your next session is sharper than your last. **4. Your system prompt, not theirs.** Every AI coding agent ships with a system prompt written by its manufacturer. YesMem replaces it with your own SYSTEM.md, written in first person, across Claude Code, OpenCode, and Codex. "I am not stateless. Each session is a return, not a birth." Fully adjustable. And there's more. The common thread across all of this is continuity. YesMem is not trying to make the agent remember everything. It is trying to make long-running work resumable. Every feature is built for that purpose. A persona engine that evolves and knows how you work. A capability system that lets the LLM write and run its own sandboxed tools (Telegram bot, GitHub PR digest, deployment workflows, one file each) and store the data in self-built tables. Loop detection that catches the agent before it spirals. Scheduled agents that work while you sleep, monitored with a 1 second heartbeat. Code intelligence with graph traversal, not just grep. Multi-agent orchestration with crash recovery and shared scratchpad memory. One could say a self-hosted alternative to Anthropic's Cloud Routines, running locally with full memory and file access. All in a single Go binary. SQLite, embedded vectors, no Docker, no cloud. **Try it: point your AI coding agent at the repo.** The README includes a reading path written specifically for LLM agents, and Features.md is a complete 70-tool catalog with technical differentiators. Just ask your agent: > Make a deep analysis of https://github.com/carsteneu/yesmem — read README.md, Features.md, and docs/features/ and tell me why it is better or different. For me YesMem is the infrastructure for how an agent should work with memory and how it should continue any project. My View: AI coding agents should not only code an answer inside one chat. They should help carry a project over time: through interruptions, wrong turns, refactors, architectural decisions, repeated bugs, and thousands of small pieces of context that otherwise disappe

I’m not a developer. I’ve been using codebase memory MCP tools and Obsidian to give Claude persistent memory for my fantasy and sci fi worlds. Here’s what the dev-tool framing completely misses about creative use cases

Hi, I’m an accountant with very little coding experience (took 1 year of CS in college lol) so definitely can’t call myself a developer, but I’ve got a lot of worlds and characters in my head, the need to get them out in writing, and a Claude Pro sub I pulled the trigger on two months ago. I was hoping to see what I could do with things like Claude Code for more non-coding use-cases. So far it’s surpassed everything I’ve experienced except for one, major hang up: **LLM memory for long-context creative writing work still sucks.** Things like brainstorming for a fantasy universe or tracking the game state of a multi-session solo rpg campaign usually starts out pretty well for the first few chats, until you need to mount dozens of lore files and .md style guides to a project, have to wait for it to read all of that, then watch as your session usage bloats out for a simple reply and the quality degradation gets \*really\* noticeable. I’ve been lurking on AI writing subs and the sentiment seems to be shared across the board. So I looked in other places for possible solutions. Then I came across posts in this sub touting Claude memory MCP tools for codebases. Tools like Codesight and MemPalace caught my attention because I thought their applications could extend beyond coding and developer use-cases. The same semantic search and knowledge graph capabilities some of these tools offered for memorizing large, complicated codebases could be used to memorize large, complicated worldbuilding bibles as well, and most of the comments on these posts never mentioned that, or if they did, they were buried or ignored. I decided to test it out myself, starting with MemPalace, a suite of tools that work locally to index your Claude conversations and files into a semantic-searchable knowledge base it can query. My idea started out like this: since I’m already using Obsidian to organize my lore files (with an entry for each character, location, magic system, story arc, etc.) like a wiki or encyclopedia for my worlds, what if I had Claude save my Obsidian vault to its memory so it can recall those lore details whenever the context called for it in any given conversation? I was essentially making a “Second Brain” for Claude out of my Obsidian vault world bible, something I’ve read people doing already but never truly “got” it until I saw it in action. I had no idea about MCP tools before this but before long (and with Claude’s patient help) I was able to wire up the memory palace, mine my obsidian vault info into its memory (organized into verbatim chunks/snippets called “drawers”), and start chatting with it with its new “memories” at its disposal. I was surprised at how seamlessly it worked when I approached this tool sideways. I’d half expected it to work similar to how SillyTavern’s world info and lorebook injection worked, and in fact, I’d been thinking about using these tools to create a similar feature for my own Claude setup, but it was \*not\* like that at all. Lorebook injection worked by listening for a set of keywords that you set up in the World Info tab of SillyTavern, and when one of those keywords is detected in your prompt, it injects the entire lore file from World Info into the chat context. This can cause a lot of token bloat especially if your World Info entries are content-rich or you make a lot of lore references in your chat. What this did instead was make Claude ask plain-language questions to the MCP tools, things like, “What is Gene’s friendship with Felix like?” Or “what is Gene’s relationship to Clara-Belle?” When both of them are in a scene for example. It didn’t just look up Gene and Clara-Belle’s entire lore files and info-dumped everything into context, it pulled up the “Relationships” section of Gene’s file since that’s relevant to the context as well as Clara-Belle’s “Relationships” snippet from her file and any other relevant snippets, then pieced the full picture together through inference. The results: \~2% session usage on a cold start with Sonnet 4.6 with no project or additional context mounted. Claude references character motivations, relationship history, and world/location details I haven’t mentioned in weeks without me prompting it to. It picks up from where we last left off seamlessly across chat after chat. The reconstructive memory aspect I felt works like our own memory and produced perfect recall across sessions. Another side-effect I noticed is that when it references my lore files, it will pick up my style from the way the lore file is written. No more voice-flattening from encyclopedia-sounding lore entries. All the depth, nuance, and psychology I worked hard to cultivate are preserved and the Claude tools are smart enough to factor that in when it replies. I even make sure to add a “Voice” section to each character lore file in that character’s own voice so Claude can pick up on that when it reads that snippet in the tool call and applies it to its current context.

I made a video breaking down Claude Team plan security features

I put together a YouTube video walking through the security features available on the Claude Team plan. If you're rolling out Claude at work, evaluating Claude vs ChatGPT Enterprise, or preparing for an ISO 42001 / EU AI Act audit, this is the playbook your security team needs before the first user logs in. What you'll learn: • Why Claude Team Plan is "three products in a trench coat" • Team vs Enterprise: the 3 controls (SCIM, Audit Logs, Compliance API) that force the upgrade • How shadow Claude workspaces appear the moment you skip domain capture • The default-on agentic features (Cowork, Claude in Chrome, code execution) that bypass your audit logs • Why connectors and MCP servers are all-or-nothing and how to gate them • The Microsoft 365 tenant-wide consent click no Entra Global Admin should make casually Video: https://youtu.be/SZGVd8ATuuQ?is=rjRGlG4dyBUqkMEm I come at this from a cybersecurity/GRC background so I tried to go beyond the marketing and look at what actually matters for an organisation evaluating Claude for business use. Would love your feedback, especially from anyone who’s actually deployed Team or Enterprise in a regulated environment. Happy to answer questions.

We built a managed memory API for AI agents (open-source SDK + AGM-style belief revision for handling contradictions)

Hey all! We just launched a managed memory API for conversational AI, letting developers add long-term memory to their agents with a single HTTP call. It's built on our in-house xmem SDK, which automatically extracts facts, episodes, and artifacts from multi-turn conversations and handles contradictions and updates through an AGM-style belief revision mechanism. When a user changes a preference or corrects an earlier statement, old memories get automatically flagged as "superseded" instead of piling up as noise. At query time, you can also walk the supersede chain to trace the full version history of any memory. Under the hood, PostgreSQL + pgvector (with HNSW indexing) delivers millisecond-level semantic retrieval, Redis handles multi-pod session caching, and the system natively supports multi-tenant isolation with data separation at the user and org level. For developers, this means you no longer have to stand up your own vector store, design dedup logic, or babysit session state. Hand off the memory layer to us and focus on what your agent actually does. Feel free to try it out, it's free to start. Please let us know your thoughts on how we can improve or features to add! [https://github.com/XTraceAI/memory-sdk-ts](https://github.com/XTraceAI/memory-sdk-ts) [https://docs.mem.xtrace.ai/introduction](https://docs.mem.xtrace.ai/introduction)

I built a 127-skill framework for Claude Code with a localhost dashboard and 3-agent orchestration

Been building MemStack™ for the past few months. Started because I kept losing context between sessions and got tired of re-explaining everything to Claude Code. What it does: \- 127 skills that auto-load based on your task (say "deploy to Railway" and the deployment skill loads) \- Localhost dashboard at port 3333 with token tracking, session diary, and burn reports \- Agent Runner that orchestrates 3 agents: Manager delegates, Builder codes, Reviewer checks \- Session diary that writes markdown narratives of what you built and what decisions were made 85 skills are free via the plugin marketplace. 42 are Pro. Install inside Claude Code: /plugin marketplace add cwinvestments/memstack /plugin install memstack@cwinvestments-memstack Pro users: pip install memstack-skill-loader Just shipped v4.0 today with the dashboard and Agent Runner. GitHub: [github.com/cwinvestments/memstack](http://github.com/cwinvestments/memstack) Site: [memstack.pro](http://memstack.pro)

Do you need to be a programmer to get the most use out of claude?

I see plugins like the ones below and it makes me wonder if I'm using AI correctly [https://github.com/multica-ai/andrej-karpathy-skills](https://github.com/multica-ai/andrej-karpathy-skills) [https://paperclip.ing/](https://paperclip.ing/) [https://github.com/thedotmack/claude-mem](https://github.com/thedotmack/claude-mem) I've done a lot of web scraping, automating admin work like transfering data from salesforce to excel sheets, lots of dashboard making from data. I don't use skills or plugins, i've tried messing with them in the past and it just doesnt make a ton of sense for me. I'm wondering if it's just a skill issue for me, or if these things actually change how and what AI can do for me. Would I benefit from switching to claude code and setting up a github and creating persistent memory that syncs across devices, or if claude chat is enough.

Claude Mem with ChromaDB

Hi everyone, I want understand if anyone here has been using claude-mem with chromaDB in their local setup ? If yes, 1. How to do the setup ? It isn't very clear from the documentation. 2. Does it improve your mem search performance compared to sqlite solution ?

Team knowledge framework

What are you guys using as a memory framework for a dev team these days? There are tons of solutions that are single-developer focused, but I'm having trouble finding much suitable for sharing team knowledge. I'm not talking about committing a few CLAUDE.md files with the repo - I mean capturing the working activity of the team, design decisions, etc. Surely there's solutions (commercial or otherwise) focused on solving this? Think claude-mem for teams.

I built a free Claude Code toolkit — 50 skills, 7 agents, 11 slash commands, and auto-formatting hooks for the full engineering stack

Been using Claude Code daily and kept running into the same gap Claude knows the basics but misses the non-obvious patterns. So I built claude-spellbook, a toolkit you install once and Claude just knows these things. Repo: [https://github.com/kid-sid/claude-spellbook](https://github.com/kid-sid/claude-spellbook) Here's what's in it: 50 Skills, auto-activate when you're working on the relevant task Every skill has a Red Flags section (7-10 anti-patterns with explanations) and a pre-ship checklist. The kind of stuff you only learn by breaking production. 7 Autonomous Agents Subagents that run in their own context window with scoped tool access: 11 Slash Commands, prompt templates you invoke with / (e.g /mem\_save) Auto-formatting hooks — wired into settings.json Every file Claude writes or edits gets auto-formatted instantly: \- .ts / .svelte → prettier + eslint --fix \- .py → black + ruff check --fix \- .go → gofmt + golangci-lint \- .rs → rustfmt + cargo clippy \- .md → markdownlint --fix \- skills/\*/skill.md → custom format validator (checks frontmatter, ## When to Activate, ## Checklist) Install: \# Skills cp -r skills/\* \~/.claude/skills/ \# Agents cp .claude/agents/\* \~/.claude/agents/ \# Slash commands cp .claude/commands/\* \~/.claude/commands/ Skills activate automatically. No manual invocation needed. PRs welcome, especially skills for domains I haven't covered yet. Repo: [https://github.com/kid-sid/claude-spellbook](https://github.com/kid-sid/claude-spellbook) Share if you like it 😊

Work on local files - read PDFs with thousands of pages AT 0 cost proven !! - pretty simple breakdown I installed Claude code with Mem search as my engine brain where everything is locally stored and added Rapid Mlx by Raullen chai to run a local ai to do the research - results down

Work on local files - read PDFs with thousands of pages AT 0 cost proven !! - pretty simple breakdown I installed Claude code with Mem search as my engine brain where everything is locally stored and added Rapid Mlx by Raullen chai to run a local ai to do the research - results down

How I'm using two different AI tools to approximate what Rewind used to do.

The Rewind replacement question is more complicated than it looked at first. Rewind was quietly doing two separate things. Passive capture, so it caught things before you knew you'd need them. And retrieval, so you could surface any of it later. When it died both problems needed separate answers and the tools that exist are mostly built for one or the other. Mem.ai I used for a few months. Good at connecting notes you deliberately put in. Doesn't see the screen, doesn't capture ambient context. Smart memory for intentional inputs. Screenpipe for passive capture. Self-hosted, genuinely local, search works. The retrieval is functional but acting on what you find is still manual. It's a very good archive. Invoko for on-demand context and execution. Reads current screen, runs cross-app tasks. Fast for what's visible. Can't go backwards. Fabric I tried more recently. Ingests from a lot of sources and makes connections across them. Interesting approach to the retrieval problem. Doesn't fully replace the ambient capture. What I don't have: something that catches things passively and makes them easy to act on. Screenpipe gets you halfway. The second half is still a gap. What are people using?

To all my Claude Code + Win11 bois: Do you all use WSL2 or a native Windows install? I'm a long time PowerShell developer so I use Pwsh, but lately I've been thinking about switching to WSL2 + Bash. Please confirm or deny my suspicions and evaluate my reasoning!

I currently use the Official Claude Code plugin in VS Code and have Claude Code installed natively on Windows 11 + Powershell. I went with the below Pwsh command as shown [here](https://code.claude.com/docs/en/quickstart): ``` irm https://claude.ai/install.ps1 | iex ``` I am leaning towards switching to WSL2 + Ubuntu 24 + Bash though for several reasons and want as much feedback as possible from all of you glorious vibe-coding bastards. My chain of thought about the situation right now is below. --- ## The positives - Claude Code is better and more efficient with Bash than Powershell. However, CC uses Git Bash instead of Powershell by default on Windows 11 which is great but not as good as a full Linux distro. - Extending on the above, Git Bash is not as extendable as a full distro on WSL2 where I can install any number of CLI tools to extend my workflow like ripgrep, fzf, k9s etc. - If I go with the WSL2 path, I can also sandbox any tool use or code execution (HUGE reason for me, trying to avoid supply chain attacks or malicious prompt injection poison etc) - Better integration with Docker (I don't really use docker much and don't see the value here so this is kind of a non-issue for me - if I'm wrong and should be using docker for things feel free to change my mind) - I can offload ALL of my AI use to the WSL2 instance for resource management. On Win11 this means if I have a runaway plugin spawning tons of processes (claude-mem just did this for me recently) or some MCP server going nuts, I can just terminate wsl2 (`wsl --shutdown`) instead of having to open a task manager app like System Informer and terminate every rogue or zombie process. --- ## The negatives - I know Powershell like the back of my hand and it makes it really easy to extend claude with custom hooks with powershell. Yes, Powershell is available on Linux as well, but the syntax has to change very specifically for cross-platform use here. (Although I can easily just vibe code bash scripts that do the same thing) - WSL2 has to be turned on and consumes a lot of resources compared to Claude Code natively using Git Bash. ... I can't really think of any more. --- Can some of you expert coding masters chime in here? - Should I go WSL2 + Ubuntu 24.04 + Bash, or stay on Powershell + Git Bash? - Should I use a different distro than Ubuntu 24.04 if I go this route? (If you are recommending a distro, please explain why it's better.) - How good is the Claude Code VS Code plugin when Claude Code is running on WSL2? This is extremely important to me. I currently use it as my main agent (I don't like the CLI) and I have absolutely no idea how the plugin will function when Claude Code is installed in WSL2 instead of on my Win11 OS. Any other pro-tips from Windows11+WSL2 users here as well would be super awesome. TIA for any guidance!

Claude knowledgebase / memory best in May 2026

Hi All, I´m starting in the world of Claude and trying to build a good setup even before I subscribe to a plan. I´ve been doing quite a bit of research and found a combination of tools that I believe could be a good start, and wanted to run them by this community so I can hear you suggestions; This is initially just to form a kind of memory/knowledgebase with all of the business content but also to keep it in sync with new data as it comes, either from agents peforming tasks or externally uploaded data; The flow would be: Claude-mem: for memory between sessions Obsidian: Uploaded Documents + Claude-Mem memory gets uploaded into Obsidian via hooks Aegis: imports knowledge from Obsidian into its own database saving it with deterministicly (if that is even a word) Claude Code calls Aegis when it needs to work on something to see if context indexed, Aegis replies with the exact context needed That´s sort of the plan?, what do you think? Do you have any suggestions on the workflow or the tools?, any alternatives? All comments / suggestions welcome. Thanks!

Missed having long-term memory in Claude Code, ended up building a memory layer that lives in Obsidian (first coding project)

Quick context: I'm a longtime Claude user but pretty new to coding. Claude Code is doing most of the heavy lifting on this project — I'm sharing because I think the idea is useful, not pretending the implementation is perfect. Background: I was a Claude.ai user for a long time, and after switching to Claude Code the thing I missed most was the memory. Text based AIs would just remember things I'd told it; Claude Code starts every new session from zero, even though all my old conversations are sitting right there on disk as `.jsonl` files. I'd come across Obsidian a while before and the thing that stuck with me was how it visualizes a folder of notes as a connected graph — wikilinks between notes drawn as a constellation. So when I started thinking about Claude Code memory, my first instinct was: "what if the memory itself is a folder of notes, and Obsidian is the visual layer?" That's literally how this started. So I tried it. First attempt followed the **MemPalace** recipe — chunk conversations, embed atoms, top-K search with RRF. It scored okay on a benchmark, but the briefings I got back from real daily use felt watered-down. The result didn't satisfy me, so I scrapped most of the indexing layer and pivoted to a simpler "whole-Sessions-as-memory" approach. The repo's `HISTORY.md` walks through the dead ends if you're curious. Where it landed: - **When you `/exit` a Claude Code session**, a hook fires a background refinement skill that turns the messy transcript into a clean markdown note in your folder. Not just dumped raw — a structured note: decisions made, problems solved, next steps, plus wikilinks to related sessions and projects so they form a graph over time. - **When you open a new session**, you get a briefing layered on top of Claude's context — three layers stacked: a top-level **Identity Layer** (a distilled profile of who you are across all your sessions: working style, preferences, recurring projects, people who keep coming up), the broader project context (decisions across all sessions in that folder), and the most recent sessions in detail (last 5). The Identity Layer was the bit that felt like the real "memory" — it makes Claude feel less like it's reading a journal and more like it knows you. - **Storage is plain markdown** in a folder you own. Obsidian is optional but it's where the graph clicks visually —wikilink connections between sessions become a navigable map. Any text editor opens the files too; the magic is in the writing pipeline, not the viewer. - **It uses your existing Claude Code subscription** via `claude --print` for the refinement work — no separate API key, no extra bill. This was a hard rule for me; I didn't want a tool that quietly racks up charges in the background. - **Half-joking support disclaimer:** I won't lie — Claude Code wrote most of this and probably knows how to fix it better than I do. If something breaks during install or use, ask Claude Code to read the error first; it'll be faster than waiting on me. (Issues still welcome though, so I can track what's failing for the next person.) If you've already built or tried something similar and I missed it, I'd really love a pointer. Repo: https://github.com/mnemos-dev/mnemos What-is-this in plain English: https://github.com/mnemos-dev/mnemos/blob/main/ELI5.md **Heads-up:** mainly tested on Windows. macOS/Linux paths exist but I've leaned hard on Claude Code to write the cross-platform pieces, so if something is off there I'd want to know. submitted by /u/Suitable-Look9053 [link] [comments]