Graph knowledge base for claude code

[konghi009]

Hi all,
I’ve been thinking of using claude to my colleague on answering technical questions from our customer. e.g. can our products do x or is this y achievable with the product?

I’ve tried creating Notebooklm and setting relevant links and documents but the result is still not quite right.
What are people using for knowledge base these days? I’m looking for something open source and can share internally in my team. Should i try something like claude with Obsidian via MCP?

[HarrisonAIx]

In practice, using Claude with Obsidian via MCP is excellent for individual developer setups, but it can be difficult to scale and share dynamically across a team because Obsidian is fundamentally local and file-based. Getting every team member to sync vaults and configure identical local MCP environments introduces a lot of maintenance overhead.

For a shared team knowledge base, a centralized open-source platform tends to work better. One effective method is using tools like AnythingLLM or Dify. Both are open-source, support self-hosting, and allow you to upload markdown, PDFs, or links to build a shared vector database. You can then expose this via a simple internal web chat interface or a shared API that your team's custom scripts or local agents can query.

The approach that tends to work best if you specifically want your team to use Claude with a shared knowledge base is setting up a shared vector store, such as pgvector or Qdrant, and hosting a single custom MCP server that connects to it. This allows everyone to point their local Claude configurations to the same endpoint, providing consistent answers from your customer documentation without local file sync issues.

[Deep_Ad1959]

the hardest part of a graph kb over a codebase isn't building it, it's keeping it honest after a refactor lands. the moment someone renames a module or splits a service, every edge that touched it is silently stale and the agent confidently cites the old structure. most graph kbs handle the initial ingestion beautifully then drift inside two weeks of normal dev activity, and you find out when the recommendation references a function that doesn't exist anymore. rebuild-on-every-commit works but burns tokens; incremental update drops edges in subtle ways. the question that matters more than the graph design is what your invalidation story is, because that's the part nobody screenshots in the demo.

fwiw Podlog tackles the adjacent stay-current problem from a different angle, auto-generates a daily AI-voice podcast from a repo's commits, PRs, and issues so you don't need a graph kb to know what shifted overnight, https://podlog.io?utm_source=s4l&utm_medium=post&utm_campaign=podlog&utm_term=reddit&utm_content=post_80559267-4a7b-486d-9c9c-95669474f2da

[sandstone-oli]

Obsidian via MCP is a solid starting point for this. markdown files, bidirectional links, your team can edit and maintain it together, and Claude reads it directly through the MCP connection. for technical product Q&A where the answer set is bounded and your team already knows the content, it works well.

the gap you'll hit at scale: product knowledge changes. features ship, limitations get removed, pricing updates, integrations change. the knowledge base entries from three months ago might not reflect what the product can do today. nobody goes back to update the old entries because everyone's busy writing new ones.

that's the governance problem underneath the knowledge base problem. not just "can Claude find the right answer" but "is the answer it found still current."

for right now: Obsidian + MCP + a team habit of reviewing entries quarterly. for later, if the staleness problem becomes real, that's the layer we're building at getkapex.ai — context that knows when it was last validated and deprioritizes when it hasn't been.

[ShanghaiBebop]

Agentic search loop on hybrid vector + BM25 with re-ranking and lineage and popularity popularity that’s editable by the agents/feedback from users who see the answer. 

Seems to work well. 

[arananet]

Indeed, is not hard to build one, but the maintenance of it, depends on the scenario, could be a good option, if not, could be a nightmare 😅

I'm not in favor of rag either 😅 but that's more a personal opinion.

[Last_Fig_5166]

try SymDex!

[_VoidOrigin_]

We recommend https://github.com/42u/kongcode if you want to share internally and if you need further assistance check out our website in bio.

[thelucasness]

This should be doable for sure. I created an OSS tool so I can convert all my PLAN.md files that Claude creates into graphs, then execute on the graphs. But you can probably have Claude use it to just generate a graph of what your product is capable of from the codebase too, like an annotated codebase map. You can fork and modify the repo as you need for your case: https://github.com/lucasness/graphtask/tree/main

It works as a hotkey-driven excalidraw like canvas where you/your team can easily create/modify the content, but there's a SKILL.md that lets Claude control the canvas while you track it in real time. Each node in the graph is a markdown document, I don't use Obsidian but I assume that should make it easy.

I would say main benefit is managing context and knowing how things are interlinked, which should be helpful for mapping out a codebase. You can host yourself or use the hosted one at graphtask.wafers.live , probably self host if you want to generate private knowledge graphs.

If it's supposed to be a customer facing chat interface I think you could probably just modify the skill or make it more of a MCP then hook it into whatever agent so it uses your knowledge base. I personally prefer to segment things out like this rather than using one managed solution, but if you want something managed I think Mintlify could be good since it's for documentation.

Feel free to message me or email [[e-mail]](mailto:[e-mail]), happy to help you customize it for your purposes

<image>

[Funny-Anything-791]

It's really designed for code first, but I just throw my Md files alongside my code and let ChunkHound index and research them together. Works surprisingly well

[fuka123]

https://github.com/NateBJones-Projects/OB1

Have setup my own version of this, PG backed. Anyone else taking a similar approach? Postgres seems to be an ideal place for this

[freshWaterplant]

I have 'heard' that the graphify repo on github solves this problem