GraphNews

Introducing Brahmand: a Graph Database built on top of ClickHouse. Extending ClickHouse with native graph modeling and OpenCypher, merging OLAP speed with graph analysis. While it’s still in early development, it’s been fun writing my own Cypher parser, query planner with logical plan, analyzer, and optimizer in Rust. On the roadmap: native JSON support, bolt protocol, missing Cypher features like WITH, EXISTS, and variable-length relationship matches, along with bitmap-based optimizations and distributed cluster support. Feel free to check out the repo: https://lnkd.in/d-Bhh-qD I’d really appreciate a ⭐ if you find it useful!

The field is evolving from Prompt Engineering, treating context as a single, static string, to Contextual Engineering, which views context as a dynamic system of structured components (instructions, tools, memory, knowledge) orchestrated to solve complex tasks. 🔎 Nearly all innovation is a response to the primary limitation of Transformer models: the quadratic (O(n2)) computational cost of the self-attention mechanism as the context length (n) increases. All techniques for managing this challenge can be organized into three areas: 1. Context Generation & Retrieval (Sourcing Ingredients) Advanced Reasoning: Chain-of-Thought (CoT), Tree-of-Thoughts (ToT). External Knowledge: Advanced Retrieval-Augmented Generation (RAG) like GraphRAG, which uses knowledge graphs for more structured retrieval. 2. Context Processing (Cooking the Ingredients) Refinement: Using the LLM to iterate and improve its own output (Self-Refine). Architectural Changes: Exploring models beyond Transformers (e.g., Mamba) to escape the quadratic bottleneck. 3. Context Management (The Pantry System) Memory: Creating stateful interactions using hierarchical memory systems (e.g., MemGPT) that manage information between the active context window and external storage. Key Distinction: RAG is stateless I/O to the world; Memory is the agent's stateful internal history. The most advanced applications integrate these pillars to create sophisticated agents, with an added layer of dynamic adaptation: Tool-Integrated Reasoning: Empowering LLMs to use external tools (APIs, databases, code interpreters) to interact with the real world. Multi-Agent Systems: Designing "organizations" of specialized LLM agents that communicate and collaborate to solve multi-faceted problems, mirroring the structure of human teams. Adaptive Context Optimization: Leveraging Reinforcement Learning (RL) to dynamically optimize context selection and construction for specific environments and tasks, ensuring efficient and effective performance. Contextual Engineering is the emerging science of building robust, scalable, and stateful applications by systematically managing the flow of information to and from an LLM. | 16 comments on LinkedIn

Open-source tool for network discovery, visualization, and monitoring. Built with Go, FastAPI, and React, supports Docker host scanning. - karam-ajaj/atlas

Graph algorithms address a wide variety of problems by representing entities as nodes and relationships as edges. Want to find the fastest route through a city? Spot influential users on a social media platform? Or detect communities hidden in a sprawling network? Graph algorithms provide the tools

Semantic and graph technologies are gaining traction. Unfortunately, this rise often comes with an overload of buzzwords — and even semantic conflations across terms.

Telling a story semantically

Help !! I just let the pre-order live! 😬 All of you who signed up for more information shall have received an e-mail with pre-order option now. This is the most scariest sh*t I've done in a long time. Seeing pre-orders ticking in to something I've created---together with the most amazing guest authors---is a super weird feeling. THANK YOU! ❤️ It's been quite a process. From an idea planted in 2022, to now seeing the light at the end of the tunnel. I've spend hours and hours inside TeXworks, nerding around with LaTeX and Ti𝘬Z. Numerous moments at pubs, while waiting for someone, to edit, edit and edit. Taking vacation off work to isolate myself to write (so effective, btw!). Having a gold team of proofreaders, providing with super valuable feedback. Working with awesome SHACL practitioners to tell great SHACL stories to you! IT HAS BEEN GREAT FUN! This week, I have been focusing on final touches (thank you Data Treehouse for letting me do this!!). Indexing like a hero. Soon the words, bits and blobs will hit the printing press, and the first copies will ship on 𝐍𝐨𝐯𝐞𝐦𝐛𝐞𝐫 3𝐫𝐝. If you want to pre-order, tag along to https://lnkd.in/dER72USX for more information. All pre-orders will get a tiny SHACL surprise inside their book. 😇 Btw: the final product will probably not look like this, I got good help from our mutual friend ChatGPT, but I know it will be yellow at least. 💛

by Timothy Coleman and J Bittner Picture this: an AI system confidently delivers a financial report, but it misclassifies $100M in assets as liabilities. Errors of this kind are already appearing in financial AI systems, and the stakes only grow as organizations adopt Retrieval-Augmented Generation

