Build Hermes a Second Brain with Graphify

Wire a local code knowledge graph to Hermes via MCP for structural memory.

Introduction

30 Second Summary

Think about how you navigate a codebase you haven't touched in months. You open files, search for function names, and try to piece together what connects to what.

In this project, you will use Graphify to parse your code into a knowledge graph. Then you'll wire that graph to your Hermes agent via MCP so it can answer structural questions about your codebase through natural conversation.

What You'll Build

Picture opening an interactive graph in your browser where every function and class in your project is a clickable, color-coded node, then asking Hermes "what depends on the config module?" and watching it return an answer grounded in real graph edges.

By the end of this project, you'll have:

An interactive knowledge graph you can open in your browser, with clickable nodes, color-coded communities, and a search bar covering every function, class, and concept in your code.
A live MCP connection between Graphify and Hermes, so you can ask structural questions about your codebase and get answers grounded in real graph traversals instead of hallucinated guesses.
A multi-project global brain that merges graphs from multiple codebases, letting Hermes trace connections across everything you've built in a single query.
Secret Mission: Install Graphify as a native Hermes skill so it can rebuild its own brain on demand.

Are there any prerequisites?

You need Hermes Agent installed and configured with a provider before starting this project. If you haven't done that yet, complete Set Up Hermes Agent for Free first.

Before We Start

Before We Start...

Before you start building, take a moment to lock in what you're creating and why it matters.

You're about to give Hermes a persistent, visual brain built from your own code projects using Graphify.

Set Up Graphify

Right now, Hermes can chat and run tasks, but it has zero structural understanding of your codebases. It can't tell you which functions depend on which modules or trace how data flows through a project.

Graphify is an open-source tool that parses code into knowledge graphs using tree-sitter AST parsing. In this step, you'll install Graphify and get it ready to build your first graph.

In this step, get ready to:

Confirm Python 3.10 or higher is installed.
Install Graphify with MCP support in a virtual environment.
Verify the graphify command works from your terminal.

Check your Python version

Graphify requires Python 3.10 or higher. Let's confirm you have the right version before installing anything.

Check your Python version by running this command:

python3 --version

✔️ I see version 3.10 or higher

Your Python version is good to go. Move on to the next substep.

ⓧ I see an older version

You have Python installed, but it's an older version than 3.10. Graphify needs 3.10 or higher to run correctly.

Install a newer Python version alongside your current one by running:

sudo apt update
sudo apt install python3.10

After the install finishes, verify by running python3.10 --version.
Use python3.10 instead of python3 for all commands in the rest of this project.

ⓧ Command not found

Python is not installed yet. Let's install it now.

Install Python by running:

sudo apt update
sudo apt install python3

Once the install finishes, confirm it worked by running python3 --version. You should see a version number of 3.10 or higher.

Create a virtual environment and install Graphify

A virtual environment gives Graphify its own isolated Python installation so it doesn't interfere with anything else on your system.

Create the virtual environment and install Graphify with MCP support by running these commands:

python3 -m venv ~/graphify-env
~/graphify-env/bin/pip install "graphifyy[mcp]"

What do these commands do?

python3 -m venv ~/graphify-env creates a new virtual environment folder in your home directory called graphify-env.

~/graphify-env/bin/pip install "graphifyy[mcp]" installs the Graphify package (graphifyy with a double-y) plus the MCP extras needed for the MCP server you'll wire to Hermes later.

You should see pip download and install several packages. The final line confirms a successful install.

Seeing an error during install?

If you see a permissions error, make sure you are NOT using sudo with pip. The virtual environment's own pip does not need root access.
If you installed Python 3.10 in the previous tab, replace python3 with python3.10 in the venv creation command.
help me troubleshoot my Graphify pip install error

The graphify command now lives inside ~/graphify-env/bin/, but your terminal doesn't know to look there yet.

Add the virtual environment's bin folder to your PATH so the graphify command is available from anywhere. Run:

echo 'export PATH="$HOME/graphify-env/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

What does this do?

The first line appends the PATH export to your ~/.bashrc file so it persists across terminal sessions.

The second line reloads ~/.bashrc in your current session so the change takes effect right now.

Using zsh instead of bash?

If your shell is zsh, replace ~/.bashrc with ~/.zshrc in both lines above.

Verify the installation

Everything is installed and on your PATH. Before you run the version check, what do you expect to see if the install worked?

Confirm Graphify is working by running:

graphify --version

You should see a version number printed, such as 0.9.42. The exact number may differ depending on when you install.

