Cognee has developed a framework geared towards constructing AI memory. This means they turn your documents into a persistent memory layer, one that can be carried forward and queried across all language model queries.

This is a very simple post, but if you are confused about LLMs, Knowledge Graphs and Ontologies, if you have questions like "what is a knowledge graph?", "can LLM do all?" or "do we still need ontologies?", I hope this post can bring some simple of fundamental orientation. Warning: this is not a tre

Sign in or join now to see posts like this one and more.

Graph-based Retrieval-Augmented Generation (RAG) methods have significantly enhanced the performance of large language models (LLMs) in domain-specific tasks. However, existing RAG methods do not...

Learn how neurosymbolic frameworks and knowledge graphs are the key to bring structure, context, and flexibility to LLM-powered systems.

Now we can build knowledge graphs without tedious text preprocessing using smaller LLMs on laptops

A framework for measuring retrieval quality in Model Context Protocol agents

Graph retrieval-augmented generation (GraphRAG) has effectively enhanced large language models in complex reasoning by organizing fragmented knowledge into explicitly structured graphs. Prior...

If you could hire the smartest engineers and drop them in your code base would you expect miracles overnight? No, of course not! Because even if they are the best of coders, they don’t have context on your project, engineering processes and culture, security and compliance rules, user personas, business priorities, etc. The same is true of the very best agents.. they may know how to write (mostly) technically correct code, and have the context of your source code, but they’re still missing tons of context. Building agents that can deliver high quality outcomes, faster, is going to require much more than your source code, rules and a few prompts. Agents need the same full lifecyle context your engineers gain after being months and years on the job. LLMs will never have access to your company’s engineering systems to train on, so something has to bridge the knowledge gap and it shouldn’t be you, one prompt at a time. This is why we're building what we call our Knowledge Graph at GitLab. It's not just indexing files and code; it's mapping the relationships across your entire development environment. When an agent understands that a particular code block contains three security vulnerabilities, impacts two downstream services, and connects to a broader epic about performance improvements, it can make smarter recommendations and changes than just technically correct code. This kind of contextual reasoning is what separates valuable AI agents from expensive, slow, LLM driven search tools. We're moving toward a world where institutional knowledge becomes portable and queryable. The context of a veteran engineer who knows "why we built it this way" or "what happened last time we tried this approach" can now be captured, connected, and made available to both human teammates and AI agents. See the awesome demos below and I look forward to sharing more later this month in our 18.4 beta update!

GraphRAG doesn’t lack ideas, it struggles to scale up. It’s easy to be impressed by a demo that runs on a few documents and carefully curated questions. In that controlled environment, the answers appear seamless, latency is low and everything seems reliable. But the reality of enterprise is very different. Production workloads involve gigabytes of content, thousands of questions and tens of thousands of documents that are constantly changing. In such an environment, manual review is no longer an option. You can’t hire teams to check every answer against every evolving dataset. For GraphRAG to succeed in enterprise production, it must therefore rely on automated control mechanisms that continuously validate efficiency. Validation cannot be based on subjective impressions of 'good answers'. What is needed is a synthetic index of accuracy: a measurable framework that automatically tests and reflects performance at each stage of the workflow. This means validating ingestion (are we capturing the correct data?), embeddings (are entities represented consistently?), retrieval (are relevant entities retrieved reliably?) and reasoning (is the output aligned with the validated context?). Each step must be monitored and tested continuously as data and queries evolve. Another critical requirement is repeatability. In chatbot use cases, a degree of LLM creativity might be tolerated. In enterprise environments, however, it undermines trust. If the same query over the same dataset yields different answers each time, the system cannot be relied upon. Reducing the LLM's freedom to enforce repeatable, auditable answers is essential for GraphRAG to transition from prototype to production. The real differentiator will not be which graph model is 'purest', or which demo looks smoothest, but rather which implementation can demonstrate efficiency within enterprise constraints. This requires automation, accuracy, repeatability, and resilience at scale. Without these features, GraphRAG will remain an experimental solution rather than a practical one. #GraphRAG #RAG #AITrust #AutomatedValidation #AIBechmark

Atomic Facts, Validation, Entity Resolution, KG and more

