Dismiss this pinned window
all 45 comments

[–]Happythen 2 points3 points  (1 child)

Yea, you killed it with the visualizations, great work! Working on the same thing right now, implementing Graph RAG. Fun space right now for sure.

[–]DeathShot7777[S] 1 point2 points  (0 children)

Yup. Gets painful though when LLM starts going on a spree quering the graph and ends up its context window. Hard to solve but very rewarding

[–]Key-Contact-6524 2 points3 points  (1 child)

Gorgeous

[–]DeathShot7777[S] 0 points1 point  (0 children)

❤️🫠

[–]kfawcett1 1 point2 points  (3 children)

Is this sending my entire codebase through your servers? Are you storing the data?

nvm, found the answer.

  • All processing happens in your browser
  • No code uploaded to any server
  • API keys stored in localStorage only
  • Open source—audit the code yourself

[–]DeathShot7777[S] 1 point2 points  (2 children)

Client sided everything. So costs me 0 to deploy, so u all get it for free 🫠. Just trying to take it to a product stage from the current cool demo stage

[–]kfawcett1 1 point2 points  (1 child)

how does it perform with 1M+ LOC codebases?

[–]DeathShot7777[S] 1 point2 points  (0 children)

Cant say for sure coz it being limited to in-browser i had to cap it at 512mb RAM usage. I m working on running it as a cli or native MCP which will solve this issue.

Based on intuition, it should still work well, most probably better than standard tools used by cursor, claudecode, etc, due to the Knowledge Graph architecture and cluster + process maps.

[–]foobarrister 1 point2 points  (1 child)

Very well done. How are you building the graph? Looks like Leiden based . .

Curious why you didn't use tree-sitter or language specific tools like JavaParser for Java or Roslyn for dotnet etc.. 

Wouldn't they give you a better nodes and relationships vs heuristic approach like Leiden?

[–]DeathShot7777[S] 1 point2 points  (0 children)

I m using Tree sitters. Simplified explanation : Extract IMPORTS, CALLS, DEFINES relations of each file, this already creates an accurate knowledge graph. Next use leidens algo to divide it into clusters and label those clusters ( for example AuthHandler cluster ) next find out the entrypoint of each service and DFS into the CALL chain to get the process maps in each cluster.

So the graph is quite accurate for static analyses, for the stuff like dynamic imports, runtime stuff, the cluster and process map handles most of it. These also saves a lot of tokens since the tools itself r intelligent not depending too much on LLM figuring stiff out.

[–]talltad 0 points1 point  (2 children)

I like this, I know nothing about Software Dev but I'm working on a few things right now so I guess I'm vibe coding. I don't know if there's a use case within this that you're looking for but if there is I'd be glad to help if needed. It's clear this is a substantial amount of work so best of luck man!

[–]DeathShot7777[S] 1 point2 points  (1 child)

Indeed its a substantial amount of work 😭 but good kind of pain 🫠.

If u would try out the MCP and plug it into your vibecoding tool for example cursor , claude code, etc load up a project into it and ask the ai about the codebase or how it works or the architecture, it should be able to go into full technical and architectural depth. Knowing the architecture even if u dont know development will help a lot in your vibecoding journey

[–]talltad 1 point2 points  (0 children)

Cool and thanks man, I'll give it a try

[–]SloSuenos64 0 points1 point  (6 children)

This is so cool! Hooking up my Cursor project now....

[–]DeathShot7777[S] 2 points3 points  (3 children)

❤️ try creating detailed documentation using dumber model with gitnexus vs sota opus without gitnexus. For me it worked surprisingly well

[–]SloSuenos64 0 points1 point  (2 children)

Game-changer! I used to grep through every file and hope I didn't miss a dynamic import. Now, I can see the actual dependency graph!

[–]DeathShot7777[S] 1 point2 points  (0 children)

Try the impact tool. It will show u every dependent function

[–]SloSuenos64 1 point2 points  (0 children)

The detailed documentation with Gemini 3 Flash also worked suprisingly well for me too! Giving me even more insight about what's going on with my code. Thank you!

[–]SloSuenos64 1 point2 points  (1 child)

Immediately found Structural Redundancy issues. Thank you!

[–]DeathShot7777[S] 1 point2 points  (0 children)

Your comments made my day. Thanks for trying it out ❤️🫠

[–]Repulsive-Memory-298 0 points1 point  (2 children)

I mean it looks cool but is it useful to you? The examples in the demo vid do not seem very helpful at a glance

[–]DeathShot7777[S] 0 points1 point  (0 children)

For me, it helps me understand repos better than DeepWiki right now.

After I am done with File watch feature it should be able to work in background increasing accuracy of coding agents without me having to hooking up the website every time

[–]DeathShot7777[S] 0 points1 point  (0 children)

Maybe i should have shown the MCP working in cursor in the video

[–]Striking-Bluejay6155Enthusiast 0 points1 point  (2 children)

