GraphNews

Imagine you’re handed a mountain of books in a language you barely speak. Traditional RAG systems do just that: they treat every text…

Perhaps you’ve come across the paper From Local to Global: A GraphRAG Approach to Query-Focused Summarization, which is Microsoft…

One of the few things I love as much as Knowledge Graphs (KGs) is basketball (and LEGO bricks, but that’s another story)! So it made…

The new AI powered Anayltics stack is here…says Gartner’s Afraz Jaffri ! A key element of that stack is an ontology powered Semantic Layer that serves as the brain for AI agents to act on knowledge of your internal data and deliver timely, accurate and hallucination-free insights! #semanticlayer #knowledgegraphs #genai #decisionintelligence

Do you want to fine-tune an LLM model for triplet extraction? These findings from a recently published paper (first comment) could save you much time. ✅ Does the choice of coding vs natural language prompts significantly impact performance? When fine-tuning these open weights and small LLMs, the choice between code and natural language prompts has a limited impact on performance. ✅ Does training fine-tuned models to include chain-of-thought (rationale) sections in their outputs improve KG construction (KGC) performance? It is ineffective at best and highly detrimental at worst for fine-tuned models. This performance decrease is observed regardless of the number of in-context learning examples provided. Attention analysis suggests this might be due to the model's attention being dispersed on redundant information when rationale is used. Without rationale lists occupying prompt space, the model's attention can focus directly on the ICL examples while extracting relations. ✅ How do the fine-tuned smaller, open-weight LLMs perform compared to the CodeKGC baseline, which uses larger, closed-source models (GPT-3.5)? The selected lightweight LLMs significantly outperform the much larger CodeKGC baseline after fine-tuning. The best fine-tuned models improve upon the CodeKGC baseline by as much as 15–20 absolute F1 points across the dataset. ✅ Does model size matter for KGC performance when fine-tuning with a small amount of training data? Yes, but not in a straightforward way. The 70 B-parameter versions yielded worse results than the 1B, 3B, and 8B models when undergoing the same small amount of training. This implies that for KGC with limited fine-tuning, smaller models can perform better than much larger ones. ✅ For instruction-tuned models without fine-tuning, does prompt language or rationale help? For models without fine-tuning, using code prompts generally yields the best results for both code LLMs and the Mistral natural language model. In addition, using rationale generally seems to help these models, with most of the best results obtained when including rationale lists in the prompt. ✅ What do the errors made by the models suggest about the difficulty of the KGC task? difficulty in predicting relations, entities, and their order, especially when dealing with specialized terminology or specific domain knowledge, which poses a challenge even after fine-tuning. Some errors include adding superfluous adjectives or mistaking entity instances for class names. ✅ What is the impact of the number of in-context learning (ICL) examples during fine-tuning? The greatest performance benefit is obtained when moving from 0 to 3 ICL examples. However, additional ICL examples beyond 3 do not lead to any significant performance delta and can even lead to worse results. This further indicates that the fine-tuning process itself is the primary driver of performance gain, allowing the model to learn the task from the input text and target output.

