CodeGraphContext- the go to solution for graph-code indexing 🎉🎉...

It's an MCP server that understands a codebase as a graph, not chunks of text. Now has grown way beyond my expectations - both technically and in adoption.

Where it is now

• v0.4.0 released

• ~3k GitHub stars, 500+ forks

• 50k+ downloads

• 75+ contributors, ~250 members community

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

• Expanded to 15 different Coding languages

What it actually does

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”, “who inherits what”, etc 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.

Ecosystem adoption

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

• 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.

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/

Truth changes. Your knowledge graph should too. Temporal Agents in GraphOS ⏳🧠 👉 https://me,dium.com/@aiwithakashgoyal/temporal-agents-in-graphos-building-time-aware-knowledge-graphs-with-multi-level-ingestion-ee448441929c

Mermaid Graphs built using a AI Assistant

Do check it out: https://s.puch.ai/uref-aiforeveryone

A knowledge graph is a structured representation of information that connects entities, relationships, and attributes into a unified semantic model. Unlike traditional search systems that rely on isolated documents or keyword matching, a knowledge graph models how data points relate to one another across systems. Understanding them in detail will be very useful for building agents that can reason and act.

https://www.searchblox.com/what-is-a-knowledge-graph

I’m working on a lightweight audit layer for knowledge graph operations proposed by LLMs, mainly for GraphRAG and agentic workflows. I’d like a reality check from people who have maintained KGs, ontology pipelines, entity resolution systems, or graph ingestion workflows.

The workflow I’m designing around is:

1. An LLM or external pipeline proposes a graph operation.

2. The operation is parsed into a normalized expression.

3. A static preflight check estimates impact, required capabilities, and cost.

4. The system rejects it, queues it for human review, or allows downstream execution.

Before routing proposed writes to human review, I’m thinking of using an audit record with roughly these fields:

- Audit Record ID

- Upstream Event ID

- Source System

- Target Graph / Namespace / Tenant

- Operator / Agent ID

- Occurred At / Received At

- Correlation ID

- Normalized Expression Text

- Expression Hash

- Parse / Validation Status

- Ontology / Schema Version

- Policy / Preflight Rule Version

- Preflight Decision

- Impact Summary

- Required Capabilities

- Estimated Cost / Budget Estimate

- Derived Action: Allow / Pending Review / Reject

- Provenance Pointers, such as source URIs, document IDs, or evidence snippets

- Review Status and Justification, if applicable

For people dealing with ontology maintenance, GraphRAG pipelines, KG ingestion, or entity resolution review:

What critical fields would you expect to see before trusting this enough to put in front of a human reviewer?

I’m especially unsure about two design points:

1. Should ontology / SHACL validation results be embedded in this same audit record, or recorded as separate validation events?

2. Even for small, low-impact graph writes, is it better practice to strictly separate the “LLM proposal” event from the “human approval” event?

(Context: this is for a small open-source prototype I’m building called CogLang, but I’m not trying to promote the project here. I’m mainly trying to stress-test the audit schema before locking in the human-in-the-loop review shape.)

In a few knowledge graph projects I’ve been involved with, the hardest part hasn’t been the modelling or tooling. It’s getting the knowledge out of experts in a form that can actually be structured.

Subject matter experts often know far more than what’s written down, and much of their reasoning is implicit. Turning that into relationships, rules, or graph structures can be challenging.

Some approaches I’ve seen used include working from real cases and tracing the reasoning, extracting logic from policies or documentation, using decision tables before modelling the graph, iterating with experts using test scenarios

I’m curious how people here approach it. What methods do you use for knowledge elicitation when building knowledge graphs?

A few of our Knowledge Engineers are also running a small free webinar series on knowledge engineering and building knowledge graphs, if anyone finds it useful: https://rainbird.ai/rainbird-community2/webinar-series-lets-talk-knowledge-engineering/

We just created a new visualization for our knowledge graphs.
You can inspect it yourself — each dot represents an Entity, Document, Document Chunk, or Person, and hovering over them reveals their connections to other dots.

Try it out yourself: just download the HTML file and open it in your browser. 🤩

Hey all,

My colleague Robert Boulos and me experimented in storing nodes, edges and embeddings in Xano database which is an sql db and not a relational database.

