In today’s hyper-connected digital world, ensuring system resilience is an important business necessity. For platforms like BOSS Zhipin, Asian leading job-matching app with millions of monthly active users, even minutes of downtime can erode user trust and impact revenue. The platform relies on a complex web of services, hosts, databases, and network infrastructure. Yet, like many fast-scaling companies, BOSS Zhipin faced a challenge: **traditional monitoring tools were failing to keep up with the complexity of their architecture.**

Enter [NebulaGraph](https://www.nebula-graph.io/), the open-source, distributed graph database that’s helping BOSS Zhipin transform reactive firefighting into proactive, intelligent operations.

# The Operational Challenges Behind Rapid Growth
BOSS Zhipin revolutionized online recruitment with its “direct hiring” model — enabling real-time communication between job seekers and recruiters. But behind the seamless user experience lies a sprawling, multi-team, polyglot tech stack with intricate service dependencies.

As the platform scaled, their O&M team hit a breaking point:
* Data Silos: Metrics, logs, traces, and events lived in separate tools, making correlation nearly impossible.
* High MTTR: Root cause analysis (RCA) relied on tribal knowledge, leading to long mean time to recovery (MTTR) and engineer burnout.

In short, they were diagnosing system-wide outages with fragmented, secondhand information — a recipe for instability.

# Why Graph? Because Systems Are Graphs
The team realized that modern cloud-native systems are fundamentally graphs — services calling services, containers running on hosts, databases tied to networks. Trying to model this with tables or trees was like mapping a neural network with spreadsheets.

They needed a database that could:
* Handle billions of nodes and edges (services, instances, dependencies)
* Support real-time, complex traversals (e.g., “Find all upstream services affected by this DB latency”)
* Scale horizontally and remain highly available
* Allow flexible schema evolution as the system grows

**Technology Selection**
| Dimension               | Neo4j                                                                 | NebulaGraph                                                                                     | Impact on Root Cause Localization                                                                 |
|-------------------------|-----------------------------------------------------------------------|--------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|
| **Data Model**          | Supports flexible property graph models                             | Also supports property graphs, with customizable properties, labels, and edge types; the model better aligns with actual business structures | Both can meet modeling requirements. However, NebulaGraph provides clearer management of labels and edge types, making it more suitable for maintaining large-scale business graphs. |
| **Performance & Scalability** | Single-node/cluster edition, suitable for medium-sized data volumes | Native distributed architecture with strong horizontal scalability, supporting tens of millions of nodes and billions of edges | In root cause localization scenarios, NebulaGraph can easily handle future growth. |
| **Query Language**      | Cypher: Strong semantic expression capability, low learning cost    | nGQL: Low learning cost, supports graph computation expressions                                 | Both are powerful, but nGQL is closer to engineering practices. |
| **Temporal Capabilities** | Not good at handling time-series data                              | Supports multi-version storage of edges (TimeRank) mechanism                                     | In root cause analysis, service dependencies and performance metrics have clear temporal correlations. NebulaGraph's TimeRank support is crucial. |
| **Ecosystem & Integration** | Rich ecosystem, mature tools and community                        | Rapidly growing ecosystem, compatible with Spark, Flink, Prometheus, Grafana, etc.              | NebulaGraph is better suited for Boss Zhipin system in terms of cloud-native and observability integration. |
| **Operations & Cost**   | Community edition has limited features; enterprise license is costly | Fully open-source, low resource consumption, simple deployment                                  | NebulaGraph has lower costs, which facilitates centralized middleware construction and horizontal rollout. |

After evaluating options like Neo4j, they chose [NebulaGraph](https://www.nebula-graph.io/) — a distributed graph database built for scale, performance, and production-grade reliability.

>“NebulaGraph wasn’t just faster — it was the only solution that could model our entire infrastructure as a living, breathing dependency graph.”
— Wan Jiafei, SRE Engineer at BOSS Zhipin

# Building the Intelligent RCA Engine with NebulaGraph

After completing the technology selection, BOSS Zhipin built a complete root cause location mechanism based on NebulaGraph, focusing on “how to transform complex fault problems into structured graph problems”, covering the four core parts of modeling, collection, calculation and display.
 
![https://www-cdn.nebula-graph.io/blogs/BOSS%20Zhipin%20Demonstration.png](https://www-cdn.nebula-graph.io/blogs/BOSS%20Zhipin%20Demonstration.png)

## Multi-Layer Dependency Modeling
They started by modeling the system across multiple dimensions:
* Horizontal layer: Service-to-service call relationships (HTTP, RPC, SQL)
* Vertical layer: Dependencies between applications and infrastructure (VMs, databases, gateways)
* Root cause dimension: Abstraction of potential failure sources (e.g., configuration changes, resource exhaustion)
* Time-series modeling: Using NebulaGraph’s multi-version edges (TimeRank) to track performance changes over time

## Data Collection and Graph Data Construction
In terms of data acquisition, the system connects multiple key data sources for operation and maintenance, including:
* Trace/Span: service call chain tracing information
* Metric: Performance metrics from Prometheus, JVM, etc.
* Log/Event: log and alarm events
* Infra information: host, container, and middleware resource status.

Data from traces (Trace/Span), metrics (Prometheus, JVM), logs, events, and infrastructure metadata was collected via Kafka, enriched, and loaded into NebulaGraph as a property graph — where edges carry latency, error rates, and timestamps.

## [Graph Algorithms](https://www.nebula-graph.io/posts/Graph-Algorithms-And-How-to-Use-Them) for Smarter RCA
With a clear graph model, BOSS Zhipin implemented a graph-driven root cause analysis process on NebulaGraph:
* Impact Propagation Analysis: Traversing upstream dependencies to find blast radius
* PageRank-Based Scoring: Nodes with high in-degree and error spikes are ranked as top root cause candidates
* Visualized Fault Chains: Automatically generating a “root cause → service → user impact” path

### Use PageRank Algorithm to Dynamically Calculate Node Failure Weight
1. [Data Fusion](https://www.nebula-graph.io/posts/When_AI_Meets_Graph_Databases_Innovating_with_Multimodal_Data_Fusion)

By integrating the three major data sources of link tracking, system indicators, and logs, a unified full-link anomaly topology map was constructed. It was found that multiple true subgraphs appeared scattered in the graph structure, and each subgraph had a “storm center.”

2. Graph Algorithm-Driven Positioning
* Calculation: Rank value is calculated by weighting the node in-degree, link error number, and events.
* Output: TopN faulty nodes with the highest Rank values

3. Association Analysis

Use graph relationships to divide related queues (direct fault nodes) and non-related queues (indirectly affected nodes) to accurately narrow the scope of investigation.

In one case, a network port failure cascaded through a host to an auth-service — NebulaGraph identified the true root cause (network device) in under 20 seconds, not the “storm center” (auth-service) that traditional tools would flag.

# The Results: 20-Second Root Cause
The impact of BOSS Zhipin’s graph-powered operations system has been transformative. 

Mean Time to Recovery (MTTR) has been reduced by over 70%, enabling faster resolution of critical incidents. Incident triage is now 90% faster, allowing engineers to identify and act on root causes within seconds. With a unified, graph-based view of the system, engineers spend significantly less time switching between disparate tools and correlating data manually. 

As a result, post-mortem analyses have shifted from being anecdotal to fully data-driven, improving accountability, accuracy, and long-term system resilience.

**Implementation Plan - Benefits**

Strictly following the three stages of fault response to reduce Mean Time To Recovery (MTTR)

| Fault Stage       | Duration (Max/Avg)                     | Response Measures                                      |
|-------------------|----------------------------------------|--------------------------------------------------------|
| Fault Detection   | 1 min (average convergence time: 20s) | Fault localization, quickly identify root cause        |
| Fault Handling    | 5 min (average response time: 40s)    | Coordinate responsible personnel based on root cause to develop mitigation plan |
| Fault Recovery    | 10 min (average response time: 2 min) | Activate mitigation measures and restore services      |

# The Future: Graph + AI = Autonomous Operations
BOSS Zhipin isn’t stopping at RCA. They’re building toward autonomous operations with:

* Data Agents: AI assistants that analyze graph patterns to surface hidden anomalies
* Root Cause Agents: LLM-powered bots that correlate logs, traces, and topology to predict failures
* Precomputed Subgraphs: Caching common traversal patterns for instant insights

This is the promise of AIOps 2.0 — not just automation, but intelligent, context-aware decision-making powered by graph.

BOSS Zhipin’s journey shows that with the right data model — and the right database — you can turn chaos into clarity, and minutes into seconds.

As systems grow more distributed and ephemeral, traditional monitoring tools are hitting their limits. **Graph databases like NebulaGraph are becoming essential infrastructure for observability, SRE, and platform engineering.**

Discover how BOSS Zhipin uses NebulaGraph to achieve root cause analysis in just 20 seconds. Learn how graph databases power intelligent operations, reduces MTTR, and brings clarity to complex distributed systems.

20-Second Root Cause Identification: BOSS Zhipin Builds Intelligent Operations and Maintenance Based on NebulaGraph

> NebulaGraph supports a rich set of graph algorithms, efficiently transforming hidden relationships into actionable insights. This blog will introduce you to graph algorithms, NebulaGraph Algorithms, and explore how users are using these algorithms in production environments and how to get started.

# Graph Databases and Graph Algorithms
## What is a “Graph”?
Imagine you have a network, vertex represents an independent entity and edges represent the relationships between these entities. This structure consisting of vertices and the edges connecting them is called a “graph”.

![https://www-cdn.nebula-graph.io/blogs/graph%20algorithm-01.png](https://www-cdn.nebula-graph.io/blogs/graph%20algorithm-01.png)

*Fig.1 Using NebulaGraph Studio to Analyze a Company’s Equity*

## What is a [Graph Algorithm](https://en.wikipedia.org/wiki/List_of_algorithms#Graph_algorithms)?

Graph algorithm is a set of smart “problem-solving ideas” or “toolkits” that are specifically used to analyze the relationship network composed of “points” and “lines” and calculate problems about this network.

### Why Do We Need Specialized “Graph Algorithms”?
* **Beyond Simple Queries:** Traditional queries find immediate neighbors, but graph algorithms can analyze the structure and dynamics of the entire network.
* **Quantify the Value of Relationships:** Transform vague “associations” into calculable indicators (such as importance, closeness, and similarity).
* **Discover Hidden Patterns:** Automatically identify communities, key hubs, and communication paths that are difficult to query using traditional relational databases.
### Applications of Graph Algorithms
1. Find the Shortest Path:
* **Question:** When navigating from home (point A) to workplace (point B), how does the navigation plan the fastest or lowest cost route?
* **Graph Algorithm:** The classic shortest path algorithm (such as Dijkstra algorithm) can quickly calculate the path with the smallest total weight (usually representing distance length, travel time or comprehensive cost) among all possible routes from A to B.

![https://www-cdn.nebula-graph.io/blogs/the%20Shortest%20Path.png](https://www-cdn.nebula-graph.io/blogs/the%20Shortest%20Path.png)

2. [Friends Recommendation](https://www.nebula-graph.io/posts/graph_database_for_recommendation_systems):
* **Question:** How does Instagram, X, or Facebook know who you might know and recommend friends to you?
* **Graph Algorithms:** Common neighbor-based link prediction algorithms (such as the Jaccard algorithm) analyze your social network, focusing on your direct friends (first-degree neighbors) and then examining their friends (second-degree neighbors). People with whom you have many common friends (first-degree neighbors) but with whom you are not yet connected are likely to be recommended to you.
3. Page Rank:
* **Question:** How do search engines decide which web pages should appear first when you search for “graph algorithms”?
* **Graph Algorithm:** PageRank algorithm. Its core idea is:
  * Web pages (points) that are pointed to by many other web pages are usually more important (have more scores).
  * A web page pointed to by an important web page will also gain higher importance (an important vote has more weight).
  * The algorithm will continuously calculate the “importance score” of each web page, and the ones with higher scores will be ranked higher.

# Graph Algorithm Types and Application Scenarios
Graph algorithms can be broadly categorized into the following types: 

![https://www-cdn.nebula-graph.io/blogs/Graph%20Algorithm%20Types.png](https://www-cdn.nebula-graph.io/blogs/Graph%20Algorithm%20Types.png)

# Graph Algorithms Supported by [NebulaGraph](https://www.nebula-graph.io/)

![https://www-cdn.nebula-graph.io/blogs/Graph%20Algorithms%20Supported%20by%20NebulaGraph.png](https://www-cdn.nebula-graph.io/blogs/Graph%20Algorithms%20Supported%20by%20NebulaGraph.png)

The above figure shows the basic graph algorithms, and the enterprise version of NebulaGraph supports more high-performance algorithms, such as InfoMap, APSP, DegreeWithTime, HyperANF, etc., and custom graph algorithms based on [ISO-GQL](https://www.nebula-graph.io/posts/Unveiling%20ISO-GQL).

> *Note: When writing the algorithm results into the NebulaGraph, make sure that the tag in the corresponding graph space has properties names and data types corresponding to the table above.*

# How to Use NebulaGraph Algorithm
How do NebulaGraph users unlock business value with graph algorithms?
1. Centrality Analysis – PageRank
 
**When to Use:** When you need to find the most influential or widely cited/connected nodes in the entire network.

**Scenario Examples:** Identifying key opinion leaders on social media; locating core transit accounts in financial transaction networks.

**Use Case:** Boss Zhipin (leading recruitment platform in Asia) integrated three data sources: trace, metrics, and logs, to construct a unified, full-link anomaly topology map. They discovered multiple true subgraphs scattered throughout the graph structure, each with a “storm center”. Therefore, they used the PageRank algorithm to dynamically calculate node failure weights (rank values are weighted by node in-degree, link error count, and events). This algorithm identified the TopN faulty nodes with the highest rank values, enabling rapid root cause identification with an average convergence time of just 20 seconds.

2. Community Discovery - Louvain, Hanp

**When to Use:** When you need to discover hierarchical community structures in large-scale networks.

**Scenario Examples:** Division of interest groups in social networks; segmentation of e-commerce user groups (similar purchasing patterns); and zoning of urban traffic flow.

**Use Case:** China Mobile first built a relationship network based on all mobile users and used the Louvain and Hanp algorithms to discover and mine communities, such as individual credit scores and relationships between individuals. It then scored the community to identify whether it is a fraudulent community or a low-credit community, thereby conducting risk management.

3. Community Discovery-Label Propagation

**When to Use:** When you need to quickly discover communities, or when the network structure is clear and the community boundaries are distinct.

**Scenario Examples:** Identifying user interest circles in real-time recommendation systems; group segmentation along news/information dissemination paths.

**Use Case:** At ZhongAn Insurance, Label Propagation was used in the loan processing phase. Label Propagation primarily propagated information from a specific point Y and derived related points. For example, if a user on the loan processing list is severely overdue, this user becomes point Y, labeled as overdue. Based on established risk control rules, the system checks which points associated with point Y exhibit similar overdue behavior, thereby determining whether these points belong to a community with severe overdue payments.

4. Connected Component/Strongly Connected Component

**When to Use:** CC (weakly connected components) cares about whether paths are connected (ignoring edge direction). That is used to detect isolated islands. SCC (strongly connected components) cares about whether paths are reachable from each other via directed paths. That is used to analyze tight cyclic dependencies.

**Scenario Examples:** Analyzing isolated user groups in social networks (CC); identifying research schools in a paper’s citation network (SCC); analyzing circular dependencies between system modules (SCC).

**Use Case:** ZhongAn Insurance used Connected Component to calculate a user relationship graph. When an unusual number of people (e.g., 50 or 60) mark a mobile phone number as a “family contact”, that number and its associated users constitute a potentially risky community. Being in such an unusual community is a strong signal (sufficient, but not necessary) that the user is at risk, and the user may also be implicated due to relatives involved in illegal activities. Based on this, ZhongAn conducted preliminary risk control flagging and in-depth verification of users within the community.

Graph algorithms turn connected data into actionable insights—from finding key nodes to uncovering hidden patterns. The real value starts when you apply them to your own data.

Ready to explore? Platforms like [NebulaGraph](https://www.nebula-graph.io/) provide the scalable foundation to run these analyses and discover what your data truly knows. Start experimenting today!

This blog will introduce the graph algorithms, NebulaGraph Algorithms, and explore how users are using these algorithms in production environments and how to get started.

What are Graph Algorithms? And How to Use Them?

> The EU’s MiCA Act and OFAC Sanctions are raising the bar for crypto risk control. How can we build secure, compliant systems in this new era? BlockSec, a global leader in blockchain security, offers a solution: a robust risk control system built on NebulaGraph, enabling seamless flow from data ingestion to actionable risk insights. Yunfei Xie, a security R&D engineer at BlockSec, leads work on crypto address tagging and graph databases.

# The Core Idea: From Transaction Data to a Risk Network

## The Atomic Unit: The Transfer as the Core of Fund Flow

All complex on-chain value transfer activities are ultimately reduced to the most basic token transfer.

However, the raw on-chain data is incredibly complex, including batch processing of multiple transfers, complex swap logic, and cross-chain messaging.

Our goal is to build a foundation for risk analysis from these massive and complex on-chain “atomic units”, including noise filtering (such as removing junk tokens) and the establishment of a Fund Flow Graph.

## Risk Network: The Graph is the Skeleton, Labels are the Soul

Imagine you have only raw blockchain data: connections between anonymous addresses, such as the transfer from “0x098b…2f96” to “0x1361…1f39” and then to “0xd90e…f31b.” This data forms an “anonymous skeleton”—we see structured connections but lack meaningful context. We know funds are flowing, but we don’t know who’s moving them, why, or what they represent.

When we assign labels to these addresses and transactions, the data comes to life.

For example, by labeling “0x098b…2f96” and “0x1361…1f39” as “Lazarus Group: Ronin Bridge Exploiter,” and “0xd90e…f31b” as “Tornado.Cash Router,” we can clearly see that the renowned North Korean hacker group, the Lazarus Group, laundered 3,000 ether through the sanctioned mixer Tornado.Cash after the Ronin Bridge attack.

Through labeling, the anonymous skeleton becomes an insightful risk map. Labeling gives meaning to the data, allowing us to accurately identify high-risk entities and behaviors from massive amounts of on-chain data.

## Accurate Portrait: On-Chain Risk Classification System

By combining graph analysis with a sophisticated tagging system, we can accurately profile on-chain risks. The system needs to be able to identify and tag multiple threat types to help us fully understand and respond to the “dark forest” of the crypto world.

As shown in the following figure:
 
![https://www-cdn.nebula-graph.io/blogs/blocksec_01.png](https://www-cdn.nebula-graph.io/blogs/blocksec_01.png)

By accurately identifying and classifying these threats, the risk control system can provide multi-dimensional risk assessment.

# The Implementation: Building the Risk Control System with [NebulaGraph](https://www.nebula-graph.io/)

## Reasons for Choosing NebulaGraph

First and foremost, performance was the primary consideration. **NebulaGraph’s distributed architecture and superior concurrent processing capabilities can easily handle queries on tens of billions of nodes and edges,** ensuring we complete complex graph traversals and analyses in milliseconds.

Secondly, a flexible data model allows us to better depict the complex relationships in the blockchain world. The property graph model in NebulaGraph is ideally suited to capture the rich, multi-layered connections in blockchain data.

![https://www-cdn.nebula-graph.io/blogs/blocksec_02.png](https://www-cdn.nebula-graph.io/blogs/blocksec_02.png)

Finally, ecosystem compatibility is also a key consideration. NebulaGraph natively supports [ISO-GQL](https://www.nebula-graph.io/posts/Unveiling%20ISO-GQL), which reduces the learning curve for our team. Its rich visualization tools and APIs allow us to quickly build intuitive cash flow analysis interfaces.

## System Architecture: Four Pillars of Risk Control System

BlockSec’s risk control system is built on four pillars, which work together to support the functionality of the entire system.

**The Data Layer** is responsible for extracting and processing filtered on-chain fund flow data in real time from various blockchain networks (such as BSC, ETH, and Tron full nodes). This data is mined through data extractors and cleaned using a multi-filter pipeline to ensure data accuracy and relevance.

**The Intelligence Layer** is the “brain” of the system. Through 24/7 intelligence collectors, it draws information from a variety of sources, including public APIs, open-source intelligence (OSINT) feeds, and regulatory agency lists. This raw intelligence is processed through intelligence processors to generate precise address tags, providing critical context for subsequent risk analysis.

**The Storage Layer** is the core infrastructure of the system and is powered by NebulaGraph. NebulaGraph was chosen for its superior graph data storage and query capabilities, which can efficiently handle massive amounts of addresses and transaction relationships, providing a solid foundation for building the risk network.

**The Computation Layer** deploys predefined and custom risk engines. These engines leverage graph data from the Storage Layer and labels provided by the Intelligence Layer to perform advanced risk pattern detection and threat assessment. These engines interact with the system through the nGQL (NebulaGraph Query Language) query interface to obtain real-time risk analysis results.

These four pillars together constitute a powerful encryption risk control system, ensuring efficient operation of the entire chain from data capture to risk insight.

## Qualitative Analysis: Using Labels to Give Data Meaning

Where do labels come from? How can we ensure their accuracy? This is precisely the key to qualitative analysis.

Our label sources are multi-dimensional:

* On-Chain Heuristics: Analyze behavioral patterns from blockchain activity, build phishing detection engines and attack detection engines, and identify phishing addresses and attack transactions.
* Off-Chain Intelligence: This information is gathered from public sources, including social media, official legal documents, and collaboration with third-party intelligence partners. If an address is sanctioned by an official agency or widely identified as a hacker in the public community, it will be labeled accordingly.
* Human Analysis: As an important supplement to the automated system, a team of experts conducts in-depth investigations to verify automated findings and discover new and complex crime patterns that the system may have missed.

We adopt the following strategies to ensure the label accuracy:

* Automated Cross-Validation: The system automatically aggregates and cross-references data from multiple intelligence sources. If an address is labeled as fraudulent by multiple independent sources, the confidence level of that label is higher.
* Human-in-the-Loop Feedback: Leverage product suites (e.g., MetaSleuth, Phalcon, and API services) to form a continuous feedback loop. When analysts use these tools to investigate, any labeling errors or updates they discover can be immediately corrected and fed back into the system, continuously optimizing labeling accuracy and coverage.

## Risk Quantification: Building a Computable Risk Model

To quantify the risk and trace the sources of funds, we apply a heuristic algorithm with the following key steps:

1. Fiat Exposure Calculation

**Objective**: Standardize the USD value of token transfers.

**Approach**: Use price oracles to calculate the USD equivalent for every token transfer. 

2. Time Series Filtering

**Objective**: Ensure temporal consistency in tracing.

**Approach**: Only edges in compliance with a time sequence rule are preserved. An address cannot spend funds that it has not yet received.

3. Haircut Strategy

**Objective**: Focus on the most relevant paths.

**Approach**: Apply proportional weight allocation and introduce a threshold to prune low-contribution or irrelevant paths. This prevents contamination of the result by negligible or noisy funding sources.

Through these steps, we can build a relatively accurate and flexible risk quantification model to provide a quantitative basis for attributing high-risk transactions.

# The Value of Risk Control Systems

## Proactive Prevention: Building a Proactive Defense System

**Core Capability:** Real-time blocking of risky transactions.

**Application Scenario:**
When processing user deposits on an exchange or interactions on a DeFi protocol, an API call can fetch the risk score of associated addresses. If the score exceeds a threshold (e.g., funds from a mixer or sanctioned entity), the system can automatically halt or reject the transaction, stopping the risk at the gate.

## In-Process Control: Raising the Security Baseline of Partners

**Core Capability:** Comprehensive due diligence on counterparties and projects.

**Application Scenario:**
When evaluating a new DeFi project for integration or conducting a large transaction with an institution, graph analysis can review the historical behavior and funding network of their contracts and wallets. This effectively identifies if they have close ties to "high-risk entities," providing critical data for partnership decisions.

## Post-Mortem Forensics: Providing Precise Investigation & Evidence

**Core Capability:** Deep penetration and tracing of on-chain funds.

**Application Scenario:**
After a security incident (like a hack), provide clear, visual fund flow reports for the project team and law enforcement. Our system can quickly trace the complete path of stolen funds through multiple hops, mixers, and into exchanges, securing the crucial time window for asset freezing and recovery.

# Conclusion
Leverage [NebulaGraph](https://www.nebula-graph.io/), BlockSec has built a robust risk control system from transaction data to risk networks. In the future, we believe that NebulaGraph can provide more stable and solid support for the compliant development of global crypto finance.

BlockSec uses graph technology and tagging to turn transaction data into a risk network for crypto compliance. This article covers the core idea, implementation with NebulaGraph, and key benefits.

Address Labels, Fund Flows & Graphs: BlockSec Builds a Crypto Risk Control System with NebulaGraph

# Bridging Knowledge Layers for Smarter Enterprise AI
In the rapidly evolving landscape of enterprise AI, the ability to harness organizational knowledge effectively has become a critical competitive advantage. While GraphRAG technology represented a significant leap forward in connecting LLMs with structured knowledge, the demands of complex enterprise environments have driven the natural evolution toward a more sophisticated approach. Today, we’re excited to introduce Fusion GraphRAG — not as a replacement, but as a strategic enhancement to the GraphRAG foundation that unlocks deeper business value through intelligent knowledge integration.

The term “Fusion” reflects the core innovation of this approach: an intelligent framework that deeply couples knowledge graph technology with dynamic retrieval optimization. Rather than treating different retrieval techniques as separate components, Fusion GraphRAG fuses multiple state-of-the-art approaches — including document structure analysis, semantic relationship mapping, and business rule integration — into a single, cohesive system where each component enhances the others.

![https://www-cdn.nebula-graph.io/blogs/fusion%20graphrag_01.gif](https://www-cdn.nebula-graph.io/blogs/fusion%20graphrag_01.gif)

# Understanding the Knowledge Challenge

Enterprise knowledge exists in complex, multi-dimensional structures that traditional RAG systems struggle to navigate effectively. Conventional approaches to document processing create inherent limitations that impact knowledge retrieval quality:

Traditional document segmentation methods break content into isolated chunks, which can sever important semantic relationships and disconnect related concepts that span across different sections of documentation. When critical information spans multiple documents or sections, systems often struggle to synthesize comprehensive answers because they cannot bridge these artificial gaps between separated content fragments.

The classic “needle in a haystack” problem emerges when fine-grained information becomes difficult to locate within fragmented content, as precise queries fail to surface relevant details when they’re isolated from their supporting context. Organizations also face the “forest vs. trees” dilemma — a persistent trade-off between detailed analysis and broad comprehension, making it challenging to address both global questions and granular details simultaneously.

# The Fusion GraphRAG Approach
Fusion GraphRAG represents a comprehensive evolution beyond traditional GraphRAG approaches, designed as a complete enhancement that builds upon the GraphRAG foundation while extending capabilities to meet enterprise demands. Rather than operating as a complementary technology requiring integration with additional search mechanisms, Fusion GraphRAG is architected as a unified, standalone solution that positions the graph structure as its foundational core.

![https://www-cdn.nebula-graph.io/blogs/fusion%20graphrag_02.png](https://www-cdn.nebula-graph.io/blogs/fusion%20graphrag_02.png)

## Global Context Preservation
Fusion GraphRAG preserves the integrity of knowledge by maintaining explicit connections between concepts, entities, and ideas regardless of their physical location within documents. This ensures related information remains contextually linked, providing the foundation for truly comprehensive understanding.

The system leverages graph structure to traverse semantic relationships and intelligently link scattered information from multiple sources into coherent, comprehensive answers. This connection-oriented retrieval capability enables precise information discovery without sacrificing broader context — allowing users to locate specific details while understanding their relationship to the larger knowledge framework.

## Hierarchical Intelligence
Fusion GraphRAG operates across different levels of granularity, from document, sections to high-level conceptual relationships, enabling both detailed examination and broad analysis within a unified framework. This multi-scale analysis capability ensures the system can adapt to the specific needs of each query.

Using advanced techniques like the Leiden algorithm, Fusion GraphRAG automatically identifies hierarchical communities within the knowledge graph, revealing complex patterns and organizational structures that emerge naturally from the data. This community detection capability transforms raw information into meaningful insights.

The system dynamically adjusts its focus based on query characteristics, seamlessly navigating between forest-level insights for broad questions and tree-level details for specific inquiries. This adaptive focus ensures optimal responses whether users need strategic overviews or precise technical details.

# Why This Matters for Enterprise AI
Fusion GraphRAG delivers tangible business value by seamlessly integrating semantic search capabilities with advanced knowledge graph indexing. This unified approach eliminates the need for multiple disparate systems, providing organizations with a single, powerful platform that delivers superior performance across all retrieval scenarios.

By building upon the GraphRAG architecture rather than replacing it, Fusion GraphRAG preserves all the benefits of relationship-based knowledge retrieval while adding critical enterprise-ready capabilities. The result is a more efficient, cost-effective solution that helps organizations achieve their knowledge management goals with significantly less complexity.

Early adopters have reported experiencing 5–10x efficiency improvements and substantial cost savings while achieving the same or better results compared to traditional approaches. This isn’t about replacing existing systems — it’s about optimizing knowledge retrieval to unlock the full potential of enterprise AI investments.

# The Path Forward
As organizations continue to leverage AI to drive innovation and efficiency, the ability to connect knowledge across all dimensions of the enterprise will become increasingly critical. Fusion GraphRAG represents a natural evolution in this journey — enhancing the GraphRAG foundation with capabilities designed specifically for the complex knowledge landscapes of modern enterprises.

This advancement isn’t about creating a new paradigm, but about refining and optimizing existing approaches to better serve the evolving needs of businesses navigating the AI revolution. By preserving the strengths of GraphRAG while addressing enterprise-specific requirements, Fusion GraphRAG enables organizations to extract maximum value from their knowledge assets with unprecedented efficiency.

The future of enterprise AI lies not in isolated technologies, but in intelligent systems that understand how knowledge connects across all dimensions of the business. Fusion GraphRAG represents an important step on this journey — helping organizations transform their knowledge into actionable intelligence that drives real business outcomes.

This blog introduces Fusion GraphRAG, a strategic advancement beyond traditional GraphRAG that enables deeper, more intelligent integration of enterprise knowledge with LLM. Learn how it evolves the GraphRAG foundation to unlock greater business value in complex organizational environments.

Fusion GraphRAG: The Next Evolution in Enterprise Knowledge Intelligence

> In our [previous article](https://www.nebula-graph.io/posts/When_AI_Meets_Graph_Databases_Innovating_with_Multimodal_Data_Fusion), we explored how graph databases—leveraging their unique topological structure and a four-step framework of content analysis, semantic alignment, domain modeling, and relationship map—establish a robust intelligent data foundation for enterprises. This approach fundamentally addresses the challenge of integrating multi-source, heterogeneous data. In this article, we’ll examine how this powerful data foundation unlocks intelligent applications across the enterprise, transforming the very way organizations operate and make decisions.

# Intelligent Systems: Innovations Powered by the Intelligent Data Foundations

With this robust data foundation in place, innovation accelerates. From intelligent Q&A systems that deliver precise, context-aware responses, to advanced analytics that uncover hidden patterns and insights, to the seamless transfer and utilization of data assets—this intelligent core becomes the engine driving next-generation applications. It’s where the latent value of enterprise data is fully unlocked, transforming real-world business operations.

## Intelligent Q&A: The Leap from Data to Knowledge

Traditional question-answering systems rely heavily on keyword matching, extracting isolated fragments from siloed data sources. They often fall short when faced with complex, context-rich queries. For instance, when a user asks, “What factors might be related to a customer’s loan application being rejected?” a conventional system may return a single, surface-level answer—such as “insufficient credit score”—while overlooking critical but hidden factors like transaction anomalies or complex guarantee relationships. This fragmented output hinders comprehensive decision-making.

In contrast, an intelligent Q&A system, powered by a robust intelligent data foundation, represents a fundamental shift—from data retrieval to knowledge understanding. When a user submits a query, a LLM first interprets the underlying intent. The system then taps into the unified, interconnected data within the intelligent foundation, using the graph database’s powerful relationship traversal capabilities to explore paths between the “customer” node and related entities such as “credit score,” “transaction anomaly,” and “guarantee default.”

The graph database is pivotal: it rapidly identifies all relevant entities and their connections, ensuring the response captures not just direct causes but also indirect, contextually significant relationships. The system then synthesizes these distributed yet interlinked insights into a coherent, multi-dimensional answer—delivering “one question, full insight.” Users gain accurate, holistic responses, dramatically improving both the speed and accuracy of decision-making.

## Intelligent Analysis: Uncovering Hidden Value

The vast data accumulated during business operations often conceals valuable patterns and risks that remain invisible to traditional, single-dimensional analysis. Conventional methods fail to construct the rich, interconnected views needed to understand complex realities.

An intelligent analysis system, built on a robust intelligent data foundation, overcomes these limitations by leveraging the graph database’s “global relationship network.” This enables deep exploration of implicit connections across multimodal data, revealing hidden risks and opportunities that span organizational and data silos.

Graph databases excel not only in rapid data retrieval but also in uncovering deeper insights through multi-hop relationship traversal. By connecting fragmented data points—such as transactions, behaviors, and relationships—across degrees of separation, they allow organizations to construct comprehensive risk profiles and holistic customer views. This transforms analytics from reactive reporting to proactive early warning.

This powerful capability drives breakthroughs in fintech, marketing, healthcare, and beyond, delivering unprecedented, actionable insights across the enterprise.

## [Data MCP Marketplace](https://www.nebula-graph.io/posts/Announcing_the_Open_Source_Release_of_NebulaGraph_MCP_Server): Unlocking Data Assets Value

Traditional data management is plagued by inconsistent formats, misaligned semantics, and opaque relationships across departments. This fragmentation perpetuates “data silos”, hinders efficient sharing and circulation of data assets, and leads to costly duplication and redundancy.

The Data MCP Marketplace emerges as a transformative solution. Built on the intelligent data foundation, it centrally integrates and standardizes data assets scattered across disparate business systems, creating a unified, on-demand “data resource pool”.

For example, within a bank, risk management, marketing, and customer service teams can access and share a single, semantically consistent version of customer relationship data through the marketplace. This eliminates redundant data collection and processing, ensures organizational alignment, and dramatically increases data utilization and trust.

As the foundational engine of the MCP Data Marketplace, graph databases provide two critical guarantees for secure and efficient data asset sharing:

* Consistency Assurance: By leveraging the unified semantic layer of the intelligent data foundation, graph databases ensure that data accessed across departments maintains consistent meaning and context. This eliminates ambiguities and prevents business conflicts caused by “same term, different meanings”.

* Traceability Assurance: Graph databases capture the full lifecycle of data, including its origin, transformations, and dependencies, by modeling data lineage as explicit relationships. When a department uses a data asset, it can trace back through connected nodes to identify its source, processing history, and downstream impacts—ensuring data provenance, compliance, reliability, and full auditability.

The establishment of the Data MCP Marketplace has transformed data assets from siloed, department-specific resources into shared enterprise capital. This shift not only significantly reduces data management costs and eliminates redundant investments but also fuels innovation through cross-departmental data integration. Data becomes truly “liquid”—flowing freely to where it creates the most value—driving growth and maximizing its strategic impact.

These innovations are not isolated advancements; together, they signify a deeper, enterprise-wide transformation: the evolution from a traditional “data-driven” paradigm to a more sophisticated “knowledge-driven” model. In a knowledge-driven organization, decisions are no longer based merely on surface-level correlations in historical data, but on a deep understanding of underlying connections, context, and causal relationships.

The intelligent data foundation, powered by graph databases, provides the essential infrastructure to transform vast, heterogeneous data into structured, interconnected knowledge. It enables enterprises to move beyond reactive analytics to proactive intelligence—transitioning from simply being *data-driven* to truly being *knowledge-driven*.

# Future Tendency: The Infinite Potential of Graph Databases and AI

From integrating siloed data to powering intelligent Q&A, analytics, and Data MCP Marketplaces, the fusion of graph databases and AI has rapidly reshaped enterprise intelligence. As AI evolves, this synergy will unlock even deeper insights, autonomous knowledge discovery, and adaptive systems—driving a new era of cognitive, knowledge-driven enterprises.

![https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%20(part%202).png](https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%20(part%202).png)

In application scenarios, the fusion of graph databases and AI will transform diverse fields.

## Smart City Development
Graph databases will integrate massive traffic, energy, and public service data into a dynamic urban operations network. AI, leveraging this interconnected structure, can analyze real-time relationships between traffic flow, weather, and events to optimize signal timing. It can uncover patterns linking energy use, industrial distribution, and population density for intelligent grid management. By mapping public service supply against community needs, it enables precise planning of schools, hospitals, and infrastructure—empowering cities to truly “think and respond”.

## Healthcare
By integrating a patient’s genetic data, medical history, imaging, and lifestyle into a unified health graph, AI can deliver more accurate diagnoses and personalized treatments. In infectious disease control, AI can analyze a “patient-contact-location-variant” network to rapidly trace transmission chains, predict outbreaks, and inform effective public health interventions.

## Personalized Recommendations 
Graph databases and AI will transcend the limits of behavior-based recommendations. By integrating social connections, interests, contexts, and emotional cues into a rich, multidimensional user profile network, AI can uncover deeper intent and relationships. This shifts recommendations from simple “similar items” to truly anticipating user needs—delivering truly personalized, context-aware experiences.

## Financial Risk Management
The integration of graph databases and AI enables more precise risk detection. By constructing a comprehensive graph of users, transactions, merchants, affiliates, and market conditions, AI can monitor hidden risk pathways in real time. It can uncover money laundering through complex transaction chains and predict defaults by analyzing corporate equity and guarantee networks—strengthening financial security with deeper, proactive insights.

## Scientific Research and Innovation
AI and graph databases will accelerate knowledge discovery. In materials science, for instance, AI can analyze graph-connected data on composition, structure, processing, and performance to identify promising new material combinations—dramatically shortening R&D cycles and driving innovation.

# Conclusion
Ultimately, the immense promise of graph databases and AI lies in their shared focus on the defining feature of the “Internet of Everything”: **relationships**. In a world where natural systems and human activities are deeply interconnected, value resides not just in data points, but in the connections between them.

Graph databases like [NebulaGraph](https://www.nebula-graph.io/) make these relationships explicit and navigable through their node-link structure, while AI leverages this connectedness to understand context and uncover hidden patterns. Together, they enable enterprises to move beyond data volume and see the essential structure beneath.

In this article, we’ll examine how the powerful intelligent data foundation unlocks intelligent applications across the enterprise, transforming the very way organizations operate and make decisions.

When AI Meets Graph Databases: Innovating with Multimodal Data Fusion (Part II)

[Vesoft Inc.](https://www.nebula-graph.io/about_us), the company behind NebulaGraph — the world’s leading distributed graph database — today announced that NebulaGraph Cloud has successfully achieved SOC 2 Type 1 compliance, audited by Ernst & Young Hua Ming LLP. This certification validates that the cloud platform’s security controls are designed in alignment with the AICPA’s Trust Services Criteria — including security, availability, and confidentiality — reinforcing trust for global enterprises adopting graph technology.

Achieving SOC 2 Type 1 is a critical step in demonstrating NebulaGraph Cloud’s commitment to enterprise-grade data protection and operational integrity. As organizations increasingly rely on real-time relationship analytics for fraud detection, knowledge graphs, and AI-driven decision-making, robust cloud security is no longer optional — it’s foundational.

[NebulaGraph Cloud](https://www.nebula-graph.io/cloud-2025) is a fully managed Graph Database-as-a-Service (DBaaS) designed for super-large-scale connected data. It delivers exceptional scalability, supporting billions of nodes and trillions of edges with millisecond query latency, even under high concurrency. The platform offers end-to-end capabilities—from schema management and efficient data import to no-code visual graph exploration—making graph analytics accessible to users of all skill levels. With real-time observability, pay-as-you-go pricing, and native support for ISO-GQL, NebulaGraph Cloud simplifies development, and ensures enterprise-grade performance and flexibility.

![image](https://www-cdn.nebula-graph.io/blogs/dbaas-visualization.png)
*TiDB Cloud Visualization*

SOC 2 is the first of many compliance frameworks Vesoft seeks to implement as the NebulaGraph Cloud service continues to mature. For more information about NebulaGraph Cloud or to sign up for a free trial, visit [https://cloud.nebula-graph.io/login](https://cloud.nebula-graph.io/login).


Vesoft Inc., the company behind NebulaGraph, today announced that NebulaGraph Cloud has successfully achieved SOC 2 Type 1 compliance.

NebulaGraph Cloud Achieves SOC 2 Type I Compliance, Strengthening Trust in Secure Graph Database-as-a-Service

We're deeply honored to share that NebulaGraph has been recognized as the #2 graph database worldwide on the [DB-Engines](https://db-engines.com/en/ranking/graph+dbms) ranking—a milestone that belongs not to us alone, but to our entire community. This achievement reflects the collective effort of users, customers, contributors, and supporters who've believed in the power of graph technology from the very beginning.

# What This Recognition Means
DB-Engines is the industry's most objective database ranking system, measuring organic traction through search trends, job listings, technical discussions, and enterprise adoption—not vendor payments. Being ranked #2 signifies that NebulaGraph has earned genuine trust across the global graph ecosystem for solving real-world challenges at scale.

This isn't just a number—it's validation that our shared vision of building a truly distributed, enterprise-ready graph database is resonating with those who need it most: developers building the next generation of intelligent applications, and enterprises transforming how they understand complex relationships in their data.

![https://www-cdn.nebula-graph.io/pic-upload/Nebula%20Rank%202.png](https://www-cdn.nebula-graph.io/pic-upload/Nebula%20Rank%202.png)

# A Community Achievement
This milestone exists because of you:
* Our open-source contributors who've submitted PRs, shared production deployments, and built critical integrations with Spark, Flink, and LlamaIndex
* Our enterprise customers who trusted us with mission-critical workloads—from financial fraud detection to supply chain optimization
* Our developer community whose GitHub discussions and real-world use cases have directly shaped our roadmap
* Our partners who've integrated NebulaGraph into solutions that serve industries from finance to automotive

When we started [NebulaGraph](https://www.nebula-graph.io/) in 2018, we dreamed of creating a graph database that could handle the scale of modern applications while remaining accessible to developers. Your feedback, your challenges, and your successes have been the compass guiding our journey.

# Real Impact, Real Stories
Behind this ranking are tangible outcomes our community has achieved:

* Financial institutions mapping 15-hop transaction networks to cut fraud investigation time from days to seconds
* Developers building AI applications with our Fusion GraphRAG technology—without needing to retrain their models
* Enterprises running production workloads on graphs with billions of nodes, where other solutions hit scaling walls

These stories—not rankings—are what truly matter. They're why we come to work every day, and why this community continues to grow.

# With Sincere Gratitude
To everyone who has contributed to NebulaGraph's journey—whether you've opened an issue, shared a use case, deployed in production, or simply followed our progress—thank you. This ranking is yours as much as it is ours.

The best part of this achievement isn't the number—it's knowing we're building something meaningful together. Here's to the next chapter of our shared graph journey.

NebulaGraph has been recognized as the #2 graph database worldwide on the DB-Engines ranking.

NebulaGraph Ranks #2 Globally Among Graph Databases: A Milestone Achieved Together

# Data Challenges in the AI Era

As intelligence transforms industries, data is exploding in volume and variety. Banks generate structured transactions, unstructured customer call recordings, and semi-structured JSON profiles. Hospitals manage free-text medical notes, numerical lab results, and diagnostic images. This flood of multi-source, heterogeneous data is no longer an exception—it’s the norm.

Legacy data systems, built for siloed, single-format processing, can’t keep up. They handle one data type at a time, missing the rich connections between them. But modern AI demands more: it needs holistic, context-rich insights drawn from all available data dimensions.

The challenge has shifted. It’s no longer just about storage—it’s about understanding. In the AI era, systems must mimic human cognition, linking disparate data points across modalities to form meaningful networks.

At present, the integration of multi-source heterogeneous data has become an inevitable trend, and Graph Database is one of the key technologies to solve this problem.

# Why Do We Need Graph Databases?  

## The Limits of Traditional Data Approaches

Traditional data processing methods are struggling to keep up in today’s complex landscape. Early storage models created fragmented, isolated “data silos” with little to no connection between them—making it nearly impossible to see the full picture or unlock the true value hidden in the data.

Taking enterprise customer management as an example, a customer’s profile might live in one table, purchase history in another, and service interactions in yet another. To understand their full journey, you need cross-table joins. But as data grows, these queries become slow and unwieldy with latency jumps from milliseconds to minutes. Worse, mismatched fields during joins can introduce errors, leading to inaccurate insights and flawed business decisions.

The result? Slow, inefficient analytics, overlooked relationships, and a widening disconnect between raw data and actionable insights.

## New Demands in the AI Era: Semantic Understanding and Multimodal Fusion

Traditional databases have inherent shortcomings when dealing with multimodal data. Complex implicit associations exist between multimodal data. However, the two-dimensional table structure of traditional databases cannot intuitively express such associations, making the fusion analysis of multimodal data difficult to achieve. AI’s demand for deep semantic understanding further highlights the shortcomings of traditional databases in handling complex and nonlinear relationships.

## From Multimodal Data to Relationships Analytics in One Step

To solve the data connectivity challenge, graph databases reframe relationships intuitively: disparate data points become “nodes”, and their logical connections are explicitly modeled as “edges”. This structure enables “one-click” data association—no complex joins required.

Graph databases seamlessly integrate structured and unstructured data into a unified model. For instance, when analyzing how a product’s visual features relate to user sentiment, an “image node” can be directly linked to a “comment text node” via an edge. By combining AI-driven image and text analysis, these connections reveal hidden patterns between visuals and emotions—enabling deeper semantic understanding and powerful cross-modal analytics in the AI era.

# How Do Graph Databases Empower Intelligent Data Foundations?

The data intelligence foundation is the core infrastructure for enterprises to achieve intelligent transformation, aiming to integrate multi-source heterogeneous data and provide unified, efficient data support for intelligent applications. Its construction follows a four-step framework: “content analysis, semantic alignment, domain modeling, and relationship map.” In this process, graph databases—natively designed to handle entities and relationships—play a critical role at every stage, serving as the cornerstone for multimodal data fusion and value extraction.

![https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-1.png](https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-1.png)

## Content Quarks: Turning Raw Data into Structured Building Blocks

Content analysis kicks off the data intelligence foundation. It’s all about unpacking massive, messy raw data—text, images, audio, documents—and extracting the essentials: entities, attributes, and relationships. Think of it as breaking data down into tiny, atomic units we call “content quarks”.

![https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-2.png](https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-2.png)

Advanced tools make this possible: OCR reads text in images, speech recognition converts audio to text, and LLM parse meaning from documents. Together, they transform unstructured data into clean, structured fragments.

By defining entity and relationship types upfront, graph databases provide a clear blueprint for extraction. For example, when processing payment records, a pre-built schema can guide the system to spot “User ID”, “Merchant Code”, or actions like “transfers to” with precision. This not only reduces errors but ensures consistency—setting the stage for smarter, more reliable insights down the line.

## Semantic Alignment: Breaking Down “Data Silos” and Building a Unified Semantic Space

The goal of semantic alignment is to map data from different systems and with different naming conventions into a unified semantic space, thereby achieving seamless cross-source data connection and interoperability.

![https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-3.png](https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-3.png)

This process combines the power of large language models (LLMs) for semantic understanding, data lineage analysis, and business-specific rules to identify synonyms across systems. For instance, “buyer ID” in an e-commerce platform and “account holder number” in a bank system can be recognized as the same core concept: a “user unique identifier.”  

Graph databases are a natural fit for this task. Using their native node-edge structure, they can merge different names for the same real-world entity into a single, unified node. Attributes on that node preserve the original labels from each source—like a “User X” node tagged with Customer ID: 123 and User Number: 456.

This approach allows systems to automatically recognize that different names refer to the same entity—effectively breaking down long-standing data silos and paving the way for powerful, cross-scenario analytics.  

## Domain Modeling: Flexible Data Structures for Every Use Case

Different business scenarios demand different data perspectives. Risk control focuses on user networks, suspicious transactions, and blacklisted merchants, while marketing looks at user preferences, behaviors, and campaign engagement. Domain modeling tailors the data structure to these specific needs by defining relevant concepts and business rules.

![https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-4.png](https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-4.png)

Here, graph databases act like a “customizable shelf”—flexible and easy to rearrange. Instead of rigid table schemas, they represent core ideas as nodes and connections as edges. This makes it simple to model complex relationships, like linking “blacklisted merchants” to “abnormal transactions” in fraud detection.

Best of all, the model can evolve with the business. Need to add “logistics information”? Just introduce a new node and connect it—no schema overhaul required. This agility makes graph databases ideal for building scalable, future-proof data models.

## Relationship Map: Connecting the Dots at Scale

The relationship map is the culmination of the four-step data intelligence framework—bringing together all entities and connections uncovered during content analysis, semantic alignment, and domain modeling. It forms a unified, global graph that integrates multimodal data into a single, coherent network, enabling deep data fusion and efficient querying.

![https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-5.png](https://www-cdn.nebula-graph.io/pic-upload/Multimodal%20Data%20Fusion%201-5.png)

This integrated graph consolidates fragmented data into one connected space. Powered by a robust graph computing engine, it uncovers hidden patterns and complex relationships that traditional systems miss.

The graph database becomes the central “hub” for storage and computation. It efficiently handles billions of nodes and edges while enabling fast, multi-hop traversals and complex pattern searches. For example, in fraud detection, querying “User A” can instantly reveal their transactions, linked merchants, triggered risk rules, and even indirect connections to known bad actors—like tracing a detective’s case map in real time.

With everything interconnected, the graph turns scattered data into actionable intelligence, unlocking the full value of enterprise multimodal data and empowering smarter, faster decisions.

# Graph Databases: The Engine of Data Intelligence

Graph databases provide a standardized framework for content extraction, enable a unified semantic layer for data alignment, offer a flexible structure for domain-specific modeling, and serve as a high-performance engine for storing and querying the relationship map.

More than just a database, graph databases represented by [NebulaGraph](https://www.nebula-graph.io/) is the core enabler of multimodal, heterogeneous data fusion—turning fragmented information into connected knowledge. By unlocking deep relationships and hidden patterns, graph databases power advanced applications like intelligent analytics, real-time risk detection, and precision marketing, laying a strong, scalable foundation for the intelligence of enterprise.


>In the first half, this article delved into the core role of graph databases in addressing the challenges of multimodal and heterogeneous data and detailed how they empower the intelligent data foundation. In the next part, we will further explore application innovation based on this and the exciting potential of integrating graph databases with AI. Stay tuned.

This article explores the core role of graph databases in addressing the challenges of multimodal and heterogeneous data and explains how they empower the intelligent data foundation.

When AI Meets Graph Databases: Innovating with Multimodal Data Fusion (Part I)


> Chunhui Huang is a Senior Development Engineer of ZKH Big Data Platform. Since 2024, he has been promoting the deep integration of NebulaGraph into multiple business scenarios at ZKH, including intelligent procurement decisions and supply chain risk control systems. This article introduces these application practices.



# About ZKH

ZKH is an online industrial products service platform dedicated to digital transformation. We aim to provide customers with transparent, efficient, and low-cost one-stop industrial product solutions. Leveraging digital management tools and big data technologies, we collaborate with partners to optimize the entire supply chain, covering the entire process from procurement and manufacturing to delivery. Additionally, ZKH offers high-quality industrial product selection services. Combined with self-built warehousing and logistics system, we create an efficient and reliable industrial product procurement and delivery experience for online and offline customers.


# Business Challenges


Before adopting [NebulaGraph](https://www.nebula-graph.io/), our main business pain points were as follows:
* **Data Scale and Complexity**: Business expansion led to rapid growth of complex relational data. Traditional databases struggled with efficient storage, querying, and real-time analysis.
* **Relational Database Limitations**: Significant performance bottlenecks in multi - table joins made it impossible to support real - time analysis of complex relational data.
* **Data Value Realization Difficulty**: Applications of complex relational data faced challenges in data modeling, algorithm optimization, and effectiveness verification.


# NebulaGraph Selection and Architecture



## Why NebulaGraph?


* **Efficient Relational Expression**: Graph structures intuitively represent entities and their relationships. This is suitable for ZKH's complex supply chain network.
* **Powerful Path Analysis**: Supports efficient graph traversal algorithms for rapid path analysis.
* **Real - time Queries and Responses**: Capable of high - concurrency, low - latency queries, supporting real - time recommendations and risk warnings.
* **Scalability and High Performance**: Distributed and storage - computing separated architecture, supporting horizontal scalability.




## Technical Architecture

![https://www-cdn.nebula-graph.io/pic-upload/ZKH.png](https://www-cdn.nebula-graph.io/pic-upload/ZKH.png)

* **Data Collection**: Data from ERP, MySQL, etc., is synchronized to Alibaba Cloud MaxCompute via DataX or Flink - CDC. Client behavior data is collected via SDK and uploaded to Alibaba Cloud DataHub. Unstructured data is stored via OSS.
* **Data Processing**: Offline computing uses MaxCompute and Spark for large - scale batch data processing. Real - time computing uses Flink for stream data processing.
* **Data Storage:** Two clusters are deployed. The online service cluster handles real - time queries, and the graph algorithm cluster deals with complex graph algorithms.
* **Data Services**: API gateway provides unified interfaces. Customized APIs meet different business needs.


# Application Practices



## Precision Recommendation


Previously, our precision recommendation in e - commerce faced challenges. We planned to introduce NebulaGraph to build a smarter recommendation system.

* **Data Input and Modeling**: User behavior data and product data are used as inputs, cleaned and transformed, and loaded into NebulaGraph for graph modeling.
* **Graph Database Structure**: A graph structure centered on products and users is constructed. Relationships between users and products are established through behavioral trajectories.
* **Real - time Feature Extraction and Recommendation Optimization**: Through NebulaGraph's nGQL query language, we can real - time extract user behavioral features. These features are used to optimize the recommendation process.


### Outcomes


After introducing NebulaGraph, we achieved a 15% increase in search recommendation click - through rates and a 5% improvement in order conversion rates. Moving forward, we aim to expand into more relational data dimensions and incorporate AI real - time learning mechanisms.


## Supply Chain


ZKH's supply chain is product - centered and driven by customer demand. With the support of NebulaGraph, we have built an efficient and visual supply chain network.

* **Procurement Decisions**: After a customer order is submitted, the system intelligently selects the most suitable supplier channels within NebulaGraph, which can help to optimize the procurement costs.
* **Inventory Management**: Products are managed in inventory based on various attributes, such as batch, quantity, and status. Real - time data sharing lets warehouse staff instantly check product status across warehouses, improving stocking operations, reducing stockpiling, and enabling joint inventory management and smart replenishment.
* **Intelligent Fulfillment**: The system optimizes the entire process from customer orders to logistics delivery. With NebulaGraph, intelligent management not only enhances the inventory turnover but also reduces warehousing costs and optimizes the overall supply chain efficiency.
* **Accurate Delivery**: We utilize real-time logistics sharing and NebulaGraph's shortest path algorithm to optimize delivery routes, ensuring that products can be delivered to customers on time and efficiently.


### Outcomes


* **Customer Satisfaction**: Transparent logistics info, on - time deliveries, and efficient order fulfillment significantly enhanced customer satisfaction, with a 20% drop in after – sales work orders.
* **Intelligence and Automation**: Graph algorithms based on NebulaGraph, such as the shortest path algorithm, collaborative filtering algorithm, etc., can automatically optimize inventory, procurement, fulfillment and delivery, reducing manual work. The intelligent supply chain system via NebulaGraph quickly responds to market shifts, boosting competitiveness.
* **Cost and Efficiency**: Optimizing inventory, procurement, and delivery has reduced operational costs, raised stock availability by 15%, and cut stagnant inventory by 10%.


# Future Plans



## Knowledge Base Management System


We're working with the [NebulaGraph GenAI](https://www.nebula-graph.io/posts/announcing_nebulagraph_RAG) team to build a knowledge base management system for ZKH. We aim to integrate structured and unstructured data efficiently. This will empower our internal teams, including sales, customer service, and operations staff, to use the knowledge base for intelligent Q&A. They can quickly access the info they need, which will make work more efficient.


## Intelligent Risk Control System


Leveraging NebulaGraph, we are exploring to build a unified customer-supplier risk-control network that fuses business registration, credit, fulfillment, and news data. At transaction time, the system instantly analyzes behaviors and legal risks, extracts risk features via nGQL, and applies algorithms to flag fraud, cutting supply-chain exposure.


# Summary


The implementation of NebulaGraph at ZKH has achieved significant results in business scenarios such as precision recommendation and supply chain optimization. In the future, ZKH and NebulaGraph will further explore the deep application of knowledge bases and intelligent risk control.

This article introduces the application practices of NebulaGraph at ZKH from aspects like selection and architecture of NebulaGraph, business scenarios, and future plans.

How ZKH Leveraged NebulaGraph to Achieve 15% Gains in Core Business Areas

# The New Era of Stablecoin Compliance

The passage of the GENIUS Act marks a watershed moment for stablecoin issuers—no longer operating in regulatory gray areas, they are now formally designated as "financial institutions" under the Bank Secrecy Act with stringent obligations. This transformation brings three critical challenges that traditional risk systems are ill-equipped to handle:

First, issuers must implement KYC/AML protocols capable of binding real-world identities to pseudonymous on-chain addresses—a near-impossible task when a single entity manipulates hundreds of wallets to launder funds. Second, they need to maintain real-time transparency between stablecoins and their 1:1 reserve assets, despite transactions fragmenting across multiple blockchains. Third, with stablecoin holders gaining priority claim status in insolvency, issuers must proactively model systemic risk exposure across interconnected user networks.

The core problem? Stablecoin transactions form complex relationship networks, but legacy systems treat them as isolated events. When a user's funds hop across Bitcoin, Ethereum, and Solana chains, relational databases see disconnected silos—while money launderers exploit these very gaps.

This is where graph technology becomes indispensable. Unlike traditional databases, graph databases natively model the relationships between entities —mapping how user identities connect to addresses, how transactions flow across chains, and how risks propagate through networks. By transforming fragmented data into intelligent relationship graphs, issuers can:

- Automatically detect hidden wallet clusters through community detection algorithms
- Reconstruct end-to-end transaction paths across chains in seconds, not hours
- Simulate insolvency scenarios by modeling issuer-reserve-user dependency networks

# How NebulaGraph Enhances Stablecoin Fraud Detection

[NebulaGraph](https://www.nebula-graph.io/) has been validated in production environments by leading stablecoin platforms, including Binance, OKLink and BlockSec. Its technical strengths address the three systemic challenges:

## Dynamic Graph Analytics: Real-Time Data for Cross-Border Compliance
Stablecoins’ cross-chain nature fragments transaction paths, and traditional risk systems—due to data silos—cannot quickly reconstruct end-to-end trails. 

NebulaGraph’s multi-chain transaction graph modeling aggregates and correlates addresses, timestamps, and transaction amounts from disparate blockchains (e.g., Bitcoin, Ethereum, Solana) into a unified fund flow visualization. It updates address relationships in milliseconds, capturing criminals’ frequent wallet-switching behaviors.

For example, a cross-border payment platform used shortest-path analysis to trace a stablecoin’s complete transfer path from TRON to Ethereum in seconds, assessing risk levels in real time. This dynamic graph capability also supports one-click generation of compliance evidence chains aligned with multi-jurisdictional regulations, drastically shortening compliance response times.

## Graph Computing: Penetrating Complex Relationships to Expose Hidden Risks

A core challenge for stablecoin issuers is deep-linking user identities to on-chain addresses. Traditional systems rely on static rules (e.g., blacklist matching) or simple associations, failing to detect sophisticated "cluster attacks" where criminals manipulate hundreds of addresses to disperse funds.

NebulaGraph’s graph computing models user identities, on-chain addresses, device fingerprints, and transaction timestamps into a dynamic relationship network. It leverages community detection algorithms (e.g., Louvain, PageRank) to automatically identify hidden fund pools.

In a cross-border money laundering case, the system analyzed transaction patterns across 200+ addresses , flagging anomalous fund flows that deviated significantly from normal user behavior. It locked down the hidden controller (back-end operator) in milliseconds. Additionally, graph computing simulates issuer-bank-creditor dependency networks to predict liquidity crisis transmission paths during stablecoin runs, providing institutions with systemic risk early-warning models.

## Real-Time Graph Features: Millisecond Response at Scale
In high-concurrent scenarios (e.g., market volatility surges), stablecoin issuers must handle traffic spikes while meeting regulatory demands for real-time risk interception. Traditional databases often lag under complex joins at thousands of queries per second, but NebulaGraph’s distributed architecture has proven its capability for trillion-edge real-time analysis.

NebulaGraph supports tens of thousands of concurrent queries per second with stable millisecond latency, even under extreme scenarios. This real-time capability not only meets regulatory deadlines but also proactively intercepts systemic risks like money laundering and bank runs, ensuring institutional stability.


# Building Resilient Risk Infrastructure for the Stablecoin Era

As U.S. regulators tighten stablecoin oversight, graph databases like NebulaGraph are no longer optional—they’re the foundation of modern risk infrastructure. By combining real-time cross-chain analytics, advanced graph algorithms, and high-concurrency scalability, NebulaGraph turns compliance from a cost center into a strategic advantage.

The GENIUS Act imposes direct compliance obligations on stablecoin issuers, but its ripple effects extend to the broader ecosystem, including compliance and security firms serving virtual asset transactions, financial institutions doing exchanges, payment gateways, as well as DeFi Protocols and NFT platforms.

For technical teams, this isn’t just about meeting deadlines—it’s about future-proofing systems against the next generation of financial threats. Ready to see how graph technology can transform your stablecoin risk strategy? Schedule a [1:1 demo](https://www.nebula-graph.io/contact) with our technical consultants to explore more.

NebulaGraph’s graph technology helps stablecoin issuers meet U.S. GENIUS Act compliance by addressing identity linking complexity and systemic risk through dynamic graph analytics and high-concurrency processing.

Bridging Compliance and Security: Graph Technology for Stablecoin Transaction Monitoring

Interact with biomedical knowledge graphs using graph-based retrieval augmented generation.

BioGraphRAG - Biomedical Knowledge Graph Retrieval Augmented Generation

As the Web3 ecosystem continues to expand, blockchain-based transactions have introduced a new paradigm of decentralized finance (DeFi) characterized by anonymity, intricate interaction paths, and a lack of centralized oversight. While this innovation offers unparalleled freedom and flexibility, it also creates significant challenges for risk management and compliance. **Traditional tools like rule engines, relational databases, and statistical analysis struggle to keep pace with the dynamic and the hidden nature of Web3 threats. Enter graph databases—a technology uniquely suited to model and analyze the complex relationships inherent in blockchain networks.**

In this article, we’ll explore why graph databases are becoming indispensable for Web3 risk management, how they address the shortcomings of traditional solutions, and their transformative impact on combating fraud, money laundering, and other illicit activities.

# The Challenges of Web3 Risk Management
## Anonymity and Lack of Context
In Web3, user identities are represented by blockchain addresses, which do not require real-name registration. This anonymity, combined with privacy-enhancing protocols and privacy coins, makes it nearly impossible to trace the origins of transactions or identify malicious actors. For example, attackers often exploit these features to launder money through multi-layered transfers or obfuscate transaction paths using time delays and decoy addresses. Traditional risk management systems, which rely on static rules and predefined thresholds, are ill-equipped to handle such sophisticated evasion tactics.

## Limitations of Rule Engines
Traditional rule-based systems operate on simple heuristics, such as flagging an address after a certain number of consecutive transactions or identifying high-value transfers as suspicious. While effective against predictable patterns, these rules falter when faced with the adaptive strategies of Web3 attackers. For instance, a money-laundering operation might split large sums into smaller amounts distributed across multiple addresses, making it difficult for static rules to detect the underlying scheme. Without the ability to understand the broader context of transactions, rule engines are rendered ineffective.

## Isolated Data Analysis
Statistical methods used in traditional risk management focus on individual metrics, such as transaction frequency or average transfer amounts. However, these approaches fail to capture the interconnected nature of Web3 transactions. Many fraudulent activities, such as Sybil attacks or airdrop farming, involve coordinated actions across multiple addresses controlled by a single entity. Analyzing each address in isolation misses the bigger picture, leaving organizations vulnerable to "group-based" attacks.

## Performance and Real-Time Constraints
The sheer scale and complexity of blockchain data pose additional challenges. Traditional relational databases rely on complex joins and queries to map relationships between entities, leading to slow performance and high resource consumption. In contrast, Web3 demands real-time risk detection and mitigation, which legacy systems cannot deliver.

# How Graph Databases Handle Web3 Risk Challenges
## Native Representation of Complex Relationships
At its core, Web3 operates as a vast network of interconnected entities—addresses, transactions, smart contracts, and protocols. Unlike relational databases, which require multiple tables and joins to represent these connections, graph databases model this data natively. Addresses become nodes, while transactions and interactions become edges, creating a semantic-rich and intuitive representation of the blockchain ecosystem. This structure simplifies modeling and enables lightning-fast queries, even across billions of nodes and edges.

For example, tracking a fund flow from a high-risk address involves traversing multiple layers of transactions. A graph database can perform this task in milliseconds, identifying all downstream addresses within 10 hops of the original source. This capability is crucial for real-time risk assessment and response.

## Pattern Recognition and Structural Analysis
Web3 fraud often exhibits distinct structural characteristics, such as circular transactions where funds loop back to their origin, star-shaped aggregations (multiple addresses funneling funds to a central account), or shared-source clusters (multiple users linked to the same IP). Graph databases excel at detecting these patterns through subgraph matching techniques, allowing systems to identify suspicious behaviors with remarkable accuracy.

By integrating with risk decision platforms, graph databases enable real-time alerts and dynamic analysis. As soon as an abnormal transaction or connection to a known blacklist node is detected, the system can trigger immediate warnings, far outpacing traditional batch-processing methods.

## Advanced Graph Algorithms for Fraud Detection
Graph databases come equipped with powerful algorithms that uncover hidden risks in large-scale networks. Take Community Detection Algorithms and Connected Components Analysis for instance. Techniques like Louvain clustering group highly interconnected addresses into potential fraud clusters. These clusters may represent orchestrated attacks, such as airdrop abuse or coordinated money laundering. Connected Components Analysis is often leveraged by Identifying isolated subgraphs to help detect rogue groups operating independently from the broader network. Such structures are often indicative of automated scripts or bot-controlled addresses.

These advanced graph algorithms allow graph databases to go beyond simple anomaly detection, providing deep insights into the structural vulnerabilities of Web3 ecosystems.

# The Future of Web3 Risk Management
As Web3 continues to reshape the financial landscape, the need for robust risk management solutions has never been greater. Graph databases offer a transformative approach to addressing the unique challenges posed by decentralized, anonymous, and complex blockchain environments. By enabling precise, real-time analysis of transaction networks, they empower organizations to stay ahead of evolving threats while ensuring regulatory compliance.

**For businesses operating in the Web3 space, adopting [graph database](https://www.nebula-graph.io/) technology is no longer optional—it’s essential.** Whether you’re a cryptocurrency exchange, a DeFi protocol, or a blockchain analytics firm, leveraging graph databases will help you unlock the full potential of your data and build a safer, more resilient Web3 ecosystem.


In the rapidly evolving world of Web3, where blockchain transactions are decentralized, anonymous, and complex, graph databases are emerging as the critical solution to tackle fraud, money laundering, and other risks with precision and speed.

Tag