GraphNews

Cognee introduces graph-aware embeddings: graph signals boost semantic search for faster and more precise retrievals in paid plans. Learn more and book a call.

In this blog by Alex Gilmore, learn about strategies and methods for ingestion and knowledge graph generation.

Think like a cyberattacker to quickly and easily identify vulnerabilities in your system with minimal query writing.

Many teams adopt graph databases believing they need specialized tools for relationship data, adding unnecessary complexity to their stack. This session reveals that for most use cases, the performance benefits don't justify the overhead. You'll learn to evaluate whether you truly need graph DB capabilities and how to implement graph patterns using simpler alternatives.

Table of Contents

Knowledge graphs (KGs) are foundational to many AI applications, but maintaining their freshness and completeness remains costly. We present ODKE+, a production-grade system that automatically...

So I am worried. https://lnkd.in/gfpkjUNZ A semantic exchange format in YAML? Because there is nothing to build on already? https://lnkd.in/gB-iEeXn :(

city2graph logo city2graph logo city2graph is a Python library for converting geospatial datasets into graphs for GNN with integrated interface of GeoPandas, NetworkX, and Pytorch Geometric across ...

According to mathematical legend, Peter Sarnak and Noga Alon made a bet about optimal graphs in the late 1980s. They’ve now both been proved wrong.

Snowflake, Salesforce, dbt Labs and major tech companies launch Open Semantic Interchange (OSI), an unprecedented open-source initiative to standardize business data definitions and accelerate enterprise AI adoption.

I had my first presentation at SEO Wiesn (SEO conference at SIXT Munich) yesterday and WOW, what an experience it has been! This is not a sales pitch, nor a product demo: we're talking about an open source project that is rooted in science, yet applicable in practical industry scenarios as already tested. No APIs, no vendor lock-in, no tricks. It's our duty as SEOs to produce NEW INSIGHTS, not just rewrite stuff, digest information or promote ourselves. Big thanks goes to our sponsors WordLift and Kalicube for supporting this research and believing in me and my team to deliver WebKnoGraph: THE FIRST FULLY transparent, AI-driven framework for improving SEO and site navigation through reproducible methods. We plan on deepening this research and iterating with additional industry & research partners. If you’d like to try this on your website, DM me. Full project repo: https://lnkd.in/d-dvHiCc. A scientific paper will follow. More pics and detailed experience retrospective with the amazing crew will be shared in the upcoming days too 💙💙💙 Until then, have a sneak peek at the deck. SEO WIESN TO THE WIIIIIIN!

Learn what Entity Resolution is, how it works, and why it’s essential for data quality. Explore methods, tools, and use cases in MDM, customer 360, fraud detection, and more.

The Linked Data Benchmark Council has, for over a decade, been the quiet force behind much of the progress in graph technology. Their mission is deceptively simple: to design, maintain, and promote standard benchmarks for graph data management systems. Read about the recent meeting and the announcem

ApeRAG: a production-ready RAG that combines Graph RAG, vector search, and full-text search. Looks pretty cool. There are a lot of use cases where a "knowledge graph" would help a lot. I still think this is still one of the most powerful way to understand "connections" and "hierarchy" the easiest. 🔤 Github: https://lnkd.in/gdYuShgX | 18 comments on LinkedIn

More thoughts on shapes

We have conducted a detailed analysis of the performance of the world's most widely used models for text to graph tasks. Discover the results.

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.