#Anthropic just disrupted the first AI-orchestrated cyberattack.

Simple way of starting with ontologies: start with your favorite LLM and the following prompt:

Scientific Reports - Research on the construction and application of retrieval enhanced generation (RAG) model based on knowledge graph

Large language models (LLMs) have demonstrated remarkable capabilities in a wide range of tasks, yet their application to specialized domains remains challenging due to the need for deep...

Labels as the Real Semantic Layer of LPG in GraphRAG and Applied Knowledge Graphs

Inside LinkedIn’s AI ‘cookbook’: How engineers scaled GenAI to 1.3B users by distilling models to 220M parameters for a 10x throughput gain.

I used the o word last week and it hit a few nerves. Ontologies bring context. But then context engineering is very poorly understood. Agent engineers speak about it, expect everyone is doing it, know but almost everyone is winging it. Here's what context engineering is definitely not - ie. longer prompts. What it actually is - the right information, with the right meaning, at the right time. Not more but the right information with the right meaning. Sounds super abstract. That's why a brief video that actually breaks down how to load context. Okay. Not brief. but context needs context.

Your LLM based agent can't reason about what it can't traverse.

Alhamdulillah, ATOM is finally here! A scalable and fast approach that can build and continuously update temporal knowledge graphs, inspired by atomic bonds. Just as matter is formed from atoms, and galaxies are formed from stars, knowledge is likely to be formed from atomic knowledge graphs. Atomic knowledge graphs were born from our intention to solve a common problem in LLM-based KG construction methods: exhaustivity and stability. Often, these methods produce unstable KGs that change when rerunning the construction process, even without changing anything. Moreover, they fail to capture all facts in the input documents and usually overlook the temporal and dynamic aspects of real-world data. What is the solution? Atomic facts that are temporally aware. Instead of constructing knowledge graphs from raw documents, we split them into atomic facts, which are self-contained and concise propositions. Temporal atomic KGs are constructed from each atomic fact. Then, we defined how the temporal atomic KGs would be merged at the atomic level and how the temporal aspects would be handled. We designed a binary merge algorithm that combines two TKGs and a parallel merge process that merges all TKGs simultaneously. The entire architecture operates in parallel. ATOM employs dual-time modeling that distinguishes observation time from validity time and has 3 main modules: - Module 1 (Atomic Fact Decomposition) splits input documents observed at time t into atomic facts using LLM-based prompting, where each temporal atomic fact is a short, self-contained snippet that conveys exactly one piece of information. - Module 2 (Atomic TKGs Construction) extracts 5-tuples in parallel from each atomic fact to construct atomic temporal KGs, while embedding nodes and relations and addressing temporal resolution during extraction. - Module 3 (Parallel Atomic Merge) employs a binary merge algorithm to merge pairs of atomic TKGs through iterative pairwise merging in parallel until convergence, with three resolution phases: (1) entity resolution, (2) relation name resolution, and (3) temporal resolution that merges observation and validity time sets for relations with similar (e_s, r_p, e_o). The resulting TKG snapshot is then merged with the previous DTKG to yield the updated DTKG. Results: Empirical evaluations demonstrate that ATOM achieves ~18% higher exhaustivity, ~17% better stability, and over 90% latency reduction compared to baseline methods (including iText2KG), demonstrating strong scalability potential for dynamic TKG construction. Check our ATOM's architecture and code: Preprint Paper: https://lnkd.in/dsJzDaQc Code: https://lnkd.in/drZUyisV Website: (coming soon) Example use cases: (coming soon) Special thanks to the dream team: Ludovic Moncla, Khalid Benabdeslem, Rémy Cazabet, Pierre Cléau 📚📡 | 14 comments on LinkedIn

How to stay sane about “semantic Graph RAG” when your job is shipping reliable systems, not winning ontology theology wars. You don’t wake up in the morning thinking about OWL profiles or SPARQL entailment regimes.

Looking to run local GraphRAG or other graph analytics use cases? With DGX Spark, you can prepare your local text files for graph use cases at your desk.In t...

