GraphNews

This one is about sync'ing data with a knowledge graph, also known as change data capture (CDC). CDC events are graph mutations, yet nobody builds them that way. When Debezium tails your Postgres WAL and emits a row-level change event, it hands you something like this: { op: "u", before: { customer_id: 42, status: "prospect" }, after: { customer_id: 42, status: "client" } }... What actually happened in your knowledge graph? A node property changed. But more interestingly, probably an edge dissolved and another was created. The prospect relationship to your pipeline entity is gone and a client relationship exists now, with a timestamp, a source, and a provenance trail. The tools don't see it that way. Debezium, Airbyte, Estuary Flow etc. they're excellent at what they do but they model the world as rows before and rows after. The graph semantics is your problem. This impedance mismatch has real consequences. For example, entity resolution breaks at event granularity. A CDC event from a CRM says account_id: 7821 changed. Your KG has a node with IRI . The mapping between those two things is a whole other pipeline, one that has to run before, or alongside, the mutation. Most teams discover this the hard way. SAP and enterprise systems make it worse. Their change events are coarse-grained: a BAPI call, an IDoc, a business object delta. A single event can encode what is, in graph terms, a subgraph replacement: several nodes touched, several edges rewritten, some implied by absence. You have to reconstruct the mutation algebra from domain knowledge, not from the event structure. Kafka helps and hurts simultaneously. As a transport layer for CDC events it's superb, ordered, replayable, partitioned by entity. Still, a Kafka topic per table is not a topic per graph concept. The partitioning strategy that makes relational CDC fast is orthogonal to the entity-centric partitioning a KG pipeline wants. The right mental model: every CDC event is a patch on a graph. Not a row diff but a typed mutation on a typed graph.  If you build your ingestion layer thinking in those primitives, the downstream logic becomes dramatically simpler. The tooling will catch up I presume but right now, if you're building a live knowledge graph on top of CDC infrastructure, you're doing graph mutation modeling in your head. - Estuary Flow: https://lnkd.in/epkuF4HY - Airbyte: https://docs.airbyte.com - Debezium: https://debezium.io #KnowledgeGraphs #Debezium #ApacheKafka #ETL #GraphDatabase

By now most people in the software industry are very familiar with the concept of DevOps – normally understood as the combination of software development combined with operations to deliver software more efficiently and effectively, with an eye towards scalability as the system matures over time. It

We are living through another cycle of the same promise, wearing a new name. Every decade produces its golden hammer: UML would solve interoperability.

Following up on my Graphlit wind-down announcement, I’ve put together a non-confidential overview of the technology and IP available for acquisition. Graphlit is a production AI context and agent platform. It connects enterprise data, processes multimodal content, builds evidence-linked knowledge and context graphs, and makes that context available to applications and durable agents. The available portfolio includes: - 50+ source integrations and multimodal processing - Evidence-linked knowledge, context graph, search, and GraphRAG - Provider-neutral model operations across 25+ AI providers - Durable agents, hosted MCP, governed tools, skills, channels, and delivery actions - Four complete product applications - Public APIs, CLI, SDKs, infrastructure-as-code, and operating assets The technology and IP are available as an asset purchase, either as an integrated platform or around a focused set of assets. The attached document describes what was built and what can transfer. If it maps to something your company is building, contact me at kirk@graphlit.com.

How a useful architecture term became a vendor catch-all

A graph is only as trustworthy as the triples flowing into it. Most of them arrive with their meaning already stripped.

Thira raises $21M seed round led by Madrona to build an AI-powered agentic execution system for enterprise back-office automation.

How to Align Content with Knowledge Graph Entities Introduction to Knowledge Graph A Knowledge Graph (KG), also called an Entity Graph, is a structured database of real-world entities — people …

With the help of AI, a new open dataset turns global news into structured narratives of disasters that unfolded from 2014 to 2024, helping to better understand the dynamics of crises and human-environment interactions.

Posted in r/semanticweb by u/ScholarForeign7549 • 3 points and 4 comments

Rewriting Spark #GraphFrames in #Rust, or a billion-edges scale graph analytics using just a Laptop. I experimented with graph algorithms using #DataFusion as the core, achieving impressive results. For example, I can compute PageRank for a billion-edge graph using only 5 GB of memory. Or I can identify all the weakly connected components in a graph with two billion edges using only 10 GB of memory. Under the hood, Pregel ('think like a vertex') and the recent BSP/Map-Reduce papers are expressed as #DataFusion joins and aggregates. For comparison, igraph, which represents graphs as CSR matrices in memory, would require at least 16 GB of RAM (in reality, much more: 32 GB or even 64 GB for a more realistic estimate) to achieve the same. The trade-off is performance: if the graph fits in memory, the algorithms complete in 1-2 minutes. However, for out-of-core Pregel/BSP, it takes around 20–40 minutes (in the tight scenario). Previously, I thought that for billion-scale graph analytics, you needed Apache #Spark + #GraphFrames. Now, however, I think that a laptop with a large SSD is sufficient. Not vibe-coded: I'm learning Rust/DataFusion using this project, so no reasons to do "Claude write this make no mistakes".