💡 Graph of Ideas -- LLMs paired with knowledge graphs can be great partners for ideation, exploration, and research. We've all seen the classic detective corkboard, with pinned notes and pictures, all strung together with red twine. 🕵️  The digital version could be a mind-map, but you still have to draw everything by hand. What if you could just build one from a giant pile of documents? Enter GoAI - a fascinating approach that just dropped on arXiv combining knowledge graphs with LLMs for AI research idea generation. While the paper focuses on a graph of research papers, the approach is generalizable. Here's what caught my attention: 🔗 It builds knowledge graphs from AI papers where nodes are papers/concepts and edges capture semantic citation relationships - basically mapping how ideas actually connect and build on each other 🎯 The "Idea Studio" feature gives you feedback on innovation, clarity, and feasibility of your research ideas - like having a research mentor in your pocket 📈 Experiments show it helps produce clearer, more novel, and more impactful research ideas compared to traditional LLM approaches The key insight? Current LLMs miss the semantic structure and prerequisite relationships in academic knowledge. This framework bridges that gap by making the connections explicit. As AI research accelerates, this approach can be be used for any situation where you're looking for what's missing, rather than answering a question about what exists. Read all the details in the paper... https://lnkd.in/ekGtCx9T

Unlock true AI potential with neuro-symbolic AI. Learn how combining LLMs with knowledge graphs solves unreliable and inaccurate outputs for enterprise success.

This post captures the desire for a short cut to #KnowledgeGraphs, the inability of #LLMs to reliably generate #StructuredKnowledge, and the lengths folks will go to realize even basic #semantic queries (the author manually encoded 1,000 #RDF triples, but didn’t use #OWL). https://lnkd.in/eJE_27gS #Ontologists by nature are generally rigorous, if not a tad bit pedantic, as they seek to structure #domain knowledge. 25 years of #SemanticWeb and this is still primarily a manual, tedious, time-consuming and error-prone process. In part, #DeepLearning is a reaction to #structured, #labelled, manually #curated #data (#SymbolicAI). When #GenAI exploded on the scene a couple of years ago, #Ontologist were quick to note the limitations of LLMs. Now some #Ontologists are having a "Road to Damascus" moment - they are aspirationally looking to Language Models as an interface for #Ontologies to lower barrier to ontology creation and use, which are then used for #GraphRAG, but this is a circular firing squad given the LLM weaknesses they have decried. This isn't a solution, it's a Hail Mary. They are lowering the standards on quality and setting up the even more tedious task of identifying non-obvious, low-level LLM errors in an #Ontology (same issue Developers have run into with LLM CodeGen - good for prototypes, not for production code). The answer is not to resign ourselves and subordinate ontologies to LLMs, but to take the high-road using #UpperOntologies to ease and speed the design, use and maintenance of #KGs. An upper ontology is a graph of high-level concepts, types and policies independent of a specific #domain implementation. It provides an abstraction layer with re-usable primitives, building blocks and services that streamline and automate domain modeling tasks (i.e., a #DSL for DSLs). Importantly, an upper ontology drives well-formed and consistent objects and relationships and provides for governance (e.g., security/identity, change management). This is what we do EnterpriseWeb. #Deterministic, reliable, trusted ontologies should be the center of #BusinessArchitecture, not a side-car to an LLM.

Guy van den Broeck (UCLA)https://simons.berkeley.edu/talks/guy-van-den-broeck-ucla-2025-04-29Theoretical Aspects of Trustworthy AIToday, many expect AI to ta...

