graphify

1. Project Overview

Graphify turns any codebase — along with its documentation, SQL schemas, configuration files, and PDFs — into a queryable knowledge graph, letting developers understand large, unfamiliar projects through explainable graph traversal instead of grepping files or relying on opaque semantic search.

2. Background & Positioning

Understanding a large codebase traditionally means either grepping through files manually or trusting a vector-embedding search that returns "similar" results without explaining why two pieces of code are related. Graphify was built to close that gap: it parses source code locally with deterministic AST tooling (tree-sitter) and builds a real graph of entities and relationships that can be traversed, queried, and explained.

The project's core mission is transparency. Every relationship it extracts is tagged either EXTRACTED (explicit in the source, such as an import or function call) or INFERRED (resolved by graphify's own analysis), so developers always know whether a connection is a fact from the code or a derived conclusion.

Compared to typical RAG-style code assistants, graphify explicitly positions itself as not a vector index — there are no embeddings and no vector store involved in building the core graph. Code analysis runs entirely on the local machine via tree-sitter, with zero LLM calls and zero API credits required to build a graph for source code. Optional AI backends are only invoked for semantic extraction from non-code formats like PDFs, images, and video.

3. Feature Categories

🕸️ Graph Construction — core capability, builds the knowledge graph from a project

• God-node detection (identifying the most-connected concepts in a codebase)
• Community detection using Leiden-based clustering to find subsystems
• Cross-file link resolution across roughly 40 languages via tree-sitter
• Rationale extraction that turns # NOTE: and # WHY: comments into first-class graph nodes
• Incremental updates that re-extract only changed files

🔍 Query & Exploration — commands for interrogating the graph once it exists

• Natural-language querying against graph.json
• Shortest-path lookups between two named entities
• explain command for surfacing why an entity matters and what connects to it
• AI-assisted PR triage that ranks a review queue by relevance
• Architecture diagram export (e.g. call-flow HTML visualizations)

🌐 Multi-Format Ingestion — extending the graph beyond source code

• Source code across 36 tree-sitter grammars (Python, TypeScript, Go, Rust, Java, C/C++, Ruby, and more)
• Documentation and PDFs
• Images and video/audio, with local transcription via faster-whisper
• SQL schemas and infrastructure-as-code (Terraform)
• Optional extras for Salesforce Apex, Pascal/Delphi, and other niche ecosystems

🤖 AI Assistant Integrations — bringing the graph into existing developer workflows

• Native /graphify skill/command support in 20+ AI coding assistants
• Platform-specific installers (hooks, instruction files, or native skill registration)
• Coverage spanning Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot CLI, and others

4. Key Highlights