Seeing command not found?

Double-check that the PATH export line was added correctly. Run cat ~/.bashrc | tail -3 and look for the export PATH= line you just added.
Try opening a brand new terminal window and running graphify --version again. The source command sometimes doesn't fully update the current session.
As a last resort, run the command using its full path to confirm the install itself worked: ~/graphify-env/bin/graphify --version. If this prints a version but the short command doesn't, the issue is your PATH.
help me fix graphify command not found on Linux

Graphify is installed and ready. Next up, you'll point it at a real codebase and watch it build an interactive knowledge graph you can explore in your browser.

Build Your First Knowledge Graph

Graphify is installed and ready to go. Now it is time to point it at real code and see what comes out.

Before Hermes can answer questions about your codebase, the data needs to exist. Graphify's tree-sitter parser reads your project files locally, extracts every function, class, import, and dependency, and turns them into an interactive knowledge graph you can explore in your browser. No API keys needed, and nothing leaves your machine.

In this step, get ready to:

Run graphify extract . on a code project to build a knowledge graph.
Explore the interactive graph visualization in your browser.
Read the graph report to understand your project's key concepts and connections.

Extract a knowledge graph from your code

Graphify needs a folder with code files to scan. You can use any project on your machine: a previous Hermes project, a personal side project, or a cloned open-source repository.

✔️ I have a code project on this machine

Navigate to your project folder by running:

cd [[PROJECT_PATH="path to your code project folder"]]

You are now inside the folder Graphify will scan.

ⓧ I don't have a project handy

Move to your Desktop by running this command:

cd ~/Desktop

Clone a small open-source repository to use as your test project by running:

git clone https://github.com/tiangolo/fastapi

Confirm the folder was created by running:

ls

You should see a fastapi folder in the output.

Move into the cloned folder by running:

cd fastapi

Clone not working?

Check that git is installed by running git --version. If it is not installed, run:

sudo apt install git

Help me fix git clone.

Build the knowledge graph from your project by running:

graphify extract .

What does this command do?

graphify extract . scans the current directory for code files.
It uses AST parsing via tree-sitter to identify every function, class, import, and dependency.
The entire process runs locally. No API keys are needed, and no code leaves your machine.

Graphify prints its progress in the terminal as it parses each file. Once it finishes, you should see a summary of the nodes and edges it discovered.

Confirm the output files were created by running:

ls graphify-out/

You should see three files: graph.html, GRAPH_REPORT.md, and graph.json.

Not seeing graphify-out/?

Make sure you ran graphify extract . from inside your project folder, not from a parent or sibling directory.
Check that the project folder contains actual code files (.py, .js, .ts, etc.). An empty folder produces no graph.
If you see graphify: command not found, revisit Step 1 to confirm ~/graphify-env/bin is on your PATH.

Help me fix graphify extract.

Open the interactive graph in your browser

The graph.html file is the visual brain. It renders every node and edge from your code into a clickable, searchable interface.

Before you open it, take a guess: what do you think the most-connected node in your project will be?

Open the graph in your default browser by running:

xdg-open graphify-out/graph.html

Your browser opens with an interactive node graph. Each colored cluster represents a community of closely related concepts in your code.

Click on any node to highlight its connections to other nodes.
Use the search bar at the top to find a specific function or class name from your project.
Notice how communities are color-coded by subsystem. Tightly connected concepts share the same color.

What am I looking at?

Each node represents a concept from your code: a function, a class, an import, or a dependency.

Each edge represents a relationship: a function calling another, a file importing a module, or a class inheriting from a parent. Communities (color groups) are clusters of closely related nodes that Graphify detected automatically.

Browser didn't open?

If xdg-open did not launch your browser, you can open the file manually. Copy the full path to graphify-out/graph.html and paste it into your browser's address bar.

Help me open graph.html in my browser.

Read the graph report

Alongside the visual graph, Graphify generates a written summary of your project's structure. This report highlights the concepts that matter most.

View the graph report by running:

cat graphify-out/GRAPH_REPORT.md

What's in this report?

God nodes are the most-connected concepts in your project. These are the functions, classes, or modules that everything else depends on.
Surprising connections highlight unexpected relationships between parts of your code that you might not have noticed.
Suggested questions are starting points for querying the graph in the next step.

You should see sections listing the god nodes, surprising connections, and suggested questions for your project. Take note of the suggested questions. You will use them in the next step.

Your knowledge graph is built and ready to explore. Next, you will query it from the terminal and discover what happens when Hermes tries to access it.

