SQL (Structured Query Language) has been the standard language for managing and querying relational databases for decades. Relational databases store data in tables and use structured schemas to define relationships between these tables. However, with the increasing complexity of data relationships in modern applications, there has been a growing need to model and query data in ways that go beyond traditional tabular structures.

Graph databases, such as Neo4j, Amazon Neptune, and NebulaGraph, have emerged to address these needs by storing data as nodes (entities) and edges (relationships). They are optimized for traversing and querying complex relationships, making them ideal for applications like social networks, recommendation engines, fraud detection, and network analysis.

In response to the rising popularity of graph databases and the demand for more flexible data modeling, several major SQL database systems have introduced support for graph queries. This includes the ability to create, manage, and query graph structures directly within a SQL database, leveraging the familiar syntax and capabilities of SQL. 

This introduction does bring benefits to organizations looking for unified data management as both relational and graph data can be managed within the same database system, simplifying their data architecture and reducing the need for multiple specialized databases. However, it does not necessarily mean that graph databases will no longer be needed or that they will be replaced. 
Here are several key points to consider regarding the impact of this development on graph databases:

# Data Model Complexity and Flexibility
The graph database is a natural fit for graph data. If the data inherently represents complex relationships and networks (e.g., social networks, knowledge graphs), a graph database provides a more natural and intuitive way to model and query the data. What’s more, graph databases offer more flexibility in evolving the data model. In relational databases, schema changes can be complex and disruptive, whereas graph databases allow for more dynamic and flexible schema evolution.

# Query Language and Usability
Graph databases often provide specialized query languages (e.g., Cypher for Neo4j, Gremlin for TinkerPop) that are designed specifically for graph traversal and pattern matching, making it easier to express complex queries. Since the ISO-GQL was officially released in April this year, the graph database industry is expecting this standard graph query language to provide a unified and standard experience for developers familiar with graph concepts, as using a standard graph-specific query language, can be more intuitive and efficient compared to using SQL extensions for graph queries.

# Real-Time Analytics and Insights
For applications requiring real-time insights and analytics, such as fraud detection or recommendation engines, graph databases are optimized for low-latency query execution and can handle real-time data updates and queries more effectively. Some graph databases are designed to integrate seamlessly with streaming data sources, enabling real-time graph updates and analytics. Apparently, under situations requiring real-time analytics and insights, even though relational databases can perform graph queries, they may not be ideal options.

# Scalability and Distributed Processing
In terms of scalability and distributed processing, relational databases with graph query support might not be competitive to dedicated graph databases. Many graph databases are designed to scale horizontally, distributing data and queries across multiple nodes in a cluster, for instance NebulaGraph. This can be particularly important for large-scale graph applications where the data volume and query complexity require distributed processing. Besides, dedicated graph databases often come with built-in, optimized graph algorithms (e.g., shortest path, centrality, community detection) that can be executed efficiently at scale. 

# Complementary Use Cases
Graph databases are optimized specifically for graph data and queries, offering advanced features such as efficient graph traversals, pattern matching, and handling of complex relationships. While SQL databases with graph query support can handle basic graph operations, dedicated graph databases are likely to remain superior for use cases that require high performance and scalability in graph processing. Therefore, SQL databases with graph capabilities and dedicated graph databases can coexist, each serving different needs and use cases.

# Performance Considerations
While SQL databases with graph query support can handle graph data, they might not match the performance and efficiency of dedicated graph databases, especially for large-scale graph processing and real-time analytics. Graph databases are designed with specific optimizations for graph workloads, such as index-free adjacency, which can significantly improve query performance for certain types of graph operations.

# Conclusion
In summary, while the support for graph queries in SQL databases enhances their capabilities and provides more flexibility, it does not render dedicated graph databases obsolete. Each type of database has its strengths and is suited for different use cases. Organizations will continue to choose the best tool for their specific requirements, and dedicated graph databases will remain crucial for applications that demand high-performance graph processing and advanced graph analytics. The coexistence of these technologies provides organizations with a broader range of tools to meet their diverse data management needs.

While the support for graph queries in SQL databases enhances their capabilities and provides more flexibility, it does not render dedicated graph databases obsolete.

Graph Databases vs. SQL with Graph Queries: Friends or Foes?

GQL, a property graph query language newly released this year by the ISO, is the second international standard database query language since SQL's debut over 40 years ago. It integrates the strengths of Cypher, SQL, and various general programming languages, making it a powerful tool for analyzing complex graph data.

# Building on Cypher: How GQL Enhances Graph Queries

## Enhanced Graph Pattern Matching

### Powerful Label Matching Syntax

One of the standout features of GQL is its advanced label matching syntax. This allows for more complex queries using logical operators such as `&`, `|`, and `!`.

In Cypher, a typical query might look like this:

```
MATCH (n:Person)
WHERE n.age > 30
RETURN n
```

With GQL, you can perform more sophisticated queries:

```
MATCH (n:Manager & FullTime | !Intern)
WHERE n.age > 30
RETURN n.name AS managerName, n.department AS dept
```

This GQL query finds nodes that are both `Manager` and `FullTime`, or not `Intern`, and have an age greater than 30.

### Regex-like Variable-Length Path Pattern

GQL introduces a regex-like syntax for variable-length patterns, enhancing flexibility in path matching. Examples include `-[e]->{1,3}`, `-[e]->+`, `-[e]->*`, and` -[e]->?`. This allows for more complex path pattern matching compared to Cypher’s syntax.

### Path Restrictors

GQL provides four path restrictors—`WALK`,`TRAIL`,`ACYCLIC`, and `SIMPLE`—to control whether paths can have repeated nodes or edges.

### Path Selectors

GQL offers versatile shortest path queries, including options for finding all shortest paths, any shortest path, and the top k shortest paths. This flexibility allows for detailed and efficient path retrieval in various scenarios.

## Modern Variable Definition

### Local Variable Definition

GQL introduces a dedicated syntax for defining local variables at the beginning of a procedure, similar to early C language practices. These variables are visible throughout the entire procedure scope. The introduction of local variables allows GQL to express nonlinear data flows, enabling data to be reused multiple times.

For instance, when users need to perform multiple analyses on the same dataset, GQL's local variables provide an efficient way to store and reuse intermediate results. This is particularly useful for complex calculations or when the same base data needs to be processed in different ways.

Consider a scenario where we want to analyze user interactions in a social network:

```
TABLE userActivity = {
    MATCH (u:User)-[a:ACTION]->()
    RETURN u.id AS userId, a.timestamp AS actionTime, a.type AS actionType
}
 
VALUE activeUsers = VALUE {
    FOR i IN userActivity
    WHERE i.actionTime > datetime('2024-01-01')
    RETURN collect_list(DISTINCT i. userId)
}
 ​
VALUE uniqueActionTypes = VALUE {
    FOR i IN userActivity
    WHERE i.userId IN activeUsers
    RETURN count(DISTINCT i.actionType) AS uniqueActionTypes
}
```

In this example,` userActivity` captures the base dataset of user actions, which is then reused to identify active users and calculate action statistics. This demonstrates how GQL's local variables enable efficient data reuse and modular query construction.

### The LET Statement: Another Way to Define Variables

The LET statement in GQL defines variables by adding a new column to the current output table, unlike VALUE, which creates procedure-scope visible variables. LET is non-blocking, allowing you to define new variables without interrupting the flow of existing ones, unlike Cypher’s WITH, which requires manual inclusion.

In Cypher, you must explicitly pass all existing variables when defining a new one:

```
MATCH (v)-[e]->(v2)
WITH v, e, v2, 1 AS a
```

Or use `WITH *` to retain all:

```
MATCH (v)-[e]->(v2)
WITH *, 1 AS a
```

In GQL, `LET` simplifies this process:

```
MATCH (v)-[e]->(v2)
LET a = 1
```

Here, `v`, `e`, and `v2` remain accessible, and `a` is seamlessly added. This makes `LET` a more efficient and intuitive choice for variable definition.

## Complex Nested Queries

GQL's `CALL` statement allows you to encapsulate a set of statements into a subquery block, treating them as a single unit that can be referenced by outer statements. This is particularly useful when you need to apply operations on the combined results of multiple queries.

For example, to sort the combined results of two different queries:

```
CALL {
    MATCH (v:Person) RETURN v.name AS name
    UNION
    MATCH (v:City) RETURN v.name AS name
}
ORDER BY name
```

The `CALL` block enables the `ORDER BY` to be applied to the unioned results, rather than just the last query.

# Comparison between GQL and SQL/PGQ

SQL/PGQ extends its graph query capabilities based on SQL, and it shares a read-only graph pattern matching syntax with GQL. However, compared to SQL/PGQ, GQL provides a complete set of read-write syntax, which can better meet the various operation requirements of graph databases.

In addition, although SQL is powerful, its syntax design has some well-known issues. For example, the clause order of SQL is not intuitive and difficult to combine, and users often need to use workarounds to achieve complex requirements. Google recently published an article titled "SQL Has Problems. We Can Fix Them: Pipe Syntax In SQL," pointing out these syntax design issues of SQL and proposing a special pipeline operator aimed at making clauses more linear and combinable, thereby enhancing the flexibility and intuitiveness of SQL.

GQL, on the other hand, is inherently linear and composable. It features orthogonal statements like `MATCH` for graph pattern matching, `FILTER ` for filtering results, `FOR ` for iterating over lists, `LET` for variable definitions, and CALL for complex nested queries.

In addition, GQL includes `INSERT`, `SET` and other DML statements, which can be also elegantly combined in a linear manner with DQL statements.

