GuideIntermediate

Graphify · give your AI the full map of your project (the most advanced piece)

This is the most advanced piece of your AI's knowledge — the graph, one of the three parts of the brain you just saw. You've already given your AI memory, you're already saving to GitHub, you already know when to use a RAG and what a brain is. But there's a point where similarity search falls short: when your project gets SO big that the AI no longer understands how everything connects — what depends on what, what breaks if you touch one piece. That's when it starts reading files blind, burning extra tokens, repeating mistakes, and breaking things that used to work. Graphify solves that at the root: it turns your entire project —code, database schemas, documents, papers, even images and videos— into a knowledge graph that the AI queries with a single question. It's open-source, free, and today it's a "skill" you install with one command. And heads up: it's not just for programmers — here you'll see several scenarios for different kinds of users.

Jun 19, 202611 min

The most advanced piece of your AI's knowledge

This guide goes deep on the graph, the third piece of the brain you saw in the previous resource: [memory](/recursos/memoria-para-tu-ia-herramientas) → [RAG](/recursos/rag-sin-humo-cuando-lo-necesitas) → [brain](/recursos/el-brain-cerebro-de-tu-app) → graph in depth. You don't need to code to understand it, and you'll see scenarios beyond code (documents, research, your business).

When does the need show up? (beyond searching)

The need shows up when your project stops being "a pile of things to search" and becomes "a network of connected things." Signs: you ask the AI for a change and it breaks something at the opposite end of the project; you ask it "what happens if I change this?" and it doesn't know; or you have so much information that neither memory nor RAG gives the AI the full picture of how everything fits together.

The pain: the AI that "fixes" one thing and breaks another

It's the most frustrating pain of building with AI at scale. The AI touches a file without knowing that five other pieces depended on it → what it fixes on one side, it breaks on the other. It's not that it's dumb: it's that it searches by similarity, but doesn't understand the connections. The graph gives it exactly what it's missing.

Memory vs RAG vs graph · the difference in one sentence

All three give your AI knowledge, but they solve different things. This is the difference almost nobody explains clearly:

The three, without mixing them up

Memory → remembers your rules and your project between sessions. (Continuity.)

RAG → searches by similarity and pulls the pieces of your documents that resemble your question. (Finding.)

Graph → understands the connections: what depends on what, what breaks if you change something. (Reasoning about the structure.)

Picture it like this · the subway map

Without a graph, your AI is a tourist in a huge city asking for directions on every corner (that burns tokens and gets lost). With a knowledge graph, you give it the subway map: it sees the whole city at a glance, knows which station connects to which, and gets there directly. RAG tells you "here are streets similar to the one you're looking for"; the graph tells you "this street leads to that one, and if you close this, that whole area jams up."

What is Graphify? (in plain terms)

Graphify is a free, open-source tool that takes an entire folder —your code, your database schemas, your documents, papers, even images and videos— and turns it into a knowledge graph: a map where every thing is a point and every connection is a line. Instead of reading 50 files blind, the AI asks the map "how does X connect to Y?" and gets the answer in a single query.

Today Graphify works as a "skill" (just like the ones in the 5 office skills resource): you install it once and your AI assistant —Claude Code, Cursor, Codex, Gemini CLI and more— uses it whenever it needs to. And it's multi-modal: it doesn't just understand code, it also handles SQL, scripts, documents, papers and more.

safishamsi/graphify

REPO

Graphify — turns any folder (code, SQL schemas, scripts, documents, papers, images, videos) into a queryable knowledge graph, for AI assistants (Claude Code, Codex, Cursor, Gemini CLI and more). Open-source, maintained by Safi Shamsi.

PythonMITView on GitHub

For every kind of user · 4 real scenarios

Graphify isn't just for people who code. Anyone with a pile of connected information benefits. Here are four different scenarios:

1 · The one building an app (code)

The classic case: your project grew and the AI gets lost among files. With the graph, before touching anything, it knows what depends on what — and stops breaking what worked. Fewer bugs, fewer tokens, safer changes.

