Hi, guys, I m building GitNexus, an opensource Code Intelligence Engine which works fully client sided in-browser. What all features would be useful, any integrations, cool ideas, etc?

site: https://gitnexus.vercel.app/
repo: https://github.com/abhigyanpatwari/GitNexus ( Would appreciate a ⭐)

This is the crux of how it works:
Repo parsed into Graph using AST -> Embeddings model running in browser creates the embeddings -> Everything is stored in a graph DB ( this also runs in browser through webassembly ) -> user sees UI visualization -> AI gets tools to query graph (cyfer query tool), semantic search, grep and node highlight.

So therefore we get a quick code intelligence engine that works fully client sided 100% private. Except the LLM provider there is no external data outlet. ( working on ollama support )

Would really appreciate any cool ideas / inputs / etc.

This is what I m aiming for right now:

1> Case 1 is quick way to chat with a repo, but then deepwiki is already there. But gitnexus has graph tools+ui so should be more accurate on audits and UI can help in visualize.

2> Downstream potential usecase will be MCP server exposed from browser itself, windsurf / cursor, etc can use it to perform codebase wise audits, blast radius detection of code changes, etc.

3> Another case might be since its fully private, devs having severe restrictions can use it with ollama or their own inference

I’ve built an Obsidian plugin that automatically manages bidirectional property relationships and provides an interactive relationship graph for navigating complex knowledge systems.

GitHub: https://github.com/Real1tyy/Nexus-Properties

Core Features

Bidirectional Relationship Management

• Define parent, child, or related relationships in one place

• Automatic synchronization of reverse links

• Optional sibling linking and recursive hierarchy computation

Interactive Relationship Graph

Multiple view modes to explore your knowledge structure:

• Hierarchical – parent–child trees

• Related – direct relationships

• All Related – full constellations

Property Inheritance & Automation

• New notes can automatically inherit properties from their parent

• Keeps metadata consistent across large vaults

• Reduces manual frontmatter maintenance

Custom Node Colors & Filtering

• Color nodes based on frontmatter using JavaScript expressions

• Filter graphs to focus only on relevant subsets of your vault

Zoom Mode

• Open note previews directly inside the graph

• Toggle frontmatter and content visibility for focused reading

Quick Node Creation

• Create parent, child, or related notes instantly from the command palette

• Relationships and properties are set up automatically

Who this is for

This plugin is a good fit if you:

• Maintain large or long-lived vaults

• Use structured frontmatter and metadata

• Think in hierarchies, relationships, and systems

• Want automatic consistency instead of manual linking

Probably not for you if:

• You prefer minimal notes with no metadata

• You want a lightweight, manual note-taking workflow

If you’re building a structured PKM system, this should feel like a natural extension. If you prefer unstructured notes, it will probably feel like overkill — intentionally.

Why I built this

As my vault grew, manual relationship management didn’t scale. I needed a system where structure emerges automatically, relationships stay correct, and navigation is visual and intuitive.

Nexus Properties is opinionated, but it removes a lot of cognitive and maintenance overhead once you commit to structured metadata.

To find out more

• Full documentation of all features and settings

• YouTube walkthrough

• Everything is linked in the GitHub repo

I’d love your feedback. Especially from people running larger or more structured Obsidian setups.

Installation: Available via BRAT (Community Plugins coming later)

I have been looking into tools that parse a codebase into a structural knowledge graph and expose it via MCP. The goal is to give agents better architectural awareness without them burning through context doing raw file searches.

I’ve been testing GitNexus recently, and I actually found that lower-tier models get a little better with it. Because the dependencies and call chains are pre-computed, the agent gets much better upstream and downstream context right away. It feels like it translates directly to better edits and solid token savings (did not count just observed with usage limits), since the model doesn't have to struggle to infer the system architecture on the fly or ingest massive raw files.

I’ve also seen Codegraph popping up specifically for optimizing Claude Code exploration.

Has anyone been using these two, or using something similar in their stack? Curious to hear how they handle larger repos, if you're seeing any increase in efficiency?

I’m curious what benefits (besides cost) Obsidian Sync has over Obsidian Git and vice versa.

I’m already very familiar with Github, and I’m planning on donating to Obsidian if I don’t bother with Sync.

I started a job at a company that relies on Nexus Repository Manager. From what I saw and researched its primary use-case is storing and distributing artifacts of various kinds coming from CI frameworks such as jenkins (also part of the companies stack).

In the past I made heavy use of gitlab, azure (I'm not the biggest fan of azure but it is used at that company as well) and github which all (if I'm not mistaken) come with ways to handle artifacts. I'm wondering if there are reasons to still support that stack (azure, jenkins, nexus) or to transition fully to azure as this should be able to handle all these requirements but in a single place.

Hi guys, I m working on this free to use opensource project Gitnexus, which I think can enable claude code like tools to reliably audit the architecture of codebases while reducing cost and increasing accuracy and with some other useful features,

I have just published a CLI tool which will index your repo locally and expose it through MCP ( skip the video 30 seconds to see claude code integration ). LOOKING FOR CRITICAL FEEDBACK to improve it further.

repo: https://github.com/abhigyanpatwari/GitNexus (A ⭐ would help a lot :-) )

Webapp: https://gitnexus.vercel.app/

What it does:
It creates knowledge graph of codebases, make clusters, process maps. Basically skipping the tech jargon, the idea is to make the tools themselves smarter so LLMs can offload a lot of the retrieval reasoning part to the tools, making LLMs much more reliable. I found haiku 4.5 was able to outperform opus 4.5 using its MCP on deep architectural context.

Therefore, it can accurately do auditing, impact detection, trace the call chains and be accurate while saving a lot of tokens especially on monorepos. LLM gets much more reliable since it gets Deep Architectural Insights and AST based relations, making it able to see all upstream / downstream dependencies and what is located where exactly without having to read through files.

Also you can run gitnexus wiki to generate an accurate wiki of your repo covering everything reliably ( highly recommend minimax m2.5 cheap and great for this usecase )

repo wiki of gitnexus made by gitnexus :-) https://gistcdn.githack.com/abhigyantrumio/575c5eaf957e56194d5efe2293e2b7ab/raw/index.html#other

to set it up:
1> npm install -g gitnexus
2> on the root of a repo or wherever the .git is configured run gitnexus analyze
3> add the MCP on whatever coding tool u prefer, right now claude code will use it better since I gitnexus intercepts its native tools and enriches them with relational context so it works better without even using the MCP.

Also try out the skills - will be auto setup on when u run: gitnexus analyze

{

"mcp": {

"gitnexus": {

"command": "npx",

"args": ["-y", "gitnexus@latest", "mcp"]

}

}

}

Everything is client sided both the CLI and webapp ( webapp uses webassembly to run the DB engine, AST parsers etc )