For example, you can match nodes and then insert an edge between them:

```
MATCH (a:player{id:1, name:"Tim"}(b:player{id:2, name:"Jerry"})
INSERT (a)-[:follow{followness:90}]->(b)
```

The following two figures intuitively demonstrate the differences in syntax between SQL and GQL.

**Figure 1: SQL's Rigid Clause Structure**

![](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/74ac57c6f7a292190fc6b1ff2b10139f.png)

**Figure 2: GQL's Linear Statement Composition**

![](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/c5ab0435a24e95b58f87f65bde9d2103.png)

# Looking Forward: The Road Ahead for GQL

The first version of GQL has already included numerous features, showcasing the outstanding contributions of the standard committee members. Personally, I look forward to the possibility of future developments such as subgraph extraction, diverse table construction methods, window functions, and advanced programming constructs like conditional statements, loop statements, and lambda expressions. These enhancements will further solidify GQL's role as a powerful and user-friendly query language。

As a modern, advanced data query language, GQL excels in functionality and ease of use, making it essential for industries managing vast networks, such as telecommunications and social media. Its capability for real-time analytics provides immediate insights, which is crucial for decision-making in dynamic environments. Looking ahead, GQL's ongoing development promises to shape how we interact with data, paving the way for innovations in AI, healthcare, logistics, and beyond.

In conclusion, GQL is set to transform data management, and we eagerly anticipate its future advancements.


GQL, ISO's new graph query language, boosts complex data analysis with advanced pattern matching and versatile queries, vital for network-intensive industries.

Unveiling ISO-GQL: The Future of Graph Query Languages

In today's rapidly evolving business landscape, modern enterprises are constantly seeking innovative solutions to stay competitive and drive success. One of the most significant advancements in data management and analytics this year has been the release of [the first ISO-GQL standard on April 12](https://www.nebula-graph.io/posts/nebulagraph_enterprise_5.0_gql_support). This groundbreaking development in the graph database industry introduces a standardized graph query language, unifying the querying of graph databases and offering immense potential for enterprises.

# Why ISO-GQL is Important to Modern Enterprises

ISO-GQL's release is particularly relevant as it directly addresses several critical factors that underpin the success of modern enterprises. By providing a universal querying language, ISO-GQL ensures consistency and interoperability across different graph database platforms, which is crucial for data-driven decision-making. The efficiency of ISO-GQL in traversing and querying complex networks supports agility and innovation, allowing businesses to quickly adapt to market changes and innovate continuously.

ISO-GQL provides a standardized graph query language that unifies the querying of graph databases, which is crucial for several reasons:

- Standardization: ISO-GQL offers a universal querying language that ensures consistency and interoperability across different graph database platforms.
- Efficiency: Designed specifically for graph data, ISO-GQL enables efficient traversal and querying of complex networks, which is essential for applications requiring deep link analysis.
- Flexibility: ISO-GQL supports flexible data modeling, allowing enterprises to represent and query intricate relationships without the constraints of traditional relational databases.
- Scalability: Graph databases using ISO-GQL can scale horizontally, handling large volumes of interconnected data with ease.
Future-Proofing: Adopting ISO-GQL positions enterprises to stay ahead of technological advancements and industry standards, ensuring long-term compatibility and support.

# Top 10 Use Cases for GQL in Modern Enterprises
## 1. Property Graph Model
ISO-GQL defines a property graph model where nodes (vertices) and edges (relationships) can have properties (key-value pairs) associated with them. In social network analysis, platforms use property graphs to represent users (nodes) and their interactions (edges), with properties like user demographics and interaction types, facilitating detailed analysis of user behavior and network dynamics. LinkedIn uses property graphs to model its professional network, representing users as nodes and connections as edges with properties like job titles, companies, and skills. This allows LinkedIn to efficiently manage and query vast amounts of user data, providing personalized job recommendations and networking suggestions. This capability enables detailed and scalable modeling of complex relationships, enhancing data-driven decision-making and personalized user experiences.

## 2. Graph Pattern Matching (GPM)
ISO-GQL supports complex graph pattern matching, enabling users to specify intricate patterns to search within the graph data. In fraud detection, financial institutions can use GPM to identify suspicious transaction patterns, such as circular payment schemes or unusual connections between accounts, helping to uncover fraudulent activities. For example, JPMorgan Chase uses graph pattern matching to detect fraud by identifying suspicious transaction patterns and relationships between accounts. By analyzing these patterns, the bank can proactively prevent fraudulent activities. This enhances security and compliance by enabling the detection of complex fraud patterns and anomalies in real-time.
## 3. Query Performance and Optimization (QPP)

ISO-GQL includes mechanisms for query performance and optimization, ensuring efficient execution of complex queries. In e-commerce, platforms can optimize recommendation queries to provide real-time, personalized product suggestions to users, enhancing the shopping experience and increasing sales. Amazon optimizes product recommendation queries to provide real-time, personalized suggestions to users based on their browsing and purchase history. This improves customer satisfaction and drives sales by delivering fast, relevant recommendations and insights.

## 4. Data Manipulation

ISO-GQL allows for the creation, updating, and deletion of graph data, enabling dynamic and real-time data management. In IT infrastructure management, companies use data manipulation capabilities to continuously update the status and relationships of IT components, ensuring an accurate and current view of the infrastructure. Netflix uses data manipulation to continuously update its content library and user preferences, ensuring that recommendations are always current and relevant. This supports dynamic and agile data management, allowing enterprises to respond quickly to changing data and user needs.
## 5. Multi-Graph Joint Query
ISO-GQL supports querying across multiple graphs, allowing for the integration and analysis of data from different sources. In healthcare data integration, providers can perform joint queries across patient records, treatment data, and research databases to derive comprehensive insights for personalized patient care. Pfizer performs joint queries across clinical trial data, patient records, and research databases to derive comprehensive insights for drug development and personalized medicine. This facilitates comprehensive data integration and analysis, leading to better-informed decisions and innovative solutions.
## 6. Undirected Graph Support
ISO-GQL supports undirected graphs, which are useful for scenarios where the direction of relationships is not significant. In telecommunications network optimization, undirected graphs can represent symmetrical relationships between network nodes, helping to optimize network performance and reliability. This enhances network optimization and reliability, ensuring robust and efficient communication infrastructures.
## 7. Path Queries
ISO-GQL allows querying for paths between nodes, including shortest paths, all paths, and paths with specific constraints. In supply chain management, companies, such as DHL, use path queries to find the most efficient routes for transporting goods, considering factors like distance, cost, and time, thereby optimizing logistics and reducing costs.
## 8. Schema Flexibility
ISO-GQL supports flexible schema definitions, allowing for dynamic and evolving data models without rigid schemas. In enterprise search, organizations can continuously update and integrate new types of data from various sources, ensuring a comprehensive and up-to-date information retrieval system. Google uses schema flexibility to continuously update and integrate new types of data from various sources into its knowledge graph, enhancing search accuracy and relevance. This supports agile and adaptive data management, enabling enterprises to evolve their data models as needed.
## 9. Declarative Syntax
ISO-GQL provides a declarative query language, making it easier for users to specify what they want to retrieve without detailing how to retrieve it. In enterprise search, employees can use simple and intuitive queries to search across integrated knowledge graphs, retrieving relevant information quickly and accurately without needing deep technical knowledge. Salesforce uses declarative syntax to allow users to easily query customer relationship data, generating insights and reports without needing deep technical expertise. This empowers business users to access and analyze data independently, improving productivity and decision-making.
## 10. ACID Compliance
ISO-GQL ensures ACID (Atomicity, Consistency, Isolation, Durability) compliance, providing reliable transaction processing. In financial services, banks rely on ACID compliance to ensure the integrity and consistency of transactions, even in the event of system failures, thus maintaining trust and reliability in their operations.

# Conclusion
The technical characteristics of ISO-GQL, such as the Property Graph Model, Graph Pattern Matching, Query Performance and Optimization, and others, provide powerful capabilities for managing and querying graph data. These features enable modern enterprises to address complex data challenges across various domains, from fraud detection and social network analysis to supply chain management and IT infrastructure monitoring. By adopting ISO-GQL, enterprises can leverage the full potential of their graph databases, driving innovation, efficiency, and competitive advantage.

