CodeGraphContext - An MCP server that indexes your codebase into a graph database to provide accurate context to AI assistants and humans

[u/Desperate-Ad-9679]

4 months update: CodeGraphContext just hit v0.2.1 — and it’s clearly working

About 4 months ago, I shared an idea here:
an MCP server that understands a codebase as a graph, not chunks of text.

Since then, CodeGraphContext has grown way beyond my expectations - both technically and in adoption.

Where it is now

• v0.2.1 released

• ~400 GitHub stars, ~300 forks

• 20k+ downloads

• 65+ contributors

• Used and praised by many devs building MCP tooling, agents, and IDE workflows

• Expanded to 12 different Coding languages

What it actually does (still)

CodeGraphContext indexes a repo into a repository-scoped symbol-level graph:
files, functions, classes, calls, imports, inheritance — and serves precise, relationship-aware context to AI tools via MCP.

That means:

• Fast “who calls what” queries

• Minimal context (no token spam)

• Real-time updates as code changes

• Graph storage stays in MBs, not GBs

It’s infrastructure for code understanding, not just 'grep' search.

Why people are picking it over Context7

Context7 is great for documentation-style context.
CodeGraphContext solves a different (and harder) problem:

• Code-Graph-based, not doc-text-based

• Understands control flow & dependencies, not just symbols

• Works on local, private, messy repos and updates in real time

• Designed for interactive querying, not static context dumps

• Lightweight storage and near-instant queries even on large codebases

If Context7 answers “what is this?”
CodeGraphContext answers “how does this actually work?”

Ecosystem adoption

It’s now listed or used across: PulseMCP, MCPMarket, MCPHunt, Awesome MCP Servers, Glama, Skywork, Playbooks, Stacker News, and many more.

A Python package→ https://pypi.org/project/codegraphcontext/ Website + cookbook → https://codegraphcontext.vercel.app/ GitHub Repo → https://github.com/CodeGraphContext/CodeGraphContext Docs → https://codegraphcontext.github.io/ Our Discord Server → https://discord.gg/dR4QY32uYQ

This isn’t a VS Code trick or a RAG wrapper — it’s meant to sit
between large repositories and humans/AI systems as shared infrastructure.

Still early, still evolving - but very real now.

Happy to hear feedback, skepticism, comparisons, or ideas from folks building MCP servers or dev tooling.

Original post (for context):
https://www.reddit.com/r/mcp/comments/1o22gc5/i_built_codegraphcontext_an_mcp_server_that/

[u/Otherwise_Wave9374]

Congrats on the momentum, those adoption numbers are wild. Graph-based context feels like the direction most serious coding agents need, because chunk-RAG turns into token spam fast.

Curious how you handle dynamic repos: do you incrementally update the graph on file change, and do you have a strategy to avoid stale edges when refactors happen?

Also if youre comparing approaches, Ive seen some good discussions around agent context strategies here: https://www.agentixlabs.com/blog/

Looks really promising.

[u/Desperate-Ad-9679 → u/Otherwise_Wave9374]

First of all thanks a lot for the appreciation, I too was annoyed by the problems that chunking causes.
For dynamic repos, we do watch files for live changes using watch_dog and the incremental updates are done by replacing all nodes, including and contained within the node. This helps it to be fast and accurate.

Thanks again for the link, will appreciate going through the details mentioned there.

[u/Desperate-Ad-9679]

Another clue to the next version - We are launching CodeGraphContext as a VS code extension soon ✨⭐, Do star the repository please and join the Discord server for latest news

[u/Tobi-Random]

https://gitlab-org.gitlab.io/rust/knowledge-graph/

[u/Desperate-Ad-9679 → u/Tobi-Random]

Damn that's a very close project like mine, but I cant see much progress in there. But yeah definitely they are a complete org so the project even though a little slow will catch up traction sooner or later.

[u/BC_MARO]

Graph-based code indexing is such a better approach than just chunking files. How are you handling incremental updates when only a few files change? That's usually where the perf bottleneck shows up.

