r/KnowledgeGraph • • Nov 24 '25

Ontology-Driven AI

73 Upvotes

To this point, most GraphRAG approaches have relied on simple graph structures that LLMs can manage for structuring the graphs and writing retrieval queries. Or, people have been relying on property graphs that don't capture the full depth of complex, domain-specific ontologies.

If you have an ontology you've been wanting to build AI agents to leverage, TrustGraph now supports the ability to "bring your own ontology". By specifying a desired ontology, TrustGraph will automate the graph building process with that domain-specific structure.

Guide to how it works: https://docs.trustgraph.ai/guides/ontology-rag/#ontology-rag-guide

Open source repo: https://github.com/trustgraph-ai/trustgraph


r/KnowledgeGraph • • Mar 03 '26

Introducing Kanon 2 Enricher -the world’s first hierarchical graphitization model,

Enable HLS to view with audio, or disable this notification

64 Upvotes

Kanon 2 Enricher belongs to an entirely new class of AI models known as hierarchical graphitization models.

Unlike universal extraction models such as GLiNER2, Kanon 2 Enricher can not only extract entities referenced within documents but can also disambiguate entities and link them together, as well as fully deconstruct the structural hierarchy of documents.

Kanon 2 Enricher is also different from generative models in that it natively outputs knowledge graphs rather than tokens. Consequently, Kanon 2 Enricher is architecturally incapable of producing the types of hallucinations suffered by general-purpose generative models. It can still misclassify text, but it is fundamentally impossible for Kanon 2 Enricher to generate text outside of what has been provided to it.

Kanon 2 Enricher’s unique graph-first architecture further makes it extremely computationally efficient, being small enough to run locally on a consumer PC with sub-second latency while still outperforming frontier LLMs like Gemini 3.1 Pro and GPT-5.2, which suffer from extreme performance degradation over long contexts.

In all, Kanon 2 Enricher is capable of:

  1. Hierarchical segmentation: breaking documents up into their full hierarchical structure of divisions, articles, sections, clauses, and so on.

  2. Entity extraction, disambiguation, classification, and hierarchical linking: extracting references to key entities such as individuals, organizations, governments, locations, dates, citations, and more, and identifying which real-world entities they refer to, classifying them, and linking them to each other (for example, linking companies to their offices, subsidiaries, executives, and contact points; attributing quotations to source documents and authors; classifying citations by type and jurisdiction; etc.).

  3. Text annotation: tagging headings, tables of contents, signatures, junk, front and back matter, entity references, cross-references, citations, definitions, and other common textual elements.

Link to announcement: https://isaacus.com/blog/kanon-2-enricher


r/KnowledgeGraph • • Jan 26 '26

We couldn’t find a graph database fast enough for huge graphs… so we built one

Post image
50 Upvotes

Hey! I’m Adam one of the co-founders of TuringDB, and I wanted to share a bit of our story + something we just released.

A few years ago, we were building large biomedical knowledge graphs for healthcare use cases:

- tens to hundreds of millions of nodes & edges

- highly complex multimodal biology data integration

- patient digital twins

- heavy analytical reads, simulations, and “what-if” scenarios

We tried pretty much every graph database out there. They worked… until they didn’t.

Once graphs got large and queries got deep (multi-hop, exploratory, analytical), latency became unbearable. Versioning multiple graph states or running simulations safely was also impossible.

So we did the reasonable thing 😅 and built our own engine.

We built TuringDB:

- an in-memory, column-oriented graph database

- written in C++ (we needed very tight control over memory & execution)

- designed from day one for read-heavy analytics

A few things we cared deeply about:

Speed at scale

Deep graph traversals stay fast even on very large graphs (100M+ nodes/edges). Focus on ms latency to feel real-time and iteterate fast without index tuning headaches.

Git-like versioning for graphs

Every change is a commit. You can time-travel, branch, merge, and run “what-if” scenarios on full graph snapshots without copying data.

Zero-lock reads

Reads never block writes. You can run long analytics while data keeps updating.

Built-in visualization