🚀 LLMs can be powerful tools to extract information from texts and automatically populate Knowledge Graphs guided by ontologies given as inputs. BUT how good are they? To reply to this question, we need benchmarks! 💡 With Lettria, we build the Text2KGBench-LettrIA benchmark covering 19 different ontologies in various domains (company, film, food, politician, sports, monument, etc.) and consisting of near 5k sentences strictly annotated with triples conforming to these ontologies (208 classes, 426 properties) yielding more than 17k triples. What's more? We throw a lot of compute to compare the performance and efficiency of numerous Closed LLMs models and variants (GPT4, Claude 3, Gemini) and numerous fine-tuned Open Weights models (Mistral 3, Qwen 3, Gemma 3, Phi 4). ✨Key take-away: when being provided with high quality data, fine-tuned open models largely outperform larger, proprietary counterparts! 📄 Curious about the detailed results? Read our paper at https://lnkd.in/e-EZCjWm See our presentation at https://lnkd.in/eEdCCpdA that I have just presented at the Knowledge Base Construction from Pre-Trained Language Models Workshop colocated with the ISWC - International Semantic Web Conference. You want to use these results in your operations? Sign-up for using the newly released PERSEUS model, https://lnkd.in/e7exyJHc Joint work with Julien PLU, Oscar Moreno Escobar, Edouard Trouillez, Axelle Gapin, Pasquale Lisena, Thibault Ehrhart #iswc2025 #LLMs #KnowledgeGraphs #NLP #Research EURECOM, Charles Borderie

How semantic layers and GraphRAG provide the foundation for building trustworthy AI systems that can deliver reliable results.

Build AI agents with LangGraph and cognee: persistent semantic memory across sessions for cleaner context and higher accuracy. See the demo—get started now.

KG-R1, Why Knowledge Graph RAG Systems Are Too Expensive to Deploy (And How One Team Fixed It) ... What if I told you that most knowledge graph systems require multiple AI models just to answer a single question? That's exactly the problem plaguing current KG-RAG deployments. 👉 The Cost Problem Traditional knowledge graph retrieval systems use a pipeline approach: one model for planning, another for reasoning, a third for reviewing, and a fourth for responding. Each step burns through tokens and compute resources, making deployment prohibitively expensive for most organizations. Even worse? These systems are built for specific knowledge graphs. Change your data source, and you need to retrain everything. 👉 A Single-Agent Solution Researchers from MIT and IBM just published KG-R1, which replaces this entire multi-model pipeline with one lightweight agent that learns through reinforcement learning. Here's the clever part: instead of hardcoding domain-specific logic, the system uses four simple, universal operations: - Get relations from an entity - Get entities from a relation - Navigate forward or backward through connections These operations work on any knowledge graph without modification. 👉 The Results Are Striking Using just a 3B parameter model, KG-R1: - Matches accuracy of much larger foundation models - Uses 60% fewer tokens per query than existing methods - Transfers across different knowledge graphs without retraining - Processes queries in under 7 seconds on a single GPU The system learned to retrieve information strategically through multi-turn interactions, optimized end-to-end rather than stage-by-stage. This matters because knowledge graphs contain some of our most valuable structured data - from scientific databases to legal documents. Making them accessible and affordable could unlock entirely new applications.

Your agents NEED a semantic layer 🫵 Traditional RAG systems embed documents, retrieve similar chunks, and feed them to LLMs. This works for simple Q&A. It fails catastrophically for agents that need to reason across systems. Why? Because semantic similarity doesn't capture relationships. Your vector database can tell you that two documents are "about bonds." It can't tell you that Document A contains the official pricing methodology, Document B is a customer complaint referencing that methodology, and Document C is an assembly guide that superseded both. These relationships are invisible to embeddings. What semantic layers provide: Entity resolution across data silos. When "John Smith" in your CRM, "J. Smith" in email, and "john.smith@company.com" in logs all map to the same person node, agents can traverse the complete context. Cross-domain entity linking through knowledge graphs. Products in your database connect to assembly guides, which link to customer reviews, which reference support tickets. Single-query traversal instead of application-level joins. Provenance-tracked derivations. Every extracted entity, inferred relationship, and generated embedding maintains lineage to source data. Critical for regulatory compliance and debugging agent behavior. Ontology-grounded reasoning. Financial instruments mapped to FIBO standards. Products mapped to domain taxonomies. Agents reason with structured vocabulary, not statistical word associations. The technical implementation pattern: Layer 1: Unified graph database supporting vector, structured, and semi-structured data types in single queries. Layer 2: Entity extraction pipeline with coreference resolution and deduplication across sources. Layer 3: Relationship inference and cross-domain linking using both explicit identifiers and contextual signals. Layer 4: Separation of first-party data from derived artifacts with clear tagging for safe regeneration. The result: Agents can traverse "Product → described_in → AssemblyGuide → improved_by → CommunityTip → authored_by → Expert" in a single graph query instead of five API calls with application-level joins. Model Context Protocol is emerging as the open standard for semantic tool modeling. Not just describing APIs, but encoding what tools do, when to use them, and how outputs compose. This enables agents to discover and reason about capabilities dynamically. The competitive moat isn't your model choice. The moat is your knowledge graph architecture and the accumulated entity relationships that took years to build. | 28 comments on LinkedIn