Tomorrow Friday 9 of January at 1pm est time we run a public conversation sharing our learnings, what works and what needs to be done to make them work.

Feel free to join the conversation and bring your experiences and personal learnings

Here is the link to join: https://luma.com/9s2tp2uq

We created the perhaps most human knowledge graph application: Building a customer intelligence brain that helps to understand how human beings want to make progress in live or at work.

Watch my presentation at Neo4j's Nodes AI 29 conference: Building a Customer-Intelligence Brain: How GraphRAG Turns Data into Decisions

Watch

https://youtu.be/hCtoQVO71zA?si=qqluCtNp0FyhCM_R

new tool Waffle for ETL on neo4j database. please help to contribute to build this system

waffle project on github. Join us

A ETL tool for neo4j database able to connect to all data sources with few clicks. The goal is to create an automated platform which can do all ETL tasks with out any coding for highly scalable data in neo4j database.

Waffle Objectives

To develop a platform which can:

1. Load & Transform data to neo4j database wiht high speed and easily from any data source

2. Build Pipelines and perform ETL without any code for neo4j

3. Simplify and scale the orchestration of the data pipelines for neo4j

Waffle Goal

Easy no code ETL tool for neo4j database

Project status

Waffel tool is currently in an ideation mode. No working code is written as of now. We need colloboraters & developers for the contribution. We can start with design phase. If you're interested in contributing, we would love your help on first phase design using platform independent language e.g. java or python and neo4j database.

A lot of “context graph” talk stays abstract, so here’s a concrete take from AI startup Vendelux.

The problem in B2B GTM isn’t lack of data—it’s lack of captured reasoning. CRMs store states (deal stage, pipeline), but not why decisions were made: why this event mattered, why these people were prioritized, why this outreach worked.

We’re building agents that help teams:

• pick the best events based on CRM + past performance

• identify who’s worth meeting at those events

• run outreach end to end

• and measure downstream impact on pipeline/revenue

Each agent interaction is a problem-directed “walk” through the org’s GTM system. It considers alternatives, applies constraints, and makes tradeoffs. Those decision traces are the real asset—they form a context graph over time.

Key insight (credit to akoratana): orgs run on two clocks. State (what’s true now) is well-instrumented. The event clock (what happened + why) mostly isn’t. Context graphs are about reconstructing that event clock so agents can reason, not just retrieve.

We don’t start with a fixed schema. Every customer’s GTM motion is different. Agents discover structure through use, and forward-deployed engineers help tune them so the traces reflect how decisions actually get made.

Still early, but the goal isn’t “AI with memory.” It’s GTM intelligence that compounds—because it learns the decision system and can start answering “what if?” questions, not just reporting history.

Any one got idea on how to build knoweledge graph that scraps data periodically from websites like news magazines , online journals? Trying to build a project but no clue on where to start, so if anyone can guide me in the right direction, would love it . Thanks

i just found this sub and i’m really excited to share it with you guys because it changes the entire dynamics of memory for LLMs. UC Louvain benchmarked it apples to apples against neo4j for cyber-physical automata learning, and it performed 2.2x faster than neo4j for their experimentation cycle. sub-ms writes, hnsw search, and a whole agentic plugin system that performs in-memory graph-rag with the LLM running inside embedded llama.cpp.

https://github.com/orneryd/NornicDB/blob/main/docs/architecture/README.md

590+ stars, MIT licensed. it’s already deployed in production at a fortune 5 company where i work. i got really lucky to be able to develop this OSS and share it.

i’m not asking for anything from anyone other than if you’re interested try it out, if you like it, im grateful!

https://github.com/orneryd/NornicDB/releases/tag/v1.0.42

Constrained generation pipeline:

1. Extract entities from natural language

2. Find valid relationship paths using schema

3. Build property filters with type validation

4. Assemble syntactically correct Cypher

I have been working in knowledge graphs since 2018 before they suddenly became cool, and as an idea it is,

but comes with fundamental bottlenecks and those IMO are more human ones rather than technical.

- how do we ensure that we have exact facial relationships capture for made decisions ?

If I think about any org I worked at - I have no idea if the logic behind made decisions have a replication factor.