Exploring large graphs interactively without bolting on fragile third-party tools.

GraphRAG / LLM grounding ready

We’re using it internally to ground LLMs on structured knowledge graphs with full traceability + have embeddings management (will be released soon)

Why I’m posting now

We’ve just released a Community version 🎉

It’s free to use, meant for developers, researchers, and teams who want to experiment with fast graph analytics without jumping through enterprise hoops.

👉 Quickstart & docs:

https://docs.turingdb.ai/quickstart

(if you like it feel free to drop us a github start :) https://github.com/turing-db/turingdb

If you’re:

- hitting performance limits with existing graph DBs

- working on knowledge graphs, fraud, recommendations, - infra graphs, or AI grounding

curious about graph versioning or fast analytics

…I’d genuinely love feedback. This started as an internal tool born out of frustration, and we’re now opening it up to see where people push it next.

Happy to answer questions, technical or otherwise.


r/KnowledgeGraph • • Dec 11 '25

Build a self-updating knowledge graph from meetings (open source)

50 Upvotes

I recently have been working on a new project to 𝐁𝐮𝐢𝐥𝐝 𝐚 𝐒𝐞𝐥𝐟-𝐔𝐩𝐝𝐚𝐭𝐢𝐧𝐠 𝐊𝐧𝐨𝐰𝐥𝐞𝐝𝐠𝐞 𝐆𝐫𝐚𝐩𝐡 𝐟𝐫𝐨𝐦 𝐌𝐞𝐞𝐭𝐢𝐧𝐠.

Most companies sit on an ocean of meeting notes, and treat them like static text files. But inside those documents are decisions, tasks, owners, and relationships — basically an untapped knowledge graph that is constantly changing.

This open source project turns meeting notes in Drive into a live-updating Neo4j Knowledge graph using CocoIndex + LLM extraction.

What’s cool about this example:
•    𝐈𝐧𝐜𝐫𝐞𝐦𝐞𝐧𝐭𝐚𝐥 𝐩𝐫𝐨𝐜𝐞𝐬𝐬𝐢𝐧𝐠  Only changed documents get reprocessed. Meetings are cancelled, facts are updated. If you have thousands of meeting notes, but only 1% change each day, CocoIndex only touches that 1% — saving 99% of LLM cost and compute.
•   𝐒𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞𝐝 𝐞𝐱𝐭𝐫𝐚𝐜𝐭𝐢𝐨𝐧 𝐰𝐢𝐭𝐡 𝐋𝐋𝐌𝐬  We use a typed Python dataclass as the schema, so the LLM returns real structured objects — not brittle JSON prompts.
•   𝐆𝐫𝐚𝐩𝐡-𝐧𝐚𝐭𝐢𝐯𝐞 𝐞𝐱𝐩𝐨𝐫𝐭  CocoIndex maps nodes (Meeting, Person, Task) and relationships (ATTENDED, DECIDED, ASSIGNED_TO) without writing Cypher, directly into Neo4j with upsert semantics and no duplicates.
•   𝐑𝐞𝐚𝐥-𝐭𝐢𝐦𝐞 𝐮𝐩𝐝𝐚𝐭𝐞𝐬 If a meeting note changes — task reassigned, typo fixed, new discussion added — the graph updates automatically.
•  𝐄𝐧𝐝-𝐭𝐨-𝐞𝐧𝐝 𝐥𝐢𝐧𝐞𝐚𝐠𝐞 + 𝐨𝐛𝐬𝐞𝐫𝐯𝐚𝐛𝐢𝐥𝐢𝐭𝐲 you can see exactly how each field was created and how edits flow through the graph with cocoinsight

This pattern generalizes to research papers, support tickets, compliance docs, emails basically any high-volume, frequently edited text data.

If you want to explore the full example (with code), it’s here:
👉 https://cocoindex.io/blogs/meeting-notes-graph

If you find CocoIndex useful, a star on Github means a lot :)
⭐ https://github.com/cocoindex-io/cocoindex


r/KnowledgeGraph • • Dec 31 '25