2 · The researcher or student (papers and documents)

You've got 80 papers or a pile of thesis documents. The graph connects ideas across them: "which authors are related?", "what concept connects this paper to that one?". Your AI reasons over your ENTIRE library, not document by document.

3 · The business owner (your operation)

Your processes, policies, products and customers are connected in a thousand ways. A graph lets your AI understand those relationships: "if I change this policy, which processes does it affect?". It goes from answering isolated facts to understanding your business as a system.

4 · The one who mixes it all (data + docs + code)

The most powerful part: Graphify puts your code, your database schema and your documentation into ONE single graph. Your AI sees the app, the data and the decisions as a single network — the full context that no single loose file gives it.

Installation · one command (you need Python)

Graphify installs with a single command. You need Python on your computer. (Heads up: the package is called graphifyy, with a double "y".)

Install Graphifybash

pip install graphifyy && graphify install

If the command fails

On macOS, or if you see an "externally-managed-environment" error, use pipx install graphifyy (it handles everything on its own). On Windows, if graphify isn't recognized after installing, pipx install graphifyy also fixes it. And the easiest route: if you use a coding agent, hand it the prompt below and let it deal with the installation.

How to use it · you ask the map

Once installed, Graphify is a skill you invoke with /graphify. You build the graph of your folder once, and then you ask it questions in natural language. Here's what a real query looks like:

Query your graph (real example)bash

/graphify query "what connects the login to the users database?"

The habit that makes it valuable

The graph isn't a one-time thing: make it a reflex to query it BEFORE a big change ("what breaks if I touch this?") and to rebuild it when the project changes a lot. An old map misleads you; a fresh one saves you hours. Same as across the whole series: the tool is worth it for the habit, not for installing it once.

Prompt 1 · Have your AI install it and build the graph

If you'd rather not touch the terminal, let your coding agent do it all. Copy it and paste it in:

Paste it to your agent · install and build the graphtexto

I want to use Graphify (https://github.com/safishamsi/graphify) to turn this project into a knowledge graph you can query. Guide me and do it yourself where you can, in plain language.

1. Check whether it's installed; if not, install it (pip install graphifyy && graphify install, or pipx install graphifyy if pip fails).
2. Build the graph over the root of this project for me.
3. Explain what it generated (the visual graph, the queryable file and the report) in simple words.
4. Run a test query to confirm it works, for example how two key parts of my project connect.
5. If there's anything only I can do, tell me with exact steps.

Prompt 2 · Use it before every big change (anti-breaking-things)

This is the one that really saves you headaches. Before asking the AI for an important change, have it query the graph first:

Paste it to your agent · change without breakingtexto

Before making this change: [describe the change you want], query the Graphify knowledge graph to understand the impact.

1. Ask the graph which parts of the project depend on what I'm about to touch.
2. Tell me what could break and what to check after the change.
3. Only then propose the change, taking those connections into account.
4. When we're done and it works, remind me to save the progress to GitHub.

The idea is to not break anything that's connected underneath.

Why it crowns the knowledge (and supercharges C-A-R)

This is where it all comes together

The graph makes the audit phase of the C-A-R protocol far more powerful: the AI audits while understanding how EVERYTHING connects, not just the file it touched. And it builds on the earlier steps: save the graph and your changes to GitHub, use it when the RAG falls short for understanding structure. It's the top of your AI's knowledge ladder.

In NeuralOS, the graph is part of the brain

The knowledge graph is exactly the kind of "structural brain" we're bringing to NeuralOS: so every project and agent understands how everything of theirs connects, without you setting anything up. The vision is already drawn into the interface; the engine is part of the road we're building.

RAG with no fluff · the previous step

Before the graph, what you usually need is a good RAG. Start there if you skipped it.

The C-A-R protocol · build without bugs

The method that pairs perfectly with Graphify for bulletproof software.

#contexto#grafo#open-source#claude-code

Ready to build?