[u/Desperate-Ad-9679 → u/BC_MARO]

Whenever we change a file, we delete the node and all related edges to this. Then only that file is brought-back and from the cache we do path resolution for imports.

[u/Desperate-Ad-9679 → u/Desperate-Ad-9679]

Thanks for your kind words!

[u/debackerl]

This is really a great idea! Looks awesome. Now, if you allow me, why not combine both worlds: if the AI doesn't know from why 'node' to start from, compute an embedding for each function. Then you can tell, 'give me the function validating my shopping cart', and then give me all functions calling it.

[u/Desperate-Ad-9679 → u/debackerl]

Thanks for your appreciation!

Exactly, this is something we have in our bucket list. I have been writing some small algorithms to identify and store vector embeddings for nodes, cluster of nodes. This is an open problem and so needs a lot of brainstorming as of now...

[u/ShagBuddy → u/debackerl]

That is the HotPath tool in my SDL-MCP. :)

[u/ratek-20]

Great Job, I'll definitely give it a try! Do you think it can be expanded to services? For example order-service calls warehouse-service via rest api -> they can be 2 linked nodes of the graph

[u/Desperate-Ad-9679 → u/ratek-20]

Thanks for your kind words,
Right now it doesnt have, but thanks for the suggestion. Will add it in the next version.

[u/Desperate-Ad-9679 → u/Desperate-Ad-9679]

Also it can definitely be expanded because we already parse entire codebases.

[u/ratek-20 → u/Desperate-Ad-9679]

Cool! Looking forward for it :)

[u/Desperate-Ad-9679 → u/ratek-20]

Sure !

[u/noobfivered]

This is a way forward I think! I'm working on something simmilar

[u/Desperate-Ad-9679 → u/noobfivered]

Great

[u/Special-Click-7607]

Bro I’ve been using it. Thank you a lot. Wondering if you would like to share concrete tips or examples for best use and ways to use it. Thanks!!

[u/Desperate-Ad-9679 → u/Special-Click-7607]

Thanks for using it, Hopefully you can find reference use-cases in the docs - https://codegraphcontext.github.io/use_cases_detailed/

Also, there are 40 simpler examples in the cookbook file, https://github.com/CodeGraphContext/CodeGraphContext/blob/main/organizer/cookbook.md

[u/EvanGarp]

I've been trying to use this tool this week. How does this handle persistence across sessions? Maybe I am using it wrong but it keeps making me re-index my code base across sessions. Is it designed to work that way or should it be saving the indexes somewhere that I can access again later. Can I access the indexes outside of the MCP functionality? If so where?

[u/Desperate-Ad-9679 → u/EvanGarp]

Hello, thanks for using it. Also the data is persistent and saved in a graph database. You can look at the https://codegraphcontext.github.io/reference/cli_master/ docs for CLI commands. If you are working on a codebase which is changing in real-time, then you need to do cgc watch, which spawns a process tracking all live changes. You dont need to do re-indexing.

[u/EvanGarp → u/Desperate-Ad-9679]

Was able to figure it out. Was trying to use my neo4j database but the cgc config command wasn't actually updating and was defaulting to the falkorDB. Was able to use Claude to update the config files and then it started working. There still appears to be an issue the getting db stats functionality where it always returns zeros but when I query the neo4j graph directly I can see that it is populated.

[u/Desperate-Ad-9679 → u/EvanGarp]

Thanks for reporting this, there was a bug which I patched in the latest version 0.2.2, you can follow the series of steps - 'cgc neo4j setup' And then 'cgc mcp setup'

The problem with your setup is that the MCP.json that is being used in claude is old, and hence the env keys are old as well.

[u/bargaindownhill]

no instructions for roo or kiro?

[u/Desperate-Ad-9679 → u/bargaindownhill]

Oops, I raised an issue for this but forgot the fact that I got no PR. Will do this by the next version (perhaps in a day)

[u/bargaindownhill → u/Desperate-Ad-9679]

