← Back to Blog

Graphify: Turn Any Codebase into a Queryable Knowledge Graph for Your AI Coding Assistant

Graphify: Turn Any Codebase into a Queryable Knowledge Graph for Your AI Coding Assistant

Type /graphify . in your AI coding assistant and it maps your entire project — code, docs, PDFs, images, and videos — into a knowledge graph you can query instead of grepping through files. It's like giving your AI assistant an internal GPS for your codebase.

What is Graphify?

Graphify is an open-source Claude Code skill (backed by a Python library) that turns any folder of code into a queryable knowledge graph. It works across 31 programming languages and supports docs, PDFs, images, and even video transcripts. Created by Safi Shamsi and backed by Y Combinator (S26), Graphify has exploded to 53,000+ GitHub stars in under two months.

The result is three files:

  • graph.html — an interactive visual graph you can open in any browser
  • GRAPH_REPORT.md — highlights: key concepts, surprising connections, suggested questions
  • graph.json — the full structured graph for programmatic queries

Once built, you can type /graphify query "what connects auth to the database?" instead of digging through files.

Why is it Trending?

Graphify hit the sweet spot of a massive, real pain point. AI coding assistants (Claude Code, Codex, Cursor, Gemini CLI) are powerful, but they struggle with large codebases — context windows fill up fast, and the assistant can't see the forest for the trees. Graphify solves this by building a persistent, queryable map that costs 71× fewer tokens to query than reading raw files.

Key drivers of its popularity:

  • Works with 17+ AI coding platforms — Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Aider, OpenCode, OpenClaw, Hermes, Kimi Code, Kiro, Pi, and more
  • 71.5× token reduction on real-world corpora (Karpathy repos + papers + images: 52 files)
  • Privacy-first — code is analyzed locally via tree-sitter AST (no API calls for code). Only docs/PDFs/images use your assistant's model
  • YC-backed — S26 batch, indicating real startup traction
  • Zero-config — install once, type /graphify . and get your graph

How it Works

Graphify processes your files in three passes:

Graphify Architecture

Pass 1 — Code Structure (Free, No API Calls)

Tree-sitter parses your code files and extracts classes, functions, imports, call graphs, and inline comments. This runs entirely locally. 31 languages are supported, plus SQL files get special treatment (tables, views, foreign keys, JOIN relationships).

Pass 2 — Video and Audio (Local, No API Calls)

Video and audio files are transcribed with faster-whisper locally. The transcription prompt is seeded with your top "god nodes" (most-connected concepts) to focus on domain relevance.

Pass 3 — Docs, Papers, Images (Uses AI Model)

Markdown, PDFs, images, and transcripts are sent to your AI assistant for semantic extraction. Multiple subagents run in parallel, each outputting a JSON fragment with nodes and edges. These fragments are merged into a single graph.

Community Detection

Graphify uses the Leiden algorithm — a graph-clustering method that groups nodes by edge density. No embeddings, no vector database needed. The semantic similarity edges that your AI model extracts are already in the graph, so they influence community shape directly.

Confidence Tagging

Every relationship is tagged:

  • EXTRACTED — found directly in source (e.g., function call, import)
  • INFERRED — reasonable deduction with a confidence score (0.0–1.0)
  • AMBIGUOUS — uncertain, flagged for manual review

Prerequisites

  • Python 3.10+python --version to check
  • uv (recommended) or pipx for installation
  • One of: Claude Code, Codex, Cursor, Gemini CLI, or any supported AI coding assistant
  • For headless/CI extraction: an API key (Anthropic, Gemini, OpenAI, DeepSeek)

Installation & Setup

Step 1 — Install the Package

# Recommended — uv puts graphify on PATH automatically
uv tool install graphifyy

# Alternatives:
pipx install graphifyy
pip install graphifyy

Note: The PyPI package is graphifyy (double-y). The CLI command is still graphify.

Step 2 — Register the Skill with Your AI Assistant

graphify install

That's it. Open your AI assistant and type /graphify . to build your first graph.

Step 3 — Platform-Specific Setup

Graphify supports all major platforms with dedicated install commands:

# Claude Code (Linux/Mac)
graphify install

# Codex (add multi_agent = true in config)
graphify install --platform codex

# VS Code Copilot Chat
graphify vscode install

# Cursor
graphify cursor install

