3 GitHub Projects That Give Your AI Agent a Project Map and Cross-Session Memory

Core question of this article: When your AI coding assistant faces hundreds or thousands of files, why does it always get lost? How can you make it understand the project structure like a senior engineer and remember what you discussed yesterday?

Have you ever opened a project with hundreds of files — src/, docs/, scripts/, SQL, configs, several PDFs, some screenshots, and scattered Markdown notes — and asked Hermes (an AI coding assistant) to make sense of it? It tries hard: reads a few files, searches keywords, runs some commands. But problems surface quickly:

• It knows a file exists, but not which module it belongs to.
• It understands a function’s internal logic, but fails to connect that function to the database, config entries, or API.
• It reads the README but misses the more detailed architecture description hidden in docs/.

What’s even more frustrating: yesterday you explained a design decision to Hermes. Today you start a new session, and it asks the same question again. The command sequence you debugged, the reasoning behind that decision, the entire troubleshooting path — all gone.

This isn’t just Hermes’ problem. Every agent tool that lacks “project structure awareness” and “cross-session memory” will feel like onboarding a new junior every single day.

But several open-source projects on GitHub already solve these two problems. This article explains three of them: graphify (project map), agentmemory (cross-session memory), and graphiti (temporal knowledge graph). What each does, how to connect them to Hermes, how to run them for the first time, and which pitfalls to avoid.

1. graphify: Draw a Map of Your Project First, Then Let Hermes Navigate

Core question of this section: How can you help an AI assistant see the entire project structure, module relationships, and core nodes at a glance — instead of reading files in isolation?

Graphify’s purpose is straightforward: type /graphify . in your terminal (inside an AI coding assistant like Hermes), and it scans every file in the current folder — code, docs, PDFs, images, even videos — and generates a queryable knowledge graph.

After it finishes, you get three core outputs:

graphify-out/
├── graph.html          ← interactive visualization, open in browser to click and search
├── GRAPH_REPORT.md     ← text report: core nodes, unexpected connections, suggested questions
└── graph.json          ← full graph data for repeated queries

A real-world large-scale run

I ran it on my own workspace — I tried to scan all my workspace documents, and that almost broke things. 14,247 files, about 160 million words. Graphify generated 90,688 nodes, 100,210 edges, and 14,775 communities. 99% were “extracted” relationships, only 1% “inferred”. The report also listed the most connected “god nodes” and surprising cross‑module links.

It felt like — for the first time — my project folder had a satellite map. No longer “here’s a pile of files”, but “here’s how these files relate, which modules are most central, and where links might be broken”.

(Above: a node graph after pruning)

Why graphify pairs perfectly with Hermes

Hermes is great at executing: reading files, searching content, running commands, writing code. But in large projects, the most critical step is understanding the whole picture first. If you ask Hermes to change code immediately, it will search as it goes and often take detours.

A more reliable workflow:

1. First, use Graphify to generate GRAPH_REPORT.md.
2. Feed that report to Hermes as project context.
3. Then ask about specific modules, paths, and impact scope.

You can say this to Hermes:

Please read graphify-out/GRAPH_REPORT.md first. Do not modify any files. Just tell me: what are the most central modules, the most critical relationships, and 5 questions you recommend I explore first?

After Hermes reads the report, you can ask “which files are involved in the login flow”, “which modules would be affected if I change the permission logic”, or “where is this config entry referenced” — and it will follow the map instead of blindly searching.

Installation (the most common pitfall)

Core question: What’s the exact install command for graphify? Why is the package name spelled with a double ‘y’?

The most common trap: the PyPI package is called graphifyy (double y). But the command‑line tool is named graphify (single y). The README explicitly warns that other graphify* packages do not belong to this project.

uv tool install graphifyy && graphify install

Then install Hermes platform support:

uv tool install graphifyy && graphify install --platform hermes

You can also use pipx or pip, but uv is the most hassle‑free. Requires Python 3.10+.

After installation, go to your project directory and run inside Hermes:

/graphify .

Note for Windows PowerShell users: The leading / will be treated as a path separator. Just write graphify .

Pitfalls to avoid (from first‑hand experience)

Lesson 1: Don’t scan your entire workspace on the first run
A large project may take minutes to tens of minutes, depending on file count and types. Do not run it on all your workspace folders at once — you’ll get a gigantic graph that is painfully slow to open and even slower for an agent to read. Add only what you need.

Lesson 2: Use .graphifyignore to exclude junk directories
Exclude node_modules/, dist/, build/, .cache/, *.log, .env — anything useless or sensitive. This saves time and model quota.

Lesson 3: Know the privacy boundary
Code files are parsed locally with tree‑sitter and never leave your machine. However, semantic extraction from documents, PDFs, and images may be sent to a model API. Graphify has no telemetry or tracking, but if your folder contains client information, internal financial data, or unpublished materials, set up .graphifyignore first.

2. agentmemory: Let Your Agent Remember What It Did Last Time

Core question of this section: Why does an AI assistant forget everything about your project each new session? How can it remember the design decisions and debugging paths we discussed yesterday?

Graphify solves the “project structure” problem — helping the agent understand relationships between files. But there’s another annoying issue: cross‑session memory.

Today you teach Hermes a specific coding convention, spend two hours debugging a tricky issue together, confirm a library version choice. Tomorrow you start a new session — everything reset.

What agentmemory does

agentmemory does one simple thing: it acts like a note‑taker sitting behind Hermes, automatically capturing what the agent does, compressing it into structured memories, and storing them in a local index. The next session, it automatically injects relevant context back in.