🕸️ Can LLMs Really Build Knowledge Graphs We Can Trust? There’s a growing trend: “Let’s use LLMs to build knowledge graphs.” It sounds like the perfect shortcut - take unstructured data, prompt an LLM, and get a ready-to-use graph. But… are we sure those graphs are trustworthy? Before that, let’s pause for a second: 💡 Why build knowledge graphs at all? Because they solve one of AI’s biggest weaknesses - lack of structure and reasoning. Graphs let us connect facts, entities, and relationships in a way that’s transparent, queryable, and explainable. They give context, memory, and logic - everything that raw text or embeddings alone can’t provide. Yet, here’s the catch when using LLMs to build them: 🔹 Short context window - LLMs can only “see” a limited amount of data at once, losing consistency across larger corpora. 🔹 Hallucinations - when context runs out or ambiguity appears, models confidently invent facts or relations that never existed. 🔹 Lack of provenance - LLM outputs don’t preserve why or how a link was made. Without traceability, you can’t audit or explain your graph. 🔹 Temporal instability - the same prompt can yield different graphs tomorrow, because stochastic generation ≠ deterministic structure. 🔹 Scalability & cost - large-scale graph construction requires persistent context and reasoning, which LLMs weren’t designed for. Building knowledge graphs isn’t just data extraction - it’s engineering meaning. It demands consistency, provenance, and explainability, not just text generation. LLMs can assist in this process, but they shouldn’t be the architect. The next step is finding a way to make graphs both trustworthy and instant - without compromising one for the other. | 11 comments on LinkedIn