# Gemini CLI
graphify install --platform gemini

# Hermes Agent
graphify install --platform hermes

Project-Scoped Install

To install the skill into a specific repository (so teammates get it automatically):

graphify install --project
graphify install --project --platform codex

This writes the skill file under .claude/skills/graphify/SKILL.md or .agents/skills/graphify/SKILL.md in your project directory — commit these files to share with your team.

Using Graphify

Build Your First Graph

# Map the current directory
/graphify .

# Map a specific folder
/graphify ./src

# Re-extract only changed files
/graphify ./src --update

# Skip HTML visualization (JSON + report only)
/graphify . --no-viz

Query the Graph

# Natural language queries
/graphify query "what connects auth to the database?"
/graphify query "show the login flow"

# Graph traversal
/graphify path "UserService" "DatabasePool"
/graphify explain "RateLimiter"

# Add external resources
/graphify add https://arxiv.org/abs/1706.03762
/graphify add <youtube-url>

Team Workflow

Graphify is designed for teams:

# Auto-rebuild on every git commit
graphify hook install

# Commit graphify-out/ to the repo so everyone starts with a map
# Recommended .gitignore additions:
#   graphify-out/manifest.json
#   graphify-out/cost.json

One person runs /graphify . and commits graphify-out/. Everyone pulls — their assistant reads the graph immediately. The git hook also sets up a merge driver that union-merges graph.json automatically when two devs commit in parallel.

Optional Extras

pip install "graphifyy[pdf]"      # PDF extraction
pip install "graphifyy[video]"    # Video/audio transcription
pip install "graphifyy[mcp]"      # MCP stdio server
pip install "graphifyy[all]"      # Everything

MCP Server Integration

Graphify can expose its graph as an MCP server for structured, tool-call access:

# Start the MCP server
python -m graphify.serve graphify-out/graph.json

# Register with Kimi Code
kimi mcp add --transport stdio graphify -- python -m graphify.serve graphify-out/graph.json

The MCP server provides: query_graph, get_node, get_neighbors, shortest_path, list_prs, get_pr_impact, triage_prs.

PR Dashboard

Graphify includes a built-in PR dashboard for team workflows:

graphify prs                    # General PR dashboard
graphify prs 42                 # Deep dive on PR #42
graphify prs --triage           # AI ranks your review queue
graphify prs --conflicts        # PRs sharing graph communities

Environment Variables (Headless/CI Extraction)

These are only needed for running graphify extract without an IDE:

Variable Purpose
ANTHROPIC_API_KEY Claude backend
GEMINI_API_KEY Gemini backend
OPENAI_API_KEY OpenAI backend
DEEPSEEK_API_KEY DeepSeek backend
OLLAMA_BASE_URL Ollama local inference
AWS_* / ~/.aws/credentials Bedrock (IAM-based, no API key)

Verification Checklist

  • graphify --version shows the installed version
  • /graphify . completes without errors
  • graphify-out/graph.html opens in browser showing an interactive graph
  • graphify-out/GRAPH_REPORT.md contains god nodes and connections
  • /graphify query "show the architecture" returns meaningful results
  • graphify install adds the skill to your AI assistant
  • Running graphify extract ./docs --backend gemini works for headless extraction

Resources

← Retour au Blog

Graphify : Transformez Votre Codebase en Graphe de Connaissances Interrogeable pour Votre Assistant IA

Graphify : Transformez Votre Codebase en Graphe de Connaissances Interrogeable pour Votre Assistant IA

Tapez /graphify . dans votre assistant IA et il cartographie l'intégralité de votre projet — code, documentation, PDFs, images et vidéos — en un graphe de connaissances que vous pouvez interroger au lieu de fouiller vos fichiers. C'est comme offrir un GPS interne à votre assistant IA pour naviguer dans votre codebase.

Qu'est-ce que Graphify ?

Graphify est un skill open-source pour Claude Code (alimenté par une bibliothèque Python) qui transforme n'importe quel dossier de code en un graphe de connaissances interrogeable. Il fonctionne avec 31 langages de programmation et prend en charge la documentation, les PDFs, les images et même les transcriptions vidéo. Créé par Safi Shamsi et soutenu par Y Combinator (S26), Graphify a explosé à plus de 53 000 étoiles GitHub en moins de deux mois.