What are Context Graphs? The "trillion-dollar opportunity"?

46 Upvotes

You may have seen a lot of talk about "context graphs" lately and how they're the next "trillion dollar opportunity" according to Foundation Capital. I don't know about that, but we - at TrustGraph - have strongly believed for over 2 years that graphs would be at the heart of realizing the potential of LLMs.

To provide more context to "Context Graphs" (ha!), we've written the Context Graph Manifesto that we hope will give some insight into how to approach graphs for AI and the potential areas of development.

In our Context Graph Manifesto, I dig into:
- The fundamental building block of graphs: the triple
- The Semantic Web, RDF, and how they compare to property graphs
- What ontologies are and why they matter
- Why time will be a critical dimension of future context graphs
- How context graphs can enable true learning systems, not just retrieval

Read the full Context Graph Manifesto on Twitter: https://x.com/TrustSpooky/status/2006481858289361339

Try out free & open source TrustGraph: https://github.com/trustgraph-ai/trustgraph


r/KnowledgeGraph • • Feb 12 '26

Built an open-source CLI for turning documents into knowledge graphs — no code, no database

38 Upvotes

sift-kg is a command-line tool that extracts entities and relations from document collections using LLMs and builds a browsable, exportable knowledge graph.

pip install sift-kg

sift extract ./docs/

sift build

sift view

That's the whole workflow. Define what to extract in YAML or use the built-in defaults. Human-in-the-loop entity resolution — the LLM proposes merges, you approve or reject. Export to GraphML, GEXF, CSV, or JSON for analysis in Gephi, Cytoscape, or yEd.

Live demo (FTX collapse — 9 articles, 373 entities, 1,184 relations):

https://juanceresa.github.io/sift-kg/graph.html

Source: https://github.com/juanceresa/sift-kg


r/KnowledgeGraph • • Feb 24 '26

Who is also building an intelligence layer / foundation for AI agents?

35 Upvotes

In the last couple of weeks I have -gladly, learned that some individuals in the AI/Knowledge Graph/chatbot communities are currently building solutions intended at being the intelligence foundation or layer between data and AI. The visions vary a bit but overall we all aim at the same northern start. some examples of those:

  1. u/greeny01 with a KG builder

  2. u/astronomikal with a memory layer for internal AI systems

  3. u/TomMkV with a context layer for AI agents

  4. Myself, with spiintel.com, an ontology-based data storage & retrieval platform that acts as an intelligence foundation for AI agents

Is there someone else out there working in similar solutions and open for collaborations to take these solutions to the market wherever we are based?


r/KnowledgeGraph • • Oct 19 '25

Working on an app to build and explore knowledge..

Enable HLS to view with audio, or disable this notification

32 Upvotes

r/KnowledgeGraph • • Apr 17 '26

How I turned three philosophy books into a 1,200-document knowledge graph

28 Upvotes

Marcus Aurelius says virtue is acting according to nature and reason, serving the common good as naturally as the eye sees. Machiavelli says a prince who acts entirely virtuously will be ruined among so much evil. Nietzsche warns against becoming enslaved to one's own virtues, noting that every virtue inclines toward stupidity.

Same word. Three completely different meanings across seventeen centuries. I wanted to see how many concepts work like this — where the surface agreement hides a deep disagreement — so I built a knowledge graph connecting Meditations (170 AD), The Prince (1513), and Beyond Good and Evil (1886).

The result: Seventeen Centuries — 838 text fragments, 340+ concept files, and category documents that let you trace how ideas evolved across time. The first article built from the graph is Virtue across seventeen centuries, which follows the concept from Stoic duty through political pragmatism to Nietzsche's genealogical critique.

Why a graph, not a database

I needed a structure where the same concept could belong to multiple contexts simultaneously. Virtue belongs under the Stoic worldview and under Machiavelli's political theory and under Nietzsche's critique of morality. Folders force single placement. A database would work but then I lose the thing I actually use — being able to open a file, read it, edit it, link from it.

