Claude Memory Analysis: How to See What Your AI Remembers and Find the Gaps in Its Memory

If you use AI like Claude, then you probably know that it remembers everything. And this memory is then used to provide better responses to you. However, the problem is that you don't really see the structure of this memory. And more importantly, you also don't see the gaps in it. So you never know whether the responses that you're going to get from this memory are actually going to be relevant to the task that you're working on.

You can solve this problem by using an analytical layer on top of your memory. So instead of looking at those memory snippets as text, you see them as a graph where you can see the structure of this memory. You get a peek inside the model's brain. You see the main topical clusters of this memory, and you can also look at the gaps and see what's missing. Then you can give instructions to whatever memory agent you're using, whether it's Claude's native memory, or some additional layer like Mem0 or claude-mem, using the insights that you get from this graph. Below I show how it works on two real cases: my Claude app memory, and the Mem0 memory of a project I'm working on, analyzed through the InfraNodus MCP server.

Watch the video walkthrough

The same two use cases, recorded live: the Claude app memory export in the InfraNodus web app, then the Mem0 memories analyzed from Claude Code through the MCP server.

Why You Should Check What Your AI Remembers

Whatever is in the memory gets added to the context of every session, and the model then gives you the most probable answer from that context. So if one topic takes over the memory, the answers go there too. If the memory is full of status messages like "files remain uncommitted", the decisions you actually wanted it to remember get lost. And if two important topics are in the memory but not connected, the model will not connect them for you either.

So more memory is not better memory. When I look at a memory graph, I want to know a few things. What are the main topics? What is just noise? Which smaller clusters are underdeveloped? And what is missing between them? You can't really get that from a list of memories. You can get it from a graph, because you see the structure right away.

If you want to go deeper into why the memory that's injected into every session should be visible, see the AI memory stack. And for why similarity search keeps giving you back what you already said, see RAG vs LLM Wiki vs knowledge graph.

Where Your AI Memories Are Stored

So, first of all, where are those memories stored? If you use Claude, you probably have memory in up to three places:

You can look through all of them. But it's quite difficult to get the gist of what those memories are about, and none of them shows you the gaps. Claude Code memory covers the Claude Code files in detail, and the agent memory tools comparison covers Mem0, Zep, Letta, Cognee, Supermemory and the native Claude and ChatGPT memory. If you keep your notes in an Obsidian vault and use it as memory, the first use case works for it too, because it's also a folder of Markdown files.

Use Case 1: Finding Gaps in My Claude App Memory to Improve It

1. Export the memory

If you're using Claude desktop or Claude web, you can go to your user and then settings. When you click on memory, you can actually see a list of all the memories that Claude has of you. They are categorized by topics, areas, people you're working with, and projects. And you can export those memories. They will be downloaded as a set of Markdown files, and you can look through them. You can even give them back to Claude and ask it to analyze them. But then you get the most probable summary, not the structure, and you can't check it.

2. Import the files into InfraNodus

It's actually very simple to import them into InfraNodus. Go to the Apps page, choose the file import, and select the memories you downloaded from Claude. I chose my InfraNodus content folder, so it's the memories of this project. Then I click Next, InfraNodus analyzes them, and in the end I get a graph that shows me the main topics in my Claude memory and how they're connected to one another.

By the way, if you don't want to use graphs, you can also connect to InfraNodus through your favorite AI tool. In my case, I'm using Claude in Warp. It's like a terminal, but a bit fancier. With the InfraNodus MCP server connected, I can simply ask it to analyze those files for me ("Analyze the files in this folder with InfraNodus and show me the main clusters and gaps"). It calls generate_topical_clusters and generate_content_gaps and saves the graph, so I can open the same thing in the browser later.

3. Look at the main topics and the smaller clusters

So I can see that the main topics I'm talking about when I'm conversing with Claude about the content I'm making about InfraNodus are knowledge strategy, obviously, then a viral framework (how to make the videos or content more viral), the different tools that I use, and structural analysis, because it's one of the strong sides of InfraNodus. That makes sense. It already tells me the memory is about the right things.

