GraphNews

Text2graph is and online service for transforming free text into a knowledge graph form (nodes and relationships). The graph can be also exported using Cypher or Gremlin statements for quick import into your favourite database.

Construction of a large painter network with ~3000 painters using the PainterPalette dataset, connecting painters if they lived at the same place for long enough time. - me9hanics/painter-network-e...

Discover what's possible with Nodestream: a declarative framework for building, maintaining, and analyzing graph data, compatible with Neo4j & Amazon Neptune.

🚀 𝗰𝗶𝘁𝘆𝟮𝗴𝗿𝗮𝗽𝗵 𝘃𝟬.𝟭.𝟲 𝗶𝘀 𝗻𝗼𝘄 𝗹𝗶𝘃𝗲! 🚀 city2graph is a Python library that converts geospatial datasets into graphs (networks). 🔗 GitHub https://lnkd.in/gmu6bsKR What's New: 🛣️ 𝐌𝐞𝐭𝐚𝐩𝐚𝐭𝐡𝐬 𝐟𝐨𝐫 𝐇𝐞𝐭𝐞𝐫𝐨𝐠𝐞𝐧𝐞𝐨𝐮𝐬 𝐆𝐫𝐚𝐩𝐡𝐬 - Generate node connections by a variety of relations (e.g. amenity → street → street → amenity) 🗺️ 𝐂𝐨𝐧𝐭𝐢𝐠𝐮𝐢𝐭𝐲 𝐆𝐫𝐚𝐩𝐡 - Analyse spatial adjacency and neighborhood relationships with the new contiguity graph support 🔄 𝐎𝐃 𝐌𝐚𝐭𝐫𝐢𝐱 - Work seamlessly with OD matrices for migration and mobility flow analysis You can now install the latest version via pip and conda. For more examples, please see the document: https://city2graph.net/ As always, contributors are most welcome! #UrbanAnalytics #GraphAnalysis #OpenSource #DataScience #GeoSpatial #NetworkScience #UrbanPlanning #Python #SpatialAnalysis | 25 comments on LinkedIn

GraphQA is Catio’s new open-source agent for natural-language questions over architecture graphs, fusing LLMs with graph algorithms to deliver fast, structure-aware answers for dependencies, flows, and system reasoning.

Rough news on #kuzu being archived - startups are hard and Semih Salihoğlu + Prashanth Rao did so much in ways I value, and the same architectural principles we've been quietly tackling in GFQL. For those left in the lurch for an embeddable compute-tier solution to graphs, #GFQL should be pretty fascinating yet also familiar (ex: Apache Arrow-native graph queries for modern OSS ecosystems), and hopefully less stress due to a sustainable governance model. Likewise, as an oss deeptech community, we add interesting new bits like the optional record-breaking GPU mode with NVIDIA #RAPIDSAI . If you're new to it and seeing this: #GFQL, the graph dataframe-native query language, is increasingly how Graphistry, Inc. and our community work with graphs at the compute tier. Whether the data comes from a tabular ETL pipeline, a file, SQL, nosql, or a graph storage DB, GFQL makes it easy to do on-the-fly graph transforms and queries at the compute tier at sub-second speeds for graphs anywhere from 100 edges to 1,000,000,000 . Currently, we support arrow/pandas, and arrow / #nvidia #RAPIDS as the main engine modes. While we're not marketing it much yet, GFQL is already used daily by every single Graphistry user behind-the-scenes, and directly by analysts & developers at banks, startups, etc around the world. We built it because we needed an OSS compute-tier graph solution for working with modern data systems that separate storage from compute. Likewise, data is a team sport, so it is used by folks on teams who have to rapidly wrangle graphs, whether for analysis, data science, ETL, visualization, or AI. Imagine an ETL pipeline or notebook flow or web app where data comes from files, elastic search, databricks, and neo4j, and you need to do more on-the-fly graph stuff with it. We started building what became GFQL *before* Kuzu because it solves real architectural & graph productivity problems that have been challenging our team, our users, and the broader graph community for years now. Likewise, by going dataframe-native & GPU-mode from day 1, it's now a large part of how we approach GPU graph deep tech investments throughout our stack, and means it's a sustainably funded system. We are looking at bigger R&D and commercial support contracts with organizations needing to do subsecond billion+-scale with us so we can build even more, faster (hit me up if that's you!), but overall, most of our users are just like ourselves, and the day-to-day is wanting an easy OSS way to wrangle graphs in our apps & notebooks. As we continue to smooth it out (ex: we'll be adding a familiar Cypher syntax), we'll be writing about it a lot more. 4 links below: ReadTheDocs, pip install, SOTA GPU benchmarks, and original aha moment + Russell Jurney Ben Lorica 罗瑞卡 Taurean Dyer Bradley Rees