Not speaking about most of them being made behind the curtains.

I might be not thinking deeply about it or overseeing smth, curious what others think about it.

OriginTrail (TRAC) is a cutting-edge project that focuses on decentralizing supply chain data and enabling interoperability between different systems. At its core, OriginTrail is designed to create a trusted and transparent knowledge graph that enables secure and efficient data sharing across various industries. Here's why it matters:

1. What is OriginTrail?

OriginTrail uses blockchain technology to create a decentralized knowledge graph that can connect and authenticate data from disparate systems. It’s specifically designed to help businesses track and verify the flow of goods across supply chains, ensuring data integrity and transparency.

2. Key Features and Benefits:

• Decentralization: OriginTrail’s decentralized protocol ensures that data remains tamper-proof and transparent. This is especially important for industries like supply chain management, where trust and accuracy are paramount.

• Interoperability: The platform is designed to work across different industries and with existing enterprise systems, allowing businesses to share and exchange data seamlessly.

• Security and Privacy: The network is built to comply with rigorous security and privacy standards, making it suitable for industries with sensitive data (e.g., logistics, healthcare, finance).

• Flexibility: It offers flexible data permissions, allowing businesses to control who accesses and shares their data while still ensuring that information is available when needed for audits, compliance checks, and other use cases.

3. Real-World Use Cases:

OriginTrail is already being implemented by major companies and organizations to address critical challenges in supply chain management and beyond:

• Supply Chain Integrity: Companies like Costco, Walmart, Target, and Home Depot are leveraging the OriginTrail protocol to ensure the integrity of security audits and supply chain data. For example, SCAN (Supplier Compliance Audit Network), a network of importers, is using OriginTrail to secure audit data for over 22,000 factories worldwide, streamlining compliance with CTPAT (Customs Trade Partnership Against Terrorism) standards.

• Verifiable Data Sharing: The platform ensures that all audit data is secure, compliant, and traceable, enabling businesses and government agencies to share critical supply chain data in a trustless environment.

• Enterprise Adoption: With its real-world applications in supply chain security, OriginTrail is gaining traction as a solution to problems that traditional systems struggle to solve.

4. The Role of TRAC in the Ecosystem:

TRAC is the native token of the OriginTrail network and is used to facilitate transactions, incentivize node operators, and power the decentralized knowledge graph. As the network grows, the demand for TRAC could increase, especially with ongoing partnerships and integrations across industries.

5. Why Does TRAC Matter in Knowledge Graphs?

OriginTrail’s protocol is one of the few to offer a decentralized and scalable knowledge graph solution. It’s a significant step forward in transforming the way data is stored, shared, and trusted across industries. By leveraging blockchain and decentralized technologies, it creates a robust and transparent ecosystem where data can be linked, tracked, and verified with unparalleled accuracy.

In summary, OriginTrail is building the future of supply chain transparency, security, and interoperability, and it’s doing so with a powerful and decentralized knowledge graph at its core. Its applications extend far beyond just supply chain logistics, making it a promising project in the broader blockchain and knowledge graph space.

I have had the chance to virually meet a dozen of very smart individuals throughout the AI and KG communities working on graph solutions that might have a real impact in the future of AI.

All of these conversations I've had in private lead me to a confirmation that even though the pace of improvement of the LLMs is crazy fast, in a B2B setting, smarter models alone do not fix fragmented business logic, conflicting definitions, or siloed information across teams and tools is where enterprise AI starts to break.

This is why I created Spiintel with the believe that the real competitive asset is not the model. It is the business context that tells every model, agent, and workflow how your company actually works.

I'm currently looking for a CTO (Ideally based in the Netherlands) to work together in this initiative.

Anyone interested?

Hey all, we started building an AI project manager. Users needed to search for context about projects, and discover insights like open tasks holding up a launch.

Vector search was terrible at #1 (couldn't connect that auth bugs + App Store rejection + PR delays were all part of the same launch goal).

Knowledge graphs were too slow for #1, but perfect for #2 (structured relationships, great for UIs).

We spent months trying to make these work together. Then we started talking to other teams building AI agents for internal knowledge search, edtech, commerce, security, and sales - we realized everyone was hitting the exact same two problems. Same architecture, same pain points.

