Graphify is an open-source tool designed to address the "memory problem" of AI coding assistants like Claude Code, enabling them to provide more accurate answers at significantly reduced token costs. It achieves this by transforming any repository, including code, documentation, images, and videos, into a comprehensive knowledge graph.

Core Methodology:

Graphify's core methodology involves a three-pass data extraction process to construct the knowledge graph, followed by the generation of graph components:

1. Pass 1: Code Structure Analysis (Deterministic & Local)
   • This initial pass focuses on the structural elements of the codebase. It operates deterministically without any Large Language Model (LLM) involvement, ensuring high accuracy and no associated API costs.
   • A tree-sitter parser is utilized to traverse code files.
   • It extracts established connections and relationships within the code, including:
     • Classes
     • Functions
     • Imports
     • Call graphs
     • Inline comments
   • The output from this pass forms the foundational layer of the knowledge graph.

2. Pass 2: Media File Processing (Transcription)
   • If the repository contains video or audio files, this pass processes them.
   • faster-whisper is employed to transcribe the audio content into text.
   • The resulting transcribed text is then injected into the evolving knowledge graph.

3. Pass 3: Documentation and Image Analysis (Semantic Analysis with LLM)
   • This pass handles non-code assets such as PDF files, general documentation, and images.
   • An LLM is introduced in this stage to perform semantic analysis on these unstructured or semi-structured data types.
   • The LLM determines the meaning and context of these documents and images, deciding where they should semantically fit within the larger knowledge graph.
   • This process is described as being "kind of similar without true embedding to what a RAG system does," distinguishing it from full-fledged RAG (Retrieval Augmented Generation) systems.

Knowledge Graph Construction:

After data extraction, Graphify constructs the knowledge graph using three primary components:

• Nodes: These are the individual entities or pieces of information represented as circles in the graph visualization. Each extracted element (e.g., a function, a class, a document) becomes a node.
• Edges: These are the connections or relationships between two nodes, depicted as lines. Edges represent how different pieces of code or information are related (e.g., a function calling another function, a document referencing a code module).
• Communities: These are larger groupings of nodes that share similar characteristics or are closely related. Graphify automatically identifies and clusters these communities, aiding in macroscopic understanding of the repository's structure.

Benefits and Comparison:

• Token Savings and Accuracy: By providing a structured "map" of the codebase, Graphify significantly reduces the tokens required for an AI agent to understand and answer questions. While claims suggest up to 70x savings, a practical demonstration showed approximately 40% token cost reduction compared to traditional "grepping" or "explore agent" methods. This also leads to more accurate answers as the AI has a clear understanding of relationships.
• Memory and Efficiency: The pre-built knowledge graph acts as a persistent memory. Once built, subsequent queries are cheaper and faster, as the AI doesn't need to re-crawl the repository each time.
• Graphify vs. Graph RAG:
  • Embeddings: Graphify does not use an embedding system whatsoever for its core functionality, particularly for code. Graph RAG systems, conversely, heavily rely on embeddings for semantic similarity.
  • Use Cases: Graphify is primarily optimized for understanding codebases and structured relationships within them. Graph RAG is better suited for highly unstructured datasets like tens of thousands of disparate PDF documents, where connections are not explicitly defined. Graphify's third pass, however, allows it to perform "RAG-light" functions for documentation.
• Comparison to Obsidian: Graphify shares some conceptual overlap with Obsidian in organizing information, and can even export to an Obsidian vault. However, Graphify is tailored for code and structured data analysis, whereas Obsidian is a general-purpose knowledge base.

Usage and Maintenance:

• Integration with AI Agents: Graphify integrates with AI coding agents (e.g., Claude Code) by installing a "Graphify skill" that teaches the agent when and how to use Graphify commands.
• Commands: Key commands include /graphify . to run on the current directory, /graphify query or /graphify explain to explicitly instruct the AI to use the knowledge graph for a query, and /graphify claude install to enable persistent Graphify usage.
• Updates: To maintain a "living, breathing" map of the repo, Graphify supports auto-rebuilding the graph. Using /graphify hook install, it can automatically rebuild the Abstract Syntax Tree (AST) portion of the graph after each commit, incurring no API costs as it's a deterministic local process. This also supports team environments.
• Flexibility: While excelling with code, Graphify can also process non-code repositories (e.g., markdown-only documentation), demonstrating its flexible application beyond strict code analysis.