Then there are some latent topics, which are also quite important, because they're smaller. For me, these are search demand and writing scripts that attract some attention. It's very important for me to analyze search demand, yet the memory barely holds it. This is maybe an indication that I should focus on these topics a little bit more, or that I should tell Claude to develop this understanding a little bit better and make more connections between those smaller clusters of ideas.

4. Go through the gaps

However, one of the most powerful features of InfraNodus is that it also shows you the gaps in those memories. You can click on the gaps panel, and it shows me that, for example, in this Claude memory the topic of viral framework is not very well connected to the topic of search demand. Or that topic saturation is not very well connected to the tool sessions, and so on. I iterate through those gaps, and when I find one I like, I click on the point between them and send it to AI to develop an interesting question that would bridge these two topics.

When it comes up with something interesting, I can either think of the answer myself, or I can ask the built-in AI in InfraNodus to answer this question. I really like to work in this way: AI first generates the question, and then I answer it myself or ask it to generate an answer. It goes in a few iterations, I'm participating in this process, and this is how I come up with great ideas. I can also just ask AI to develop an idea that would bridge the gap directly. This is faster, but then I'm participating in it less.

The insight clusters on the topical view work the same way. These are the smaller, underdeveloped clusters that should be better connected, and you can ask AI to generate ideas that bridge a triad of them together.

5. Save the ideas, then give them back to Claude

If I like what I see, I select it and save it into my project notes by clicking this button. I like to think of this metaphor: this is like a tree of knowledge, and I'm picking fruits from this tree. Whatever I like, I save into my project notes, because then I can reuse it later. Don't forget to favorite your graph, so you can always find it again.

Then I simply copy the notes from the project notes folder, go back into Claude, and tell it: "Add this into your memories of the InfraNodus content project." It adds them into memories. This is how you optimize your memory: you make its structure more interconnected, cover those smaller clusters, and bridge the gaps.

Use Case 2: A Product Idea from Mem0 Memories with the InfraNodus MCP Server

If you like to use more advanced tools, there is a very popular additional memory tool called Mem0. It connects to your Claude like a plugin. In my list of connected MCP servers, I have claude-mem, which is like Mem0, and I have Mem0 as well. Every time I converse with Claude in any project I'm working on, the Mem0 agent saves memories of this project: some decisions I made about how the app should work, how I coded it, and so on. You can see a log of those memories in Mem0 directly.

But again, it's very hard to understand what this is all about. Mem0 doesn't offer any analytical layer on top. I can of course ask Claude itself and hope for the best that it's going to give me a good insight, but I want something verifiable, and I want something visual, because I want to see the structure of the memory that is being created.

1. Connect the InfraNodus MCP server

It's very simple to install. In Claude Code, you add the server with one command:

claude mcp add infranodus -s user \
  -- env INFRANODUS_API_KEY=YOUR_KEY npx -y infranodus-mcp-server

You can also connect it to Claude directly through the connectors. Go to Customize, add a custom connector with the InfraNodus MCP server, and authorize it. Instructions for each client: Claude, Claude Code.

2. Ask Claude to fetch the memories and analyze them

Here is the prompt I used. You can reuse it yourself:

Get my Mem0 memories for this project. Pass them to InfraNodus as statements, one memory per statement, and analyze them: show the main topical clusters, the content gaps between them, and one product idea that would bridge the most important gap. Save the graph as mem0-<project>.

When I did that, it called Mem0's search_memories and then the tools inside InfraNodus that build a knowledge graph and all those clusters (generate_topical_clusters and generate_content_gaps). One memory per statement keeps every concept in the graph tied to the memory it came from, so later you can click on a cluster and read the memories behind it. With claude-mem, you use the same prompt and just change the name.

3. A product idea out of a gap

The project here is an app I'm developing called LegalPlay. It allows you to simulate any legal dispute and how it would evolve. It has several agents that play you and your opposing side. It goes through a few iterations, simulating how you would exchange emails or letters, then it plays out the worst scenario, the best scenario, and the mid scenario. And then a judge agent gets all the inputs from the different agents and generates the final response you should send to contest something you don't like.

