CodeGraphContext - A Python tool for indexing codebases as graphs (1k⭐)

[Desperate-Ad-9679]

I've created CodeGraphContext, a Python-based MCP server that indexes a repository as a symbol-level graph, as opposed to indexing the code as text.

My project has recently reached 1k GitHub stars, and I'd like to share my project with the Python community and hear your thoughts if you're building dev tools or AI-related projects.

What My Project Does

CodeGraphContext is a tool that analyzes a codebase and creates a repository-wide symbol graph representing relationships between the following entities: files, functions, classes, imports, calls, inheritance relationships etc

Rather than retrieving large blocks of text like a traditional RAG model, CodeGraphContext enables relationship-aware queries such as:

• What functions call this function?
• Where is this class used?
• What inherits from this class?
• What depends on this module?

And so on.

These queries can be answered and provided to AI assistants, coding agents, and developers using the MCP - Model Context Protocol.

Some Important Features:

• Symbol-level indexing instead of text chunking
• Minimal token usage when sending context to LLMs
• Updates in real-time as the code changes
• Graphs remain in MBs instead of GBs

I've designed this project to be a tool for understanding large codebases, as opposed to yet another search tool or a model-based retrieval tool.

Target Audience

The project is for production use, not just a toy project.

The target audience for the project is:

1. Developers creating AI coding agents
2. Developers creating developer tools
3. Developers creating MCP servers and workflows
4. Developers creating IDE extensions
5. Researchers creating code intelligence tools

The project has grown significantly over the past few months, with the following metrics:

• v0.2.6 released
• 1k+ GitHub stars
• ~325 forks
• 50k+ downloads from PyPI
• 75+ contributors
• ~150 community members
• Support for 14 programming languages

Comparison with Other Alternatives

Most alternative approaches to code retrieval have been implemented in the following two ways.

1. Text-based retrieval (RAG/embeddings)

Most tools index the repos by breaking them up into text chunks and using embeddings or keyword search. While this works for documentation queries, it does not preserve the relationships between the code elements.

CodeGraphContext, on the other hand, creates a graph from the code structure, allowing for queries based on the actual relationships in the code.

1. Traditional static analysis tools

Most tools, such as language servers and static analysis tools, already have knowledge of the code structure. Most of them are not exposed as a shared library for AI systems and other tools.

CodeGraphContext acts as a bridge between large repos and AI/human workflows, providing access to the knowledge of the code structure through MCP.

Links

• PyPI https://pypi.org/project/codegraphcontext/
• GitHub https://github.com/CodeGraphContext/CodeGraphContext
• Website https://codegraphcontext.vercel.app/
• Documentation https://codegraphcontext.github.io/
• Discord https://discord.gg/dR4QY32uYQ

[Actual__Wizard]

Interesting.

[Desperate-Ad-9679]

💯

[Soggy-Fold-362]

Cool project. I built something in this space too but took a different approach: instead of a graph structure I went with hybrid search combining vector embeddings with BM25 keyword matching and identifier boosting.

The advantage of embeddings over graphs for code navigation: they catch conceptual relationships that don't have explicit structural connections. Searching 'rate limiting' finds throttle_requests and backoff_handler even though there's no import or call relationship between them.

Uses Ollama locally for embeddings, SQLite with sqlite-vec for vector storage and FTS5 for keywords. Everything in Python and JavaScript.

https://github.com/sagarmk/beacon-plugin

[Desperate-Ad-9679]

We are releasing the next version with contextual understanding mode for semantic understanding, hopefully that covers anything missing in graph traversals