NodeRAG restructures knowledge into a heterograph: a rich, layered, musical graph where each node plays a different role. It’s not just smarter retrieval. It’s structured memory for AI agents. 》 Why NodeRAG? Most Retrieval-Augmented Generation (RAG) methods retrieve chunks of text. Good enough — until you need reasoning, precision, and multi-hop understanding. This is how NodeRAG solves these problems: 》 🔹Step 1: Graph Decomposition NodeRAG begins by decomposing raw text into smart building blocks: ✸ Semantic Units (S): Little event nuggets ("Hinton won the Nobel Prize.") ✸ Entities (N): Key names or concepts ("Hinton", "Nobel Prize") ✸ Relationships (R): Links between entities ("awarded to") ✩ This is like teaching your AI to recognize the actors, actions, and scenes inside any document. 》 🔹Step 2: Graph Augmentation Decomposition alone isn't enough. NodeRAG augments the graph by identifying important hubs: ✸ Node Importance: Using K-Core and Betweenness Centrality to find critical nodes ✩ Important entities get special attention — their attributes are summarized into new nodes (A). ✸ Community Detection: Grouping related nodes into communities and summarizing them into high-level insights (H). ✩ Each community gets a "headline" overview node (O) for quick retrieval. It's like adding context and intuition to raw facts. 》 🔹 Step 3: Graph Enrichment Knowledge without detail is brittle. So NodeRAG enriches the graph: ✸ Original Text: Full chunks are linked back into the graph (Text nodes, T) ✸ Semantic Edges: Using HNSW for fast, meaningful similarity connections ✩ Only smart nodes are embedded (not everything!) — saving huge storage space. ✩ Dual search (exact + vector) makes retrieval laser-sharp. It’s like turning a 2D map into a 3D living world. 》 🔹 Step 4: Graph Searching Now comes the magic. ✸ Dual Search: First find strong entry points (by name or by meaning) ✸ Shallow Personalized PageRank (PPR): Expand carefully from entry points to nearby relevant nodes. ✩ No wandering into irrelevant parts of the graph. The search is surgical. ✩ Retrieval includes fine-grained semantic units, attributes, high-level elements — everything you need, nothing you don't. It’s like sending out agents into a city — and they return not with everything they saw, but exactly what you asked for, summarized and structured. 》 Results: NodeRAG's Performance Compared to GraphRAG, LightRAG, NaiveRAG, and HyDE — NodeRAG wins across every major domain: Tech, Science, Writing, Recreation, and Finance. NodeRAG isn’t just a better graph. NodeRAG is a new operating system for memory. ≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣ ⫸ꆛ Want to build Real-World AI agents? Join My 𝗛𝗮𝗻𝗱𝘀-𝗼𝗻 𝗔𝗜 𝗔𝗴𝗲𝗻𝘁 𝗧𝗿𝗮𝗶𝗻𝗶𝗻𝗴 TODAY! ➠ Build Real-World AI Agents + RAG Pipelines ➠ Learn 3 Tools: LangGraph/LangChain | CrewAI | OpenAI Swarm ➠ Work with Text, Audio, Video and Tabular Data 👉𝗘𝗻𝗿𝗼𝗹𝗹 𝗡𝗢𝗪 (𝟯𝟰% 𝗱𝗶𝘀𝗰𝗼𝘂𝗻𝘁): https://lnkd.in/eGuWr4CH | 20 comments on LinkedIn

ServiceNow will acquire AI data quality vendor Data.world in a quest for better management of corporate data for AI.

Today, Amazon Web Services (AWS) announced the general availability of Amazon Bedrock Knowledge Bases GraphRAG (GraphRAG), a capability in Amazon Bedrock Knowledge Bases that enhances Retrieval-Augmented Generation (RAG) with graph data in Amazon Neptune Analytics. In this post, we discuss the benefits of GraphRAG and how to get started with it in Amazon Bedrock Knowledge Bases.