Blue Morpho: A new solution for building AI apps on top of knowledge bases Blue Morpho helps you build AI agents that understand your business context, using ontologies and knowledge graphs. Knowledge Graphs work great with LLMs. The problem is that building KGs from unstructured data is hard. Blue Morpho promises a system that turns PDFs and text files into knowledge graphs. KGs are then used to augment LLMs with the right context to answer queries, make decisions, produce reports, and automate workflows. How it works: 1. Upload documents (pdf or txt). 2. Define your ontology: concepts, properties, and relationships. (Coming soon: ontology generation via AI assistant.) 3. Extract a knowledge graph from documents based on that ontology. Entities are automatically deduplicated across chunks and documents, so every mention of “Walmart,” for example, resolves to the same node. 4. Build agents on top. Connect external ones via MCP, or use Blue Morpho: Q&A (“text-to-cypher”) and Dashboard Generation agents. Blue Morpho differentiation: - Strong focus on reliability. Guardrails in place to make sure LLMs follow instructions and the ontology.  - Entity deduplication, with AI reviewing edge cases. - Easy to iterate on ontologies: they are versioned, extraction runs are versioned as well with all their parameters, and changes only trigger necessary recomputes.  - Vector embeddings are only used in very special circumstances, coupled with other techniques. Link in comments. Jérémy Thomas #KnowledgeGraph #AI #Agents #MCP #NewRelease #Ontology #LLMs #GenAI #Application -- Connected Data London 2025 is coming! 20-21 November, Leonardo Royal Hotel London Tower Bridge Join us for all things #KnowledgeGraph #Graph #analytics #datascience #AI #graphDB #SemTech #Ontology 🎟️ Ticket sales are open. Benefit from early bird prices with discounts up to 30%. https://lnkd.in/diXHEXNE 📺 Sponsorship opportunities are available. Maximize your exposure with early onboarding. Contact us at info@connected-data.london for more.

Just released a new notebook exploring Semantic Entity Resolution & Extraction using DSPy (Community) and Google's new LangExtract library. Inspired by Russell Jurney’s excellent work on semantic entity resolution, this demo follows his approach of combining: ✅ embeddings, ✅ kNN blocking, ✅ and LLM matching with DSPy (Community). On top of that, I added a general extraction layer to test-drive LangExtract, a Gemini-powered, open-source Python library for reliable structured information extraction. The goal? Detect and merge mentions of the same real-world entities across text. It’s an end-to-end flow tackling one of the most persistent data challenges. Check it out, experiment with your own data, 𝐞𝐧𝐣𝐨𝐲 𝐭𝐡𝐞 𝐬𝐮𝐦𝐦𝐞𝐫 and let me know your thoughts! cc Paco Nathan you might like this 😉 https://wor.ai/8kQ2qa

Stop manually building your company's brain. ❌ Having reviewed the excellent DeepLearning.AI lecture on Agentic Knowledge Graph Construction, by Andreas Kollegger and writing a book on Agentic graph system with Sam Julien, it is clear that the use of agentic systems represents a shift in how we build and maintain knowledge graphs (KGs). Most organizations are sitting on a goldmine of data spread across CSVs, documents, and databases. The dream is to connect it all into a unified Knowledge Graph, an intelligent brain that understands your entire business. The reality? It's a brutal, expensive, and unscalable manual process. But a new approach is changing everything. Here’s the new playbook for building intelligent systems: 🧠 Deploy an AI Agent Workforce Instead of rigid scripts, you use a cognitive assembly line of specialized AI agents. A Proposer agent designs the data model, a Critic refines it, and an Extractor pulls the facts. This modular approach is proven to reduce errors and improve the accuracy and coherence of the final graph. 🎨 Treat AI as a Designer, Not Just a Doer The agents act as data architects. In discovery mode, they analyze unstructured data (like customer reviews) and propose a new logical structure from scratch. In an enterprise with an existing data model, they switch to alignment mode, mapping new information to the established structure. 🏛️ Use a 3-Part Graph Architecture This technique is key to managing data quality and uncertainty. You create three interconnected graphs: The Domain Graph: Your single source of truth, built from trusted, structured data. The Lexical Graph: The raw, original text from your documents, preserving the evidence. The Subject Graph: An AI-generated bridge that connects them. It holds extracted insights that are validated before being linked to your trusted data. Jaro-Winkler is a string comparison algorithm that measures the similarity or edit distance between two strings. It can be used here for entity resolution, the process of identifying and linking entities from the unstructured text (Subject Graph) to the official entities in the structured database (Domain Graph). For example, the algorithm compares a product name extracted from a customer review (e.g., "the gothenburg table") with the official product names in the database. If the Jaro-Winkler similarity score is above a certain threshold, the system automatically creates a CORRESPONDS_TO relationship, effectively linking the customer's comment to the correct product in the supply chain graph. 🤝 Augment Humans, Don't Replace Them The workflow is Propose, then Approve. AI does the heavy lifting, but a human expert makes the final call. This process is made reliable by tools like Pydantic and Outlines, which enforce a rigid contract on the AI's output, ensuring every piece of data is perfectly structured and consistent. And once discovered and validated, a schema can be enforced. | 32 comments on LinkedIn