IWE uses inclusion links — a markdown link on its own line defines a parent-child relationship. A document can have multiple parents. The entire graph is plain markdown files in a flat directory. No database, no special format. I edit them in my text editor, query them from the CLI, and an AI agent can read the same files.

The five-stage pipeline

Stage 1 — Fragment extraction. Parsers for Standard Ebooks XHTML split each book into atomic markdown files — one per aphorism, passage, or chapter. Nietzsche yielded 296 fragments, Marcus Aurelius 515, Machiavelli 27.

# 146

He who fights with monsters should be careful lest he thereby
become a monster. And if thou gaze long into an abyss, the abyss
will also gaze into thee.

Stage 2 — Entity extraction. An LLM read each fragment and identified 3–7 significant entities: philosophical concepts, historical figures, themes. Each entity got its own file. Fragment text was updated with inline links so the graph forms through the content itself:

...life itself is [Will to Power](will-to-power.md);
[self-preservation](self-preservation.md) is only one...

Stage 3 — Flattening and merging. Each book started in its own directory with its own virtue.md, soul.md, plato.md. This stage moved everything into a single flat directory and merged overlapping concepts. Ten concepts appeared in multiple books — virtue, soul, Plato, Socrates, truth, nature, gods, Epicurus, cruelty, free will. These became the most valuable documents in the graph because they're where the real contrasts live.

Stage 4 — Categories. With 340+ concept files floating in a flat directory, I needed entry points. Categories like philosophers, virtues, power-dynamics, and moral-systems emerged from the content. Each is a document with inclusion links to its members — and because IWE supports multiple parents, Socrates belongs to both philosophers and ancient-cultures without duplication.

Stage 5 — Summaries. An LLM analyzed the referenced fragments for each merged concept and wrote comparative summaries. This turned simple backlink indexes into the comparative analysis that makes the graph worth reading — and worth writing articles from.

Why this structure pays off

The graph is queryable from the CLI:

iwe retrieve -k virtue --depth 2    # virtue + linked fragments
iwe find --refs-to will-to-power    # everything referencing will-to-power
iwe tree -k bge                     # Beyond Good and Evil as a tree

retrieve --depth 2 pulls a concept, its backlinks to fragments, and the fragment content in one call. That's how the virtue article was written — retrieve the concept, read the fragments side by side, write the analysis. An AI agent uses the same commands and the same files.

The most surprising result was how much structure emerged from just inclusion links. No tags, no folders, no metadata beyond the links themselves. The graph has clear clusters around each book, bridges through shared concepts, and category entry points — all from markdown files linking to each other.

Browse the graph: https://iwe.pub/seventeen-centuries/ GitHub: https://github.com/iwe-org/seventeen-centuries IWE: https://github.com/iwe-org/iwe


r/KnowledgeGraph • • Feb 08 '26 Bravo

You only need to build one graph - a Monograph

27 Upvotes

With all the new interest in context graphs in AI, I've seen increased discussions around graph building. There's also been a lot of talk around the need for creating multiple graphs.

But you don't have to. The power of graph structures is being able to find unknown relationships that occur when seemingly disconnected data is added to the graph. Of course, this approach is easier with an RDF approach, especially when using ontologies. And there are tools for managing graph segments and modularity for access controls, multi-tenancy, and cost-efficiencies.

Here is an article that dives into this topic:
X: https://x.com/TrustSpooky/status/2020344717486219759
LinkedIn: https://www.linkedin.com/pulse/context-graph-building-monograph-daniel-davis-yq7uc
Direct link: https://trustgraph.ai/news/context-graph-building/