It uses hybrid search to match “what past experiences are relevant to the current task”. All 1,067 tests pass. The latest version v0.9.21 fixes 9 bugs and explicitly declares Hermes plugin hooks (PR #486). There’s also a dedicated integration proposal on Hermes’ official GitHub (Issue #6715).

What this means for Hermes users

You can run agentmemory in your own project and configure it as Hermes’ memory layer. From then on, every time Hermes works, it records key decisions, pitfalls encountered, and successful command sequences. Next time you ask Hermes to do something similar, it automatically pulls in past experience — no need to explain again.

This transforms “onboarding a junior every day” into “a senior engineer starting work by reading their own past notes”.

Installation and integration

npm install -g agentmemory

Then follow the Hermes integration documentation. Specific configuration instructions are available on agentmemory’s Hermes plugin page.

Pitfalls to avoid: memory quality depends on your embedding model

agentmemory stores memory locally, so privacy is safe. But two things to watch:

1. Memory quality depends on your embedding model. If you use a lightweight model, search precision will suffer. For high precision requirements, consider a better embedding solution.
2. It records “what the agent did”, not “what the project architecture is”. So the best approach is graphify + agentmemory together: graphify figures out what the project looks like, agentmemory remembers the human‑agent collaboration process — one handles the map, the other handles the diary.

In fact, there is already a discussion in graphify’s repository (Issue #152) about integrating the two: letting agentmemory directly read graphify’s graph.json to combine project structure knowledge with session experience.

3. graphiti: When You Need Finer Temporal Memory

Core question of this section: When project knowledge changes over time (e.g., pricing logic, frequently updated requirement docs), how can the agent know “when did this fact change, who said it, and how reliable is it”?

The two tools above — graphify handles “what it looks like now”, agentmemory handles “what we did in the past”.

But there is a more complex need: if the agent needs to know “when a fact changed, who said it, and how reliable it is” — for example, your agent is continuously tracking a product’s pricing logic, or maintaining a knowledge base that evolves over time — then you need graphiti, a temporal knowledge graph.

graphiti’s core capability

graphiti is an open‑source context graph engine from Zep. Its core capability: a knowledge graph with a timeline. It doesn’t just record entities and relationships — it records when each fact was established, when it changed, and what the source was. It supports two graph database backends: FalkorDB and Neo4j.

Recently, graphiti released MCP Server 1.0, already with “hundreds of thousands of weekly active users”, and can be directly integrated into Claude Desktop, Cursor, or any MCP‑compatible agent tool.

How to connect it with Hermes

graphiti integrates via the MCP protocol. You install the graphiti MCP server, add it to Hermes’ MCP configuration, and the agent can directly read from and write to your knowledge graph. This is suitable for team‑shared knowledge, long‑term project maintenance, or scenarios where you need to audit “how did this conclusion come about”.

Pitfalls to avoid: graphiti is heavier than the other two

graphiti requires a graph database backend (FalkorDB or Neo4j), which can be a significant deployment cost for beginners. If your only need is “let the agent remember what it did last time”, agentmemory is much lighter and more direct. If you need “a complete chain of how knowledge evolved over time” — for instance, maintaining a product knowledge base or building a research agent — then graphiti is the right choice.

How to Combine the Three Tools? Recommended Priority for Hermes Users

Core question of this section: As a regular developer, which tool should I install first? How do I use them together?

A complete workflow after installation

Here’s how the workflow looks:

1. Go to your project, run /graphify ., wait for GRAPH_REPORT.md
2. Have Hermes read the report first to build global understanding
3. During daily work, agentmemory automatically records key decisions and successful paths
4. Next time you start a new session, Hermes automatically recalls relevant memories — no need to re‑explain

Try It Now: The Minimal On‑Ramp

Core question of this section: I don’t want to read a long article — give me a command sequence I can run in 10 minutes.

# 1. graphify - draw a project map
uv tool install graphifyy && graphify install
graphify install --platform hermes
cd your-project && /graphify .

# 2. Let Hermes read the map
# In Hermes, say: Please read graphify-out/GRAPH_REPORT.md first…

# 3. agentmemory - add the memory layer
npm install -g agentmemory
# Follow Hermes plugin docs to integrate

Pick one folder you work with. Run it, read the report, ask Hermes a few relationship‑based questions using the graph. You’ll feel the difference in about ten minutes.

Let your agent learn the terrain first, then do the work — this isn’t hard, but it will save you from endless repetitive explanations.

Practical Summary & One‑Page Overview

Action checklist

• [ ] Install graphify (note the double‑y package name), run /graphify .
• [ ] Inspect graphify-out/GRAPH_REPORT.md, identify core nodes
• [ ] In Hermes, feed the report first, then ask questions
• [ ] Configure .graphifyignore to exclude sensitive / useless directories
• [ ] Install agentmemory and integrate with Hermes as memory layer
• [ ] If you need temporal knowledge, evaluate graphiti + MCP

One‑page overview

Frequently Asked Questions (FAQ)

Q1: Does graphify upload my code to the cloud?
No. Code files are parsed locally with tree‑sitter. Only semantic extraction from documents, PDFs, and images may call a model API. Use .graphifyignore to exclude sensitive files.

Q2: Where does agentmemory store memories? Can I clean them manually?
Stored in a local index. You can delete the index files or clean via configuration. Privacy safe.

Q3: Can I use all three tools at the same time?
Yes. graphify handles static structure, agentmemory handles session experience, graphiti handles temporal knowledge. They don’t conflict, and there are already discussions about integrating them.

Q4: I’m a Windows user. /graphify . gives an error. What do I do?
In PowerShell, the leading / is treated as a path separator. Just write graphify .

Q5: How long does graphify take on a large project?
Depends on file count and types. A repository with tens of thousands of files may take ten minutes or more. Narrow the scope with .graphifyignore first.

Q6: agentmemory’s memory precision is low. What can I do?
Upgrade to a better embedding model. Lightweight models reduce hybrid search accuracy.

Q7: Is graphiti suitable for individual developers?
Not really. It requires a graph database backend, which adds deployment overhead. Individual developers are better off starting with agentmemory.

Q8: Doesn’t Hermes have these features built in?
Hermes is excellent at executing tasks, but “project map” and “cross‑session memory” require additional tools. That’s exactly the value these three projects provide.