Last week I was fortunate to attend the Knowledge Graph Conference in NYC! Here are a few trends that span multiple presentations and conversations. - AI and LLM Integration: A major focus [again this year] was how LLMs can be used to enrich knowledge graphs and how knowledge graphs, in turn, can improve LLM outputs. This included using LLMs for entity extraction, verification, inference, and query generation. Many presentations demonstrated how grounding LLMs in knowledge graphs leads to more accurate, contextual, and explainable AI responses. - Semantic Layers and Enterprise Knowledge: There was a strong emphasis on building semantic layers that act as gateways to structured, connected enterprise data. These layers facilitate data integration, governance, and more intelligent AI agents. Decentralized semantic data products (DPROD) were discussed as a framework for internal enterprise data ecosystems. - From Data to Knowledge: Many speakers highlighted that AI is just the “tip of the iceberg” and the true power lies in the data beneath. Converting raw data into structured, connected knowledge was seen as crucial. The hidden costs of ignoring semantics were also discussed, emphasizing the need for consistent data preparation, cleansing, and governance. - Ontology Management and Change: Managing changes and governance in ontologies was a recurring theme. Strategies such as modularization, version control, and semantic testing were recommended. The concept of “SemOps” (Semantic Operations) was discussed, paralleling DevOps for software development. - Practical Tools and Demos: The conference included numerous demos of tools and platforms for building, querying, and visualizing knowledge graphs. These ranged from embedded databases like KuzuDB and RDFox to conversational AI interfaces for KGs, such as those from Metaphacts and Stardog. I especially enjoyed catching up with the Semantic Arts team (Mark Wallace, Dave McComb and Steve Case), talking Gist Ontology and SemOps. I also appreciated the detailed Neptune Q&A I had with Brian O'Keefe, the vision of Ora Lassila and then a chance meeting Adrian Gschwend for the first time, where we connected on LinkML and Elmo as a means to help with bidirectional dataflows. I was so excited by these conversations that I planned to have two team members join me in June at the Data Centric Architecture Workshop Forum, https://www.dcaforum.com/

In a previous post I was touching on how ontologies are foundational to many data activities, yet "obscure". As a consequence, the different roles of ontologies are not always known among people that make use of them, as they may focus only on some of the aspects relevant for specific use cases.

Ontologies, OWL, SHACL: I was going to react to a comment that came through my feed and turned it into this post as it resonated with questions I am often asked about the mentioned technologies, their uses, and their relations and, more broadly, it concerns a key architectural discussion that I've h