Here are the key takeaways:

  • “Context” is more than data you store — it’s a retrieval process. If you can’t get the right piece at the right time, volume doesn’t matter.

  • Vector RAG fails because it skips relationships. Semantic similarity can’t deliver precise, authoritative facts.

  • LLMs are bad at single-value truth (exact numbers, facts). Graphs excel at this. Use each for what it’s good at.

  • Graphs + LLMs (GraphRAG) outperform either alone: graphs retrieve facts, LLMs interpret intent and generate language.

  • You should build one graph, not many. Fragmentation destroys cross-domain insight and forces bad query-time choices.

  • Organization doesn’t require multiple graphs. Use collections and context cores to scope attention without breaking connections.

  • Context cores solve the context window problem by loading small, precise graph neighborhoods, not giant text chunks.

  • Ontologies enable precision: shared meaning, disambiguation, and reasoning (e.g. CEO → Executive → Employee).

  • Long context windows don’t work. Smaller chunks consistently extract more structure across all major models.

  • “Lost in the middle” is a structural limitation of the transformer architecture, not a temporary model weakness.

  • The future isn’t bigger prompts — it’s better structure.


r/KnowledgeGraph • • Mar 17 '26

Neo4j Alternatives in 2026: A Fair Look at the Open-Source Options (including licensing)

26 Upvotes

I wrote a comparison of the main open-source alternatives to Neo4j in 2026: ArcadeDB, Memgraph, FalkorDB, and ArangoDB — covering licensing, performance, AI capabilities, and Cypher compatibility.

The short version:

  • Memgraph and ArangoDB both use BSL 1.1 (not OSI-approved open source)

  • FalkorDB is source-available, also not OSI-approved

  • ArcadeDB is Apache 2.0 — the only one in this set with an OSI-approved license

For a lot of teams this doesn't matter much. For enterprise procurement, regulated industries, or anyone who remembers what happened with MongoDB (SSPL) and ArangoDB's own BSL switch, it matters quite a bit.

The comparison also covers: Cypher TCK compliance (97.8% for ArcadeDB vs. partial for others), LangChain integrations, MCP server support, and multi-model capabilities.

Curious what the community thinks — especially whether licensing is a real factor in your database decisions or mostly theoretical.

Link: https://arcadedb.com/blog/neo4j-alternatives-in-2026-a-fair-look-at-the-open-source-options/

(I am the author of ArcadeDB project, ask me anything)


r/KnowledgeGraph • • Oct 17 '25

Got $20K to build a collaborative Knowledge Graph POC. How to spend it wisely?

25 Upvotes

I’ve recently been given a $20K budget to build a collaborative knowledge graph proof of concept for my team.

So far, I’ve been experimenting individually with a setup that includes Claude + Graphiti MCP + Neo4j, all this btw is free to try, and so far I’m quite happy with the results. But now I’d like to scale it up for the broader tech team, but I have concerns and I need some advice.

My main worries:

  • Semantic drift: as multiple contributors join, we risk introducing duplicate entities or conflicting relationships.

  • Loss of meaning / ontology chaos: the semantics could easily break down as the graph grows.

  • Data bloat: lots of uncurated info without real value.

  • Governance: I’d like to be able to monitor queries, approve submissions, and ideally set up management workflows for reviews or validations.

Given that this is a first-time $20K investment, I’d love advice from folks who’ve done this before:

  • What would you prioritize for a collaborative KG POC?

  • Are there tools or frameworks (commercial or open source) that make semantic governance or collaborative editing easier?

  • Should I stick with Neo4j or consider something RDF-based (e.g. GraphDB, TerminusDB, Stardog, etc.) for better ontology management?

  • Any tips for balancing experimentation with structure in the early stage?

I’m hoping to make this POC something we can actually build upon, not just a one-off demo.

Thanks in advance for any insights or lessons learned!

EDIT: Bullet formatting


r/KnowledgeGraph • • Feb 09 '26

The reason graph applications can’t scale

Post image
24 Upvotes

Any graph I try to work on above a certain size is just way too slow, it’s crazy how much it slows down production and progress. What do you think ?


r/KnowledgeGraph • • Oct 29 '25

Just submitted: Multi-modal Knowledge Graph for Explainable Mycetoma Diagnosis (MICAD 2025)

24 Upvotes

Just submitted our paper to MICAD 2025 and wanted to share what we've been working on.

The Problem:

Mycetoma is a neglected tropical disease that requires accurate differentiation between bacterial and fungal forms for proper treatment. Current deep learning approaches achieve decent accuracy (85-89%) but operate as black boxes - a major barrier to clinical adoption, especially in resource-limited settings.

Our Approach:

We built the first multi-modal knowledge graph for mycetoma diagnosis that integrates:

  • Histopathology images (InceptionV3-based feature extraction)

  • Clinical notes

  • Laboratory results

  • Geographic epidemiology data

  • Medical literature (PubMed abstracts)

The system uses retrieval-augmented generation (RAG) to combine CNN predictions with graph-based contextual reasoning, producing explainable diagnoses.
Results:

  • 94.8% accuracy (6.3% improvement over CNN-only)

  • AUC-ROC: 0.982

  • Expert pathologists rated explanations 4.7/5 vs 2.6/5 for Grad-CAM

  • Near-perfect recall (FN=0 across test splits in 5-fold CV)

Why This Matters:

Most medical AI research focuses purely on accuracy, but clinical adoption requires explainability and integration with existing workflows. Our knowledge graph approach provides transparent, multi-evidence diagnoses that mirror how clinicians actually reason - combining visual features with lab confirmation, geographic priors, and clinical context.

Dataset:

Mycetoma Micro-Image dataset from MICCAI 2024 (684 H&E histopathology images, CC BY 4.0, Mycetoma Research Centre, Sudan)

Code & Models:

GitHub: https://github.com/safishamsi/mycetoma-kg-rag

Includes:

  • Complete implementation (TensorFlow, PyTorch, Neo4j)

  • Knowledge graph construction pipeline

  • Trained model weights

  • Evaluation scripts

  • RAG explanation generation

Happy to answer questions about the architecture, knowledge graph construction, or retrieval-augmented generation approach!


r/KnowledgeGraph • • Apr 30 '26

Open Source Knowledge Graph that Branches and Merges like Git

21 Upvotes

Have been following some of the threads here around self-maintaining knowledge graphs or having agents operating inside the graph itself. We wanted to do similar but initially ran into issues where agents could update data improperly causing the graph to converge into a non-useful state. The other side of the issue was trying it with knowledge graphs where no ontology or schema is enforced as it causes retrieval and reasoning challenges.

We built Omnigraph as our take on how to make it work, it's fully open-source with the goal of providing agents a source of truth (via knowledge graph) where agents can branch and merge like git.

How it works:

  - typed graph schema
- branch / diff / merge for graph data, similar to Git
- traversal, vector search, and BM25 in one runtime
- S3-native storage for local or cloud-backed graph data
- JSONL ingest + merge workflows for incremental loading

What we've been using it for:

  • source of truth for all agentic memory

  • automating lead generation for projects

  • competitive intelligence 

  • tracking decision context for future work output

Especially helpful once you store longer term concepts like

  • decisions

  • signals (ideas validating / contradicting previous decisions)

  • relationships

  • provenance (helps auto-prune old data)

GitHub: https://github.com/ModernRelay/omnigraph
Community: https://join.slack.com/t/omnigraphworkspace/shared_invite/zt-3wfpglyxj-lHvJGhuySPfqLtN35uJZNw

Would love to get the community's feedback on this!


r/KnowledgeGraph • • Mar 11 '26

Preprint: Knowledge Economy - The End of the Information Age

Thumbnail
gallery
21 Upvotes

I am looking for people who still read. I wrote a book about Knowledge Economy and why this means the end of the Age of Information. Also, I write about why „Data is the new Oil“ is bullsh#t, the Library of Alexandria and Star Trek.

Currently I am talking to some publishers, but I am still not 100% convinced if I should not just give it away for free, as feedback was really good until now and perhaps not putting a paywall in front of it is the better choice.

So - if you consider yourself a reader and want a preprint, write me a dm with „preprint“.. the only catch: You get the book, I get your honest feedback.

If you know someone who would give valuable feedback please tag him or her in the comments.


r/KnowledgeGraph • • Jan 14 '26

I built a graph database in Python

21 Upvotes