Query the Graph from the Terminal

You have a visual knowledge graph of your codebase, complete with clickable nodes and color-coded communities. Now it is time to go deeper than browsing.

The graph data lives in graph.json, and Graphify's CLI can query it directly from your terminal. In this step, you will run natural language queries, trace paths between concepts, and then ask Hermes to do the same.

In this step, get ready to:

Query the knowledge graph with natural language using the Graphify CLI.
Trace paths between nodes and inspect individual concepts.
Ask Hermes the same structural questions about your project.

Run a natural language query

The interactive graph.html is great for exploring visually, but the real power of the graph is answering specific structural questions programmatically.

Query the knowledge graph by running this command:

graphify query "what are the most important modules?"

You should see a scoped answer listing specific node names, their relationships, and confidence tags from your graph.

What does this output mean?

Graphify traverses your graph.json using a breadth-first search, finds the most relevant nodes for your question, and returns a subgraph with only the matching results.

Each edge in the output carries a confidence tag. EXTRACTED means the connection was read directly from the source code. INFERRED means Graphify derived it through resolution.

Seeing no output or an error?

Make sure you are running the command from inside the project folder where graphify-out/ exists. Graphify looks for graphify-out/graph.json relative to your current directory.
If you see graphify: command not found, your PATH may not include the virtual environment. Re-run the export command from Step 1 or open a new terminal.

Still stuck? Why is my graphify query returning an error or no results?

Try a few more questions to see how the graph answers different kinds of structural questions:

graphify query "what are the key concepts?"

Notice how the results change based on the question. The graph scopes its answers to the specific subgraph that matches your query.

Trace a path between two concepts

Beyond broad questions, you can trace the exact connection between any two nodes in the graph. This is useful for understanding how components depend on each other.

Open the GRAPH_REPORT.md you explored in the previous step. Pick two node names from the god nodes or suggested connections sections.
Trace the shortest path between two nodes by running this command:

graphify path "[[NODE_A=\"first node name from your graph\"]]" "[[NODE_B=\"second node name from your graph\"]]"

What does the path output show?

Graphify finds the shortest route between the two nodes and prints every hop along the way. Each hop shows the relationship type and its confidence tag, so you can see exactly how two concepts connect through your codebase.

Now inspect a single node in detail by running this command:

graphify explain "[[NODE_NAME=\"a node name from your graph\"]]"

You should see the node's source file, community number, degree (number of connections), and a full list of its connections with relationship types and confidence tags.

Seeing 'No path found' or 'No node matching'?

Node names are case-sensitive. Copy the exact name from GRAPH_REPORT.md or from the graph.html search bar rather than typing it from memory.
If two nodes are in completely separate parts of the graph with no shared edges, graphify path will report no path. Try two nodes that are in the same community (same color in the visualization).

Need help? Why is graphify path or explain not finding my node?

Ask Hermes the same question

The graph works from the terminal. You can query it, trace paths, and explain nodes. Now let's bring Hermes into the conversation and ask it the same structural question.

Open a new terminal window or tab.
Start a Hermes chat session by running this command:

hermes chat

Before you type your question, take a moment to predict. What do you think Hermes will say if you ask it about the most important modules in your project?

Type the same structural question you asked Graphify earlier, something like: "What are the most important modules in this project?" or "What are the key concepts in this codebase?"

Hermes either gives a vague answer, admits it does not know, or makes something up. It has no access to the knowledge graph you just built.

Why can't Hermes answer?

The knowledge graph is sitting in graphify-out/graph.json on your local file system. Hermes has no way to read it, query it, or know it exists. Without a connection to the graph, Hermes is guessing based on whatever context it has in the conversation.

This is the gap. The graph has the answers, but Hermes cannot reach them. You need a bridge between the two. That bridge is MCP.

Exit the Hermes session by typing /exit.

You have proven the knowledge graph works from the terminal, and you have seen that Hermes cannot access it. Next up, you will wire the graph to Hermes via MCP so it can query real graph data instead of guessing.

Wire the Graph to Hermes via MCP

You've proven the knowledge graph works from the terminal. graphify query and graphify path returned real answers grounded in your code's structure. But when you asked Hermes the same questions, it came up empty.

Graphify ships an MCP server that exposes the graph through structured tools. In this step, you'll register that server in Hermes's config so it can call tools like query_graph, get_node, get_neighbors, and shortest_path directly from inside a conversation.

In this step, get ready to:

Add a Graphify MCP server entry to Hermes's config file.
Start a fresh Hermes session and confirm the graphify tools are loaded.
Ask Hermes structural questions about your codebase and get answers grounded in real graph data.

Add the Graphify MCP server to your Hermes config

Hermes reads its MCP server definitions from ~/.hermes/config.yaml. You need two pieces of information to fill in the config: your Linux username and the absolute path to your project's graph.json file.

Find your Linux username by running this command:

whoami

Note the username printed. You'll paste it into the config in a moment.

Find the absolute path to your graph.json by running this command from inside your project folder:

realpath graphify-out/graph.json

Copy the full path printed. It looks something like /home/ubuntu/Desktop/fastapi/graphify-out/graph.json.

Open your Hermes config file in a text editor by running:

nano ~/.hermes/config.yaml

Find the mcp_servers key in your config. If it does not exist yet, add it at the root level of the file.
Add the following block under mcp_servers. Replace the username and graph path with the values you just found:

# Add this block under the mcp_servers key in your existing config.
# If mcp_servers does not exist yet, create it at the root level.

mcp_servers:
  graphify:
    # Full path to the Python binary inside your Graphify virtual environment
    command: "/home/[[USERNAME="your Linux username"]]/graphify-env/bin/python3"
    # Launches the MCP stdio server pointed at your project's graph data
    args: ["-m", "graphify.serve", "[[GRAPH_JSON_PATH="absolute path to your graphify-out/graph.json"]]"]

What does this config do?

The command field points to the Python binary inside your Graphify virtual environment. Hermes launches this as a subprocess.

The args field tells Python to run Graphify's built-in MCP server module (graphify.serve) and load your project's graph.json as the data source. Hermes communicates with this server over stdio (standard input/output), so everything stays local.

Save the file. In nano, press Ctrl+O to write, then Ctrl+X to exit.

Not sure about indentation?

YAML is whitespace-sensitive. Make sure graphify: is indented exactly two spaces under mcp_servers:. The command: and args: lines should be four spaces in. If Hermes reports a config parsing error, check for mixed tabs and spaces.

help me fix YAML indentation in my Hermes config.yaml

Confirm Hermes sees the graphify tools

The config tells Hermes where to find the Graphify MCP server. Now you need to start a fresh session so Hermes discovers the new tools.

Start a new Hermes session by running:

hermes chat

Ask Hermes to list its available tools by typing this prompt:

Tell me which MCP-backed tools are available right now.

You should see the graphify tools listed. Hermes registers them with a mcp__graphify__ prefix. Look for mcp__graphify__query_graph, mcp__graphify__get_node, mcp__graphify__get_neighbors, and mcp__graphify__shortest_path.

Why the mcp__ prefix?

Hermes names every MCP tool with the pattern mcp__<server>__<tool>. The double underscores separate the server name from the tool name. This prevents naming collisions when multiple MCP servers are connected at the same time.

Tools not showing up?

If you were already in a Hermes session when you edited the config, type /reload-mcp to reload the MCP configuration without restarting.
Check that the command path actually exists. Run ls ~/graphify-env/bin/python3 in a separate terminal to confirm.
Check that the graph.json path in args is an absolute path (starts with /), not a relative one.

Help me troubleshoot why my graphify MCP server isn't loading in Hermes.

Ask Hermes a structural question about your code

The tools are loaded. Time to put them to work. Think back to Step 3 when you asked Hermes about your project's structure and it couldn't answer from the graph.

Before you ask the next question, predict: what do you think will be different about Hermes's answer this time compared to Step 3?

Ask Hermes this question in your current chat session:

What are the most connected concepts in my project?

This time, Hermes calls the query_graph tool behind the scenes. Its answer cites specific nodes and edges from your knowledge graph instead of guessing.

Try a follow-up question that uses a different tool. Ask Hermes to trace a path between two concepts you saw in the graph:

Trace the path from the main entry point to the database module.

What is happening behind the scenes?

When you ask a structural question, Hermes decides which MCP tool to call. For broad questions it uses query_graph. For a specific node it uses get_node or get_neighbors. For path tracing it uses shortest_path.

The key difference from Step 3 is that every answer is now grounded in real graph data. Hermes traverses actual edges between nodes rather than generating plausible-sounding guesses.

Getting vague or empty answers?

Make sure your question references concepts that actually exist in your graph. Open graphify-out/GRAPH_REPORT.md to see the god nodes and suggested queries for your specific project.
If Hermes answers without calling the MCP tools (no tool call visible), rephrase to be more explicit: "Use the graphify tools to find the most connected concepts."