Automatic ontology development isn't a feature you build. It's an emergent capability of the neurocognitive stack — and that changes everything about how enterprise intelligence gets made.

Core-based hierarchies improve GraphRAG by replacing unstable, stochastic clustering methods with deterministic k-core decomposition. This density-aware structure identifies cohesive subgraphs, creating reproducible, size-bounded communities that improve global sensemaking while reducing token usage by up to 40%.Why k-Core Decomposition?Traditional GraphRAG pipelines rely on Leiden or Louvain clustering to map community hierarchies. However, on sparse networks, these algorithms produce exponentially many near-optimal partitions, making them non-reproducible. The k-core approach resolves this by organizing graphs into nested layers based on network density.Determinism: The same input graph always yields identical communities, ensuring reliable and stable summarization.Hierarchy: Each node receives a core number (k), representing the largest subgraph where all nodes have at least k neighbors, organically separating peripheral ideas from central cores.How it WorksDecomposition: The system processes knowledge graphs in linear O(|E|) time to peel away the graph by core numbers.Heuristics: Lightweight heuristics split these layers into size-bounded, connectivity-preserving community structures.Sampling & Summarization: The framework recursively summarizes these structurally coherent communities for downstream retrieval, incorporating a token-budget-aware sampling strategy to minimize LLM inference costs

🟢 Yes - this is how we use AI agents to connect Ontology + LLMs (inspired by Tony Seale and his Knowledge Graph Guys blog) in our data discovery engagements. In data modernization program, every data strategist has to build context from the existing data landscape: understand each source system, reconcile conflicts, identify gaps, map use cases, take action, and eventually deliver capabilities in a modern data product architecture. This takes months. If you've done the job, you know the pain: navigating tribal knowledge in outdated documents, chasing data owners no one knows them, and the systems no one fully understands anymore. A native AI approach allows use to use AI agents to build context ontologically per source, then surface where to reconcile. That's a huge head start for building a curated view of the landscape. A quick example. From sample data a strategist uploads, the AI generates one ontology per system — Billing and Support. Ontology 1 : Billing (source 1) # Billing system ontology Account -Subscribes to- Plan Account -Billed by- Invoice Account -Has status- BillingStatus Account -Has email- EmailAddress Ontology 2 : Support (source 2) # Support system ontology Customer -Raises- Ticket Ticket -Assigned to- Agent Ticket -Has status- TicketStatus Customer -Has email- EmailAddress A reconciliation assistance Agent flags 3 places to reconcile: 1️⃣ Overlap — EmailAddress appears in both ontologies 2️⃣ Identity — Account and Customer may be the same real-world entity 3️⃣ Semantic collision — billingStatus and ticketStatus may both be a Status While the agent does the heavy lifting, our strategist verifies it in a real business context. Months of discovery compressed into a reviewable first draft. #agenti-ai #ontology #knowledge-graph | 36 comments on LinkedIn

This one is not for the faint of heart and is about the shape of knowledge: fibers, spheres and missing links. A knowledge graphs (KG) looks locally simple (flat) because any small subgraph around a node is just a star of relations.

Most GraphRAG implementations are retrieval systems wearing an agentic AI costume.

Original article: https://www.biomedima.

How MVO becomes the runtime boundary for trusted GraphRAG

Frontier LLMs fall for the story; a small model reads the graph. How ontology-guided GRPO taught Gemma 4B knowledge graph reasoning, field notes included.

