Someone built a tool that converts your entire codebase into a graph database. Instead of dumping code into LLMs, AI can navigate functions, classes, and dependencies like a map. It's called CodeGraphContext.

Link to the github repo-

that's just moving the complexity from code to graph query optimization, the overhead doesn't disappear it just changes form

Converting your codebase into a graph database so AI can understand it. The AI after seeing the graph:

this is way closer to actual retrieval than stuffing a repo into context and praying. for bigger codebases that’s a pretty different mode of work

thats how all CLI agents navige code base by default no?

I built something like this myself yesterday:

This is cool! We're using KG's too, but with additional memory/context/search tools for org-wide context. Think 1000s of agents, org wide, not just a handful locally. - repo open soon.

How does it handle circular dependencies and deeply nested inheritance chains? Those are usually where traditional static analysis tools start choking on complex codebases.

ngl the graph approach is so much better than just dumping files into context. when the model can actually trace call chains and dependency paths it catches things flat context completely misses

I use Obsidian.

cool!

interesting! Wonder if this actually works better

Graph context will matter most when symbols are stale. Are you tracking retrieval hit rate and token savings versus plain repo dumps?

just use an lsp and save yourself the headache. this thing will likely be burning tokens crazy fast.

a repo is already a graph (tree)

Brilliant tool. CodeGraphContext turning a codebase into a navigable graph lets AI explore functions and dependencies efficiently, and you explained it clearly.

this is fun

Fr

beautiful work. 👍

LLMs read code line by line. Graphs let them understand how the code actually connects.

A structurally pragmatic evolution in code→LLM pipelines: Raw code dump → LLM context forces O(N²) attention to blindly compute topology. Better: Parse to AST → DAG first → offload spatial reasoning to deterministic graph DB. Trade-off: Swap token exhaustion for graph traversal latency. Great for enterprise static analysis, but live refactoring? Real-time edge sync becomes the true bottleneck. High-signal move nonetheless.

@TheDevilOps ojo.

If CodeGraphContext scales, it could replace half the prompt-engineering tools by 2025.

this is pretty sick i like it

Finally, someone treated codebases like the complex networks they actually are. No more 'dump and pray' with LLMs! 🔥

Interesting idea, but it won’t represent cases where the function to call is determined at runtime.

How does it work with parameters? Parameters that give context. Promises that determine what is called. They would majorly change the graph I would assume. ??

Graph beats flat dumps for big repos

Now I can literally see the rabbit holes I end up going down

Representing code as a graph database aligns with how neural networks map relational dependencies. It is the end of the linear data dump.

Coding is hole World 🌍

what would help you monetize this! That’s always where I come in eventually someone has to sell and market

Interesting, I had written a paper about this idea…..

This is cool, but does it actually translate to better LLM performance?

Can i get this?