Help me get better answers from Hermes using the graphify MCP tools.

Your knowledge graph is now wired directly to Hermes. It can answer structural questions about your code by traversing real nodes and edges. Next, you'll merge multiple project graphs into a single global brain so Hermes can trace connections across everything you've built.

Build a Multi-Project Brain

Hermes can now answer structural questions about a single codebase by querying real nodes and edges in the knowledge graph. That is a huge step up from hallucinated guesses.

A single-project graph only tells part of the story. Graphify's global graph merges multiple project graphs into one unified brain, so Hermes can trace connections across everything you have built in a single query.

In this step, get ready to:

Build a second project's knowledge graph and register both into a global graph.
Update the Hermes MCP config to point at the merged global graph.
Ask Hermes cross-project questions that span project boundaries.

Extract a second project and register both graphs

You already have one project graphified. To build a multi-project brain, you need at least one more project to merge with it. Any code folder on your machine will work.

Navigate to a second code project folder by running this command:

cd [[SECOND_PROJECT_PATH="path/to/your/second/code/project"]]

Build the knowledge graph for this second project by running:

graphify extract .

Watch the terminal as Graphify's tree-sitter parser processes each file. You will see it detect code files, run AST extraction, cluster communities, and write the output files.

Confirm the extraction finished by running:

ls graphify-out/

You should see graph.html, graph.json, and GRAPH_REPORT.md in the output.

Extract command failed?

Make sure you are inside a folder that contains code files. Graphify needs source files to parse.

If you do not have a second project handy, clone a small open-source repo like FastAPI:

cd ~/Desktop
git clone https://github.com/tiangolo/fastapi
cd fastapi
graphify extract .

Help me troubleshoot the graphify extract command.

Now it is time to merge both project graphs into a single global brain. The graphify global add command registers a project's graph.json into a shared global graph file at ~/.graphify/global-graph.json.

graphify global add [[FIRST_PROJECT_GRAPH="path/to/your/first-project/graphify-out/graph.json"]] --as first-project

graphify global add [[SECOND_PROJECT_GRAPH="path/to/your/second-project/graphify-out/graph.json"]] --as second-project

What does --as do?

The --as flag gives each project graph a human-readable alias inside the global graph. When Hermes traverses the merged graph later, these aliases help identify which project a node or edge belongs to.

You can name them anything descriptive. first-project and second-project work fine, or use the actual project names if you prefer.

Confirm both projects are registered by running:

graphify global list

You should see both first-project and second-project listed in the output along with their node and edge counts.

Only one project showing up?

Double-check that you ran graphify global add twice, once for each project. Each command needs the full path to that project's graphify-out/graph.json file.

If you see an error about the file not being found, verify the path by running ls on the graphify-out/ directory inside each project folder.

Help me register both projects into the global graph.

Point the MCP server at the global graph

Hermes is still pointed at a single project's graph.json. You need to update the MCP config so it reads from the merged global graph instead.

Confirm the location of the global graph file by running:

graphify global path

You should see ~/.graphify/global-graph.json printed in the terminal.

Open ~/.hermes/config.yaml in a text editor.
Find the args line under the graphify MCP server entry. It currently points to a single project's graph.json:

    args: ["-m", "graphify.serve", "/home/your-username-here/<project-folder>/graphify-out/graph.json"]

Replace the path in the third argument with the global graph path, so the line looks like this:

    args: ["-m", "graphify.serve", "/home/your-username-here/.graphify/global-graph.json"]

Replace your-username-here with your actual Linux username, just like you did when you first added this entry.
Save ~/.hermes/config.yaml.

✔️ Awesome, I've got everything!

Great. Make sure you have saved the file before moving on.

ⓧ I'd like to double check the full code

Your ~/.hermes/config.yaml MCP server entry should look like this (with your actual username substituted):

mcp_servers:
  graphify:
    command: "/home/your-username-here/graphify-env/bin/python3"
    args: ["-m", "graphify.serve", "/home/your-username-here/.graphify/global-graph.json"]

Ask Hermes cross-project questions

The global graph is merged and Hermes is pointed at it. Time to see if Hermes can trace connections across project boundaries.

Before you start the session, think about what concepts or tools your two projects might share. Do they use the same libraries? Similar patterns? Overlapping modules?

Start a fresh Hermes session by running:

hermes chat

Why a fresh session?