[NebulaGraph, as the first distributed graph database with native GQL support, empowers enterprises to unlock the full potential of their data and stay ahead in a competitive landscape.](https://www.nebula-graph.io/posts/enterprise_5.0_GA_announcement) If you’re interested in taking a trial, feel free to [contact us](https://www.nebula-graph.io/contact).


The ISO-GQL release introduces a standardized graph query language, unifying the querying of graph databases and offering immense potential for enterprises.

Top 10 Use Cases for GQL in Modern Enterprises


# What is GQL?

Graph Query Language (GQL) is a specialized language designed for graph databases, paralleling the role that SQL plays in relational databases. 



## Background 

GQL is the second language in the entire database field, having undergone approximately five years from the initial establishment of the project to its final release. Initially, scholar Alastair Green found that the graph database field was fragmented, with various query languages such as  Cypher, GSQL and PGQL. Recognizing the redundancy and need for standardization, Green advocated for a unified, standardized language for querying graph databases. His proposal garnered widespread support, with over 4,000 organizations and individuals participating in a vote, resulting in a 95% approval rate for the creation of a standard language for graph database queries.In May 2024, ISO officially released ISO/IEC GQL.


## Comprehensiveness 

GQL is a comprehensive language that includes Data Manipulation Language (DML), Data Definition Language (DDL), and Data Query Language (DQL), effectively covering all necessary aspects of database operations. This capability allows GQL to support the creation, deletion, modification, and querying of graph data, as well as the definition and modification of the structure of graph databases. GQL aims to provide a unified standard for querying and managing graph databases, thereby enhancing interoperability and reducing dependency on specific graph database vendors.


# What impact will GQL have?



### Enhancing the Importance of Graph Database Technology

The establishment of GQL as a standard underscores the significance of graph database technology. Since 2013, graph databases have been at the forefront of database technology trends.According to Gartner, 80% of data and analytics innovations will use graph technologies by 2025.


### Reducing Learning and Migration Costs

The market is replete with graph database vendors, each with their own query language, leading to high learning and migration costs. GQL standardization mitigates these costs by providing a unified language, facilitating easier transitions and switches between different graph database products.


### Promoting the Application and Development of Graph Databases

Graph databases have evolved through various stages, from initial confusion about the concept to widespread recognition of their problem-solving capabilities. Today, they have proven their value in applications such as public security, recommendation systems, data selection, and supply chain manufacturing. The standardization of GQL is expected to further promote their application and development.


### Encouraging "Thinking in Graph" 

Nowadays, graph databases have passed the capability verification phase and have arrived at a critical time where they are used to think about and solve problems. GQL standardization is crucial for promoting the concept of "Thinking in Graph" , enhancing efficiency and enthusiasm for new database products and languages.


### Active Engagement from Education and Academia

Currently, numerous universities both domestically and internationally are looking to collaborate with NebulaGraph to offer courses related to GQL, preparing students who are about to enter the workforce to understand and utilize this new database language.


# What challenges will GQL face?


Despite its potential, the promotion and application of GQL will face several key challenges:



### Adaptability Challenge for Database Vendors


Database vendors each have their own unique languages and architectural systems. Faced with the implementation of the new GQL language, how will these vendors respond? Some may choose to directly adapt, converting GQL into their own proprietary languages and implementing a conversion mechanism. However, this approach could lead to a significant decrease in performance, and as GQL continues to evolve, this adaptation method may gradually fail to meet new demands. Therefore, for database vendors, aligning their graph database products with GQL is an extremely challenging task. 

But for NebulaGraph, this is merely following a trend of technological integration, as NebulaGraph has been fully committed to supporting GQL for two years. From the very beginning of GQL's proposal and formulation, NebulaGraph has been deeply involved, frequently obtaining the latest information and continuously optimizing its underlying data architecture to ensure outstanding performance when executing GQL.


### Transformation Challenge at the Application Layer

For the application layer, retrofitting existing database products to accommodate GQL presents a challenge. Graph databases are typically used in online applications that require handling a large number of real-time queries, thus demanding extremely high stability. The design logic of most application vendors is to make as few changes as possible to the existing system. Consequently, asking them to replace all query languages with GQL involves a substantial amount of work.


### Talent Reserve Issue

GQL was just released on April 12th of this year, and currently, most people have limited understanding of GQL. Learning a new language and applying it in a real-world work environment requires a considerable amount of time. Therefore, building a talent pool becomes another challenge in promoting GQL.


### Inadequacies within GQL Itself

The V1 version of GQL still has room for improvement in areas such as modifying graph types, indexes, and primary keys, and it is anticipated that future versions will address these issues. We need to allow GQL ample time to become more refined and robust, and in the meantime, we also gain more time to adapt to the requirements of GQL.


# Conclusion


In summary, GQL as the standardized language for graph databases will not only enhance the importance of graph database technology and reduce learning and migration costs but also promote the application and development of graph databases, encourage "Thinking in Graph" and gain active participation from the education and academic sectors. 

Despite the many challenges GQL will face, overall, the future of GQL is full of hope and excitement. Because when we embrace GQL, we are not just adopting a new standard; we are stepping into a future where the possibilities are as vast as the connections within a graph. We must rise to challenges and harness the collective power of innovation to unleash the full potential of GQL.

GQL is setting a new standard for graph databases, unifying query languages and simplifying operations. It promotes "Thinking in Graph," enhancing efficiency and fostering innovation. Despite challenges, GQL's future is bright, offering a dynamic path for data management.

Graph Databases Revolutionized: Why GQL is the New Standard

We are excited to announce the General Availability of NebulaGraph Enterprise v5.0, a groundbreaking release that establishes [NebulaGraph as the first distributed graph database to offer native support for the Graph Query Language (GQL)](https://www.nebula-graph.io/posts/nebulagraph_enterprise_5.0_gql_support).This milestone represents the pinnacle of three years of focused research and development, showcasing our commitment to innovation and excellence in the graph database industry.

Recognizing the importance of GQL early on, we embarked on this ambitious project in November 2021. The initial phase involved a thorough analysis of the GQL standards, followed by extensive design discussions. Over the next few years, we engaged in multiple development iterations and nearly a year of rigorous validation, continuously refining our implementation as the standards evolved. Today, we are proud to unveil NebulaGraph Enterprise v5.0.

# Why Native GQL Support Matters More Than GQL Compatibility

Implementing GQL at the architecture level is a complex and challenging endeavor, requiring a well-designed architecture and significant enhancements across the metadata, computation, and storage layers of the database. You could refer to the enhanced kernel engine in [Announcing NebulaGraph Enterprise v5.0 RC release: Delivering Full-Fledged GQL Support](https://www.nebula-graph.io/posts/rc_release_of_nebulagraph_enterprise_v5.0).

Some might assume that implementing a new query language is as simple as syntactic translation or adaptation. However, our experience tells us otherwise. Pure syntactic adaptation is fraught with challenges. Existing graph languages, such as Gremlin and Cypher, performing syntax translation to GQL might be in lack of catalog and schema management, which are fundamental to GQL as it draws heavily from SQL standards.

Historical attempts to translate query languages have not been successful. For example, some graph database vendors that have dedicated effort to convert Cypher to its own query languages have seen little progress. This underscores the necessity of native GQL support at the architecture level for achieving optimal performance and full compliance with the standards.

# Key Enhancements in NebulaGraph Enterprise v5.0
## Performance Boosts Up to 3x Faster with 90% Less Memory Overhead

[NebulaGraph Enterprise v5.0 delivers a significant performance boost, achieving up to 3x faster query execution while reducing memory overhead by nearly 90%](https://www.nebula-graph.io/posts/technical_preview_nebulagraph_enterprise_v5.0#post-performance). This is evidenced by the results from the LDBC SNB Interactive benchmark, where the Enterprise v5.0 demonstrated an average speedup of 3.01 times compared to the previous version.

## Graph Projection: Efficient Subgraph Analysis

NebulaGraph Enterprise v5.0 introduces support for graph projection, a powerful feature that allows users to create subgraphs based on existing graphs or MATCH queries. This capability enables users to isolate and focus on specific portions of their graph data, making it more efficient to perform complex graph computations and queries. By working with subgraphs, users can significantly reduce the computational overhead and improve query performance, leading to faster insights and more responsive applications. 

## Multi-Level Permission Management
Security and compliance are paramount in modern data management. NebulaGraph Enterprise v5.0 supports multi-level permission management, offering fine-grained access control down to the property level. This hierarchical permission system spans service groups, schema, graphtype/graph, nodetype/edgetype, and property, ensuring that only authorized users can access sensitive data. This feature not only enhances security and compliance with data privacy regulations but also improves administrative efficiency by reducing the risk of human error.
## Query Optimization and Isolation
NebulaGraph Enterprise v5.0 introduces substantial advancements in query optimization and isolation, including query-level resource limits and index hints. The query-level resource limits allow each query statement to utilize a specified amount of CPU and memory resources, and users can individually set the response time for each query. The major benefit of this capability is that it prevents a few resource-intensive queries from monopolizing system resources and potentially bringing down the entire cluster. This granular control ensures that the system remains stable and responsive, even under heavy workloads. The index hints give users more control over query execution. By specifying which indexes to use, users can optimize query performance and ensure that the most efficient execution path is taken. These improvements are crucial for enterprises handling complex relational data where efficiency, consistency, and security are paramount.

## Upgraded UI Experience for Analysts and DBAs
The new UI experience of visualization tools in NebulaGraph Enterprise v5.0 offers significant improvements for both business analysts and DBAs:
- Explorer: Redesigned for better interaction and focus on analysis, the new Explorer interface allows users to save and load historical analysis results, making it easier to track and revisit previous analyses.
- Dashboard: The Dashboard will integrate alert monitoring and diagnostics, enabling quick root cause analysis. It will also support multi-tenant management and resource allocation, providing DBAs with powerful tools to manage and optimize their database environments.

# Conclusion

NebulaGraph Enterprise v5.0 represents a significant advancement in graph database technology, offering native GQL support to meet the growing demands of complex data environments. We invite you to explore the capabilities of NebulaGraph Enterprise v5.0 and join us in advancing the frontiers of graph database technology. [Reach out to us today!](https://www.nebula-graph.io/contact)


We are thrilled to announce that NebulaGraph Enterprise v5.0 is now GA! This groundbreaking release establishes NebulaGraph as the first distributed graph database to offer native support for GQL.

Announcing the General Availability of NebulaGraph Enterprise v5.0: The First Distributed GQL Database

In the digital age, recommendation systems have become an integral part of online experience, driving better user experience and engagement. A recommendation system, often integrated with ad serving systems, is designed to suggest highly relevant content or advertisements to users based on users’ profile and engagement history. However, the complexity of user interactions and preferences demands robust data management solutions. Enter graph databases—an innovative approach that enhances the efficiency and accuracy of recommendation systems. This blog explores how recommendation systems work and how graph databases empower recommendation systems, providing real-life examples and architectural insights.

# What are Recommendation Systems and How They Work
## Key Components of Recommendation Systems:
- User Data: Information about users, including their demographics, behavior, preferences, and past interactions. This data is crucial for understanding user interests and making personalized recommendations.
- Content Data: Information about the content or ads available for recommendation. This includes metadata, categories, keywords, and performance metrics.
- Recommendation Algorithms: The core of the system, these algorithms analyze user and content data to generate personalized recommendations. Common types include collaborative filtering, content-based filtering, and hybrid methods.
- Real-Time Processing: The ability to process data and generate recommendations in real-time, ensuring that suggestions are timely and relevant.
- Feedback Loop: Mechanisms to collect user feedback on recommendations (e.g., clicks, likes, shares) to continuously improve the accuracy and relevance of the system.

## Types of Recommendation Systems
Recommendation systems are powerful tools designed to analyze user behavior and preferences to deliver personalized content and suggestions. These systems operate by collecting extensive data on user interactions, such as browsing history, ratings, and purchase activities. Using this data, recommendation systems employ sophisticated algorithms to identify patterns and relationships within the data. 

Two common approaches are collaborative filtering and content-based filtering. Collaborative filtering analyzes the behavior and preferences of similar users to make recommendations; for example, if two users have a history of liking similar movies, the system might suggest a movie liked by one user to the other. Content-based filtering, on the other hand, focuses on the attributes of items and recommends items that are similar to those a user has previously enjoyed. By combining these methods, recommendation systems can generate highly personalized suggestions that cater to individual tastes and preferences. This tailored approach not only enhances the user experience by presenting relevant content but also drives higher engagement and satisfaction, ultimately benefiting both users and businesses.

# What are Graph Databases
## Definition and Structure
Graph databases are a type of NoSQL database designed to handle and represent complex relationships between data entities. Unlike traditional relational databases that use tables to store data, graph databases use nodes, edges, and properties to create a flexible and highly interconnected data structure. Nodes represent data entities, edges denote the relationships between these entities, and properties provide additional information about the nodes and edges. This structure allows graph databases to efficiently model, store, and query intricate relationships and dependencies within data. Graph databases are quite young compared with relational databases and well-known graph databases include Neo4j, NebulaGraph, Amazon Neptune, and TigerGraph.

They excel at managing complex relationships because their inherent design closely mirrors real-world networks, such as social connections, organizational hierarchies, and financial transactions. This enables rapid traversal and querying of relationships, providing powerful insights and enabling applications like fraud detection, recommendation systems, and network analysis to operate with high performance and scalability.

## Architectural Insights

1. Data Modeling:
    * Nodes: Represent users, items, categories, etc.
    * Edges: Capture interactions such as likes, views, purchases, etc.
    * Example: In a movie recommendation system, nodes could represent users and movies, while edges represent viewing history and ratings.
2. Querying:
    * Graph Traversal Queries: Efficiently find relevant items by traversing the graph.
    * Example: To recommend books, a query might traverse from a user node to books they’ve rated highly, then to other users who rated those books highly, and finally to other books those users have rated highly.
3. Performance Optimization:
    * Indexing and Caching: Improve query performance by indexing frequently accessed nodes and caching results.
    * Example: Caching the results of common recommendation queries can reduce latency and improve user experience.

# How Graph Databases Support Better Recommendation Efficiency and Accuracy

Graph databases, such as [NebulaGraph](https://www.nebula-graph.io/), are particularly well-suited for handling the complex relationships and interconnected data involved in both ad serving and recommendation systems. Here’s how they support efficiency:

1. Complex Relationships and Connections:
    * Graph Structure: Graph databases store data in nodes (entities) and edges (relationships), making it easy to model and query complex relationships.
    * Example: Users, ads, and their interactions can be represented as nodes, with edges capturing relationships like views, clicks, and purchases. [LinkedIn](https://www.linkedin.com/) uses graph databases to model professional connections, endorsements, and job recommendations. By understanding the intricate relationships between users, companies, and skills, LinkedIn can provide highly relevant job suggestions and networking opportunities.
2. Real-Time Recommendations:
    * Fast Traversal: Graph databases excel at traversing relationships quickly, enabling real-time generation of recommendations based on user behavior and preferences.
    * Example: Quickly finding similar users or content based on shared attributes or interactions. [Pinterest](https://www.pinterest.com/) leverages graph databases to recommend pins based on user interactions and the connections between pins, boards, and users. This allows Pinterest to deliver personalized content in real-time, enhancing user engagement.
3. Personalization and Targeting:
    * Rich User Profiles: Graph databases can store and query detailed user profiles, including their connections, behaviors, and preferences, allowing for highly personalized ad targeting.
    * Example: Identifying users with similar browsing patterns and recommending ads that performed well with similar users. [eBay](https://www.ebay.com/) uses graph databases to improve its recommendation engine by analyzing user behavior, purchase history, and item relationships. This enables eBay to provide personalized product suggestions, increasing the likelihood of purchases.
4. Scalability:
    * Handling Large Datasets: Graph databases are designed to handle large volumes of interconnected data, making them suitable for high-traffic environments.
    * Example: Managing millions of users and ads, and their interactions, without performance degradation. [Facebook](https://www.facebook.com/)’s social graph, which models the relationships between billions of users, posts, and interactions, relies on graph databases to provide scalable and efficient recommendations. This ensures that users receive timely and relevant content, even as the platform grows.
5. Data Integration and Enrichment:
    * Combining Data Sources: Graph databases can integrate data from various sources, enriching user profiles and improving recommendation accuracy.
    * Example: Combining browsing history, social media activity, and purchase history to create a comprehensive user profile.
6. Feedback Loop and Continuous Learning:
    * Adaptive Algorithms: Graph databases facilitate the continuous updating of user profiles and recommendation algorithms based on real-time feedback.
    * Example: Adjusting recommendations based on recent user interactions to improve relevance.

# Conclusion
In summary, graph databases enhance the efficiency of ad serving and recommendation systems by providing a powerful way to model, store, and query complex relationships. They enable real-time personalization, effective targeting, and scalability, ultimately leading to better user engagement and optimized ad performance. As demonstrated by industry leaders like LinkedIn, Pinterest, eBay, and Facebook, leveraging graph databases can significantly improve user engagement and satisfaction.


This blog explores how recommendation systems work and how graph databases empower recommendation systems, providing real-life examples and architectural insights.

From Data to Insight: Leveraging Graph Databases for Superior Recommendations

This RideWallet is a leading force in the urban mobility payment industry worldwide. Integrated on the world’s renowned mobility service platform, the RideWallet has seamlessly facilitated millions of transactions, ensuring that passengers can effortlessly pay for their rides and other mobility services throughout the ride. **In addition to the ride payment, it supports a wide range of payment methods, including credit/debit cards, mobile wallets, loans and various local payment options tailored to regional needs.** In a short sentence, the RideWallet originated from the mobility service and evolved into a comprehensive payment solution.

# Rapid Expansion in Latin America Brings Financial Risk Management Challenges

In recent years, the RideWallet has been expanding rapidly, particularly in the Latin American market; for example, in Mexico alone, the company has issued over 5 million loans. However, with the boost of the business, it faces significant challenges in financial risk management. **The increasing geographical footprint has led to a surge in data volume, necessitating a system that can deliver faster response times, heightened accuracy, and unwavering stability.** The company encountered several critical challenges in its financial risk management operations:

- **Real-time Risk Control for Loan and New Card Issuance**: The consumer loan business, aimed at individual applicants, experiences high concurrency due to a large user base. To ensure a good user experience during the application process, the risk control decision engine cannot tolerate query delays exceeding one second. This places high demands on the graph technology's performance.

- **Mid-loan and Card Usage Risk Control**: Given the company's focus on the Latin American market, particularly Mexico, the relatively lenient overseas loan and credit card usage policies pose significant risks. Some payment institutions do not even verify CVV codes, leading to frequent misuse of loan and credit card limits. Traditional risk control rules struggle to accurately assess risks during the usage process.

- **Fraud Ring Detection**: For personal credit businesses, the risk control department is particularly concerned about fraud rings. Compared to individual loan application fraud, organized fraud poses a much greater threat. Therefore, accurately identifying high-risk communities is crucial to minimizing financial losses.

# NebulaGraph: Delivering Real-Time, High-Performance Risk Management Solutions

To address these complex challenges, NebulaGraph provided a comprehensive and efficient solution. NebulaGraph supports real-time graph construction, enabling full-graph risk control based on real-time application data. **With its high-performance data processing engine, the system can handle ultra-high concurrency, real-time bulk writes, and queries, ensuring stable operation even during peak times.**

**In terms of performance, NebulaGraph boasts exceptional computational capabilities, completing queries and calculations within the decision engine's tolerable time frame, ensuring the effectiveness of real-time rules.** The system employs advanced graph computation algorithms, combining real-time and asynchronous methods to extract relevant subgraphs from application data for asynchronous computation and then reintegrate them. This approach not only enhances processing efficiency but also ensures data accuracy and real-time performance.

Furthermore, NebulaGraph offers elastic scaling capabilities, allowing online scaling to ensure uninterrupted business operations. **The system can smoothly expand from 3 nodes to 12 nodes, and further scale online as needed to accommodate business growth, ensuring flexibility in response to increasing business demands.**

# The RideWallet's Use of NebulaGraph for Risk Control

The RideWallet leverages NebulaGraph in several key areas:

- **Real-time Risk Control During Loan Application**: Using the graph database, the system performs real-time queries to check if the applicant's IP address is a known blacklisted IP or if it connects to numerous devices. It also checks within three hops if the contact information provided by the user links to any blacklisted users.

- **Real-time Risk Control During Loan Usage**: Based on the fund flow graph, the system queries whether the user's loan funds are transferred to accounts that do not comply with the loan's intended use.

- **Risk Community Detection**: Using offline graph computations (WCC, Louvain), the system identifies communities closely linked to blacklisted nodes with high concentrations of black points. It extracts community features, such as the presence of multiple accounts with unidirectional transactions, a high proportion of midnight transactions, and several nodes with high PageRank values. These features are then fed into machine learning models for risk control decision-making.

![image](https://www-cdn.nebula-graph.io/blogs/RideWallet%20system%20architecture.png)
*System Architecture of the RideWallet*

# Achieving Significant Improvements with NebulaGraph's Advanced Capabilities

By adopting NebulaGraph's solution, RideWallet's credit and payment departments achieved significant improvements in multiple areas:

- **Business Value**: The enhanced risk control capabilities met the business expansion requirements, handling 3.3 billion edges and 630 million nodes. Through complex computations, the multi-stage risk control capabilities for application, credit approval, and loan usage based on graph technology were significantly improved, addressing data quality issues and enhancing overall risk control quality.

- **Technical Excellence**: NebulaGraph provided a stable, low-latency, high-throughput graph cluster capable of real-time updates, queries, and handling asynchronous computation tasks with a 4:9:1 ratio. Its distributed architecture and advanced graph computation technology ensured excellent performance in high-concurrency and complex computational environments, maintaining business continuity and stability.

- **Elastic Scalability**: NebulaGraph's elastic scaling capability allowed the system to smoothly expand from 3 nodes to 12 nodes, and further scale online as needed to accommodate business growth. This flexibility ensured the system could respond to business growth at any time, avoiding performance bottlenecks and service interruptions due to delayed scaling.

In summary, NebulaGraph's outstanding performance and powerful graph computation capabilities helped the customer achieve efficient real-time full-graph risk control, significantly enhancing both business and technical value.



This article introduce how a RideWallet leverages NebulaGraph for its Risk Management and the business results that NebulaGraph brings.

A RideWallet Elevates Financial Risk Management with NebulaGraph

In the ever-evolving digital landscape, the choice of a database is not just a technical decision; it's a strategic one. The right database can be the cornerstone of a business's success, while the wrong choice can lead to inefficiencies, data loss, and even business failure. In this article, let’s explore the critical factors that should guide your decision when selecting a database for modern applications.
# Part 1: The Database Product
## Data Model
The first step in choosing a database is understanding the data model that aligns with your business needs. Whether you're dealing with structured, semi-structured, or unstructured data, the data model should reflect the nature of your data and how it will be used. Relational databases are suitable for structured data, document databases for flexible data models, and graph databases for scenarios that require analyzing complex relationships. Each type of database has its unique strengths and optimal use cases, and the choice should be made considering the specific requirements of the business.

Relational databases organize data into tables with relationships defined by primary and foreign keys. They are ideal for structured data that fits neatly into rows and columns, such as financial transactions, customer information, or inventory records. Graph database, like Neo4j or NebulaGraph, which uses nodes, edges, and properties to represent and store data. They are excellent for managing complex networks of connections, such as social networks, recommendation engines, or fraud detection systems. For instance, an e-commerce platform might store product information, user reviews, and purchase history in documents. The flexibility of document databases allows the platform to change the data structure, such as adding new fields for product ratings or social media links, without significant reworking of the database schema.

## Scalability
As your business grows, so will your data. Scalability is crucial for future-proofing your database. As businesses grow, the data needs will inevitably expand, and choosing a database that can scale efficiently and cost-effectively is crucial for maintaining performance, reliability, and overall user satisfaction. Netflix's migration from Oracle to Cassandra is a well-documented case that highlights the importance of scalability when selecting a database for business. The shift allowed them to handle the exponential growth of their user base and data volume without compromising performance. 
- **Handling Growth**:
Businesses need to anticipate growth in data volume and user load. A scalable database ensures that the system can handle increased demand without significant rearchitecting or downtime.

- **Performance**:
As the user base grows, the performance of the database can directly impact the user experience. A scalable database maintains performance levels by distributing load effectively.

- **Cost Management**:
Scalable solutions often provide more cost-effective ways to grow. Horizontal scaling with commodity hardware can be cheaper than vertical scaling with high-end servers.

- **Reliability and Availability**:
Scalable databases often come with built-in mechanisms for fault tolerance and high availability, which are crucial for maintaining service levels and user trust.

## Performance
Database performance is integral to a business’s success across various dimensions, including customer experience, operational efficiency, real-time analytics, resource optimization, and customer support. Investing in high-performance databases and regularly optimizing them can yield significant benefits and provide a competitive edge in the market. A database that can't deliver quick query responses will slow down your applications and frustrate your users. For example, e-commerce websites like Amazon or eBay rely heavily on database performance. When customers search for products, add items to their cart, or complete a purchase, these actions interact with the database. If the database is slow, customers may experience delays, leading to frustration and potentially abandoning their shopping carts. Financial institutions like JPMorgan Chase or Goldman Sachs rely on real-time data analytics for trading, risk management, and customer transactions. An underperforming database can delay these analytics, leading to slower decision-making and potential financial losses. For instance, in high-frequency trading, even milliseconds of delay can translate into significant financial impacts.

## Reliability
Reliability refers to the ability of a database system to perform its functions correctly and consistently over time, especially in the face of failures or unexpected conditions. It is about the database's durability and consistency. Consistency ensures that data is accurate and reliable across all nodes in a distributed system. Companies like Walmart use data analytics to track sales, manage inventory, and forecast demand. Reliable data is essential for these analytics to be accurate and actionable. Take the case of Uber, which switched from PostgreSQL to a custom MySQL setup to ensure data consistency across its global operations, despite the high write and read demands. 

​​Investing in a reliable database system is not just a technical necessity but a strategic business decision. By ensuring that their databases are reliable, businesses can not only avoid potential pitfalls but also gain a competitive edge in their respective industries.

## Security
The security of a database is paramount for any business, as it affects a wide range of operational, legal, and reputational aspects. Here are some key reasons why database security is crucial, along with real-life examples to illustrate each point:
- **Protection of Sensitive Information**
Databases often contain sensitive information such as personal data, financial records, and proprietary business information. Securing this data is essential to prevent unauthorized access and misuse.
Companies like Equifax store vast amounts of personal and financial data. In 2017, Equifax experienced a data breach that exposed sensitive information of 147 million people. The breach led to significant financial losses and reputation damage.
- **Compliance with Regulations**
Various industries are subject to stringent regulations regarding data protection. Non-compliance can result in hefty fines and legal repercussions.
Hospitals and clinics must comply with HIPAA regulations in the United States. A breach of patient data can lead to substantial fines and legal action. For example, Anthem Inc. faced a $16 million settlement in 2018 after a data breach exposed the personal information of nearly 79 million people.
- **Preventing Financial Loss**
Data breaches can lead to direct financial losses from theft, fraud, and the costs associated with addressing the breach. Additionally, businesses may face indirect losses from reputation damage.
- **Ensuring Business Continuity**
A security breach can disrupt business operations, leading to downtime, loss of productivity, and operational inefficiencies.

# Part 2: Cost, Community and Support
## Cost
When selecting a database solution, cost is often a primary concern for businesses. The choice between open-source and commercial editions can significantly impact the overall expense. Open-source databases, such as MySQL or PostgreSQL, are generally free to use, which can be appealing for startups and small businesses with limited budgets. However, the hidden costs associated with open-source solutions often lie in the need for skilled personnel. Companies may need to hire expensive experts to handle installation, customization, and ongoing maintenance, which can add up over time. On the other hand, commercial database solutions like Oracle or Microsoft SQL Server come with licensing fees that can be substantial. However, these costs are often offset by the comprehensive support and maintenance provided by the vendor, reducing the need for in-house expertise and allowing businesses to focus on their core operations.

## Community and Support
The availability of community and support can make or break a database solution for many businesses. Open-source databases benefit from vibrant communities of developers and users who contribute to forums, documentation, and code repositories. This can be an invaluable resource for troubleshooting and best practices. However, relying solely on community support can be unpredictable and time-consuming, especially for mission-critical applications. Commercial databases, on the other hand, come with dedicated support teams from the vendor, offering guaranteed response times and expert assistance. This level of support can be crucial for businesses that require high availability and cannot afford downtime. Additionally, commercial vendors often provide training and certification programs, ensuring that your team has the skills needed to effectively manage the database.

# Part 3: Pitfalls to Avoid

When selecting a database for modern applications, companies often encounter several pitfalls that can lead to inefficiencies, higher costs, and even data loss. Here are some common pitfalls and strategies to avoid them:

- **Ignoring Business Needs**: Choosing a database without aligning it with the specific needs of the business is a common mistake. For instance, not considering the nature of the data, the expected data volume, or the required query performance can lead to a system that doesn't meet the application's requirements.

- **Underestimating Scalability**: As businesses grow, so does their data. Failing to select a database that can scale horizontally or vertically to accommodate this growth can lead to performance bottlenecks and increased costs down the line.

- **Neglecting Performance Optimization**: Performance issues can arise if a database is not properly optimized. This includes not only the database configuration but also the queries, indexing strategies, and hardware resources.

- **Overlooking Data Quality**: Poor data quality can lead to inaccurate insights and decision-making. Companies must implement data validation rules and regularly cleanse their data to maintain accuracy and consistency.

- **Insufficient Security Measures**: Data breaches can be costly. It's crucial to choose a database that supports robust security features, including encryption, access controls, and regular security updates.
Lack of Disaster Recovery Planning: Without a solid backup and recovery plan, companies risk losing data due to hardware failures, human errors, or natural disasters. Regular backups and a clear recovery strategy are essential.

- **Inadequate Resource Allocation**: Databases require maintenance and management. Not allocating sufficient resources, including personnel and budget, can lead to poorly managed databases that don't perform as needed.

- **Rigid Data Models**: Some databases have rigid data models that don't accommodate changing business requirements well. It's important to select a database that can adapt to evolving data structures and relationships.

To avoid these pitfalls, companies should conduct a thorough analysis of their data requirements, projected growth, and compliance needs. By taking a comprehensive approach to database selection, companies can choose a solution that will support their business needs both now and in the future.

# Conclusion
Selecting a database is a complex decision that requires a deep understanding of your business needs and the capabilities of the database solutions available. By considering factors like data model, scalability, performance, consistency, reliability, security, cost, you can make an informed decision that will serve your business well into the future. Remember, the database is the backbone of your applications; choose wisely.

This article explores the critical factors that should guide your decision when selecting a database for modern applications.

Database Selection: Critical Factors for Modern Applications

Snapchat, the camera-first social media platform, promotes authentic connections between its users through ephemeral photos, videos, and AR experiences. As of June of 2024, Snapchat reported having more than 432 million daily active users worldwide, ranking among the top mobile platforms in the US. **The user base growth poses growing challenges for the underlying infrastructure, requiring efficient tools to handle complex data workloads to navigate its vast, dense, interconnected social graph.** Snapchat’s Infrastructure team was seeking an efficient database solution to manage and analyze the massive interconnected user data, aiming to enhance their friend recommendation use case.

# The Challenge: Performance Bottleneck Restricts Real-time Friend Recommendations

To create better recommendations for friend suggestions, the underlying system needs to compute heuristics that leverage users and relationships, stored in aggregate and anonymized as metadata in vertices and edges. During the retrieval stage of the recommendation pipeline, these heuristics are used to compute affinity to the query user, and often require multiple hops, a task where graph databases excel compared to traditional relational databases. Moreover, the graph model is more natural for users to express data relations. At the end of 2022, Snapchat's Infrastructure team began exploring several graphDB solutions to examine their feasibility and performance.

# The Solution: NebulaGraph’s High Availability and Performance Make It the Ideal Choice

**After a thorough evaluation of various graph databases, the team decided to adopt NebulaGraph as it integrates seamlessly with their in-house environment and uniquely satisfies their production requirements of serving diverse online requests.**

NebulaGraph stood out as the team’s top choice with the following technical advantages:
- **High availability and resilience to failures**: NebulaGraph commits to delivering reliable performance with a 99.95% uptime, ensuring smooth operation during updates and upgrades.. Its high availability stands to remain unaffected in the face of failures such as node or network breakdowns, and even zone failures. This resilience is critical, considering the common occurrence of failures in large-scale clusters.
- **High performance**: NebulaGraph was among the very few top-performing databases, distinguished by its ability to store and process graphs with trillions of vertices and edges, while delivering impressive QPS and latency. It ensures highly simultaneous access, swift graph traversals, and optimized memory utilization.
- **Horizontal scalability**: NebulaGraph's shared-nothing distributed architecture offers linear scalability. This feature allows Snapchat to independently scale computing and storage, achieving desired performance at a cost-effective rate.
- **Seamless integration with Kubernetes**: NebulaGraph, with its cloud-native nature, can be effortlessly hosted within a Kubernetes environment, including AWS EKS, GCP GKE, Azure AKS, and more. Moreover, NebulaGraph holds full compatibility with the Kubernetes Operator Framework. This compatibility significantly reduces Snapchat's maintenance costs while ensuring uninterrupted service. The ability to run seamlessly in a Kubernetes environment further enhances its high-availability, offering customers peace of mind.
- **AAA security compliance**: NebulaGraph enhances Snapchat's network security through authentication, authorization, and accounting, safeguarding their user data. NebulaGraph supports both local and LDAP authentication that authorizes each user a role comprising various privileges, including metadata and data read/write access, and even fine-grained vertex and edge level permission management. Additionally, NebulaGraph logs user activities and database operations for future auditing. It also secures client-to-NebulaGraph and intra-NebulaGraph node traffic with TLS encryption. To protect data privacy, NebulaGraph supports TTL (Time-To-Live), ensuring that expired data is automatically and permanently removed from the database. Users can also delete data by dropping and clearing the database, providing control over data retention and privacy.

# The Result: Enhanced Performance, Reduced Costs and Simplified Maintenance

With the power of NebulaGraph, Snapchat has rolled out new friend recommendation workloads in production with some highlighted results, including:
- **Performance Amplification**: NebulaGraph's efficient handling of massive data sets has enabled Snapchat to employ new distributed online graph query algorithms, previously unattainable in traditional KV-store databases, while ensuring user data is stored in aggregate and anonymized as metadata in vertices and edges. This has led to a noticeable increase in new friendships formed through friends-of-friends recommendations. 
- **Large Graph Support**: NebulaGraph’s sharded architecture allowed ingestion of 12TB graphs and real-time queries at p90 <20ms. 
- **High Availability**: NebulaGraph has maintained 99.95% uptime since its initial deployment, and has shown it’s capable of handling large-scale ingestion, online query, through multiple traffic spike events. This has led to reduced operational overhead for the Snapchat Infrastructure team.
- **Cost-Effective Hardware**: Leveraging more affordable machine types for scaling, Snapchat can host NebulaGraph more economically compared to using a single, powerful machine with equivalent capacity.

**“We evaluated 9 graph DB solutions over the last year and found NebulaGraph capable of meeting our data size, query SLO, and QPS needs. NebulaGraph’s native Kubernetes support also makes it a nice fit to Snapchat’s underlying multi-cloud service mesh infrastructure. Since launch, we've thrown the book at NebulaGraph, adding 3 production clusters with more complex workloads and spiky online traffic patterns. Each time, it's scaled effortlessly, exceeding our expectations.” - Martin Qian, Sr. Manager Infrastructure at Snap.**

# Looking Ahead: Evolving the Entire Infrastructure with NebulaGraph

Moving beyond friend recommendations, Snapchat's Infrastructure team plans to leverage NebulaGraph in three new use cases:
1.	ML Edge Feature Storage: Eliminating the overhead of materializing costly multi-hop ML features, NebulaGraph can be used to power real-time inference and training queries.
2.	In-app User Engagement: Storing and querying relationships between users, content, lenses, locations and more will enable training graph convolution neural nets and relationship embeddings, boosting personalization.
3.	Off-app Analytics: Tackling identity resolution for Ads Attribution, and further data exploration opportunities beyond the app.

Additionally, NebulaGraph enables data sovereignty by allowing Snapchat to manage its own deployments of database instances. This shared-nothing data model ensures all of Snapchat's user data is maintained within Snapchat Infrastructure's controlled environments. This guarantees that enterprise data sovereignty is upheld and maximizes adoption flexibility.

This blog introduces why and how Snapchat leverages NebulaGraph for enhancing their real-time friend recommendations.

Snapchat Enhances Friend Recommendations with NebulaGraph


# Summary


NebulaGraph is an open-source, distributed, and easily scalable native graph database capable of hosting very large datasets containing hundreds of billions of points and trillions of edges and providing millisecond queries.

Thanks to their unique data model and efficient query performance, graph databases play an important role in many business scenarios. Here are several typical business applications of graph databases:

* **Knowledge Graph**: Businesses and organizations need to build domain knowledge graphs from various data silos to support intelligent Q&A and semantic search.
* **Social Network Analysis**: Social network platforms need to analyze relationships, interests, and interactions between users to offer personalized recommendations and targeted advertisements.
* **Financial Risk Control**: Financial institutions need to monitor anomalous transaction activity, detect potential fraud, and assess credit risk.
* **Recommendation system**: E-commerce and media platforms need to provide personalized product or content recommendations based on the user's browsing history, purchase records, and other information.

NebulaGraph Cloud is a **fully managed cloud service** designed for NebulaGraph, and this article will detail how to realize cost reductions and efficiencies in synergy with AWS offerings.(For further instructions, please [refer to the AWS Marketplace product landing page](https://aws.amazon.com/marketplace/pp/prodview-wctboqxrwqkjy?sr=0-1&ref_=beagle&applicationId=AWSMPContessa)


# Platform architecture and components





## Platform architecture
![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/941.webp)



NebulaGraph Cloud is designed and built on K8S with the following considerations:

* K8S's Operator mode enables the automation of all internal cluster activities, significantly reducing development costs.
* K8S offers a range of abstraction capabilities to streamline the management of compute, storage, and network resources, which can help users avoid vendor lock-in and achieve complete cloud-agnostic
* K8S's inherent features such as scaling up and down, scheduling framework, resource monitoring, and service discovery simplify various management operations.


## Service component


NebulaGraph Cloud is composed of two main parts:


### Control Plane


The control plane provides user console access for organizational management, user rights control, database management, network security settings, monitoring, alerting, and various other features designed to assist users in managing their NebulaGraph clusters.


### Data Plane


The data plane receives commands from the control plane, including resource scheduling, provisioning, versioning, horizontal scaling, specification adjustments, backup and recovery, observability, metering, and additional functions.


## Cost-optimized design


Illustrated with a sample database configuration:


```
apiVersion: apps.nebula-cloud.io/v1alpha1
kind: Database
metadata:
  name: db123456
  namespace: db123456
spec:
  provider: aws
  region: "us-east-2"
  k8sRef:
     name: "k8s-ml65nmjg"
     namespace: "k8s-ml65nmjg"
  tier: standard
  graphInstanceType: NG.C4.M32.D0
  graphNodes: 1
  StorageInstanceType: NG.C4.M32.D50
  StorageNodes: 1
  version: v3.8.2c
```


The database instance is defined using a Custom Resource Definition (CRD), and a database controller manages its operations within the control plane. Dependent compute resources are defined using the CRD NodePool, which is an abstraction of the compute resources of each cloud vendor, and is used to manage NodeGroups in AWS's EKS.As previously mentioned, NebulaGraph is a compute-storage separated architecture, so a database instance will correspond to two NodePool objects.

```
# Graph resource pool
apiVersion: apps.nebula-cloud.io/v1alpha1
kind: NodePool
metadata:
  name: gnp-7d0b156e
  namespace: db123456
spec:
  databaseRef:
    name: db123456
    namespace: db123456
  instanceCount: 1
  instanceType: x
  k8sRef:
    name: k8s-ml65nmjg
    namespace: k8s-ml65nmjg
  labels:
    platform.nebula-cloud.io/database-name: db123456
    platform.nebula-cloud.io/graph-pool: db123456-f24a
  provider: aws
  region: us-east-2
  zoneIndex: 0
# Storage resource pool
apiVersion: apps.nebula-cloud.io/v1alpha1
kind: NodePool
metadata:
  name: snp-59e9cc63
  namespace: db123456
spec:
  databaseRef:
    name: db123456
    namespace: db123456
  instanceCount: 1
  instanceType: x
  k8sRef:
    name: k8s-ml65nmjg
    namespace: k8s-ml65nmjg
  labels:
    platform.nebula-cloud.io/database-name: db123456
    platform.nebula-cloud.io/Storage-pool: db123456-un6g
  provider: aws
  region: us-east-2
  zoneIndex: 0
```



## Specification adjustments

Choosing the appropriate instance size is a more challenging task than expected for both users and service providers. Users frequently struggle to determine the optimal instance size for their needs. For example, as a user's data grows from 100GB to 1TB, they may be uncertain about the required number of CPU cores or the amount of memory necessary at each stage. It is up to the user and the SA to collaborate and ascertain these requirements.

When using fully managed cloud services, we provide an instance specification tuning function, which supports individual tuning of Query nodes or Storage nodes to meet the needs of users in terms of cost control and performance standards. Users can determine whether a single-node processing bottleneck has been reached based on the historical curve of the monitoring panel, and the cloud platform will also issue an internal alert.

![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/8d951d16b31294fcfbf25667fe48bc48.png)





## Horizontal expansion and contraction


Horizontal scale-up and scale-down supports individual tuning of the Query node, which can be regarded as a stateless service. This node can be scaled up or down to manage fluctuations in query traffic. Similarly, the Storage node, responsible for storing graph data and providing read and write capabilities, can also be scaled, with several data slices distributed across each Storage node. Each instance of expansion or contraction necessitates data migration and data slice rebalancing, thereby requiring meticulous operation.

Before proceeding with node expansion, it is essential to prepare the corresponding computing resources. The database controller will send the current desired number of nodes to the infra-controller to trigger the NodeGroup expansion of EKS. Here we do not enable CA or Karpenter for the following reasons:

* Scale-up/down decisions depend on specific cluster conditions and resource requests, and if these conditions are not met, it may not perform the intended scale-up/down operation
* Cross-availability scenarios do not guarantee the expansion and contraction of a given region
* The Pending Pod-based model is not tightly integrated with our business systems.

![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/1725438154945.jpg)

## Automatic elastic expansion and contraction


Supporting different workloads through automatic scaling up/down is a critical goal for us. Since computing and storage are separated, we can increase or decrease CPU and memory resources based on the utilization of each service node.

The Elastic Scaling Service architecture is as follows:

Every 10 minutes, the Elastic Scaling Service calculates the amount of resources that should be allocated to a database instance based on historical and current values of the monitored data and ultimately determines whether compute resources should be increased or scaled down. It can drive both horizontal scaling and vertical scaling (adjusting instance specifications) to ensure that business peaks are popped ahead of time. We will continue to make continuous improvements on this foundation to shorten the time to scale up and scale down by incorporating more metrics and proactive prediction strategies.

![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/873527167f86b6180154c413ddf8e499.png)


# Design for Efficiency Improvement





## Network security access

![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/2debb93e640f5e28273aeef9229a9230.png)

Currently, we offer two types of network connections to our users: network whitelisting and private link private connections. To ensure network security and simplify configuration steps, we introduced a proxy service, ngproxy, between the database instances and the Network Load Balancing (NLB), which takes full advantage of the functionality provided by the NLB. 

The NLB is capable of setting a PPv2 header on every transmitted packet. ngproxy parses these packets to verify whether the user's endpoint ID matches the ID configured in the console, with any mismatched requests being rejected. The same principle applies to the public network. The same principle applies to the whitelisting of public network access. Only if the source address matches the address in the whitelist will it be allowed to pass.






## Backup and recovery


Data backup serves as the primary defense against data loss, whether due to hardware failure, software error, data corruption, or human error, ensuring the safety of your data.

We provide users with both manual and scheduled backups and upload the backup data to AWS's object storage S3. We do not use a backup recovery solution based on cloud storage snapshots, as SST-based backup recovery is more rapid and does not depend on the cloud vendor's underlying services. Note that DDL and DML statements will be blocked during data backup, so it is recommended to perform backup operations during low business peak periods.

Backup data catalog structure:


```
backup_root_url/
- BACKUP_2024_08_20_16_31_43
├── BACKUP_2024_08_20_16_31_43.meta
├── data
│   └── 10.0.0.12:9779
│       └── data0
│           └── 5
│               ├── data
│               │   ├── 000009.sst
│               │   ├── 000011.sst
│               │   ├── 000013.sst
│               │   ├── CURRENT
│               │   ├── MANIFEST-000004
│               │   └── OPTIONS-000007
│               └── wal
│                   ├── 1
│                   │   ├── 0000000000000000001.wal
│                   │   └── 0000000000000000005.wal
.....
│                   ├── 30
│                   │   ├── 0000000000000000001.wal
│                   │   ├── 0000000000000000004.wal
│                   │   └── 0000000000000000005.wal
└── meta
    ├── __disk_parts__.sst
    ├── __edges__.sst
    ├── __id__.sst
    ├── __indexes__.sst
    ├── __index__.sst
    ├── __last_update_time__.sst
    ├── __local_id__.sst
    ├── __parts__.sst
    ├── __roles__.sst
    ├── __spaces__.sst
    └── __tags__.sst
- BACKUP_2024_08_20_19_02_35
```


Recovering data to a new instance of the program, so that you can take full advantage of the elastic expansion of resources on the cloud, specify a point in time after the backup set to quickly pull up a new database instance, and the user can be verified that the new database instance is working properly after the release of the old instance.




## High availability


For those who demand the highest level of service reliability, we offer a cross-availability zone disaster recovery solution. In NebulaGraph, a zone is a collection of service nodes that divide multiple Storage nodes into manageable logical zones to achieve resource isolation. At the same time, the platform service controls the access of Query nodes to replica data within the designated Zone, thus reducing network latency and traffic costs incurred by cross-availability zone communication.

One of the main challenges in managing stateful services across availability zones is the issue of zone affinity of storage volumes. To address this issue, we have taken the approach of placing a NodeGroup in each availability zone. This avoids the possibility that a newly expanded Node may be incorrectly placed in an incorrect availability zone, resulting in the Pod not being scheduled.

Drawing from past user experiences, we also support the solution of expanding capacity individually in a certain availability zone. The cloud-native community's HPA-like solution only solves the problem of the quantity after expansion, but it cannot be expanded to a specified region. Scaling according to the business traffic carried by each region can effectively improve the quality of service. If a region observes a sudden surge in QPS, the elastic scaling service of the data plane will allow the scaling of Query nodes in this region.

![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/a6c9b11cc02fcf83606ea5d3c5ee37f5.png)


# Practical exercises on the cloud




**Welcome to [NebulaGraph Cloud](https://cloud.nebula-graph.io) .** After initiating a subscription and creating a database, the next step demonstrates several ways to access the database:

## Visualization tools

Select an instance from the Database list, go to Data->Graph graph space management, and click Explorer Graph to enter the visualization application.

![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/89b9e3f86138ba8b72bcc6417c3e31e6.png)

Clicking on the Console in the upper right corner opens the console and allows you to execute queries for GQL statements.
![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/da4da5f0e3f63450cffd982bd39791fc.png)

## network whitelisting

On the Overview page of the database instance, click Connect and select the Public method.
![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/60437776c9f1654c165a796afbab220b.png)
When network whitelisting is not configured, the database instance cannot be accessed directly from the public network.


```
$ ./nebula-console -addr nebula-graph-ncqqo19eh0aus73e4un6g.aws.cloud.nebula-graph.io -port 9669 -u dbaas-test@vesoft.com -p $PASSWORD -enable_ssl
Welcome!
(dbaas-test@vesoft.com@nebula) [(none)]> show spaces;
+------------------------+
| Name                   |
+------------------------+
| "genshin"              |
| "hanxiaotest"          |
| "movie_recommendation" |
| "nba"                  |
+------------------------+
Got 4 rows (time spent 602µs/222.883326ms)
Mon, 02 Sep 2024 16:52:39 CST
```

## Privatelink private network connection

Follow the configuration steps for **Create Private Link Endpoint** to determine the VPC ID and Subnet ID where the service resides.

Run the command to create the Endpoint:


```
aws ec2 create-vpc-endpoint --vpc-id <YOUR-VPC-ID>  --region us-east-2 --service-name com.amazonaws.vpce.us-east-2.vpce-svc-04f25889c855f891b --vpc-endpoint-type Interface --subnet-ids  <YOUR-SUBNET-IDs>
```


Log in to the AWS console to view Endpoint status
![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/7cc3c33b5f8e6be1464ce3af6e4d2e0a.png)

Test access within the business VPC
![image|561x499](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/af0b663545e30935f090334da7bb2dac.png)
Next, you can maintain the data on the cloud through official eco-tools according to your business needs.


# Summary and outlook


This paper describes the architectural details of landing a fully managed cloud service for NebulaGraph on AWS based on cloud-native concepts, focusing on how AWS offerings can yield substantial benefits to users, and provide a new solution that combines cost and elasticity advantages for using NebulaGraph in the cloud.

While ensuring the quality of our services, we will persist in exploring possibilities to **reduce user costs and increase ease of use.** Our goal is for users to pay only for the resources they use, **implementing the concept of cost in every detail.**

Beta trials are currently underway, with a maximum spend of $1 per month, and you can subscribe via [AWS Marketplace ](https://aws.amazon.com/marketplace/pp/prodview-wctboqxrwqkjy?sr=0-1&ref_=beagle&applicationId=AWSMPContessa)  or [Sign up for an account](https://cloud.nebula-graph.io).

If you are interested in NebulaGraph Cloud, please [join the group](https://join.slack.com/t/nebulagraph/shared_invite/zt-2k1eawak2-00D7XxOIZr8mDt0R4JfsSw) to unlock more DBaaS-related content. 




This paper describes the architectural details of landing a fully managed cloud service for NebulaGraph on AWS.

NebulaGraph Cloud on AWS：Auto Scale, Start Free

We are excited to announce the **beta preview of NebulaGraph Cloud** on AWS Global. Starting today, businesses and developers can experience the power of NebulaGraph Cloud for **up to $1 for a month**. This exclusive beta preview will run until the end of November, 2024, offering a unique opportunity to explore a scalable and high-performance graph database technology.

NebulaGraph Cloud excels at managing super-large graphs, making it an ideal solution for small businesses seeking robust data visualization tools. With NebulaGraph Cloud, users can effortlessly visualize and analyze complex datasets, unlocking valuable insights and driving informed decision-making.


![image](https://www-cdn.nebula-graph.io/blogs/dbaas-overview.png)
*The platform overview of NebulaGraph Cloud*

# Exclusive Beta Preview Offer:
- **Powerful Scalability and Performance**: NebulaGraph Cloud effortlessly supports billions of nodes and trillions of edge while ensuring millisecond-level response times, even under high concurrency. Your system is guaranteed to be always online! 

- **End-to-End Schema Management and Visualization**: Experience a seamless, no-coding-required journey from schema management to data import (including support for S3 data sources) and visual graph exploration. NebulaGraph Cloud offers an all-in-one solution that simplifies the graph database experience, making it accessible for users at any skill level.

- **Developer-Friendly Multi-Language Support**: NebulaGraph Cloud provides comprehensive support for multiple client languages, ensuring a smooth and efficient development process. Whether you’re a seasoned developer or just getting started, you’ll find our platform intuitive and accommodating.

- **Real-Time Observability**: Keep an eye on your database’s performance with real-time monitoring of operational status and resource consumption. NebulaGraph Cloud’s observability empowers you to maintain optimal system health and performance effortlessly.

- **Flexible and Cost-Efficient Pricing**: With NebulaGraph Cloud’s pay-as-you-go model, you only pay for what you use, ensuring maximum value for your investment. During the trial period, you could experience the full capabilities of NebulaGraph Cloud with only up to $1 per month!

![image](https://www-cdn.nebula-graph.io/blogs/dbaas-virtualization-2.png)
*NebulaGraph Cloud offers visualization for data*

![image](https://www-cdn.nebula-graph.io/blogs/dbaas-visualization.png)
*Data visualization in 3D mode*

To participate in the beta preview, you should [register](https://cloud.nebula-graph.io/login) as soon as possible. The beta preview will end on *Nov 30th*, so don't miss this chance to experience NebulaGraph Cloud's capabilities. 

***To learn more about the functionalities of beta preview, please refer to the [Terms of Use](https://www.nebula-graph.io/cloud_beta_terms).***

# How to Register:
- Visit [https://cloud.nebula-graph.io/login](https://cloud.nebula-graph.io/login)
- Sign up for the beta preview
- Start exploring NebulaGraph Cloud for up to $1 a month

For more information about NebulaGraph Cloud, please contact our service team at [cloud-service@vesoft.com](cloud-service@vesoft.com).



The beta preview of NebulaGraph Cloud on AWS Global goes live.

NebulaGraph Cloud Launches Beta Preview: Experience Graph Database as a Service for Up to $1 for a Month

Since NebulaGraph’s [joint introduction with LlamaIndex](https://www.nebula-graph.io/posts/graph-RAG) in August 2023, Graph RAG has been at the forefront of a technological revolution. It addresses the limitations of conventional search enhancement techniques by providing a more contextually aware and data-trained approach, ensuring that the responses delivered are not only precise but also well-informed.

Today, at the VLDB 2024 LLM+ KG Workshop, we are thrilled to announce the groundbreaking platform designed under the Graph RAG idea to simplify the creation of knowledge applications without the need for programming skills, NebulaGraph RAG.

![image](https://www-cdn.nebula-graph.io/blogs/wey_presenting.JPG)

*Wey Gu, the GenAI lead at NebulaGraph, presenting NebulaGraph RAG at VLDB 2024 LLM+ KG workshop*

# What is NebulaGraph RAG?
NebulaGraph RAG is a minimalistic knowledge application builder that puts the power of Graph RAG technology at your fingertips. It's the go-to solution for users to create search engines, chat bots, and content generation apps through a simple dialogue interface. By activating and circulating internal knowledge, NebulaGraph RAG maximizes its value, turning insights into actions.

# Why NebulaGraph RAG?
For many enterprises, the rich expertise and business insights of team members were often confined to a few, creating knowledge silos and consultation bottlenecks. For domain experts without a computer science background, GenAI technologies like DAG, Workflow, Agent, and RAG can be daunting, posing a significant barrier to the adoption of AI capabilities. As a result, only personnel of the data or AI department typically utilize these advanced tools, akin to how only a few people master complex BI and advanced statistical functions in Excel.

NebulaGraph RAG lowers the barrier to entry for these advanced tools, empowering every employee to create and optimize applications based on their domain knowledge. Guided by an intuitive dialogue interface, users can construct and refine applications as naturally as conversing with a colleague. From next-gen search engines to customer service Q&A systems, report generators, and troubleshooting tools, NebulaGraph RAG integrates cutting-edge technologies with simplicity at its core.

![image](https://www-cdn.nebula-graph.io/blogs/RAG-user-interface.png)
*User Application Interface: GraphRAG Answer Referenced Graph Context*

## Main Benefits for Users
- **Simplified Custom Solution Creation**: Enterprises can effortlessly build customized knowledge applications tailored to their complex needs, optimizing internal workflows without delving into technical details.

- **Inclusive Knowledge Application Building**: With a well-designed user interface and streamlined processes, employees can independently create knowledge bases and build applications. This inclusive approach accelerates the flow of information and resources within the enterprise, enhancing decision-making speed and accuracy.

- **Seamless Integration of Cutting-Edge Technology at Reduced Costs**: By leveraging the latest advanced RAG and Graph RAG technologies without additional development or costly training, businesses can quickly innovate in knowledge management and application creation, accelerating business innovation and value creation.

- **Instant Access to Internal Knowledge Bases**: The search and Q&A capabilities of NebulaGraph RAG enable businesses to rapidly construct search engines for internal knowledge bases, increasing the speed and efficiency with which employees access critical information.

![image](https://www-cdn.nebula-graph.io/blogs/RAG-build-apps.jpg)

*App building interface: Set up, maintain, and optimize apps through natural language*

# Ready to Elevate Your Knowledge Management into RAG Apps?

Compared to other toB RAG products on the market, NebulaGraph RAG excels not only in its exceptional Graph RAG capabilities, but also user-friendliness and accessibility. While other solutions may require extensive programming knowledge and technical expertise, NebulaGraph RAG ensures that even non-technical users can harness the power of advanced AI technologies. Leveraging NebulaGraph RAG will reduce costs of knowledge management, and surely foster a more inclusive and innovative work environment.
Interested in transforming your enterprise's knowledge application capabilities? [Fill out the form](https://www.nebula-graph.io/contact) for a free trial!

We are thrilled to announce NebulaGraph RAG,  the groundbreaking platform designed to simplify the creation of knowledge applications without the need for programming skills

Tag