Le résultat se compose de trois fichiers :

  • graph.html — un graphe visuel interactif consultable dans n'importe quel navigateur
  • GRAPH_REPORT.md — les points forts : concepts clés, connexions surprenantes, questions suggérées
  • graph.json — le graphe structuré complet pour des requêtes programmatiques

Une fois construit, vous pouvez taper /graphify query "qu'est-ce qui relie l'authentification à la base de données ?" au lieu de fouiller les fichiers.

Pourquoi Graphify Cartographie-t-il ?

Graphify a touché le point sensible d'un problème massif et réel. Les assistants IA de codage (Claude Code, Codex, Cursor, Gemini CLI) sont puissants, mais ils peinent avec les grandes codebases — les fenêtres de contexte se remplissent vite et l'assistant ne voit pas la forêt derrière les arbres. Graphify résout ce problème en construisant une carte persistante et interrogeable qui coûte 71× moins de tokens à interroger que la lecture des fichiers bruts.

Facteurs clés de sa popularité :

  • Fonctionne avec 17+ plateformes IA — Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Aider, OpenCode, OpenClaw, Hermes, Kimi Code, Kiro, Pi, et plus
  • Réduction de 71,5× des tokens sur des corpus réels (repos Karpathy + articles + images : 52 fichiers)
  • Respect de la vie privée — le code est analysé localement via tree-sitter AST (pas d'appels API pour le code). Seuls les docs/PDFs/images utilisent le modèle de votre assistant
  • Soutenu par YC — batch S26, indiquant une réelle traction startup
  • Zéro configuration — installez une fois, tapez /graphify . et obtenez votre graphe

Comment ça Marche

Graphify traite vos fichiers en trois passes :

Architecture de Graphify

Passe 1 — Structure du Code (Gratuit, Sans Appel API)

Tree-sitter analyse vos fichiers de code et extrait les classes, fonctions, imports, graphes d'appels et commentaires. Cela s'exécute entièrement en local. 31 langages sont supportés, et les fichiers SQL bénéficient d'un traitement spécial (tables, vues, clés étrangères, relations JOIN).

Passe 2 — Vidéo et Audio (Local, Sans Appel API)

Les fichiers vidéo et audio sont transcrits avec faster-whisper localement. L'invite de transcription est alimentée par vos "nœuds principaux" (concepts les plus connectés) pour se concentrer sur la pertinence du domaine.

Passe 3 — Documentation, Articles, Images (Utilise le Modèle IA)

Le Markdown, les PDFs, les images et les transcriptions sont envoyés à votre assistant IA pour extraction sémantique. Plusieurs sous-agents s'exécutent en parallèle, chacun produisant un fragment JSON avec des nœuds et des arêtes. Ces fragments sont fusionnés en un seul graphe.

Détection de Communautés

Graphify utilise l'algorithme de Leiden — une méthode de clustering de graphes qui groupe les nœuds par densité d'arêtes. Pas besoin d'embeddings ni de base de données vectorielle. Les arêtes de similarité sémantique extraites par votre modèle IA sont déjà dans le graphe, elles influencent donc directement la forme des communautés.

Étiquetage de Confiance

Chaque relation est étiquetée :

  • EXTRACTED — trouvée directement dans la source (ex : appel de fonction, import)
  • INFERRED — déduction raisonnable avec un score de confiance (0,0–1,0)
  • AMBIGUOUS — incertaine, signalée pour révision manuelle

Prérequis

  • Python 3.10+ — vérifiez avec python --version
  • uv (recommandé) ou pipx pour l'installation
  • Claude Code, Codex, Cursor, Gemini CLI, ou tout autre assistant IA supporté
  • Pour l'extraction headless/CI : une clé API (Anthropic, Gemini, OpenAI, DeepSeek)

Installation et Configuration

Étape 1 — Installer le Paquet

# Recommandé — uv place graphify sur le PATH automatiquement
uv tool install graphifyy

# Alternatives :
pipx install graphifyy
pip install graphifyy

Note : Le paquet PyPI est graphifyy (double-y). La commande CLI reste graphify.

Étape 2 — Enregistrer le Skill avec Votre Assistant IA

graphify install

C'est tout. Ouvrez votre assistant IA et tapez /graphify . pour construire votre premier graphe.

Étape 3 — Configuration Spécifique à la Plateforme

Graphify supporte toutes les plateformes majeures avec des commandes d'installation dédiées :

# Claude Code (Linux/Mac)
graphify install

# Codex (ajoutez multi_agent = true dans la config)
graphify install --platform codex

# VS Code Copilot Chat
graphify vscode install

# Cursor
graphify cursor install

# Gemini CLI
graphify install --platform gemini

# Hermes Agent
graphify install --platform hermes

Installation par Projet

Pour installer le skill dans un dépôt spécifique (afin que vos coéquipiers l'obtiennent automatiquement) :

graphify install --project
graphify install --project --platform codex

Cela écrit le fichier skill sous .claude/skills/graphify/SKILL.md ou .agents/skills/graphify/SKILL.md dans votre projet — commitez ces fichiers pour les partager avec votre équipe.

Utiliser Graphify

Construire Votre Premier Graphe

# Cartographier le répertoire courant
/graphify .

# Cartographier un dossier spécifique
/graphify ./src

# Ré-extraire uniquement les fichiers modifiés
/graphify ./src --update

# Ignorer la visualisation HTML (JSON + rapport uniquement)
/graphify . --no-viz

Interroger le Graphe

# Requêtes en langage naturel
/graphify query "qu'est-ce qui relie l'auth à la base de données ?"
/graphify query "montre le flux de connexion"

# Parcours de graphe
/graphify path "UserService" "DatabasePool"
/graphify explain "RateLimiter"

# Ajouter des ressources externes
/graphify add https://arxiv.org/abs/1706.03762
/graphify add <url-youtube>

Workflow d'Équipe

Graphify est conçu pour les équipes :

# Reconstruire automatiquement à chaque commit git
graphify hook install

# Commitez graphify-out/ dans le dépôt pour que tout le monde démarre avec une carte
# Ajouts recommandés au .gitignore :
#   graphify-out/manifest.json
#   graphify-out/cost.json

Une personne exécute /graphify . et commite graphify-out/. Tout le monde fait un pull — leur assistant lit le graphe immédiatement. Le hook git configure également un pilote de fusion qui fusionne graph.json automatiquement lorsque deux développeurs commitent en parallèle.

Extensions Optionnelles

pip install "graphifyy[pdf]"      # Extraction PDF
pip install "graphifyy[video]"    # Transcription vidéo/audio
pip install "graphifyy[mcp]"      # Serveur MCP stdio
pip install "graphifyy[all]"      # Tout

Intégration du Serveur MCP

Graphify peut exposer son graphe via un serveur MCP pour un accès structuré par appels d'outils :

# Démarrer le serveur MCP
python -m graphify.serve graphify-out/graph.json

# Enregistrer avec Kimi Code
kimi mcp add --transport stdio graphify -- python -m graphify.serve graphify-out/graph.json

Le serveur MCP fournit : query_graph, get_node, get_neighbors, shortest_path, list_prs, get_pr_impact, triage_prs.

Tableau de Bord des PRs

Graphify inclut un tableau de bord PR intégré pour les workflows d'équipe :

graphify prs                    # Tableau de bord général
graphify prs 42                 # Analyse détaillée de la PR #42
graphify prs --triage           # L'IA classe votre file d'attente de révision
graphify prs --conflicts        # PRs partageant des communautés du graphe

Variables d'Environnement (Extraction Headless/CI)

Nécessaires uniquement pour exécuter graphify extract sans IDE :

Variable Utilité
ANTHROPIC_API_KEY Backend Claude
GEMINI_API_KEY Backend Gemini
OPENAI_API_KEY Backend OpenAI
DEEPSEEK_API_KEY Backend DeepSeek
OLLAMA_BASE_URL Inférence locale Ollama
AWS_* / ~/.aws/credentials Bedrock (basé sur IAM, sans clé API)

Liste de Vérification

  • graphify --version affiche la version installée
  • /graphify . se termine sans erreur
  • graphify-out/graph.html s'ouvre dans le navigateur avec un graphe interactif
  • graphify-out/GRAPH_REPORT.md contient les nœuds principaux et les connexions
  • /graphify query "montre l'architecture" retourne des résultats pertinents
  • graphify install ajoute le skill à votre assistant IA
  • graphify extract ./docs --backend gemini fonctionne pour l'extraction headless

Ressources