Machine Learning on Knowledge Graphs follows a natural progression from structured knowledge to adaptive decision making. The foundation is the Knowledge Graph itself. This is not machine learning. It is the symbolic layer built through taxonomies, ontologies, validation rules, SPARQL queries, and governance. It provides the trusted semantic structure that all later models depend on. The next step is graph ablation, where noisy, redundant, or weak nodes and relationships are identified. This helps improve the quality of the graph before learning begins. Embedding models then learn latent representations of entities and relationships. Techniques such as TransE, ComplEx, RotatE, and graph neural networks transform graph structure into vector spaces that can support similarity, prediction, and discovery. More advanced stages add time, space, value, probability, and uncertainty. This enables temporal reasoning, probabilistic decision boundaries, and richer analysis across complex domains. The final stage is reinforcement learning, where agents learn to navigate the graph through states, actions, and rewards. This is useful for multi hop reasoning, pathway discovery, recommendations, and decision support. The key idea is simple. First engineer reliable knowledge. Then learn from its structure. Finally, use that structure to support intelligent action. If you need specialist advice on Knowledge Engineering, Ontologies, Knowledge Graphs, Semantic AI, or GraphRAG, get in touch. Join my group for more insights, discussions, and community learning: [https://lnkd.in/d9Z8-RQd] I am currently pursuing a PhD in Knowledge Management within Cyber Physical Human Systems. Explore my research and publications here: [https://lnkd.in/d-V28h5h] #KnowledgeGraph #MachineLearning #KnowledgeEngineering #SemanticAI #GraphRAG #ArtificialIntelligence #EnterpriseAI #TrustworthyAI #OntologyEngineering #ReinforcementLearning

Ontology: A word that spent centuries inside philosophy is suddenly everywhere in enterprise AI. For years, the term stretched across different artifacts. Now people are distinguishing controlled vocabularies, taxonomies, semantic layers, knowledge graphs, and formal ontologies. That is real progress, and I am glad to see it. But naming the artifact is not the same as choosing the right one and building it well. When mission-critical work depends on reasoned conclusions, meaning that survives across systems, and answers traceable to evidence, having one and having a good one are not the same. A good applied formal ontology starts with the questions it must answer and models the relevant part of the world rigorously enough to answer them. Within that scope, it commits to which kinds of entities exist and how they relate. It holds hard distinctions steady: a thing that persists differs from a process in which it participates, and both differ from information recorded about them. It keeps one word from quietly standing for different kinds of entity, keeps its category choices open to challenge, and builds on shared foundations used and scrutinized across domains rather than reinventing the basics. Commitments that carry logical force are expressed as axioms in an open, standardized formal language, so anyone can inspect them and a reasoner can derive what follows or detect inconsistency in the model. Built and governed that way, it opens up what you can rely on: conclusions you can check and re-derive rather than take on trust, a shared basis for aligning models built by teams who never met, a chain you can trace back to its source, and a principled distinction between what follows and what the available evidence and commitments have not established. The format does not give you that. The tradecraft does. Even done well, it has a limit. A reasoner can test consistency and derive what follows, but not determine whether the axioms were right. That takes expert judgment, and if it is to carry authority, it cannot come only from the builder. You cannot audit your own books. That raises a question I hear far less often: who holds the standard for good ontology tradecraft, and who judges the work independently? This is the work we do at NCOR. Our leadership includes original developers and long-standing stewards of BFO and CCO, which serve as baseline standards for formal ontology work in the Department of Defense and Intelligence Community. Our members bring decades of experience across science, government, defense, industry, enterprise systems, and international standards. NCOR's published certification process combines independent expert review with automated structural validation. What that does is turn ontology quality from a builder's claim into a judgment others can inspect. If you want to assess your schema or ontology against formal-ontology best practices, or prepare an ontology for NCOR review and certification, reach out. | 11 comments on LinkedIn

A pragmatic graph practitioner’s view of semantics, knowledge layers and autonomous agent control

Ontology Is The Guardrail, Not The Prompt ⭕️ A telecom company had 42 definitions of the word "customer." Billing meant one thing by it. CRM another. Network, support, provisioning, each carried its own. 42 schemas, zero shared meaning, and integrations that took months. Months is how long it takes to argue about what a word means. One canonical ontology feeding a shared graph, and the same integrations dropped to days. The graph was never the hard part. The agreed meaning was. Three layers people keep collapsing into one: Schema is HOW your data is stored. Columns, types, tables. Ontology is WHAT your data means. Entities, relationships, constraints. A knowledge graph is the ontology instantiated: real entities and edges you can traverse. Skip the middle layer and your "knowledge graph" is a graph database with no semantics. GraphRAG on top of it is vector search with extra steps. Nodes and edges carrying no agreed meaning retrieve no better than embeddings, because there is nothing typed to reason over and nothing to trace an answer back to. Why the ontology IS the guardrail: A prompt-based rule is a suggestion the model can ignore. A structural one is not. When "customer" is a typed entity with defined relationships, an invalid state is unrepresentable. You do not instruct the model to respect the meaning. You make violating it impossible to express. Guardrails by design, not by prompt. That is the same move runtime agent security is converging on. An intent layer that is a monotone filter sandwiched between two deterministic gates, never the final authority (Conseca). Ontology guards the meaning of the data at design time. The sandwich guards the meaning of the action at run time. Both replace "instruct the model to behave" with "make the invalid state impossible to reach." The part that rots: ⚠️ An ontology with no owner is worse than no ontology, because it is trusted and stale. Ungoverned semantic layers are the new ungoverned data lakes. The fix is a minimal ontology, not a bigger one: define only the delta from what the model already infers, not a committee-enumerated cathedral, then give it an owner and a correction loop. Agent confusion is the signal for what deserves a formal definition next. The moat is the shared meaning behind the data, not the volume of it. Competitors can copy your tables. They cannot copy the ontology that makes them mean one thing. The insight: stop prompting agents to respect meaning your data structure never encoded. Put the meaning in the substrate, give it an owner, and let invalid stay unrepresentable. | 14 comments on LinkedIn