• Deterministic, explainable graphs — every edge is labeled as extracted fact or inferred conclusion, removing the guesswork common in embedding-based similarity search.
• Fully local code analysis — building a graph for source code requires zero LLM calls and zero API credits; nothing about the code itself leaves the machine.
• Broad language coverage — 36 tree-sitter grammars out of the box, covering nearly every mainstream language plus several specialized ones via optional extras.
• Deep AI-assistant integration — works as a native command inside more than 20 popular AI coding tools rather than requiring a separate standalone workflow.
• Rationale as data — design-decision comments (# NOTE:, # WHY:) are promoted into queryable graph nodes, preserving intent that normally gets lost.
• Strong retrieval benchmarks — on the LOCOMO benchmark (n=300), graphify reports 0.497 recall@10, notably ahead of comparable memory/retrieval tools cited in its own benchmarks.

5. Use Cases by Role

General Developers
Use /graphify . inside an existing AI coding assistant to get instant, explainable context on an unfamiliar repository — tracing how a feature connects across files without manual grepping.

DevOps/SRE
Leverage SQL schema and Terraform ingestion to map infrastructure-as-code relationships alongside application code, and use path queries to trace dependencies between services and the infrastructure that backs them.

Data/Research Scientists
Ingest documentation, PDFs, and even video/audio material into the same graph as the codebase, enabling queries that connect research notes and specs directly to implementation.

Project Managers
Use graphify prs --triage to get an AI-ranked pull-request review queue, and use graph export (e.g. call-flow diagrams) to communicate architecture to stakeholders without manually drawing diagrams.

6. Getting Started

Find what you need — browse the documentation, architecture guide, and translated READMEs (14 languages) in the repository's docs/ directory, or read ARCHITECTURE.md for a module-by-module breakdown.

Install / integrate

uv tool install graphifyy
graphify install

Then invoke /graphify . from inside a supported AI coding assistant to build a graph for the current project. Alternative install methods:

pipx install graphifyy
# or
pip install graphifyy

Contribute

git clone https://github.com/Graphify-Labs/graphify.git
cd graphify && git checkout v8
uv sync --all-extras
uv run pytest tests/ -q

Active development happens on the v8 branch; commits follow fix: / feat: / docs: prefixes, and new language support should include fixtures under tests/fixtures/ plus test cases in test_languages.py.

7. Project Structure

graphify/
├── .github/              # GitHub workflows (CI, releases)
├── docs/                 # Documentation, including translations in 14 languages
├── graphify/             # Main package source code
├── scripts/              # Utility scripts
├── tests/                # Test suite, including language fixtures
├── tools/                # Helper tools
├── worked/                # Example extractions with reviewer notes
├── ARCHITECTURE.md       # Module responsibilities and language-integration guide
├── BENCHMARKS.md         # Performance and accuracy metrics
└── AGENTS.md             # Agent framework documentation

graphify/ holds the core extraction and query engine; ARCHITECTURE.md is the recommended starting point for contributors who want to understand how modules fit together or add support for a new language.

8. Related Ecosystem

Depends on / builds on:

• tree-sitter — provides the deterministic AST parsing that powers local code analysis
• faster-whisper — used for local transcription of video/audio inputs
• Optional graph and database backends: Neo4j, FalkorDB, PostgreSQL/SQL

Complementary tools:

• Works alongside AI coding assistants (Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot CLI, and others) rather than replacing them — it supplies structured context those tools consume
• Optional AI backends (including local options via Ollama) for semantic extraction from documents, images, and video

9. License

Graphify is dual-licensed, and users may choose the license that best fits their use case.

• ✅ Use, modify, and distribute the code under either the Apache License 2.0 or the MIT License, whichever you select
• ✅ Use in commercial and proprietary projects under the terms of either license
• ❌ No warranty is provided under either license — the software is offered "as is"
• ℹ️ Attribution and license-notice requirements differ slightly between Apache-2.0 and MIT — review the specific terms of the license you choose before redistributing

10. FAQ

Q: Does graphify send my code to an external server or LLM?
A: No. Source code is parsed locally via tree-sitter, and building a graph for code requires zero LLM calls. Only optional processing of PDFs, images, and video uses a configured AI backend, and even that can be run fully locally via Ollama.

Q: Which AI coding assistants does graphify work with?
A: More than 20, including Claude Code, Cursor, Codex, Gemini CLI, and GitHub Copilot CLI. Run graphify install to set up platform-specific integration.

Q: How is this different from a RAG tool using vector embeddings?
A: Graphify builds an actual traversable graph rather than a vector index. Relationships are explicitly tagged as EXTRACTED or INFERRED, so results are explainable rather than similarity scores.

Q: How many programming languages are supported?
A: 36 tree-sitter grammars are included by default, covering most mainstream languages, with additional optional extras for languages like Salesforce Apex and Pascal/Delphi.

Q: How do I query an existing graph?
A: Use commands such as graphify query "what connects auth to database?", graphify path "ServiceA" "ServiceB", or graphify explain "ComponentName" against the generated graph.json.

11. Quick Links

• Repository: https://github.com/Graphify-Labs/graphify
• Architecture guide: ARCHITECTURE.md in the repository root
• Contributing: development setup and guidelines in the repository README
• Benchmarks: BENCHMARKS.md in the repository root

12. Summary

Graphify gives developers an explainable, locally-computed map of how a codebase — and its surrounding docs, schemas, and other artifacts — actually fits together, replacing manual file-grepping and opaque similarity search with a traversable, queryable graph. It is especially valuable for developers onboarding onto large or unfamiliar repositories, and for teams that want AI coding assistants to reason about architecture with verifiable, sourced context rather than guesses.