"GraphRAG chatter is louder than its footprint in production." That line from Ben Lorica's piece on Gradient Flow stopped me in my tracks: https://lnkd.in/dmC-ykAu I was reading it because of my deep interest in graph-based reasoning, and while the content is excellent, I was genuinely surprised by the assessment of GraphRAG adoption. The article suggests that a year after the initial buzz, GraphRAG remains mostly confined to graph vendors and specialists, with little traction in mainstream AI engineering teams. Here's the thing: at GraphAware, we have GraphRAG running in production: our AskTheDocs conversational interface in Hume uses this approach to help customers query documentation, and the feedback has been consistently positive. It's not an experiment—it's a production feature our users rely on daily. So I have a question for my network (yes, I know you're a bit biased—many of you are graph experts, after all 😊): Where is GraphRAG actually working in production? I'm not looking for POCs, experiments, or "we're exploring it." I want to hear about real, deployed systems serving actual users. Success stories. Production use cases. The implementations that are quietly delivering value while the tech commentary wonders if anyone is using this stuff. If you have direct or indirect experience with GraphRAG in production, I'd love to hear from you: - Drop a comment below - Send me a DM - Email me directly I want to give these cases a voice and learn from what's actually working out there. Who's building with GraphRAG beyond the buzz? #GraphRAG #KnowledgeGraphs #AI #ProductionAI #RAG

Recent interest in building foundation models for KGs has highlighted a fundamental challenge: knowledge-graph data is relatively scarce. The best-known KGs are primarily human-labeled, created by...

Following yesterday's announcements from OpenAI, brands start to have real ways to operate inside ChatGPT. At a very high-level this is the map for anyone considering entering (or expanding) into the ChatGPT ecosystem: Conversational Prompts / UX: optimize how ChatGPT “asks” for or surfaces brand se

Is OpenAI quietly moving toward knowledge graphs? Yesterday’s OpenAI DevDay was all about new no-code tools to create agents. Impressive. But what caught my attention wasn’t what they announced… it’s what they didn’t talk about. During the summer, OpenAI released a Cookbook update introducing the concept Temporal Agents (see below) connecting it to Subject–Predicate–Object triples: the very foundation of a knowledge graph. If you’ve ever worked with graphs, you know this means something big: they’re not just building agents anymore they’re building memory, relationships, and meaning. When you see “London – isCapitalOf – United Kingdom” in their official docs, you realize they’re experimenting with how to represent knowledge itself. And with any good knowledge graph… comes an ontology. So here’s my prediction: ChatGPT-6 will come with a built-in graph that connects everything about you. The question is: do you want their AI to know everything about you? Or do you want to build your own sovereign AI, one that you own, built from open-source intelligence and collective knowledge? Would love to know what you think. Is that me hallucinating or is that a weak signal?👇 | 62 comments on LinkedIn

Please read the previous article on Vanilla RAG

For all the excitement around large language models, the latest research from Simona-Vasilica Oprea and Georgiana Stănescu (Electronics 14:1313, 2025) offers a reality check. Automatic ontology generation, even with novel prompting techniques like Memoryless CQ-by-CQ and Ontogenia, remains a partial

Most companies are building autonomous agents with LLMs at the center, making every decision. Here's the problem: each LLM call has a ~5% error rate. Chain 10 calls together and your reliability drops to 60%. ⁉️ Here's the math: Single LLM call = 95% accuracy. Chain 10 LLM calls for agentic workflow = 0.95^10 = 60% reliability. This compounds exponentially with complexity. Enterprise can't ship that. Some companies like Rippletide Yann BILIEN getting agents to production are doing something different. They're using graphs as the orchestration layer and pushing LLMs to the edges. The architectural solution is about removing LLMs from the orchestration loop entirely and using hypergraph-based reasoning substrates instead. Why hypergraphs specifically? Regular graphs connect two nodes per edge. Hyperedges connect multiple nodes simultaneously - critical for representing complex state transitions. A single sales conversation turn involves speaker, utterance, topic, customer state, sentiment, outcome, and timestamp. A hyperedge captures all these relationships atomically in the reasoning structure. The neurosymbolic integration is what makes this production-grade: Symbolic layer = business rules, ontologies, deterministic patterns. These are hard constraints that prevent policy violations (discount limits, required info collection, compliance rules). Neural layer = RL components that learn edge weights, validate patterns, update confidences. Operates within symbolic constraints. Together they enable the "crystallization mechanism" - patterns start probabilistic, validate through repeated success, then lock into deterministic rules at 95%+ confidence. The system becomes non-regressive: it learns and improves but validated patterns never degrade. Here's what this solves that LLM-orchestration can't: Hallucinations with confidence - eliminated because reasoning follows deterministic graph traversal through verified data, not generative token prediction. Goal drift - impossible because goal hierarchies are encoded in graph topology and enforced mathematically by traversal algorithms. Data leakage across contexts - prevented through graph partitioning and structural access controls, not prompt instructions. Ignoring instructions - doesn't happen because business rules are executable constraints, not natural language hopes. The LLM's role reduces to exactly two functions: (1) helping structure ontologies during build phase, (2) optionally formatting final outputs to natural language. Zero involvement in decision-making or orchestration. Rippletide's architecture demonstrates this at scale: Hypergraph stores unified memory + reasoning (no RAG, no retrieval bottleneck) Reasoning engines execute graph traversal algorithms for decisions Weighted edges encode relationship strength, recency, confidence, importance Temporal/spatial/causal relationships explicit in structure (what LLMs fundamentally lack) | 27 comments on LinkedIn

The market is obsessed with the sexy stuff, autonomous agents, reasoning engines, sophisticated orchestration. Meanwhile, the unsexy foundation layer is completely broken. ⭕ And that foundation layer? It's the only thing that determines whether your agent actually works. Here's the technical problem killing agentic AI reliability and that a great company like Lettria solves: The document-to-knowledge-graph pipeline is fundamentally broken : Layer 1: Document Parsing Hell You can't feed a 400-page PDF with mixed layouts into a vision-language model and expect consistent structure. Here's why: Reading order detection fails on multi-column layouts, nested tables, and floating elements Vision LLMs hallucinate cell boundaries on complex tables (financial statements, technical specs) You need bbox-level segmentation with preserved coordinate metadata for traceability Traditional CV models (Doctr, Detectron2, YOLO) outperform transformers on layout detection and run on CPU Optimal approach requires model routing: PDF Plumber for text extraction, specialized table parsers for structured data, VLMs only as fallback Without preserving document_id → page_num → bbox_coords → chunk_id mapping, you lose provenance permanently Layer 2: Ontology Generation Collapse RDF/OWL ontology creation isn't prompt engineering. It's semantic modeling: You need 5-6 levels of hierarchical abstraction (not flat entity lists) Object properties require explicit domain/range specifications (rdfs:domain, rdfs:range) Data properties need typed constraints (xsd:string, xsd:integer, xsd:date) Relationships must follow semantic web standards (owl:ObjectProperty, owl:DatatypeProperty) LLM might output syntactically valid Turtle that violates semantic consistency Proper approach: 8-9 specialized LLM calls with constraint validation, reasoner checks, and ontologist-in-the-loop verification Without this, your knowledge graph has edges connecting semantically incompatible nodes Layer 3: Text-to-RDF Extraction Failure Converting natural language to structured triples while maintaining schema compliance is where frontier models crater: GPT-4/Claude achieve ~60-70% F1 on entity extraction, ~50-60% on relation extraction (measured on Text2KGBench) They hallucinate entities not in your ontology They create relations violating domain/range constraints Context window limitations force truncation (32K tokens = ~10-15 pages with full ontology) A specialized 600M parameter model fine-tuned on 14K annotated triples across 19 domain ontologies hits 85%+ F1 Why? Task-specific loss functions, schema-aware training, constrained decoding The compounding effect destroys reliability Your agent's reasoning is irrelevant when it's operating on a knowledge graph where 73% of nodes/edges are wrong, incomplete, or unverifiable. Without bidirectional traceability (SPARQL query → triple → chunk_id → bbox → source PDF), you can't deploy in regulated environments. Period. | 13 comments on LinkedIn

Building AI agents that can synthesize scattered knowledge like expert developers 🧠 I have a tutorial about building intelligent AI memory systems with Cognee in my 'Agents Towards Production' repo that solves a critical problem - developers navigate between documentation, community practices, and personal experience, but traditional approaches treat these as isolated resources. This tutorial shows how to build a unified knowledge graph that connects Python's design philosophy, real-world implementations from its creator, and your specific development patterns. The tutorial covers 3 key capabilities: - Knowledge Graph Construction: Building interconnected networks from Guido van Rossum's actual commits, PEP guidelines, and personal conversations - Temporal Analysis: Understanding how solutions evolved over time with time-aware queries - Dynamic Memory Layer: Inferring implicit rules and discovering non-obvious connections across knowledge domains The cross-domain discovery is particularly impressive - it connects your validation issues from January 2024 with Guido van Rossum's actual solutions from mypy and CPython. Rather than keyword matching, it understands semantic relationships between your type hinting challenges and historical solutions, even when terminology differs. Tech stack: - Cognee for knowledge graph construction - OpenAI GPT-4o-mini for entity extraction - Graph algorithms for pattern recognition - Vector embeddings for semantic search The system uses semantic graph traversal with deep relationship understanding for contextually aware responses. Includes working Python code, complete Jupyter notebook with interactive visualizations, and production-ready patterns. Part of the collection of practical guides for building production-ready AI systems. Direct link to the tutorial: https://lnkd.in/eSsjwbuh Ever wish you could query all your development knowledge as one unified intelligent system? ♻️ Repost to let your network learn about this too!

Is Graph Data Science a critical, transformative layer for GraphRAG? The field of enterprise Artificial Intelligence (AI) is undergoing a significant architectural evolution. The initial enthusiasm for Large Language Models (LLMs) has matured into a pragmatic recognition of their limitations, partic

I’ve tested countless Retrieval-Augmented Generation (RAG) systems, and they all failed to meet my expectations. I found a simple two-step…