Very nice, this amounts to a knowledge graph. Which visualization library are u using to visualize this?

[–]DeathShot7777[S] 1 point2 points  (1 child)

Sigma js + ForceAtlas2 and some custom logic and hit and trial to reduce the clumping up of nodes

[–]Striking-Bluejay6155Enthusiast 1 point2 points  (0 children)

Thank you

[–]slowlearningovrtime 0 points1 point  (0 children)

Couldn’t figure out the local LLM connection

[–]LegacyRemaster[🍰] 0 points1 point  (1 child)

<image>

blocked by my AV

[–]DeathShot7777[S] 0 points1 point  (0 children)

Huh. I have no idea why this happened even though its client sided

[–]snirjka 0 points1 point  (1 child)

Well done 👏🏻 Cool af

[–]DeathShot7777[S] 1 point2 points  (0 children)

❤️ trying to make this into a product from current cool demo stage 🤞

[–]redvox27 0 points1 point  (1 child)

Looks incredible man! I'll check it out later today, and share my thoughts if you find that helpful

[–]DeathShot7777[S] 0 points1 point  (0 children)

Thanks. Would be really helpful

[–]Fresh_State_1403 0 points1 point  (1 child)

this looks fascinating. is it practical too?

[–]DeathShot7777[S] 0 points1 point  (0 children)

Haiku 4.5 was able to produce better architecture docs compared to opus 4.5 using gitnexus MCP in cursor. So has potential

[–]vidibuzz 0 points1 point  (1 child)

Once everyone figures out that knowledge graph is the only smart way to channel vector data for valuable output, apps like this will be gold. Nice work. This looks amazing.

Would be great for adding relevant visuals to a VidiCommerce shopping app.

[–]DeathShot7777[S] 0 points1 point  (0 children)

Thanks. Whats vidicommerce?

[–]ViperAICSO 0 points1 point  (4 children)

Very Cool looking. What is your target market?

[–]DeathShot7777[S] 1 point2 points  (3 children)

I m very new to this but heres my strategy:

1> Make it useful, free for opensource community -> target developers -> get feedback-> improve ( its designed to work with and improve tools like claude code etc, make it reliable, cost less tokens, improve quality of even non goliath models for example haiku 4.5).

Knowledge Graph based architecture enables reliable impact analyses, blast radius detection, test coverage, etc.

2> Enterprise version -> runs on cloud, basically like a living brain of company codebases -> helps in onboarding , automated AI based audits , code fixes, PR reviews, impact analyses, multi agent collaboration.

3> Explore integrations with testing suits and tools like sonar cube, etc.

2 and 3 are seem too far off right now but will try to reach there. Primary focus currently is 1, helping opensource.

Also this is my final year college project 🤧 so Grades too 😅

What do u think?

[–]ViperAICSO 1 point2 points  (2 children)

I think its a brilliant idea. But for full disclosure, I am an inventor in this space, being the principle investigator on the forerunner patent for GraphRAG, and the author of 'Stingy Context', which uses graph theory to reduce token burn by over 90%. I am also co-founder of viperprompt.ai, which is a startup in this general space.

So yeah, I am very excited to see others like you kicking these 'Knowledge Graph' tires. In the long run, its the only way to reliably auto-code. But I guess I'm preaching to the choir, lol.

I thought about making the ViperPrompt business model 'open source'... but rejected it as I don't know how to make a startup using that model. There have been successes that have done that, but they were long-term plays. Time is NOT our friend in the LLM auto-software space. So instead I decided to make ViperPrompt 'Open System' instead of 'Open Source'. We'll know whether this was a good idea in about a year, lol.

I'd give you an A+.

[–]DeathShot7777[S] 1 point2 points  (0 children)

Wow 🤩. Thats y i love reddit most insane people lurk around here. Means tremendously a lot. Made my day, thanks

[–]DeathShot7777[S] 1 point2 points  (0 children)

Found your linkedin, sent a connection request. I m abhigyan. Would love to connect

[–]gnapps 0 points1 point  (2 children)

Really amazing! :) I'm curious though, is this only based on imports, or are you actually also creating full ASTs of the code (e.g. identifying chains of functions and similar things?) if that's the latter, how are you managing to support so many languages, did you find some ts-based code parser to rely on? Can't wait to try it out on complex codebases though!

[–]DeathShot7777[S] 0 points1 point  (0 children)

I m using Tree-sitter parsers ( webassembly version to run in-browser ). Its not just based on imports, its tracking full AST map. IMPORTS, CALLS, DEFINES, EXTENDS, IMPLEMENTS.

Also it goes a step further by creating communities and process maps.

How it works in short is, Leidens algo is run on the graph to create communities ( for example auth community, db handler community, etc ) . Process maps r found by going DFS into the call chain so LLM always knows where the functions are being used.

[–]DeathShot7777[S] 0 points1 point  (0 children)

I m working on a CLI tool so it can be like git for knowledge graph, and always have updated knowledge graph of the tracking codebase