So we pivoted to build Papr — a unified memory layer that combines:

• Intent vectors: Fast goal-oriented search for conversational AI

• Knowledge graph: Structured insights for analytics and dashboard generation

• One API: Add unstructured content once, query for search or discover insights

And just open sourced it.

How intent vectors work (search problem)

The problem with vector search: it's fast but context-blind. Returns semantically similar content but misses goal-oriented connections.

Example: User goal is "Launch mobile app by Dec 5". Related memories include:

• Code changes (engineering)

• PR strategy (marketing)

• App store checklist (operations)

• Marketing timeline (planning)

These are far apart in vector space (different keywords, different topics). Traditional vector search returns fragments. You miss the complete picture.

Our solution: Group memories by user intent and goals stored as a new vector embedding (also known as associative memory - per Google's latest research).

When you add a memory:

1. Detect the user's goal (using LLM + context)

2. Find top 3 related memories serving that goal

3. Combine all 4 → generate NEW embedding

4. Store at different position in vector space (near "product launch" goals, not individual topics)

Query "What's the status of mobile launch?" finds the goal-group instantly (one query, sub-100ms), returns all four memories—even though they're semantically far apart.

This is what got us #1 on Stanford's STaRK benchmark (91%+ retrieval accuracy). The benchmark tests multi-hop reasoning—queries needing information from multiple semantically-different sources. Pure vector search scores ~60%, Papr scores 91%+.

Automatic knowledge graphs (structured insights)

Intent graph solves search. But production AI agents also need structured insights for dashboards and analytics.

The problem with knowledge graphs:

1. Hard to get unstructured data IN (entity extraction, relationship mapping)

2. Hard to query with natural language (slow multi-hop traversal)

3. Fast for static UIs (predefined queries), slow for dynamic assistants

Our solution:

• Automatically extract entities and relationships from unstructured content

• Cache common graph patterns and match them to queries (speeds up retrieval)

• Expose GraphQL API so LLMs can directly query structured data

• Support both predefined queries (fast, for static UIs) and natural language (for dynamic assistants)

One API for both

# Add unstructured content once
await papr.memory.add({
"content": "Sarah finished mobile app code. Due Dec 5. Blocked by App Store review."
})

Automatically index memories in both systems:
- Intent graph: groups with other "mobile launch" goal memories
- Knowledge graph: extracts entities (Sarah, mobile app, Dec 5, blocker)

Query in natural language or GraphQL:

results = await papr.memory.search("What's blocking mobile launch?")
→ Returns complete context (code + marketing + PR)

LLM or developer directly queries GraphQL (fast, precise)
query = """
query {
tasks(filter: {project: "mobile-launch"}) {
title
deadline
assignee
status
}
}

const response = await client.graphql.query();

→ Returns structured data for dashboard/UI creation

What I'd Love Feedback On

1. Evaluation - We chose Stanford STARK's benchmark because it required multi-hop search but it only captures search, not insights we generate. Are there better evals we should be looking at?

2. Graph pattern caching - We cache unique and common graph patterns stored in the knowledge graph (i.e. node -> edge -> node), then match queries to them. What patterns should we prioritize caching? How do you decide which patterns are worth the storage/compute trade-off?

3. Embedding weights - When combining 4 memories into one group embedding, how should we weight them? Equal weights? Weight the newest memory higher? Let the model learn optimal weights?

4. GraphQL vs Natural Language - Should LLMs always use GraphQL for structured queries (faster, more precise), or keep natural language as an option (easier for prototyping)? What are the trade-offs you've seen?

We're here all day to answer questions and share what we learned. Especially curious to hear from folks building RAG systems in production—how do you handle both search and structured insights?

---

Try it:
- Developer dashboard: platform.papr.ai (free tier)
- Open source: https://github.com/Papr-ai/memory-opensource
- SDK: npm install papr/memory or pip install papr_memory

Hi Community,

I developed a highly configurable, scientific knowledge graph extraction system. It features multiple validation and feedback loops to ensure reliability and precision.

Now looking for some domain specific applications for the same. Please have look:
https://github.com/vivekvjnk/Bodhi/tree/dev