Everyone's talking about LLMs. I went a different direction 🧠 While everyone's building RAG systems with document chunking and vector search, I got curious about something else after Prof Alsayed Algergawy and his assistant Vishvapalsinhji Parmar's Knowledge Graphs seminar. What if the problem isn't just retrieval - but how we structure knowledge itself? 🤔 Traditional RAG's limitation: Chop documents into chunks, embed them, hope semantic search finds the right pieces. But what happens when you need to connect information across chunks? Or when relationships matter more than text similarity? 📄➡️❓ My approach: Instead of chunking, I built a structured knowledge graph from Yelp data (220K+ entities, 555K+ relationships) and trained Graph Neural Networks to reason through connections. 🕸️ The attached visualization shows exactly why this works - see how information naturally exists as interconnected webs, not isolated chunks. 👇🏻 The difference in action: ⚡ Traditional RAG: "Find similar text about Italian restaurants" 🔍 My system: "Traverse user→review→business→category→location→hours and explain why" 🗺️ Result: 94% AUC-ROC performance with explainable reasoning paths. Ask "Find family-friendly Italian restaurants in Philadelphia open Sunday" and get answers that show exactly how the AI connected reviews mentioning kids, atmosphere ratings, location data, and business hours. 🎯 Why this matters: While others optimize chunking strategies, maybe we should question whether chunking is the right approach at all. Sometimes the breakthrough isn't better embeddings - it's fundamentally rethinking how we represent knowledge. 💡 Check my script here 🔗: https://lnkd.in/dwNcS5uM The journey from that seminar to building this alternative has been incredibly rewarding. Excited to continue exploring how structured knowledge can transform AI systems beyond what traditional approaches achieve. ✨ #AI #MachineLearning #RAG #KnowledgeGraphs #GraphNeuralNetworks #NLP #DataScience  | 36 comments on LinkedIn

A visual introduction

You don’t need a PhD to choose the right graph representation. You just need to know what you’ll do with the graph and pick the structure that makes that fast and easy. Below is a quick, practical guide you can use today: 1. Edge List: Start here when you just need “a list of connections.” An edge list is literally a list of edges: (x, y) for directed graphs, (x, y) and (y, x) for undirected, and (x, y, w) if weighted. It shines when you process edges globally (e.g., sort by weight for Kruskal’s MST). It’s also the most compact when your graph is sparse and you don’t need constant-time lookups. When to use: • You’ll sort/filter edges (MST, connectivity batches) • You’re loading data from CSV/logs where edges arrive as rows • You want minimal structure first and you’ll convert later if needed Trade-offs: • Space: O(m) • Iterate neighbors of x: O(m) (unless you pre-index) • Check if (x, y) exists: O(m) (or O(1) with an auxiliary hash set you maintain) 2. Adjacency Matrix: Use this when instant “is there an edge?” matters. A 2D array G[x][y] stores 1 (or weight) if the edge exists, else 0 (or a sentinel like −1/∞). You get constant-time edge existence checks and very clean math/linear-algebra operations. The cost is space: O(n²) even if the graph is tiny. If memory is fine and you need O(1) membership checks, go matrix. When to use: • Dense graphs (m close to n²) • Fast membership tests dominate your workload • You’ll leverage matrix ops (spectral methods, transitive closure variations, etc.) Trade-offs: • Space: O(n²) • Check if (x, y) exists: O(1) • Iterate neighbors of x: O(n) 3. Adjacency List Choose this when you traverse from nodes to neighbors a lot. Each node stores its exact neighbors, so traversal is proportional to degree, not n. This representation is ideal for BFS/DFS, Dijkstra (with weights), and most real-world sparse graphs. Membership checks are slower than a matrix unless you keep neighbor sets. For sparse graphs and traversal-heavy algorithms, pick adjacency lists. When to use: • Graph is sparse (common in practice) • You’ll run BFS/DFS, shortest paths, topological sorts • You need O(n + m) space and fast neighbor iteration Trade-offs: • Space: O(n + m) • Iterate neighbors of x: O(deg(x)) • Check if (x, y) exists: O(deg(x)) (or O(1) if you store a set per node) ~ Pick the representation that optimizes your next operation, not some abstract ideal. Edge lists for global edge work, matrices for instant membership, lists for fast traversal. Choose deliberately, and your graph code gets both cleaner and faster. If you want a deep dive on graph representation, say “Graphs” in the comments and I’ll send it to you on DM. | 15 comments on LinkedIn

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.

Every organization shares the same ambitions: to deliver better outcomes, increase efficiency, mitigate risks, and seize opportunities before they are lost. These ambitions underpin growth, resilience, agility, and lasting competitive advantage.  Yet most organizations struggle to harness the full value of their data to realize those ambitions. Massive volumes of granular signals flow in constantly … <p class="link-more"><a href="https://blog.fabric.microsoft.com/en-us/blog/the-foundation-for-powering-ai-driven-operations-fabric-real-time-intelligence/" class="more-link">Continue reading<span class="screen-reader-text"> “The Foundation for Powering AI-Driven Operations: Fabric Real-Time Intelligence”</span></a>