🤺 𝗧𝗵𝗲 𝗙𝘂𝘁𝘂𝗿𝗲 𝗜𝘀 𝗖𝗹𝗲𝗮𝗿: 𝗔𝗴𝗲𝗻𝘁𝘀 𝗪𝗶𝗹𝗹 𝗡𝗘𝗘𝗗 𝗚𝗿𝗮𝗽𝗵 𝗥𝗔𝗚 Why? It combines Multi-hop reasoning, Non-Parameterized / Learning-Based Retrieval, Topology-Aware Prompting. ﹌﹌﹌﹌﹌﹌﹌﹌﹌ 🤺 𝗪𝗵𝗮𝘁 𝗜𝘀 𝗚𝗿𝗮𝗽𝗵-𝗘𝗻𝗵𝗮𝗻𝗰𝗲𝗱 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹-𝗔𝘂𝗴𝗺𝗲𝗻𝘁𝗲𝗱 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻 (𝗥𝗔𝗚)? ✩ LLMs hallucinate. ✩ LLMs forget. ✩ LLMs struggle with complex reasoning. Graphs connect facts. They organize knowledge into neat, structured webs. So when RAG retrieves from a graph, the LLM doesn't just guess — it reasons. It follows the map. ﹌﹌﹌﹌﹌﹌﹌﹌﹌ 🤺 𝗧𝗵𝗲 𝟰-𝗦𝘁𝗲𝗽 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄 𝗼𝗳 𝗚𝗿𝗮𝗽𝗵 𝗥𝗔𝗚 1️⃣ — User Query: The user asks a question. ("Tell me how Einstein used Riemannian geometry?") 2️⃣ — Retrieval Module: The system fetches the most structurally relevant knowledge from a graph. (Entities: Einstein, Grossmann, Riemannian Geometry.) 3️⃣ — Prompting Module: Retrieved knowledge is reshaped into a golden prompt — sometimes as structured triples, sometimes as smart text. 4️⃣ — Output Response: LLM generates a fact-rich, logically sound answer. ﹌﹌﹌﹌﹌﹌﹌﹌﹌ 🤺 𝗦𝘁𝗲𝗽 𝟭: 𝗕𝘂𝗶𝗹𝗱 𝗚𝗿𝗮𝗽𝗵-𝗣𝗼𝘄𝗲𝗿𝗲𝗱 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀 ✩ Use Existing Knowledge Graphs like Freebase or Wikidata — structured, reliable, but static. ✩ Or Build New Graphs From Text (OpenIE, instruction-tuned LLMs) — dynamic, adaptable, messy but powerful. 🤺 𝗦𝘁𝗲𝗽 𝟮: 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗮𝗻𝗱 𝗣𝗿𝗼𝗺𝗽𝘁𝗶𝗻𝗴 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀 ✩ Non-Parameterized Retrieval (Deterministic, Probabilistic, Heuristic) ★ Think Dijkstra's algorithm, PageRank, 1-hop neighbors. Fast but rigid. ✩ Learning-Based Retrieval (GNNs, Attention Models) ★ Think "graph convolution" or "graph attention." Smarter, deeper, but heavier. ✩ Prompting Approaches: ★ Topology-Aware: Preserve graph structure — multi-hop reasoning. ★ Text Prompting: Flatten into readable sentences — easier for vanilla LLMs. 🤺 𝗦𝘁𝗲𝗽 𝟯: 𝗚𝗿𝗮𝗽𝗵-𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱 𝗣𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀 ✩ Sequential Pipelines: Straightforward query ➔ retrieve ➔ prompt ➔ answer. ✩ Loop Pipelines: Iterative refinement until the best evidence is found. ✩ Tree Pipelines: Parallel exploration ➔ multiple knowledge paths at once. 🤺 𝗦𝘁𝗲𝗽 𝟰: 𝗚𝗿𝗮𝗽𝗵-𝗢𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗧𝗮𝘀𝗸𝘀 ✩ Knowledge Graph QA (KGQA): Answering deep, logical questions with graphs. ✩ Graph Tasks: Node classification, link prediction, graph summarization. ✩ Domain-Specific Applications: Biomedicine, law, scientific discovery, finance. ≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣≣ Join my 𝗛𝗮𝗻𝗱𝘀-𝗼𝗻 𝗔𝗜 𝗔𝗴𝗲𝗻𝘁 𝗧𝗿𝗮𝗶𝗻𝗶𝗻𝗴. Skip the fluff and build real AI agents — fast. 𝗪𝗵𝗮𝘁 𝘆𝗼𝘂 𝗴𝗲𝘁: ✅ Create Smart Agents + Powerful RAG Pipelines ✅ Master 𝗟𝗮𝗻𝗴𝗖𝗵𝗮𝗶𝗻, 𝗖𝗿𝗲𝘄𝗔𝗜 & 𝗦𝘄𝗮𝗿𝗺 – all in one training ✅ Projects with Text, Audio, Video & Tabular Data 𝟰𝟲𝟬+ engineers already enrolled 𝗘𝗻𝗿𝗼𝗹𝗹 𝗻𝗼𝘄 — 𝟯𝟰% 𝗼𝗳𝗳, 𝗲𝗻𝗱𝘀 𝘀𝗼𝗼𝗻: https://lnkd.in/eGuWr4CH | 35 comments on LinkedIn

A Map with No Rules The new AI Risk “ontology” (AIRO) maps regulatory concepts from the EU AI Act, ISO/IEC 23894, and ISO 31000. But without formal constraints or ontological grounding in a top-level ontology, it reads more like a map with no rules. At first glance, AIRO seems well-structured. It defines entities like “AI Provider,” “AI Subject,” and “Capability,” linking them to legal clauses and decision workflows. But it lacks the logical scaffolding that makes semantic models computable. There are no disjointness constraints, no domain or range restrictions, no axioms to enforce identity or prevent contradiction. For example, if “Provider” and “Subject” are just two nodes in a graph, the system has no way to infer that they must be distinct. There’s nothing stopping an implementation from assigning both roles to the same agent. That’s not an edge case. It’s a missing foundation. This is where formal ontologies matter. Logic is not a luxury. It’s what makes it possible to validate, reason, and automate oversight. Without constraints and grounding in a TLO, semantic structures become decorative. They document language, but not the conditions that govern responsible behavior. If we want regulations that adapts with AI instead of chasing it, we need more than a vocabulary. We need logic, constraints, and ontological structure. #AIRegulation #ResponsibleAI #SemanticGovernance #AIAudits #AIAct #Ontologies #LogicMatters