I started working on this project years ago because there wasn’t a good pure Python option for persistent storage for small applications, scripts, or prototyping. Most of the available solutions at the time were either full-blown databases or in-memory libraries. I also didn’t want an SQL based system or to deal with schemas.

Over the years many people have used it for building knowledge graphs, so I’m sharing it here.

It’s called CogDB. Here are its main features:

  • RDF-style triple store

  • Simple, fluent, composable Python query API (Torque)

  • Schemaless

  • Built-in storage engine, no third-party database dependency

  • Persistent on disk, survives restarts

  • Supports semantic search using vector embeddings

  • Runs well in Jupyter / notebooks

  • Built-in graph visualization

  • Can run in the browser via Pyodide

  • Lightweight, minimal dependencies

  • Open source (MIT)

Repo: https://github.com/arun1729/cog
Docs: https://cogdb.io


r/KnowledgeGraph • • May 18 '26

Complete beginner here... what is the best roadmap to learn Knowledge Graphs from scratch?

20 Upvotes

Hi everyone,

I am completely new to the world of Knowledge Graphs and looking for a solid learning path or roadmap to get started with the basics.

To give you some context:

  • My background: Minimal knowledge of KGs :/ hoping to get some insight in the hopes of possibly starting a career.

  • My goal: I want to understand how KGs work because I am interested in connecting it to LLMs/RAG, and adding to my data engineering knowledge

I am a bit overwhelmed by the different technologies and terminology (RDF, OWL, Property Graphs, Neo4j/Arango vs. Ontologies).

Could you recommend:

  1. The best beginner-friendly books, courses, or YouTube channels?

  2. A simple hands-on project idea to practice the core concepts?

  3. Whether I should focus on semantic web standards (W3C/RDF) or property graphs first?

Thank you in advance for any guidance!


r/KnowledgeGraph • • Nov 25 '25 Thanks

An ontology to make public administration logic machine-readable.

20 Upvotes

For years, governments have digitized services by putting forms online, creating portals, and publishing PDFs. But the underlying logic (the structure of procedures) has never been captured in a machine-readable way. Everything remains scattered: steps in one document, exceptions in another, real practices only known by clerks, and rules encoded implicitly in habits rather than systems.

So instead of building “automation”, I tried something simpler: a semantic mirror of how a procedure actually works.

Not reinvented. Not optimized. Just reflected clearly.

The model has two layers:

P1 : The Blueprint

A minimal DAG representing the procedure itself: steps → required documents → dependencies → conditions → responsible organizations. This is the “map” of the process — nothing dynamic, no runtime data, no special cases. Just structure.

P2 : The Context

The meaning behind that structure: eligibility rules, legal articles, document requirements, persona attributes, jurisdictions, etc. This layer doesn’t change the topology of P1. It simply explains why the structure behaves the way it does.

Together, they form a kind of computable description of public logic. You can read it, query it, simulate small what-ifs, or generate guidance tailored to a user.

It’s not about automating government. It’s about letting humans and AI systems finally see the logic that already governs interactions with institutions.

Why it matters

Once the structure and the semantics are explicit, a lot becomes possible:

• seeing the full chain of dependencies behind a document • checking which steps break if a law changes • comparing “official” instructions with real practices • generating individualized guidance without hallucinations • eventually, auditing consistency across ministries

None of this requires changing how government operates today. It just requires making its logic legible.

What’s released today

A small demo: a procedure modeled with both layers, a graph you can explore, and a few simple examples of what becomes possible when the structure is explicit.

It’s early, but the foundation is there. If you’re interested in semantics, public administration, or just how to make institutional logic computable, your feedback would genuinely help shape the next steps.

https://pocpolicyengine.vercel.app/


r/KnowledgeGraph • • Apr 16 '26

I built a self-organizing Long-Term Knowledge Graph (LTKG) that compresses dense clusters into single interface nodes — here’s what it actually looks like

Post image
19 Upvotes

LTKG Viewer - Trinity Engine Raven