1...2...3 Knowledge Graph!!! 🧠 Build Knowledge Graphs in Minutes—No Code, All Logic What if deploying a knowledge graph was as easy as loading a CSV? With Knowledge Mapper, it is. We’ve built a no-code intelligent assistant that empowers business users—not just data scientists—to create and deploy knowledge graphs using real enterprise data and ontologies. 🔍 What Knowledge Mapper does: Opens any ontology Reads structured data (CSV, SQL) Guides users through a graphical mapping process Deploys to Amazon Neptune or GraphDB 💬 Powered by LLMs, it: Assists in mapping with natural language Translates business questions into SPARQL Visualizes queries graphically Suggests additional queries for testing and exploration 🌐 Whether you're working with Semantic Web technologies, implementing FAIR data principles, or trying to bridge enterprise architecture with business logic, Knowledge Mapper is designed for you. It connects to multiple SQL and RDF backends, making it a versatile tool for data governance, semantic integration, and ontology-driven architectures. ⚡ Our 3-step process—Load, Map, Deploy—lets you build and launch a knowledge graph in under 10 minutes. 📊 Want to see how semantic technologies can drive real business value? Ready to make FAIR data actionable across your organization? Let’s make knowledge graphs a business asset—not just a technical artifact. #SemanticWeb #KnowledgeGraph #FAIRData #Ontologies #DataGovernance #EnterpriseArchitecture #NoCode #LLM #SPARQL #GraphDB #AmazonNeptune #LinkedData #AI #KnowledgeMapper

Who is going to win the battle of the knowledge graph? RDF* or LPGs or XBRL? Is XBRL even in the running? Those are actually the wrong question to be asking. The right question is, "What useful things can I do with these interesting technologies?" Another good question is, "How will things change because of knowledge graphs?" This is what I am going to do: Universal Global Open Standard for Digital Accounting and Audit Working Papers https://lnkd.in/gtUhquRt | 11 comments on LinkedIn

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

Ever caught yourself bouncing between your code editor and database client just to test a single query? Annoying, right? That context switching kills your flow. Now you can bring the Ultipa VS Code Extensions for ISO GQL to your workflow! Write, validate, and execute ISO GQL queries right where you

RDF, the Semantic Web Project, Linked Data, and Knowledge Graphs have always promised an Internet where data is richly interconnected, queryable, and semantically coherent. The vision was not flawed, but adoption has remained mercurial.

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

T-Box: The secret sauce of knowledge graphs and AI Ever wondered how knowledge graphs “understand” the world? Meet the T-Box, the part that tells your graph what exists and how it can relate. Think of it like building a LEGO set: T-Box (Terminological Box) = the instruction manual (defines the pieces and how they fit) A-Box (Assertional Box) = the LEGO pieces you actually have (your data, your instances) Why it’s important for RDF knowledge graphs: - Gives your data structure and rules, so your graph doesn’t turn into spaghetti - Enables reasoning, letting the system infer new facts automatically - Keeps your graph consistent and maintainable, even as it grows Why it’s better than other models: Traditional databases just store rows and columns; relationships have no meaning RDF + T-Box = data that can explain itself and connect across domains Why AI loves it: - AI can reason over knowledge, not just crunch numbers - Enables smarter recommendations, insights, and predictions based on structured knowledge Quick analogy: T-Box = blueprint/instruction manual (the ontology / what is possible) A-Box = the real-world building (the facts / what is true) Together = AI-friendly, smart knowledge graph #KnowledgeGraph #RDF #AI #SemanticWeb #DataScience #GraphData

Comparing LPG and RDF in Recent Graph RAG Architectures As a follow-up to my previous posts and discussions, I would like to share three papers on arXiv that demonstrate the wide range of design choices in combining LPG and RDF. Here’s a brief overview of each: 1. RAGONITE: Iterative Retrieval on Induced Databases and Verbalized RDF arXiv:2412.17690 This paper builds on RDF knowledge graphs. Rather than relying solely on SPARQL queries, it establishes two retrieval pathways: one from an SQL database generated from the KG, and another from text searches over verbalised RDF facts. A controller decides when to combine or switch between them, with results passed to an LLM. The insight: RDF alone is not robust enough for conversational queries, but pairing it with SQL and text dramatically improves coverage and resilience. 2. GraphAr: Efficient Storage for Property Graphs in Data Lakes arXiv:2312.09577 This article addresses LPGs. It introduces a storage scheme that preserves LPG semantics in formats such as Parquet, while significantly boosting performance. Reported gains are impressive: neighbour retrieval is ~4452× faster, label filtering 14.8× faster, and end-to-end workflows 29.5× faster compared to baseline Parquet methods. Such optimisations are critical for GraphRAG, where low-latency retrieval is essential. 3. CypherBench: Towards Precise Retrieval over Full-scale Modern Knowledge Graphs in the LLM Era arXiv:2412.18702 This work brings a benchmarking perspective, targeting Cypher queries over large-scale LPGs. It emphasises precision retrieval across full-scale graphs, something crucial when LLMs are expected to interact with enterprise-scale knowledge. By formalising benchmarks, it encourages more rigorous evaluation of GraphRAG retrieval techniques and raises the bar for future architectures. Takeaway Together, these works highlight the diverse strategies for bridging RDF and LPG in GraphRAG — from hybrid retrieval pipelines to optimised storage and precision benchmarks. They show how research is steadily moving from demos to architectures that balance semantics, performance, and accuracy.