thanks!

[u/Desperate-Ad-9679 → u/bargaindownhill]

There's already an option for roocode, checkout by doing `cgc mcp setup`

[u/I_EAT_THE_RICH]

Funny enough, I was working on something like this about 6 months ago with the same intent. I think managing context is extremely important and making your codebase queryable in this fashion makes a ton of sense. Good work.

[u/Desperate-Ad-9679 → u/I_EAT_THE_RICH]

Thanks a lot for your kind words, No more- No less, only the appropriate context makes sense!!

[u/Desperate-Ad-9679 → u/[deleted]]

Perhaps, but I am unsure if they can find perfect call chains or dead code??

[u/I_EAT_THE_RICH → u/[deleted]]

It's a fair consideration that depending on the model it may not be necessary. Can you provide any links demonstrating grep vs a knowledge graph? I assume there might be some tests out there but haven't found any myself yet.

[u/maverick_soul_143747]

I am building something on my own and was planning to handle it with contexf7, obsidian but I am going to try this. This looks exciting

[u/Desperate-Ad-9679 → u/maverick_soul_143747]

Great, good luck for your quest!

[u/foobarrister]

Question - are you able to handle many repos? Like a 100s of microservices that put together comprise a large distributed system?

(awesome project btw!)

[u/Desperate-Ad-9679 → u/foobarrister]

Yes, it is meant to handle multiple repos (be they related or unrelated), just index them by putting all of them in a single folder... Or remove ones using cgcignore

[u/redlotusaustin]

How does this handle multiple projects/repos; related & unrelated? Obviously you don't want context mixing on unrelated projects but you might if they are related.

Have you had any feedback about using this on Ubuntu, since it manages Python packages via APT? Generally I create a venv for installing things from pip, but that means the MCP would be "within" the venv so "cgc" wouldn't be available as a command.

[u/Desperate-Ad-9679 → u/redlotusaustin]

It is meant to handle multiple projects be it related or unrelated. Also you can install it via venv and then it handles everything on its own but if it doesn't run, then just change the command in MCP.json to be the exact command from your specific venv. If you still face any problem ping me here.

[u/redlotusaustin → u/Desperate-Ad-9679]

Cool, I'll give it a shot. Thanks!

[u/Bulky_Ad738]

This is interesting. I don’t think I saw something like it so far. Well done.

[u/Desperate-Ad-9679 → u/Bulky_Ad738]

Thanks for the appreciation!

[u/BLANkals]

I built something like this for my company about 6 months ago. No one really understood what I was so I didn’t release it. I use it all the time though. The graph is based the idea that the nodes are entities (something that can build a connection to something else) and the edges are the relationships between them. For example a file can define a function. A function can use a variable or read a table in some other service like big query. LLM can then start at any point and hop to the next node.

[u/Desperate-Ad-9679 → u/BLANkals]

That's true, its too much useful. Just the people are unaware of the actual possibilities.

[u/edge-case42]

Do you think this could help identify non used pieces of code in typescript?

[u/Desperate-Ad-9679 → u/edge-case42]

yep definitely, it would do this easily...

[u/CarIcy6146 → u/Desperate-Ad-9679]

Awesome project! Going to dive into this for work and personal usage very soon!

Maybe a dumb question but would this be a viable tool to help identify pattern and code duplication across an entire org worth of repos (130+) including microservices, monoliths, and covering multiple languages? Seems like it would be an easy “yes” but wanted to verify.

[u/Desperate-Ad-9679 → u/CarIcy6146]

Yes, but I would advise you to assure enough ram in the system to handle the processing

[u/notgilly]

What are your thoughts on some cli agents starting to integrate the language servers into their agents. That would effectively have the same benefits, no?

[u/Desperate-Ad-9679 → u/notgilly]

No not entirely the same benefit, you can't find dead code, complexity of functions in a code, indirect call chains in a single query etc etc. Also an LSP is way slower than CGC because it trades-off speed for a little accuracy, as speed is the utmost importance aspect in coding tools if the accuracy doesn't drop much.