Integrating Neo4j, DuckDB, and Kestra for Metadata-Driven Graph Design

How to leverage Large Language Models to create consistent Knowledge Graphs from multiple sources

Contribute to LMMApplication/RAKG development by creating an account on GitHub.

How AI is learning to build its own conceptual frameworks

Official Implementation of "Affordable AI Assistants with Knowledge Graph of Thoughts" - spcl/knowledge-graph-of-thoughts

Knowledge graphs to teach LLMs how to reason like doctors! Many medical LLMs can give you the right answer, but not the right reasoning which is a problem for clinical trust. 𝗠𝗲𝗱𝗥𝗲𝗮𝘀𝗼𝗻 𝗶𝘀 𝘁𝗵𝗲 𝗳𝗶𝗿𝘀𝘁 𝗳𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆-𝗴𝘂𝗶𝗱𝗲𝗱 𝗱𝗮𝘁𝗮𝘀𝗲𝘁 𝘁𝗼 𝘁𝗲𝗮𝗰𝗵 𝗟𝗟𝗠𝘀 𝗰𝗹𝗶𝗻𝗶𝗰𝗮𝗹 𝗖𝗵𝗮𝗶𝗻-𝗼𝗳-𝗧𝗵𝗼𝘂𝗴𝗵𝘁 (𝗖𝗼𝗧) 𝗿𝗲𝗮𝘀𝗼𝗻𝗶𝗻𝗴 𝘂𝘀𝗶𝗻𝗴 𝗺𝗲𝗱𝗶𝗰𝗮𝗹 𝗸𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗴𝗿𝗮𝗽𝗵𝘀.  1. Created 32,682 clinically validated QA explanations by linking symptoms, findings, and diagnoses through PrimeKG.  2. Generated CoT reasoning paths using GPT-4o, but retained only those that produced correct answers during post-hoc verification.  3. Validated with physicians across 7 specialties, with expert preference for MedReason’s reasoning in 80–100% of cases.  4. Enabled interpretable, step-by-step answers like linking difficulty walking to medulloblastoma via ataxia, preserving clinical fidelity throughout. Couple thoughts:   • introducing dynamic KG updates (e.g., weekly ingests of new clinical trial data) could keep reasoning current with evolving medical knowledge.  • Could also integrating visual KGs derived from DICOM metadata help coherent reasoning across text and imaging inputs? We don't use DICOM metadata enough tbh  • Adding testing with adversarial probing (like edge‑case clinical scenarios) and continuous alignment checks against updated evidence‑based guidelines might benefit the model performance Here's the awesome work: https://lnkd.in/g42-PKMG Congrats to Juncheng Wu, Wenlong Deng, Xiaoxiao Li, Yuyin Zhou and co! I post my takes on the latest developments in health AI – 𝗰𝗼𝗻𝗻𝗲𝗰𝘁 𝘄𝗶𝘁𝗵 𝗺𝗲 𝘁𝗼 𝘀𝘁𝗮𝘆 𝘂𝗽𝗱𝗮𝘁𝗲𝗱! Also, check out my health AI blog here: https://lnkd.in/g3nrQFxW | 40 comments on LinkedIn

𝐑𝐞𝐚𝐝𝐲 𝐟𝐨𝐫 𝐚 "𝐖𝐎𝐖!" 𝐦𝐨𝐦𝐞𝐧𝐭? The 𝘿𝙄𝙏𝘼 𝙂𝙧𝙖𝙥𝙝 𝙍𝘼𝙂 project automates building your content corpus's knowledge graph (KG) from structured documents. What few know are the (literally) hundreds of ways you can use a KG on your structured documents in addition to RAG retrieval for AI, so I've compiled a compendium of 150 DITA graph queries, what each does, the SPARQL queries themselves, and the business value of each. These 150 are only a sampling. Try doing THAT with the likes of Markdown, AsciiDoc, RsT, and other presentation-oriented document formats! 90 packed pages! https://lnkd.in/eY2kHcBe | 22 comments on LinkedIn