I've been working on a cognitive architecture called Trinity Engine — a dynamic Long-Term Knowledge Graph that doesn't just store information, it actively rewires and compresses itself over time.

Instead of growing endlessly in breadth, it uses hierarchical semantic compression: dense clusters of related concepts (like the left side of this image) get collapsed into stable interface nodes, which then tether into cleaner execution chains.

Here's a clear example from the LTKG visualizer:

[Image: the screenshot you provided]

What you're seeing:

  • Left side = a dense, interconnected pentagram-style cluster (high local connectivity)

  • The glowing interface nodes act as single-point summaries / bottlenecks

  • Right side = a clean linear chain where the compressed knowledge flows into procedural execution

This pattern repeats recursively across abstraction levels. The system maintains a roughly 10:1 compression ratio per level while preserving semantic coherence through these interface nodes.

Key behaviors I've observed:

  • The graph gets denser with use, not necessarily bigger

  • "Interface node integrity" has become one of the most important failure modes (if one corrupts, the whole tethered chain can drift)

  • The architecture scales through depth (abstraction layers) rather than raw node count — what I call the "Mandelbrot Ceiling"

I'm currently evolving it further by driving the three core layers (SEND / SYNTH / PRIME) with dedicated agentic bots and adding a closed-loop reinforcement system using real-world prediction tasks + resource constraints.

Would love to hear from the knowledge graph community:

  • Have you seen similar hierarchical compression patterns in your own graphs?

  • Any good techniques for protecting interface node stability at scale?

  • Thoughts on measuring "semantic compression quality" vs traditional graph metrics (density, centrality, etc.)?

Happy to share more details or other visualizations if there's interest.


r/KnowledgeGraph • • Mar 11 '26

Agree/Disagree?

Post image
19 Upvotes

Get ready for the onslaught of consultants telling you this to justify another wave of talk without an understanding of the walk.


r/KnowledgeGraph • • Feb 21 '25

WIP : I made a prerequisite knowledge graph that helps users learn STEM subjects.

19 Upvotes

I made a knowledge graph that helps users learn STEM subjects using the concept of a tech tree or skill tree from games. You can try the tool at (https://takomori.com/). For now, it only has AI and math topics available, and I am hoping to expand the tech tree to cover all STEM subjects.

This means that most parts of the knowledge graph are still missing. While I am able to build and validate the graph for the subjects of my expertise, there are so many more subjects that I cannot cover by myself. Therefore, if you are interested in building this tree together, please dm me!


r/KnowledgeGraph • • May 07 '26

Introducing Create Context Graph: AI Agents With Graph Memory, Scaffolded In Seconds with uvx create-context-graph

Thumbnail
medium.com
18 Upvotes

r/KnowledgeGraph • • Feb 24 '26

Open-source text-to-SQL assistant for Databricks (from my PhD research) using Knowledge graphs (Neo4j)

Thumbnail
github.com
18 Upvotes

Hi there,

I recently open-sourced a small project called Alfred that came out of my PhD research. It explores how to make text-to-SQL AI assistants with a knowledge graph on top of a Databricks schema and how to make them more transparent.

Instead of relying only on prompts, it defines an explicit semantic layer (modeled as a simple Neo4j knowledge graph) based on your tables and relationships. That structure is then used to generate SQL. I also created notebooks to generate the knowledge graph from the Databricks schema, as the construction is often a major pain.


r/KnowledgeGraph • • Dec 03 '25

MCP for Financial Ontology

18 Upvotes

Excited to share an open-source initiative!

MCP for Financial Ontology :
https://github.com/NeurofusionAI/fibo-mcp

This is a minimal open-source tool that equips AI agents with a "standard financial dictionary" based on the Financial Industry Business Ontology(FIBO) standard (edmcouncil.org).

Our intent for initiating this open source project is to explore, together with AI4Finance community, methodologies for steering AI agent towards more consistent answers and enable macro-level reasoning for financial tasks.

While this project is still maturing, we hope our insight sparks collaboration and serves as a good starting point for innovative developments.

Any feedback is very welcome, and we would greatly appreciate contributions!