Interesting, and something I've been suspecting for a while. In semantics, one of the things that eventually all ontologists encounter is the fact that a human being cannot readily visualize large graphs, or even moderate-sized ones. Graphs are networks, and most networks can at best only be navigated from within. All graphs are collections of interconnected links between things; semantically we simplify those links, abstract them to a certain degree, but links in turn are also themselves describable as graphs, and when describing a system, those links in turn are dynamic and changing. One thing that marks the boundary between algorithms and intentional systems is complexity. Intentional systems, such as large language models, are more complex than the human brain can understand. We have to use computers to handle this complexity, because it is outside of the scope of our human wetware. This is a humbling realisation, and is the real power of AI; the point where we reached a level of complexity that is no longer completely comprehensible to mere mortals. This isn't going to change, regardless of what model we use for that AI. | 15 comments on LinkedIn

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

Executive Summary While both Vector Databases and Graph Databases are pivotal technologies in modern artificial intelligence (AI) and data management, they operate on fundamentally different principles of data organization and retrieval. Vector Databases manage data based on statistical similarity w

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

AI-Assisted Ontology Mapping Ontology alignment, glossary mapping, semantic integration - none are new. For decades: TF-IDF, WordNet, property matching, supervised models. They work - but remain rule-bounded. The new Google + Harvard research (2025-09-08) signals a paradigm shift: Ontologies are no longer static. Every conceptual decision can be treated as a measurable task. Ontologies as Living Systems An ontology is not a document. It is a formalized knowledge backbone, where: - Concepts are expressed declaratively (OWL, RDF, OntoUML) - Relations exist as axioms - Every inference is machine-checkable In this world, the semantic layer isn’t a BI artifact - it’s the formal contract of meaning: business glossaries, KPIs, and data attributes all refer to the same conceptual entities. Measuring Ontological Precision The Google–Harvard approach reframes ontology engineering as scorable tasks: - Mapping-F1 → accuracy of mappings between glossaries and semantic layers. - Alignment% → conceptual overlap between ontologies. - Consistency → are KPI definitions aligned with their OWL/RDF axioms? Once we define these metrics, semantic mappings stop being static deliverables. They become living quality signals - ontological KPIs. AI as a Sandbox Co-Scientist The breakthrough is not automation. It’s the ability to generate, test, and validate conceptual hypotheses iteratively: - LLM proposes alternative mapping strategies: embeddings, synonym discovery, definition-based similarity. - Tree Search explores promising branches, sandbox-validating each. - Research Injection pulls external knowledge - papers, books, benchmarks - into the loop. In one small-scale ontology alignment task: - Task: map 20 glossary terms into a semantic layer. - Baseline: manual mapping → Mapping-F1 = 0.55. - AI loop: hypotheses generated, sandbox-validated. - Breakthrough: after 8 iterations, Mapping-F1 reached 0.91. This isn’t “AI hallucination.” It’s measured, validated ontology evolution. The Ontological Cockpit An ontology cockpit tracks the health of your knowledge model: - Mapping-F1 trends - how well glossaries and layers align. - Alignment% by domain - where conceptual drift emerges. - Consistency-break log - where KPI definitions diverge from formal models. - Drift detection - alerts when semantics shift silently. This cockpit is the dynamic mirror of formalism. BI 2.0 dashboards can later inherit these metrics. AI-Supported Formalism Jessica Talisman - this is close to what you’ve been advocating: formal knowledge models supported, not replaced, by AI. - Sandbox validation ensures every hypothesis is tested and versioned. - Research injection integrates state-of-the-art ontological heuristics. - Ontologies evolve iteratively, without compromising formal rigor. The Google + Harvard research shows us: a semantic backbone that learns, an ontology that continuously integrates new knowledge, and a future where conceptual precision is measurable, auditable, and improvable. | 73 comments on LinkedIn