The analysis showed the main clusters and the gaps between them, and it came up with a very good product idea. It said: look, you have scenario analysis in the app, where the legal discourse is simulated. And you have the web features cluster, which talks about reminders for what you should do when you're contesting a legal claim. But they are not connected. So it proposed: what if the reminders don't only come from the last letter, but also from how the agents simulated your case evolving in the future, and you add more events to the calendar for the whole procedure? This is a really good product idea that I didn't think about before, it was generated from the analysis of this memory, and I will implement it in this project.

4. Check the same gap in the graph

The graph is saved in InfraNodus, so I open exactly that same graph there and find exactly the same gap between web features and scenario analysis. So it's all verifiable and reproducible. That's very important. This is the snapshot of the memory. I can then ask the InfraNodus AI to generate an idea that would bridge this gap, and it talks about exactly the same thing: "turn the strategist's ordered scenario steps into a living reminder plan". I select it, save it to my project notes as a product idea, and make the graph a favorite so I don't forget it.

I actually like to use both, the MCP server and the visual interface, because then I come up with different insights. Inside InfraNodus you also have some additional features. I like the one that kind of jumps beyond the limitations of the graph. Question and develop try to bridge the gap; transcend tries to jump outside of the periphery of what you're thinking. It comes up with some really crazy ideas sometimes, but they can give you some philosophical insights and also some product ideas you haven't thought of before.

5. Look for noise

The graph also shows you what to delete. When I ran the same analysis on the Mem0 memories of another project, the repository of this website, the biggest cluster (26% of the influence) was "repository, file, remain, uncommitted". These were memories like "No repository changes have been committed." The decisions were only 7%. Automatic capture saves what happened in a session, and a lot of what happens is status. So delete those memories in Mem0, and rewrite the decisions with the reason behind them. Then the memory becomes smaller, but much more useful.

What a Well-Shaped Memory Looks Like

You want your memory to have an optimized, diversified structure. That means it's not too focused on one thing, and it's also not completely dispersed. InfraNodus shows this in the structure explainer: the graph is biased, focused, diversified or dispersed. When it's diversified, structurally it's most optimal, because it's conducive to new ideas but can also retain the most important ones inside. It's the optimal combination of being open to something new and keeping the main narrative. The four states are explained on the cognitive variability page.

So you use the gaps to bridge clusters of memory and make it more interconnected, you develop the insight clusters by asking questions that bridge them in interesting ways, and you delete the noise. If your memory is files you control, like Claude Code auto memory or an Obsidian vault, you can also keep it as a graph from the start with the Project Learnings skill or graph memory over MCP.

Web App or MCP Server?

Either InfraNodus does the analysis for you from inside your Claude application or Claude Code, or you open the graph and do it visually. I like to use both. Since the MCP server saves the graph, you can start in the chat and continue in the browser.

Analyze Your AI Memory

https://mcp.infranodus.com

https://mcp.infranodus.com

claude mcp add infranodus -s user --transport http https://mcp.infranodus.com/mcp

{
  "mcpServers": {
    "infranodus": {
      "url": "https://mcp.infranodus.com"
    }
  }
}

codex mcp add infranodus --url https://mcp.infranodus.com
codex mcp login infranodus

{
  "mcpServers": {
    "infranodus": {
      "command": "npx",
      "args": ["-y", "infranodus-mcp-server"],
      "env": {
        "INFRANODUS_API_KEY": "your-api-key"
      }
    }
  }
}

Get my Mem0 memories for this project and analyze them with InfraNodus: show the main topical clusters, the gaps between them, and one idea that would bridge the most important gap.

Frequently Asked Questions

Try It on One Memory

Try it on something small first: the Claude memory of one project, or the Mem0 memories of one repository. Having the memory visualized and the gaps shown to you helps you see how to make this memory better and make sure it includes everything you need. If you have any questions about how it works, let us know.