🔎 Lessons Learned from Evaluating NodeRAG vs Other RAG Systems I recently dug into the NodeRAG paper (https://lnkd.in/gwaJHP94) and it was eye-opening not just for how it performed, but for what it revealed about the evolution of RAG (Retrieval-Augmented Generation) systems. Some key takeaways for me: 👉 NaiveRAG is stronger than you think. Brute-force retrieval using simple vector search sometimes beats graph-based methods, especially when graph structures are too coarse or noisy. 👉 GraphRAG was an important step, but not the final answer. While it introduced knowledge graphs and community-based retrieval, GraphRAG sometimes underperformed NaiveRAG because its communities could be too coarse, leading to irrelevant retrieval. 👉 LightRAG reduced token cost, but at the expense of accuracy. By focusing on retrieving just 1-hop neighbors instead of traversing globally, LightRAG made retrieval cheaper — but often missed important multi-hop reasoning paths, losing precision. 👉 NodeRAG shows what mature RAG looks like. NodeRAG redesigned the graph structure itself: Instead of homogeneous graphs, it uses heterogeneous graphs with fine-grained semantic units, entities, relationships, and high-level summaries — all as nodes. It combines dual search (exact match + semantic search) and shallow Personalized PageRank to precisely retrieve the most relevant context. The result? 🚀 Highest accuracy across multi-hop and open-ended benchmarks 🚀 Lowest token retrieval (i.e., lower inference costs) 🚀 Faster indexing and querying 🧠 Key takeaway: In the RAG world, it’s no longer about retrieving more — it’s about retrieving better. Fine-grained, explainable, efficient retrieval will define the next generation of RAG systems. If you’re working on RAG architectures, NodeRAG’s design principles are well worth studying! Would love to hear how others are thinking about the future of RAG systems. 🚀📚 #RAG #KnowledgeGraphs #AI #LLM #NodeRAG #GraphRAG #LightRAG #MachineLearning #GenAI #KnowledegGraphs

In the world of representing and storing knowledge, things or entities have long monopolized center stage. Rows in databases represent things, where columns are just used to describe them.

A little peek into our developments of RDF-specific functionality for VS Code: 1️⃣ The autocompletion and hover-help for RDF vocabularies. Some are stored within the VS Code plugin, the rest are queried from LOV, giving intellisense to the most prominent ontologies. 2️⃣ We can use the ontology of the vocabularies to show when something is not typed correctly 3️⃣ SHACL has a SHACL meta-model. As we built a SHACL engine into VS Code, we can use this meta model to hint if something is not done correctly (e.g., a string as part of a datatype). We plan to release the plugin to the marketplace in some time (However, we are still building more functionality). To not take too much credit: https://lnkd.in/eFB2wKdz delivers important features like most syntax highlighting and auto-import of the prefixes.

A second usecase Thomas wrote for Veronika Heimsbakk’s SHACL for the Practitioner upcoming book is about Sparna’s work for the European Parliament. From validation of the data in the knowledge graph to further projects of data integration and dissemination, many different usages of SHACL specifications were explored… … and more exploratory usages of SHACL are foreseen ! “…

Large Language Models (LLMs) are revolutionizing the development of AI assistants capable of performing diverse tasks across domains. However, current state-of-the-art LLM-driven agents face...

In this post, we’ll dive into Kuzu’s core query capabilities and demonstrate how it pairs nicely with G.V()’s rich visualization tools.

An open-source Python framework for real-time, graph-based knowledge in Neo4j

How LLMs can used in a knowledge extraction and visualization pipeline