Ma chaine YouTube sur les graphes vient de dépasser les 3.000.000 de vues ! 🎉 🍾 Avec 73 vidéos disponibles 🖥️ , elle aide plus de 25.000 abonnés (et d'autres qui passent par hasard) à se familiariser sur un sujet qui devrait faire partie de la culture générale 📚 de tout ingénieur. Faites principalement à base d'exemples commentés, mes vidéos explorent de nombreux sujets de ce domaine à l'intersection entre les mathématiques discrètes et l'informatique. Les graphes sont "présents" partout, dans tous les systèmes composés d'éléments et de relations entre ces éléments ; ils peuvent aider à les modéliser, à mieux les maitriser et à les exploiter. Cela fait plusieurs mois maintenant que je n'ai plus rien publié sur cette chaine mais chaque jour de nouveaux venus (étudiants principalement mais pas que...) viennent découvrir ces objets simples à décrire mais si difficiles à manipuler efficacement ! Ma chaine n'est pas monétisée, je ne gagne donc pas d'argent avec. Les publicités sont ajoutées par Youtube, à leur seul profit... https://lnkd.in/exfWrPxA| 18 commentaires sur LinkedIn

Microsoft has launched a native graph data management, analytics, and visualization service. Its horizontally scalable, native graph engine empowers enterprises of all sizes with a relationship‑first way to model and explore interwoven data.

Moriondo, L., (2025). ArrowSpace: introducing Spectral Indexing for vector search. Journal of Open Source Software, 10(113), 9002, https://doi.org/10.21105/joss.09002

Table of Contents

The single most undervalued fact of graph theory: Every board is a graph in disguise. Here’s the 3-step mapping that turns messy “rooms” into clean, countable components. 0/ You’re given a map of walls and floor tiles. By eye, you see there are three rooms. But how do you get a computer to see them too? 1/ Start by modeling the board as a graph. Treat every floor tile as a node. Define valid moves as edges. In our case, moves are the four directions: • Up • Down • Left • Right Walls simply remove edges because you can’t step through them. 2/ Number the floor tiles arbitrarily so you can reference nodes. Now you’ve converted the board to an undirected graph. Why do this? Because two common board questions become standard graph problems. 1. “Shortest path between two tiles?” becomes “shortest path between two nodes.” 2. “How many rooms?” becomes “how many connected components?” That second one is our target. A “room” is just a maximal set of tiles reachable from each other without crossing walls. In graph terms, that’s a connected component. So the count of rooms equals the count of connected components. Here’s the practical recipe I use: • Nodes = all floor tiles. • Edges = pairs of floor tiles one step apart (U/D/L/R). • Walls = missing edges. • Rooms = connected components. • Answer = number of connected components. 3. You can run a DFS or BFS from every unvisited node and mark all reachable tiles. Each fresh start increments the room counter by one. That’s it. No heuristics, no guesswork, just graph structure doing the heavy lifting. Once you see boards as graphs, these problems stop feeling ad hoc. They become repeatable templates you can code in minutes. If this helped, repost so more people learn the “rooms = components” pattern.

Learn about how graph-wide scanning , a method that scans an entire network graph, offers a powerful solution to a major cybersecurity challenge: detecting hidden, low-signal threats like Advanced Persistent Threats (APTs) that are often missed by traditional security tools.

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

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.

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!

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

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

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>

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

Calling all data scientists, developers, and managers! 📢 Looking to level up your team's knowledge of graph technology? We're excited to share the recorded 2-part training series, "Graph Tech Demystified" with the amazing Paco Nathan. This is your chance to get up to speed on graph fundamentals: In Part 1: Intro to Graph Technologies, you'll learn: - Core concepts in graph tech. - Common pitfalls and what graph technology won't solve. - Focus of graph analytics and measuring quality. 🎥 Recording https://lnkd.in/gCtCCZH5 📖 Slides https://lnkd.in/gbCnUjQN In Part 2: Advanced Topics in Graph Technologies, we explore: - Sophisticated graph patterns like motifs and probabilistic subgraphs. - Intersection of Graph Neural Networks (GNNs) and Reinforcement Learning. - Multi-agent systems and Graph RAG. 🎥 Recording https://lnkd.in/g_5B8nNC 📖 Slides https://lnkd.in/g6iMbJ_Z Insider tip: The resources alone are enough to keep you busy far longer the time it takes to watch the training!

Apache TinkerPop™ is a graph computing framework for graph systems and the home of the Gremlin graph traversal language. Contributorcasts allow contributors ...

A canonical problem in computer science is to find the shortest route to every point in a network. A new approach beats the classic algorithm taught in textbooks.

𝗛𝗼𝘁 𝘁𝗮𝗸𝗲 𝗼𝗻 𝘁𝗵𝗲 “𝗳𝗮𝘀𝘁𝗲𝗿 𝘁𝗵𝗮𝗻 𝗗𝗶𝗷𝗸𝘀𝘁𝗿𝗮” 𝗵𝗲𝗮𝗱𝗹𝗶𝗻𝗲𝘀: The recent result given in the paper: https://lnkd.in/dQSbqrhD is a breakthrough for theory. It beats Dijkstra’s classic worst-case bound for single-source shortest paths on directed graphs with non-negative weights. That’s big for the research community. 𝗕𝘂𝘁 𝗶𝘁 𝗱𝗼𝗲𝘀𝗻’𝘁 “𝗿𝗲𝘄𝗿𝗶𝘁𝗲” 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗿𝗼𝘂𝘁𝗶𝗻𝗴. In practice, large-scale systems (maps, logistics, ride-hailing) moved past plain Dijkstra years ago. They rely on heavy preprocessing. Contraction Hierarchies, Hub Labels and other methods are used to answer point-to-point queries in milliseconds, even on large, continental networks. 𝗪𝗵𝘆 𝘁𝗵𝗲 𝗱𝗶𝘀𝗰𝗼𝗻𝗻𝗲𝗰𝘁?  • Different goals: The paper targets single-source shortest paths; production prioritizes point-to-point queries at interactive latencies.  • Asymptotics vs. constants: Beating O(m + n log n) matters in principle, but real systems live and die by constants, cache behavior, and integration with traffic/turn costs.  • Preprocessing wins: Once you allow preprocessing, the speedups from hierarchical/labeling methods dwarf Dijkstra and likely any drop-in replacement without preprocessing. We should celebrate the theoretical advance and keep an eye on practical implementations. Just don’t confuse a sorting-barrier result with an immediate upgrade for Google Maps. 𝗕𝗼𝘁𝘁𝗼𝗺 𝗹𝗶𝗻𝗲: Great theory milestone. Production routing already “changed the rules” years ago with preprocessing and smart graph engineering.

Guest Author: André Vermeij, Founder of Kenedict Innovation Analytics & Developer of...

🚀 Faster than Dijkstra? Tsinghua University’s new shortest path algorithm just rewrite the rules of graph traversal. For 65+ years, Dijkstra’s algorithm was the gold standard for finding shortest paths in weighted graphs. But now, a team from Tsinghua University has introduced a recursive partial ordering method that outperforms Dijkstra—especially on directed graphs. 🔍 What’s different?  Instead of sorting all vertices by distance (which adds log-time overhead), this new approach uses a clever recursive structure that breaks the O(m + n log n) barrier ✨.  It’s faster, leaner, and already winning awards at STOC 2025 🏆. 📍 Why it matters:  Think Google Maps, Uber routing, disaster evacuation planning, circuit design—any system that relies on real-time pathfinding across massive graphs. Paper ➡ https://lnkd.in/dGTdRj2X #Algorithms #ComputerScience #Engineering #Dijkstra #routing #planning #logistic | 34 comments on LinkedIn

I’m proud to share an exciting piece of work by my PhD student, Simon van Wageningen, whom I have the pleasure of supervising. Simon asked a bold question that challenges the state of the art in our field! A bit of background first: together with Simon, we study network visualizations — those diagrams made of dots and lines. They’re more than just pretty pictures: they help us gain intuition about the structure of networks around us, such as social networks, protein networks, or even money-laundering networks 😉. But how do we know if a visualization really shows the structure well? That’s where quality metrics come in — mathematical functions designed to measure the “goodness” of a network visualization. Many of these metrics correlate nicely with human intuition. Yet, in our community, there has long been a belief — more of a tacit knowledge — that these metrics fail in certain cases. This is exactly where Simon’s work comes in: he set out to make this tacit knowledge explicit. Take a look at the dancing man and the network in the slider — they represent the same network with very similar quality metric values. And yet, the dancing man clearly does not don’t show the network's structure. This tells us something important: we can’t blindly rely on quality metrics. Simon’s work will be presented at the International Symposium on Graph Drawing and Network Visualization in Norrköping, Sweden this year. 🎉 If you’d like to dive deeper, here’s the link to the GitHub repository https://lnkd.in/eqw3nYmZ #graphdrawing #networkvisualization #qualitymetrics #research with Simon van Wageningen and Alex Telea | 13 comments on LinkedIn

Reforms on the "Shortest Path" Algorithm, Parallels with Modular Data Architectures, and Diving Into Key Components: Product Buckets, Semantic Spine, & Insight Routers