Hermes loads its MCP server configuration at startup. Since you just changed config.yaml to point at the global graph, you need a fresh session for Hermes to pick up the new path.

If you already have Hermes open from earlier, exit with /exit and start a new session. You can also run /reload-mcp in an active session instead.

Ask Hermes a cross-project question. Try one of these:

Watch Hermes call the query_graph and get_neighbors MCP tools against the merged graph. It returns connections that span both projects. These are connections you would never have found by reading the code manually.

Try tracing a specific path across projects. Ask Hermes something like: "Trace the path from [concept in project A] to [concept in project B]." Replace the bracketed text with real node names from your two graphs.

What makes the global graph special?

Each individual graph only knows about the code inside its own project folder. The global graph merges nodes and edges from every registered project into a single connected structure.

When two projects share a library, a pattern, or a concept, those overlapping nodes become bridges in the global graph. Hermes can walk those bridges to answer questions that no single-project graph could.

Hermes not using the graph tools?

Verify that the graphify MCP tools loaded by asking Hermes "what tools do you have available?" You should see query_graph, get_node, get_neighbors, and shortest_path in the list.

If the tools are missing, check that the command path in config.yaml points to your actual Python binary inside ~/graphify-env/bin/python3. Also confirm the args path points to ~/.graphify/global-graph.json and that file exists.

Help me get the graphify MCP tools working in Hermes.

Secret mission

Make Hermes Self-Aware

Right now, you rebuild the knowledge graph manually every time your code changes. What if Hermes could rebuild its own brain on demand and keep it updated automatically with every commit?

Clean Up Your Resources

This project runs entirely locally, so there are no ongoing costs. Decide whether to keep your resources on disk, pause and come back later, or delete everything.

Resources you used:

Graphify virtual environment at ~/graphify-env/.
graphify-out/ directories inside each project folder you graphified.
Global graph data at ~/.graphify/.
MCP server entry in ~/.hermes/config.yaml.
Graphify skill files at ~/.hermes/skills/graphify/ (Secret Mission only).
Git hooks in project .git/hooks/ directories (Secret Mission only).

Keep everything running

No action needed. Choose this if you are still actively building or plan to add more projects to your global brain.

The MCP server starts fresh each time you open a Hermes session. Your graphs, global brain, config, and skill files all persist on disk.
To add more projects later, run graphify extract . inside a new project folder, then register it with graphify global add.

Pause - I'll come back to this later

Shut down any running Hermes session to free up memory. All your files, config, and graphs stay on disk for when you return.

Exit Hermes by typing /exit in your chat session.
Your graphs, global brain, MCP config, and skill files all persist. Resume anytime with hermes chat.

Delete - I don't want to use this again

Remove all project resources and start fresh. Follow each step below to clean up everything this project created.

Open ~/.hermes/config.yaml in a text editor and delete the entire graphify: block under mcp_servers. Save the file.
If you completed the Secret Mission, uninstall the Hermes skill by running:

graphify hermes uninstall

If you completed the Secret Mission, uninstall the git hooks by navigating to each project folder where you ran graphify hook install and running:

graphify hook uninstall

Delete graph outputs from each project folder you graphified by running:

rm -rf <project-folder>/graphify-out/

Replace with your real paths

Replace <project-folder> with the actual path to each project you ran graphify extract on. Run the command once per project.

Remove the global graph directory by running:

rm -rf ~/.graphify/

Remove the Graphify virtual environment by running:

rm -rf ~/graphify-env/

Confirm everything is cleaned up by running:

ls ~/graphify-env/ ~/.graphify/ ~/.hermes/skills/graphify/ 2>&1

You should see "No such file or directory" for each path. Your system is back to its pre-project state.

Nice Work!

Nice work! You have given Hermes a persistent, structural brain built entirely from your own code. No API keys, no cloud services, no guesswork.

You've learned how to:

Built knowledge graphs from code projects using Graphify's local tree-sitter AST parsing. Every function, class, import, and dependency became a clickable node in an interactive browser visualization, all generated locally at zero cost.
Wired Graphify's MCP server to Hermes via ~/.hermes/config.yaml, giving Hermes access to query_graph, get_node, get_neighbors, and shortest_path tools to answer structural questions grounded in real graph data.
Merged multiple project graphs into a single global brain using graphify global add and asked Hermes cross-project questions that traverse connections spanning your entire portfolio.
Secret Mission: Installed Graphify as a native Hermes skill and set up git hooks for auto-rebuilding, giving Hermes the ability to maintain its own brain.

Ready to quiz yourself?