Sharing our recent research 𝐅𝐢𝐧𝐑𝐞𝐟𝐥𝐞𝐜𝐭𝐊𝐆: 𝐀𝐠𝐞𝐧𝐭𝐢𝐜 𝐂𝐨𝐧𝐬𝐭𝐫𝐮𝐜𝐭𝐢𝐨𝐧 𝐚𝐧𝐝 𝐄𝐯𝐚𝐥𝐮𝐚𝐭𝐢𝐨𝐧 𝐨𝐟 𝐅𝐢𝐧𝐚𝐧𝐜𝐢𝐚𝐥 𝐊𝐧𝐨𝐰𝐥𝐞𝐝𝐠𝐞 𝐆𝐫𝐚𝐩𝐡𝐬. It is the largest financial knowledge graph built from unstructured data. The preprint of our article is out on arXiv now (link is in the comments). It is coauthored with Abhinav Arun | Fabrizio Dimino | Tejas Prakash Agrawal While LLMs make it easier than ever to generate knowledge graphs, the real challenge lies in ensuring quality without hallucinations, with strong coverage, precision, comprehensiveness, and relevance. FinReflectKG tackles this through an iterative, evaluation-driven agentic approach, carefully optimized across multiple evaluation metrics to deliver a trustworthy and high-quality knowledge graph. Designed to power use cases like entity search, question answering, signal generation, predictive modeling, and financial network analysis, FinReflectKG sets a new benchmark for building reliable financial KGs and showcases the potential of agentic workflows in LLM-driven systems. We will be creating a suite of benchmarks using FinReflectKG for KG related tasks in financial services. More details to come soon. | 15 comments on LinkedIn

SynaLinks is an open-source framework designed to make it easier to partner language models (LMs) with your graph technologies. Since most companies are not in a position to train their own language models from scratch, SynaLinks empowers you to adapt existing LMs on the market to specialized tasks.

Building Knowledge Graphs that Power Autonomous Agents

Subscribe • Previous Issues

Combine powerful schema guidance and granular pruning to turn your unstructured data into more accurate and queryable graphs

Knowledge graphs help understand relationships between the objects, events, situations, and concepts in your data so you can readily identify important patterns and make better decisions. This book provides tools and techniques for efficiently labeling data, modeling a knowledge graph, and using it to derive useful insights. In Knowledge Graphs and LLMs in Action you will learn how to: Model knowledge graphs with an iterative top-down approach based in business needs Create a knowledge graph starting from ontologies, taxonomies, and structured data Use machine learning algorithms to hone and complete your graphs Build knowledge graphs from unstructured text data sources Reason on the knowledge graph and apply machine learning algorithms Move beyond analyzing data and start making decisions based on useful, contextual knowledge. The cutting-edge knowledge graphs (KG) approach puts that power in your hands. In Knowledge Graphs and LLMs in Action, you’ll discover the theory of knowledge graphs and learn how to build services that can demonstrate intelligent behavior. You’ll learn to create KGs from first principles and go hands-on to develop advisor applications for real-world domains like healthcare and finance.

Complete technical pathway for transforming criminal network analysis from manual investigation into automated, AI-powered intelligence ...

AI-Powered Intelligence Synthesis—where network insights become comprehensive intelligence reports.

