Graphify: Solving Claude Code's Memory Problem with Knowledge Graphs

Graphify: Revolutionizing Codebase Understanding with Knowledge Graphs

This video introduces Graphify, an open-source tool designed to solve the memory and context limitations of AI coding assistants like Claude Code when dealing with large codebases.

Core Problem & Solution

• Problem: AI coding assistants struggle to understand and recall information from extensive codebases, leading to less accurate and more token-intensive responses.
• Solution: Graphify transforms code repositories into knowledge graphs, providing a structured map for AI assistants.

How Graphify Works: A Three-Pass System

1. Pass 1: Code Structure Analysis (Deterministic & Free)

   • Utilizes tree-sitter to parse code files.
   • Extracts key code elements: classes, functions, imports, call graphs, and inline comments.
   • Identifies and maps established connections between code components.
   • Runs locally with no LLM involvement.

2. Pass 2: Multimedia Transcription (Video & Audio)

   • If video or audio files exist within the repository, they are transcribed using Faster Whisper.
   • The transcribed text is then injected into the knowledge graph.

3. Pass 3: Document & Image Analysis (LLM-Powered)

   • Processes non-code files such as PDFs, documentation, and images.
   • Employs semantic analysis via a large language model (LLM) to understand the content and its relevance.
   • Integrates this information into the knowledge graph.
   • This pass is described as similar to a RAG (Retrieval-Augmented Generation) system but without explicit embeddings.

Knowledge Graph Structure

• Nodes: Represent individual pieces of information (e.g., code components, documents).
• Edges: Represent the connections between nodes.
• Communities: Groupings of similar nodes.

Key Benefits & Features

• Improved Accuracy: Enables AI assistants to provide more precise answers by referencing the structured knowledge graph.
• Reduced Token Costs: Significantly lowers the number of tokens required for queries, with potential savings up to 70x (though practically observed to be lower but still substantial).
• Open Source & Free: Graphify is freely available and open source.
• Platform Agnostic: Works with any coding agent.
• Dynamic Updates: Supports automatic rebuilding of the knowledge graph after code commits using graphify hook install (AST only, no API cost).
• Team Collaboration: Handles parallel development by multiple team members.
• Obsidian Integration: Can generate an Obsidian vault from the repository data using the --obsidian flag.

Graphify vs. Graph RAG

• Graphify: Primarily focused on codebases, excels at mapping internal code structure and relationships. Does not use embeddings.
• Graph RAG: Better suited for unstructured data (e.g., large collections of PDFs or markdown files) and relies on embeddings for semantic understanding.

Graphify can perform a "RAG-light" function on non-code data, blurring the lines between the two approaches.

Demo & Results

• Project Analyzed: Open Design (an open-source alternative to Claude Design).
• Process: Ran Graphify on the Open Design repository.
• Duration: 6 minutes.
• Output: Processed 203 files, generated 1,907 nodes, 3,447 edges, and 109 communities. Output tokens were under 120K.
• Token Savings: A query using Graphify resulted in approximately 80,000 tokens, compared to ~200,000 tokens for a similar query without Graphify (a ~60% reduction).
• Persistent Memory: Once built, the knowledge graph allows for cheap and efficient querying of the repository's information.

Installation & Usage

• Installation: Can be done easily by pasting the GitHub link into Claude Code or by following manual steps.
• Commands: Includes commands like /graphify (to run on the current directory), graphify query, graphify explain, and graphify Claude install (to ensure it's always used).
• Graphify Skill: Automatically installs a skill for Claude Code, enabling it to understand and use Graphify commands based on natural language prompts.

Use Cases

• Understanding complex or unfamiliar codebases.
• Onboarding new developers to a project.
• Efficiently querying project documentation and code.
• Creating structured knowledge bases from non-code repositories (e.g., Obsidian vaults).

Graphify is positioned as a valuable tool that bridges the gap between tools like Obsidian and full RAG systems, offering a flexible and efficient way to enhance AI's understanding of project data.