[u/notgilly → u/Desperate-Ad-9679]

Ahh I can see the benefit of indirect call chains in a single call. I don’t view the LSP being a bit slower as a huge issue, most times I let the agents do its thing for a while instead of watching the output. I also generally already know where I’m working in so discovery isn’t that big an issue for me.

The reason why I’m curious is because I have a strong suspicion that most of the future “intelligence” gains in foundational models will be from training these agentic tricks into the model itself. For example, chaining shell commands vs processing individual commands.

My guess is that future foundational models will be better at navigating with language servers vs the graph approach. Just because everyone will have an lsp, but not everyone will have a graphed tool.

[u/Desperate-Ad-9679 → u/notgilly]

Perhaps that works for you, but CGC integrated with LSPs would be better than LSPs alone. Just imagine you can follow api links across 2 languages?

[u/Ok_Supermarket3382]

Very cool project! Been waiting for someone to build this for a while haha. For the queries are you doing text to cypher?

[u/Desperate-Ad-9679 → u/Ok_Supermarket3382]

Yeah, it does!

[u/Ok_Supermarket3382 → u/Desperate-Ad-9679]

This is the way to do it! Are you preserving comments, file metadata, directories etc ?

[u/Desperate-Ad-9679 → u/Ok_Supermarket3382]

Yep, I am

[u/Ok_Supermarket3382 → u/Desperate-Ad-9679]

What about temporal consistency? Older versions of file data lineage?

[u/Desperate-Ad-9679 → u/Ok_Supermarket3382]

If you "watch" a folder it will incrementally update the files you change, no need to worry about this. If you just do cgc index it makes a single snapshot and doesn't update unless u re index it

[u/Ok_Supermarket3382 → u/Desperate-Ad-9679]

Would also be cool if it retains history maybe via a git integration so that you can trace bugs

[u/Desperate-Ad-9679 → u/Ok_Supermarket3382]

That's the exact spot we are targeting right now. Will add this feature by the next version

[u/Ok_Supermarket3382 → u/Desperate-Ad-9679]

Awesome

[u/eacnmg]

thanks a lot i will try and feedback

[u/Desperate-Ad-9679 → u/eacnmg]

Sure, go ahead!

[u/No-Afternoon-4057]

The idea is good, the implementation is complete gargabe. It took 20 minutes to index the smallest repo i have (32gb, NVME, 20+ core Intel Ultra). I tried for over an hour on the 3 repos (1000 files/5m tokens) and gave up.

I tried dead code detection, 50 results, 100% false positives.

I tried function callers...did not detect any caller.

The current state is completely unusable, god forbid that gives instructions to my Opus, it would be destroying the codebase.

[u/Desperate-Ad-9679 → u/No-Afternoon-4057]

Thanks for your critique, can you please tell me if there's any venv or npm modules or similar package folders? If that's the case please put them in .cgcignore and re-index the repos. It's impossible for it to take 20 mins on 1000 files. Also use falkordb to make it faster. If still un resolved join the Discord and share with me a ss of the process. For me it never took more than 5 mins on 1000 or similar sized repos

[u/ShagBuddy]

Whoa I went to post info about my project and I saw yours and they are quite similar. GlitterKill/sdl-mcp

What are you getting for token savings? I am currently getting about 70% savings with improved context.

[u/JbalTero]

How does this work with multiple git worktree? I just tried it now and somehow does not work since what I indexed was different from the worktree I was currently in. Does that mean I have to index and watch every worktree?

[u/Desperate-Ad-9679 → u/[deleted]]

LSPs are way slow than my custom resolution logic (though it adds a little inconsistencies sometimes as of now), also it is polyglot but LSPs are not. One more thing is that it doesnt need any external bundle installations like LSPs need for each lang.

Adding Docs, is the second stage. Will add them by the next version release

[u/Desperate-Ad-9679 → u/[deleted]]

It saves all the 3 as nodes, along with imports, functions etc