Most people talk about AI agents like they’re already reliable. They aren’t. They follow instructions. They spit out results. But they forget what they did, why it mattered, or how circumstances have changed. There’s no continuity. No memory. No grasp of unfolding context. Today’s agents can respond - but they can’t reflect, reason, or adapt over time. OpenAI’s new cookbook Temporal Agents with Knowledge Graphs lays out just how limiting that is and offers a credible path forward. It introduces a new class of temporal agents: systems built not around isolated prompts, but around structured, persistent memory. At the core is a knowledge graph that acts as an evolving world model - not a passive record, but a map of what happened, why it mattered, and what it connects to. This lets agents handle questions like: “What changed since last week?” “Why was this decision made?” “What’s still pending and what’s blocking it?” It’s an architectural shift that turns time, intent, and interdependence into first-class elements. This mirrors Tony Seale’s argument about enterprise data: most data products don’t fail because of missing pipelines - they fail because they don’t align with how the business actually thinks. Data lives in tables and schemas. Business lives in concepts like churn, margin erosion, customer health, or risk exposure. Tony’s answer is a business ontology: a formal, machine-readable layer that defines the language of the business and anchors data products to it. It’s a shift from structure to semantics - from warehouse to shared understanding. That’s the same shift OpenAI is proposing for agents. In both cases, what’s missing isn’t infrastructure. It’s interpretation. The challenge isn’t access. It’s alignment. If we want agents that behave reliably in real-world settings, it’s not enough to fine-tune them on PDFs or dump Slack threads into context windows. They need to be wired into shared ontologies - concept-level scaffolding like: Who are our customers? What defines success? What risks are emerging, and how are they evolving? The temporal knowledge graph becomes more than just memory. It becomes an interface - a structured bridge between reasoning and meaning. This goes far beyond another agent orchestration blueprint. It points to something deeper: Without time and meaning, there is no true delegation. We don’t need agents that mimic tasks. We need agents that internalise context and navigate change. That means building systems that don’t just handle data, but understand how it fits into the changing world we care about. OpenAI’s temporal memory graphs and Tony’s business ontologies aren’t separate ideas. They’re converging on the same missing layer: AI that reasons in the language of time and meaning. H/T Vin Vashishta for the pointer to the OpenAI cookbook, and image nicked from Tony (as usual). | 72 comments on LinkedIn

Over two years ago, I wrote about the emerging synergy between LLMs and ontologies - and how, together, they could create a self-reinforcing loop of continuous improvement. That post struck a chord. With GPT-5 now here, it’s the right moment to revisit the idea. Back then, GPT-3.5 and GPT-4 could draft ontology structures, but there were limits in context, reasoning, and abstraction. With GPT-5 (and other frontier models), that’s changing: 🔹 Larger context windows let entire ontologies sit in working memory at once.   🔹 Test-time compute enables better abstraction of concepts.   🔹 Multimodal input can turn diagrams, tables, and videos into structured ontology scaffolds.   🔹 Tool use allows ontologies to be validated, aligned, and extended in one flow. But some fundamentals remain. GPT-5 is still curve-fitting to a training set - and that brings limits: 🔹 The flipside of flexibility is hallucination. OpenAI has reduced it, but GPT-5 still scores 0.55 on SimpleQA, with a 5% hallucination rate on its own public-question dataset.   🔹 The model is bound by the landscape of its training data. That landscape is vast, but it excludes your private, proprietary data - and increasingly, an organisation’s edge will track directly to the data it owns outside that distribution. Fortunately, the benefits flow both ways. LLMs can help build ontologies, but ontologies and knowledge graphs can also help improve LLMs. The two systems can work in tandem.   Ontologies bring structure, consistency, and domain-specific context.   LLMs bring adaptability, speed, and pattern recognition that ontologies can’t achieve in isolation.   Each offsets the other’s weaknesses - and together they make both stronger. The feedback loop is no longer theory - we’ve been proving it:   Better LLM → Better Ontology → Better LLM - in your domain. There is a lot of hype around AI. GPT-5 is good, but not ground-breaking. Still, the progress over two years is remarkable. For the foreseeable future, we are living in a world where models keep improving - but where we must pair classic formal symbolic systems with these new probabilistic models. For organisations, the challenge is to match growing model power with equally strong growth in the power of their proprietary symbolic formalisation. Not all formalisations are equal. We want fewer brittle IF statements buried in application code, and more rich, flexible abstractions embedded in the data itself. That’s what ontologies and knowledge graphs promise to deliver. Two years ago, this was a hopeful idea.   Today, it’s looking less like a nice-to-have…   …and more like the only sensible way forward for organisations. ⭕ Neural-Symbolic Loop: https://lnkd.in/eJ7S22hF 🔗 Turn your data into a competitive edge: https://lnkd.in/eDd-5hpV