We are thrilled to unveil the latest release of NebulaGraph Enterprise v3.6.0. This version brings a series of exciting features and improvements, significantly enhancing the user experience for enterprise clients in specific use-cases. Accompanying this release are NebulaGraph Explorer and Dashboard v3.6.0, offering an optimized visual graph exploration and maintenance experience. This post will delve into the key features now supported by NebulaGraph Enterprise v3.6.0.

## Introduced Zone Management
Zone management is a pivotal feature that equips enterprise users with superior reliability and security for their data management, thereby ensuring business continuity. A Zone, referred to as a logical rack of storage nodes in NebulaGraph, segregates multiple Storage nodes into manageable logical zones for resource isolation. Specifically, the introduction of zone management empowers enterprises to achieve:
- Improved safety and reliability: Zone management allows customers to seamlessly achieve disaster recovery for multiple machine rooms and avert data loss.

- Lower cost and better efficiency: Zone management provides customers with superior control over maintenance costs and system efficiency. Customers can anticipate a significant reduction in cross-machine room access traffic and latency, while the system's throughput sees a marked improvement.

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

## New Enhancements and Improved Usability
In addition to Zone management, NebulaGraph Enterprise v3.6.0 has introduced a series of crucial features and improvements.

- Boosted efficiency of data exploration and analysis: this updated version now supports HTTP2 protocols and SSL mutual authentication (mTLS), fortifying the security of data transmission. Simultaneously, we have fine-tuned our support for INNER JOIN queries, providing customers with greater flexibility in data querying. Plus, the introduction of the FIND SINGLE SHORTEST PATH function empowers customers to swiftly pinpoint the single shortest path.
- Upgraded performance stability: the optimization of deep queries and Aggregate operators has been taken to the next level, thereby accelerating the query speed and efficiency.
- High availability: The addition of the 'partial success' monitoring indicator ensures that business operations, such as recommendations, remain uninterrupted, even if individual nodes fail. Furthermore, we have refined the reliability mechanisms of RAFT: in the event of a node's disk failure and subsequent inability to write, the system triggers a re-election, guaranteeing the cluster's continued service provision.
- Improved usability: With the latest fixes and enhancements, this version now offers more flexible configuration management and a more user-friendly experience. Now, when adjusting a user, customers can independently modify the password or whitelist.

## Augmented NebulaGraph Explorer and Dashboard
NebulaGraph Explorer now boasts support for CAS login authentication and three innovative message types, thereby enhancing compatibility, optimizing high availability, and streamlining usability.

The NebulaGraph Dashboard has been upgraded to support Zone cluster management, graph space size capacity warning management, and kernel permission management. These enhancements allow customers to manage and monitor their graph database systems with greater ease and efficiency. Moreover, the dashboard now facilitates the analysis of historical slow query statements, pinpointing the cause of slow queries with precision. Additionally, the NebulaGraph Dashboard now offers more adaptable configurations in terms of installation and deployment, enabling customers to deploy flexibly in line with enterprise security requirements.

![image](https://www-cdn.nebula-graph.io/pic-upload/NebulaGraph_3.6_dashboard.png)

## Get started
In essence, NebulaGraph Enterprise v3.6.0 continues to cement its status as a distributed graph database designed for handling super large-scale graphs with milliseconds of latency. With the added support for zone management, NebulaGraph Enterprise now offers customers heightened security, improved efficiency, and more cost-effective maintenance.

We're thrilled to present this enterprise-grade feature in NebulaGraph Enterprise v3.6.0, addressing our customers’ demands for high data reliability and consistency. We invite you to [reach out to us](https://www.nebula-graph.io/contact) for a trial.

**About Vesoft**

Vesoft is devoted to the development of NebulaGraph, an open-source, distributed and scalable graph database. With the ability to handle super-large-scale data sets with hundreds of billions of nodes and trillions of edges while maintaining millisecond-level query latency, NebulaGraph is trusted by leading corporations worldwide across sectors such as banking, financial services, e-commerce, telecommunications, and more. From financial risk management to real-time recommendations and knowledge graph creation, NebulaGraph excels in diverse business scenarios. Headquartered in Cupertino, California, Vesoft is committed to empowering enterprises with stable and reliable infrastructure software. Get started for free at [https://www.nebula-graph.io/](https://www.nebula-graph.io).



We are thrilled to unveil the latest release of NebulaGraph Enterprise v3.6.0. This version brings a series of exciting features and improvements, significantly enhancing the user experience for enterprise clients in specific use-cases.

Announcing NebulaGraph Enterprise v3.6.0: Zone Management Added to Upgrade Business Security and Efficiency

The [2023 State of Fraud report](https://www.signifyd.com/ecommerce-fraud-prevention-best-practices-statistics-trends-report/%C2%A0) by Signifyd indicates that cases of online fraud are increasing at an alarming rate. E-commerce sites, for example, experienced a 71% increase in bot attacks, and fraudulent orders grew by 34%. 

Even worse, scammers are now using new technology like artificial intelligence (AI) to automate fraud. This is bad news for any business, regardless of size or industry. Our recommendation for decision makers like yourself, is to start with the HOW. 

How do you safeguard your assets when fraudsters are adopting new technologies to attack traditional security methods?

Not to worry, graph analytics is filling the void that has overwhelmed the traditional approaches. This superior method of identifying and preventing online fraud is already working for the organizations that have embraced it. You too should make the switch. 

Let’s understand why this is important. 

# What is graph analytics?

To understand graph analytics, it is important to briefly visit how graph databases work. A typical graph database, whether a fully commercial or [open source graph database](https://nebula-graph.io/), stores data as connections rather than tables and indexes. Each database has nodes which represent different data points. Examples of data points can be details like phone numbers, addresses, or devices. Each data point is then linked to one another by a line, also called an edge. These lines can represent data transfers, phone calls, email messages, or other information linked to the nodes. Therefore, a graph database looks like a connected network. 

Now, graph analytics is the technique of studying these connected data points to find relationships and patterns. Through graph analytics, analysts can see how different data points interact within a network. It reveals the strength of each interaction and how information flows throughout the network. 

Graph analytics also prioritizes the context around data points. It assumes that no data point acts in isolation, and that certain data points can influence the rest to varying degrees. This is different from traditional analytics that calculates averages and frequencies rather than how data points affect each other. 

From what we have been seeing, fraudsters share information with each other through platforms in places like the dark web. An example of such information could be how-to tutorials for new hacking and scamming techniques. They also tend to cooperate with each other to maximize on lucrative or high-stakes targets. 

While the fraudsters’ activities may be difficult to trace, their behaviors in the real world are not. They show patterns that graph analysis can detect. This is why graph analytics have become crucial in fraud detection. 

# Strengths of graph analytics in fraud detection
Graph analytics is well suited to fraud detection because of the nature of fraudulent activities. Some online scammers act alone, but most frauds are committed by a group of people, or a fraud ring. 

A typical fraud ring may comprise a handful of individuals or thousands of members across the world. Fraud rings can target a wide range of businesses, e.g., banks, retailers, insurance companies, currency exchanges, etc. The scammers typically use different techniques to hide their identities and locations, making them difficult to track. But they cannot hide from graph analytics. 

Using machine learning algorithms, graph analytics can identify a fraud ring and reveal its connections. For example, it can spot fraudulent activities in credit card transactions or wire transfer records. Graph analytics empowers investigators to see how fraud rings operate. 

Here is a brief breakdown of the specific strengths that make graph analytics superior:

* The visual representation of graph data is more intuitive to interpret than charts or spreadsheets
* The hidden relationships between fraudulent profiles and activities become clear
* Machine learning algorithms reduce the manual tasks of scanning and analyzing data
* Fraudulent actors are identified faster and more accurately based on real-time data.

# How a typical graph data model in  graph analytics works (for fraud detection)
When used in fraud detection, a graph data model acts as a virtual detective that finds evidence of fraud. It links individuals, transactions, and financial institutions involved in crime. Then, it compares these connections with previously identified fraud patterns to find similarities or anomalies. 

Let's consider a money laundering pattern as an example. One person wants to transfer large amounts of money without being detected by banking systems. The recipient also wants to get the funds without detection. The sender usually divides the funds into smaller portions. They also open several accounts with different banks to set up the transfers. Similarly, the recipient prepares several accounts to appear as though they are receiving payments from different clients. 

At a glance, these transactions may appear normal and continue to flow without problems. But with graph analytics, the connections between the sender and recipient become clear. The graphs will show how the money flows from a single sender to a single recipient through multiple channels. This is a common pattern of money laundering, where money generated by criminal activities appears legitimate. 

Graph analytics can also determine if such fraudulent activities are expanding rapidly, e.g., new criminal rings emerging in unexpected locations. It reveals shared data points, e.g., the same devices or email addresses accessing multiple banks or websites. 

In terms of e-commerce fraud, graph analytics can alert businesses about frequent chargebacks or transaction reversals from specific customers. These patterns indicate that the customers intend to keep purchased goods without paying for them, which is a criminal offense. 
# The key approaches that graph analytics employ to identify fraud
There are four approaches that data scientists use to identify fraud using graph analytics, as we’ll explain below: 

## 1. Querying 

Graph databases require a graph query language to extract and modify data. An example of a query language is NebulaGraph’s [nGQL](https://docs.nebula-graph.io/3.0.0/3.ngql-guide/1.nGQL-overview/1.overview/). These are specialized programming languages that enable graph analysts to ask questions and derive valuable answers from their databases, such as: 

* How many individuals are transacting with a known fraudster?
* How far apart (in miles) are transactions of $10,000? 
* How many of those transactions were conducted at 3AM in the morning?

Using such questions, graph analysts can identify any data points of interest and determine how they are related. The queries can be as detailed as possible, e.g., differences between a shipping address and a billing address on specific orders. They can also analyze the contents of a checkout basket to find anomalies in purchasing patterns. These patterns may be difficult to see without graph technology. 
## 2. Machine learning
The specific form of machine learning that is utilized in this context is what we call supervised machine learning. So what is supervised machine learning? This is a process that classifies the data used to train a graph analytics model. This means assigning labels to the training datasets and allowing the machine learning model to learn and adapt. 

A common example of supervised machine learning is image recognition. This is where data scientists label the training images, e.g., photos of a bus. Then, the model is shown photos of all kinds of vehicles (planes, cars, trains, etc.) and learns how to identify a bus. 

In fraud detection, graph analysts can label training data as fraud or non-fraud. For example, a fraudulent transaction can be tagged and fed into the ML model. A tag can be a particular tax haven location which signals fraud. Using this tag, the model can analyze all transaction data and pick out all matching incidents. 

This approach is particularly helpful to track money laundering activities. Data scientists can tag the training datasets with parameters such as: 

* User identities
* Frequency of purchases
* Transfer amounts
* Internet Protocol (IP) addresses, etc.

## 3. Graph Algorithms
A graph algorithm is a mathematical tool used to detect patterns in graph databases automatically. It can identify specific qualities and connections between data points in ways that graph queries might miss. Some examples of graph algorithms include: 

* Centrality algorithms: These detect the most influential individuals or data points in a network, e.g., accounts with the most frequent chargeback activities on a payment platform.
* Community detection algorithms: These identify data points that have the most connections, e.g., transaction patterns that show signs of a fraud ring. 
* Similarity algorithms: These identify data points that have matching qualities, e.g., clusters of accounts that are linked to the same email addresses. 
* Link prediction algorithms: These predict connections between two data points, e.g.,how likely a suspicious account activity will turn out to be fraud, based on established patterns.

There are numerous other algorithms that apply to graph analytics. Data scientists can customize these algorithms to match specific use cases and derive detailed insights. This means that they can keep up with changing fraud tactics before they impact an organization.
## 4. Real-time analytics
Some types of fraud are extremely time-sensitive, such as phone-based scams targeting senior citizens. With graph analytics, such types of fraud can be detected in real time. For example, phone communications can be scanned in real-time based on the scam callers' patterns. 

The calls are automatically redirected to a fraud detection team. The call recipient can also see an alert on their devices saying that the caller is a potential scammer. 

# Conclusion

According to the [Federal Bureau of Investigations (FBI)](https://www.fbi.gov/contact-us/field-offices/springfield/news/internet-crime-complaint-center-releases-2022-statistics), the Internet Crime Complaint Center (IC3) received fewer scam reports in 2022. However, the value of the money lost in these reports increased almost by 50%. 

This increase is attributed to an emerging trend where scammers are targeting citizens who are over 60 years old, who have retirement savings and investments in large amounts. What we learn here is that scammers are constantly evolving their techniques to increase their fraudulent returns. 

Because of the increasing sophistication by frauds, it’s important that your organization’s fraud detection approaches are always a step ahead. As we have seen, graph analytics will get the job done. 

Remember that traditional fraud detection methods rely on stored data, which requires intensive human resources to categorize and analyze it for patterns. Graph analysis, however, automates databases through machine learning. It reveals patterns from the data that traditional analysis methods may fail to detect. This is why the switch to graph analytics is essential for a robust organizational fraud detection strategy. 

[Get Started](https://docs.nebula-graph.io/3.6.0/#getting_started).


Explore graph analytics: a key tool in detecting fraud by analyzing connections and patterns in data. Understand how it differs from traditional analytics and its role in identifying complex fraud schemes in today's interconnected digital world.

Fraud Detection with Graph Analytics

Happy Thanksgiving! We know it's a bit early to kick off the festivities, but we can't wait to share our heartfelt gratitude and blessings with you!

![image](https://www-cdn.nebula-graph.io/pic-upload/Banner-Thanksgiving05.jpg)

This year marks 5th anniversary of NebulaGraph. With your support and contribution, NebulaGraph has made fantastic growth on its maturity and performance. More than ever, we've seen our community flourish with new members exploring the capabilities of NebulaGraph, sharing their unique use cases and best practices. And even better, many have even contributed codes to NebulaGraph, driven by passion and dedication. We can't be more grateful to all your support, contribution and commitment. As a token of gratitude, we are excited to launch the program "Celebrating Thanksgiving with NebulaGraph", inviting all community members to celebrate our collective achievements and blessings from our journey so far.

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

The program will last until Nov 30 and below are the instructions of the program. Remember, what we are thankful the most is always **YOU**!

- **Claim Your NebulaGraph Graph Pioneer Badge**

Complete the [NebulaGraph Thanksgiving Quiz](https://forms.gle/L9Ud7CzHDXvhyXVp6) (10 questions). Anyone who gets 60 points will receive the NebulaGraph Graph Pioneer Badge.

![image](https://www-cdn.nebula-graph.io/pic-upload/Badge-NebulaGraph-pioneer.png)

⭐️ A tip: Adding NebulaGraph to your LinkedIn skills, or sharing the badge on social media, will earn you an additional set of Digital Stickers! Don't forget to **@NebulaGraph** when you're posting.

- **Tell Us What We Can Optimize**

Fill out the [survey](https://forms.gle/zSezFKLiApvRYDZ58) to rate NebulaGraph features and performance! Shouting out where NebulaGraph can improve will award you a NebulaGraph Product Champion Badge!

⭐️ A tip: Sharing your unique experience with NebulaGraph will stand you a chance to win a $50 Amazon gift card!

![image](https://www-cdn.nebula-graph.io/pic-upload/Badge-NebulaGraph-champion.png)

The Story Acceptance Criteria
- Theme: The article must be factual and related to the NebulaGraph database, and contains no unrelated content.
- Type: We welcome best practices, selection journey, performance tuning, and similar topics.
- Content: The story should be well-structured, logically clear, and well-written. The inclusion of diagrams and charts is encouraged where appropriate.
- Word count: Over 800 words.
Shoot an email with the subject of "Celebrating Thanksgiving with NebulaGraph" to devrel@vesoft.com; we will surely get back to you soon!

*Note: NebulaGraph reserves the right to use all stories submitted through this program and may share them across public accounts and other content channels. However, the original author will retain the copyright of the story.*

- **A Special SWAG Pack for Contributors**

If you're already a NebulaGraph contributor and have had a Pull Request (PR) merged, you're eligible to receive a contributor badge and a physical SWAG pack! Please paste the link to your personal GitHub profile page or the link to the PR merged [here](https://forms.gle/Lsf4PrUpxHCocvNJ9), we will reach out to you soon!

Are you excited about the program? Join us to celebrate! 🎉


We're excited to launch the program Celebrating Thanksgiving with NebulaGraph, inviting all community members to celebrate our collective achievements and blessings from our journey so far.

Celebrating Thanksgiving with NebulaGraph

As you most probably know, a graph database is designed to store data as connections rather than tables. These connections are nodes or points on a graph, or lines depicting relationships between data points. 

Graph databases look like a network linking various pieces of data, revealing complex patterns and variations. Graph data can power a typical machine learning model by capturing and leveraging intricate relationships between data points. This creates the foundation for the use of graph databases in AI applications. 

According to research by [MarketsandMarkets](https://www.marketsandmarkets.com/Market-Reports/graph-database-market-126230231.html), the graph database market is expected to grow by 20.2% annually. This high growth is primarily propelled by the increasing demand among businesses to develop applications that are fueled by interconnected data . The most familiar example of such applications is a product recommendation engine, common across e-commerce sites. 

And now as we enter the era where more organizations are leveraging artificial intelligence to build applications, the significance of graph technology becomes even more pronounced. 

So it’s highly likely that you are on a quest to explore the utilization of graph databases in AI applications, and this guide is here to offer you precisely that solution. 

Let’s explore how businesses are using graph databases like NebulaGraph for AI applications.  

# Benefits of using graph databases in AI applications

Graph machine learning offers unprecedented data insights, which can add tremendous value to a business. 

These are the key benefits that organizations are gaining as a result of using graph databases to power AI applications: 

## Improving data analytics

Data scientists can use graph algorithms to reveal complex patterns hidden in datasets. Graph data is rich with connections and relationships, which give a clearer understanding of organizational information. 

This leads to better business operations, e.g., hyper-targeted marketing campaigns and streamlined manufacturing workflows. 

## Improving application speed and performance

Compared to traditional tabular databases, graphs offer training data that is more user-friendly for AI and ML algorithms. 

Graph technology can accelerate deep learning processes for businesses that have vast amounts of data. This means that real-time applications built on graph algorithms become more responsive.

Developers can build AI apps faster using graph technology, and end users can enjoy a seamless experience when they interact with these apps. 

## Improving AI accuracy 

Graph machine learning connects relevant data points, meaning that applications yield more precise responses to prompts and queries. 

Developers can build AI applications with graph analytics to increase transparency, so they can see the inner workings of the neural network. 

In addition, data scientists can study the nodes and relationships in the AI model. They can create a highly accurate AI mode when they are able to identify how the data is accessed and processed.  

# How do graph databases work with AI applications? 

Artificial intelligence (AI) applications use vast amounts of data to generate insights. These insights are the related data points or context that the AI model links together automatically. 

Using graph technology, data scientists give context to the neural networks that power applications. 

Here are the major ways that graph technology enhances AI. Please note that these approaches apply both when you are using a commercial graph database option or an [open source graph database](https://nebula-graph.io/): 

## Graph databases offer connected features which drive accuracy

Accuracy is everything in matters of data, and graph databases do a great job here. Connected features are the metrics that show the link between two data points or nodes in a graph database. 

Graph machine learning models become more accurate with more connections. These connected features are critical in artificial intelligence models that detect criminal behavior, such as online fraud. 

Criminals tend to hide their online activities to avoid detection, but their activities are all connected. Graph analytics enable data scientists to see patterns that they may otherwise miss without the help of a graph database. This enables law enforcement authorities to accurately predict and prevent fraud.  

## Graph databases provide context for efficiency

Most organizational data is stored in tables with rows and columns, e.g., a spreadsheet. Machine learning algorithms can use tabular data for training models, but this requires a lot of computing power and human intervention. This means that the algorithm training process becomes slow and expensive. 

Graph machine learning, however, makes AI training more efficient. Graphs store data as nodes and lines rather than tables and indexes. This allows data scientists to train models on already connected data, and this accelerates machine learning pipelines. 

## Graph databases provide a foundation for credibility

[AI hallucinations](https://zapier.com/blog/ai-hallucinations/) are a common problem, where a tool like ChatGPT may present incorrect information as fact. This usually happens because of insufficient data or low quality training data. 

Unfortunately, AI hallucinations can erode trust, making it more difficult for individuals and companies to rely on AI outputs. 

Graph technology is one way to overcome this problem. Since training data is represented as nodes and lines, data scientists can trace which elements the model uses to generate its responses. 

This is particularly important for predictive applications in industries such as finance or healthcare. AI applications in these industries need to be credible to avoid ethical problems.

## Graph databases provide context for decisions

This is possible specifically through knowledge graphs. But first, what is a knowledge graph? 

We define a knowledge graph as an interconnected dataset that has contextual meaning. To put it in a much simpler way, knowledge graphs are used to link relevant information together, just as a human would use past experience to make a choice. 

A knowledge graph uses underlying data to add meaning (context) to the end user's query. The graph algorithms essentially decide which data is relevant to the keyword. This enables users to find exactly what they're searching for in their data. 

An example is the [Thomson Reuters Knowledge Graph Feed](https://www.thomsonreuters.com/en/press-releases/2017/october/thomson-reuters-launches-first-of-its-kind-knowledge-graph-feed.html). It finds relationships between billions of data points to help customers make investment decisions. 

# Emerging fields where graph databases can power AI applications

Graph technology enables data scientists to see how neural networks function. They can build AI applications that are more accurate and transparent. 

Organizations can then use these applications to make faster and better decisions. The following are the major use cases that demonstrate how graph databases function in real-world applications. 

## Fraud detection

Data science plays a critical role in online fraud detection. [Fraud rings](https://www.securitymagazine.com/articles/97824-fraud-rings-detecting-and-defeating-cybercriminal-networks) cultivate different digital personas and false identities to trap unsuspecting victims. 

They then disappear after stealing identities or money, often without a trace. However, graph technology can effectively identify patterns from how fraudsters behave online. One fraud ring can have thousands of data points, e.g., fake social media profiles, online transactions, fraudulent addresses, etc. 

Since graph algorithms can run at a large scale, fraud detectors can use link prediction techniques to identify suspicious user patterns across numerous online platforms. Therefore, they can spot fraud rings and prevent incidents in real-time. 

## Product recommendations

Graph databases are commonly used in recommendation engines. These can be e-commerce websites, hotel booking sites, product comparison platforms, etc. Graph algorithms find links between customer purchases, product searches, and reviews. They also find similarities between different types of customers on an eCommerce platform. 

This interconnected data is what informs the product recommendations. This data powers features like "frequently bought together", "frequently viewed together", or "buy again". Combined, these features increase opportunities for upselling, cross-selling, and repeat sales. An example is [eBay's ShopBot](https://medium.com/@rjpittman/ebay-shopbot-beta-under-the-hood-bedf69157a70), which is linked to Google Assistant to improve customer search results. 

## Social networks

Graph technology plays a vital role in social networks in two main ways. First, it identifies how users are interconnected on the platform, e.g., who has the highest engagements and influence, suspended or inactive accounts, etc. 

Secondly, graph data can identify fake profiles or bots that skew user data. Bot accounts often inflate the active user numbers by automatically reposting or sharing content. However, graph algorithms can identify fake accounts by examining the complex patterns around their behavior. 

For example, a genuine, highly-engaging account and a bot account have different qualities or relationships with other users. A real account has higher two-way engagement than a bot account. The difference in engagement enables platforms to filter out the fake accounts. 


## Location services 

Applications that link to location services need to provide relevant information to users on demand. Examples of such information can be traffic and weather reports, live streaming content, or pest alerts for farmers. 

Location services are also used in marketing campaigns to target customers with content, depending on where they are. Location information is essentially the context behind these applications. 

Graph analytics can determine location connections through subscriber identity module (SIM) tracking and GPS sensors. 

## Regulatory compliance

From a data science perspective, regulatory compliance is a highly dynamic process. Companies accumulate sensitive user data from numerous endpoints, all of which must be protected by the highest privacy standards. 

For example, the General Data Protection Regulation (GDPR) compliance is difficult for businesses. [Over 1,000 businesses](https://www.consultancy.uk/news/31493/four-years-on-companies-still-struggle-with-gdpr-compliance) were fined for noncompliance in 2022. 

Unfortunately, personal data is usually spread out in many different repositories. It can be housed in data centers, on-premise servers, employee accounts, etc. 

With graph technology, your organization can easily connect all the places where sensitive data resides. These connections make it possible for compliance measures to apply across all the data. They also allow a business to delete all personal data if customers request it. 

Other areas of use include robotics, Internet of Things (IoT),Enterprise Content Management, Mobility, and Digital Asset Management. In robotics, for example, adaptive robotics require artificial intelligence and machine learning to process their environment. These machines use data to keep functioning when their surroundings change or if a component breaks down. An example is the Flexiv Rizon adaptive robot, an AI-powered robotic arm used in manufacturing industries. Graph databases are used to store the data that adaptive machines generate. These include object recognition data from sensors, or positioning data from global positioning system (GPS) integrations. They can also be used to simulate and predict the behavior of the robot.  

# Conclusion 

Graph databases uncover hidden patterns and connections that traditional databases may miss.

This rich structure enables AI applications to make more context-aware, accurate predictions. The result is improved user experiences, enhanced data understanding, and more effective decision-making across various industries.

In essence, graph databases empower AI to harness the power of interconnected data.

If your business is looking for more ways to leverage big data in AI applications, then you need to start incorporating graph databases as an essential pillar across your AI development ecosystem.[ Get started](https://docs.nebula-graph.io/3.6.0/#getting_started). 

Find out why graph databases hold the key to unlocking the full potential of AI applications. Uncover opportunities to make the most of your data and spur growth.

Graph Databases: The Hidden Key to Unlocking the Full Potential of AI Applications

Author: Aqi, a developer at Arch team of [SMY Cloud](https://www.smycloud.com/)

Aqi is a community member of NebulaGraph who has done system refactoring many times. According to Aqi, migrating from OrientDB to NebulaGraph might be the most difficult one and below he shares the journey of the migration.

# The Reason for Migration

OrientDB was plagued by performance bottlenecks and single-point issues. In addition, the legacy system's tech stack couldn't support elastic scaling, and its monitoring and alerting facilities were inadequate. Thus, upgrading to NebulaGraph became a necessity.

*I will detail the specific pain points we encountered in a subsequent article, so I won't elaborate further here.*

## Migration Challenges Identified

* Complexity and contextual vagueness: the system was developed on OrientDB back in 2016, which is quite dated. Plus, we have no clue of the historical backgrounds of the system building.
* An uncharted territory of business: the requests from the Big Data team were passed onto us in a sudden, and we hadn't been involved in this aspect of the business before.
* Unfamiliar technology stack: it was our first touch with graph databases: a concept foreign to the entire team. We had no previous experience with both OrientDB and NebulaGraph, and most of the legacy system was written in Scala. Additionally, it used HBase, Spark, Kafka, all of which were relatively unknown to us.
* Time urgency: we were asked to complete the refactoring within 2 months  ;apparently, we were racing against time.

All the challenges above tell that we were in unfamiliar waters with both the business and the technology stack.
# The Technical Blueprint

## Research Undertaken

Given our unfamiliarity with the business, what research we had done to step in the situation?

* External Interface Review: We examined all external interfaces of the system, which included the interface name, its use, request volume QPS, average consumption time, and caller (services and IP).
* Core Workflow Review: We created an architectural diagram of the legacy system, and flowcharts for the important interfaces (approximately 10).
* Environment Review: We identified the projects that needed modifications, application deployments, MySQL, Redis, HBase cluster IPs, and sorted out the current online deployment branches.
* Trigger Scenarios: We determined how the interfaces were triggered by which business scenario, ensuring each interface was covered by at least one scenario. This would further support future functionality verification.
* Transformation Plan: We carried out feasibility analyses for each interface, planning how to transform them (changing OrientDB statements into NebulaGraph query statements), and how to revamp the graphing (writing process).
* New System Design: We created an architectural diagram and core process diagram for the new system.
## Project Target Aligned

Our target was to transition the data source of the graph database from OrientDB to NebulaGraph, refactor the legacy system to a unified Java tech stack, and support horizontal service scalability.

# Overall Solution Confirmed

We adopted a fairly aggressive approach as the solution was designed to be a 'once and for all' fix to facilitate future maintenance:

* Rewrite the underlying legacy system (starting at the interface entry point), ensuring the impact was manageable.
* Unify the Java tech stack and integrate with the company's unified service framework to enhance monitoring and maintenance.
* Make clear boundaries of the basic graph database application to simplify future integrations with the graph database for upper-layer applications.

*Note: The diagram was created during the research phase; the detailed one won’t be illustrated as it pertains to business specifics.*

# Project Phase Plan

Manpower invested: 4 developers, 1 QA developer

The main items and their duration are as follows:

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


# Grayscale Plan Designed

![image](https://github.com/vesoft-inc/nebula/assets/38887077/b8ecf799-de0b-4262-a9eb-05cb0d99b83e)

## Overall Strategy

* Write Requests: We employed synchronous dual writing.
* Read Requests: We gradually migrated traffic from smaller to larger volumes, ensuring a smooth transition.

## Grayscale Phases

|Phase|1|2|3|4|5|6|7|
|:----|:----|:----|:----|:----|:----|:----|:----|
|Volume|0%|1‰|1%|10%|20%|50%|100%|
|Number of grayscale days|2|2|2|5|2|2|-|
|Important node description|Synchronous dual writing, traffic playback sampling and comparison until 100% passed; |    |    |Pressure test required in this phase |    |    |    |

Notes:

* We used a configuration center switch for control, allowing us to switch back at any moment if issues arose, with recovery in seconds.
* Missed read interfaces had no impact on the project, only changes would have an effect.
* We used parameter hash values as keys to ensure consistency in results for multiple requests with the same parameters. A hit in grayscale was confirmed if abs(key) % 1000 < X (0< X < 1000, X is dynamically configured).

A side note: When refactoring, the most crucial part is the grayscale plan. Our grayscale plan this time could be regarded as a well-designed one: before the volume increase in grayscale phase, we used real-time online traffic to asynchronously compare data. Only after the comparison passed successfully did we proceed with the volume. This comparison phase took much longer than expected (in reality, it took 2 weeks and we discovered many issues).

# Data Comparison Plan Settled

## Missed grayscale data

The process for missing grayscale is as follows:

![image](https://github.com/vesoft-inc/nebula/assets/38887077/95fa106b-dd38-4807-83e1-6123d65690f7)

We started with the old system to see whether the sample was hit (sample ratio configuration 0% ~ 100%). If the sample was hit, the message queue (MQ) would be sent and dealt with within the new system. The new system interface would be requested and the data returned by the old system would be compared in JSON format. If the data matches, then the comparison would succeed. On the contrary, if the comparison is inconsistent, a notification would be sent in real time.

The same is true in reverse!!

# Data Migration Plan Designed

* Full data (historical data): We wrote scripts for full migration: if inconsistency happens during the launch period, the data for the past 3 days which was stored in MQ would be consumed 
* Incremental: Synchronous dual-write (there are few write interfaces, and the write request QPS is not high)
## Transformation - Taking Subgraph Query as an Example

Before the transformation:

```plain
@Override
    public MSubGraphReceive getSubGraph(MSubGraphSend subGraphSend) {
        logger.info("-----start getSubGraph------(" + subGraphSend.toString() + ")");
        MSubGraphReceive r = (MSubGraphReceive) akkaClient.sendMessage(subGraphSend, 30);
        logger.info("-----end getSubGraph:");
        return r;
    }
```
After the transformation:

Define the gray service module interface

```plain
public interface IGrayService {
    /**
     * Whether to hit the gray service configuration value 0 ~ 1000; true: hit, false: miss
     * @param hashCode
     * @return
     */
    public boolean hit(Integer hashCode);

    /**
     * Whether to sample; configuration value 0 ~ 100
     *
     * @return
     */
    public boolean hitSample();

    /**
     * Send request-response data
     * @param requestDTO
     */
    public void sendReqMsg(MessageRequestDTO requestDTO);

    /**
     * @param methodKeyEnum
     * @return
     */
    public boolean hitSample(MethodKeyEnum methodKeyEnum);
}
```

The interface transformation is as follows, the kgpCoreService sends requests to the new system, the interface business logic remains consistent with old system, and the underlying graph database is changed to query NebulaGraph:

```plain
@Override
    public MSubGraphReceive getSubGraph(MSubGraphSend subGraphSend) {
        logger.info("-----start getSubGraph------(" + subGraphSend.toString() + ")");
        long start = System.currentTimeMillis();
        //1. Request grayscale
        boolean hit = grayService.hit(HashUtils.getHashCode(subGraphSend));
        MSubGraphReceive r;
        if (hit) {
            //2、Hit Grayscale and go through the new process
            r = kgpCoreService.getSubGraph(subGraphSend); // Use Dubbo to call new services
        } else {
            //Here is the original process using akka communication
            r = (MSubGraphReceive) akkaClient.sendMessage(subGraphSend, 30);
        }
        long requestTime = System.currentTimeMillis() - start;

        //3.Sampling hits Sending data compared to MQ
        if (grayService.hitSample(MethodKeyEnum.getSubGraph_subGraphSend)) {
            MessageRequestDTO requestDTO = new MessageRequestDTO.Builder()
                    .req(JSON.toJSONString(subGraphSend))
                    .res(JSON.toJSONString(r))
                    .requestTime(requestTime)
                    .methodKey(MethodKeyEnum.getSubGraph_subGraphSend)
                    .isGray(hit).build();
            grayService.sendReqMsg(requestDTO);
        }
        logger.info("-----end getSubGraph: {} ms", requestTime);
        return r;
    }
```

# Benefits of Refactoring

After two months of hard work by the team, the grayscale plan has been successfully completed, with the following benefits:

* NebulaGraph itself supports distributed expansion; the new system service supports elastic scaling, and the overall performance supports horizontal expansion;
* From the pressure test results, the performance of the interface has improved significantly, and it can support requests far beyond expectations;
* It was integrated with the company's unified monitoring and alarm system, which is more conducive to later maintenance.

# Conclusion

The refactoring was successfully completed, thanks to the partners who participated in this project, as well as the support from the big data and risk control teams. At the same time, we also thank the [NebulaGraph community](https://github.com/vesoft-inc/nebula/discussions) because they quickly helped troubleshoot some of the issues we encountered.


Aqi, a NebulaGraph community member shares his journey of refactoring the graph database from OrientDB to NebulaGraph. 

The Journey of Refactoring Graph Database: Migrating from OrientDB to NebulaGraph

Exploring NebulaGraph RAG Pipeline with the Philadelphia Phillies

7 Query Strategies for Navigating Knowledge Graphs With NebulaGraph and LlamaIndex

In the era of information overload, sifting through vast amounts of data to provide accurate search results in an engaging and comprehensible manner has become an uphill battle. Traditional search enhancement techniques often fall short when it comes to complex queries and the high demand brought by cutting-edge technologies like ChatGPT. This is where Graph RAG steps in – a game-changing concept crafted by NebulaGraph that promises to revolutionize the field.

**“Graph RAG” is a concept pioneered by NebulaGraph**. This technology harnesses the power of knowledge graphs in conjunction with Large Language Models (LLMs) to provide search engines with a more comprehensive contextual understanding. It assists users in obtaining smarter and more precise search results at a lower cost.

NebulaGraph's revolutionary Graph RAG (Retrieval-Augmented Generation) technique, which is based on knowledge graphs, is a breakthrough in this area. Graph RAG combines knowledge graphs with a large language model to provide more cost-effective, intelligent, and precise search results. **Capable of deep integration with large language models such as Llama Index and LangChain, NebulaGraph is the first in the industry to propose the concept of Graph RAG.** Besides, Graph RAG has also achieved excellent results in the field of vector database integration.

In this article, we will introduce the concept of Graph RAG and compare it with other RAG techniques. You are also welcome to visit the NebulaGraph‘s website to [Try Demos](https://www.nebula-graph.io/demo).



## Challenges Faced by Traditional Search Enhancement Techniques

Obtaining accurate search results is a challenge, especially with complex or long-tail queries when traditional search engines rely on keyword matching, which often does not meet the users' actual needs. The bottleneck of traditional search augmentation techniques is the lack of training data and text understanding, which makes them less effective when it comes to generating accurate, diverse and relevant information.

To address this problem, RAG came into being. **RAG (Retrieval-Augmented Generation) refers to the process of enhancing search results through RAG models.** Specifically, it is a technique that combines retrieval and language generation to enhance the generation process. By using RAG, traditional search engines can generate more accurate and relevant search results.

However, the RAG technique still faces challenges in terms of training data and text understanding. These challenges include:

- Train data: the RAG technique requires a large amount of data and computational resources for training and generating models, especially when handling multiple languages and complex tasks.
- Text understanding: RAG needs to understand the intent of the query, but for complex queries or polysemous queries, RAG may have ambiguity or uncertainty, which affects the quality of the generated content.

Therefore, the problem of how to find more powerful retrieval enhancement techniques to obtain search results that better meet the searcher's expectations more efficiently is even more urgent.

## What is Graph RAG?

**Graph RAG** is proposed by NebulaGraph, which is a retrieval enhancement technique based on knowledge graphs. It uses a knowledge graph to show the relationship between entities and relationships and then uses the large language model LLM (Large Language Model) for retrieval enhancement.

As mentioned in the previous [blog](https://www.nebula-graph.io/posts/graph-llm), the graph database is naturally suitable for storing and expressing complex context information by organizing and connecting information in a graphical format. By using graph technology to build a knowledge graph to enhance in-context learning, users can provide more context information to help large language models (LLM) better understand the relationship between entities and improve their expression and reasoning abilities.

Graph RAG equates the knowledge graph to a large-scale vocabulary, and entities and relationships correspond to words. In this way, Graph RAG can jointly model entities and relationships as units during retrieval, which can more accurately understand the query intent and provide more accurate search results.

## Demo: Graph RAG vs. Vector RAG vs. Text2Cypher

In the following sections, we'll explore two demos that provide a visual comparison of Graph RAG with Vector RAG and Text2Cypher.

### Graph RAG vs. Graph + Vector RAG

The GIT below compares the results returned by Vector RAG (vector retrieval) with Graph and Vector RAG (graph-enhanced vector retrieval).

![Graph RAG vs. Vector RAG](https://www-cdn.nebula-graph.io/nebula-website-5.0/images/blogs/1.gif)

- Results on the left: Vector RAG 
- Results on the right: Vector RAG with Graph

As an example, let's consider the data set of "Guardians of the Galaxy 3". When we search for "Peter Quill's related information," traditional retrieval techniques like vector retrieval engines only provide simple information on his identity, plot, and actors. However, with the Graph RAG-enhanced search results, we can obtain more information about the protagonist's skills, character goals, and identity changes.

This example highlights how Graph RAG effectively complements the shortcomings of traditional methods like embedding and vector retrieval and provides more in-depth knowledge and information relevant to the query. By combining knowledge graphs with large language models, Graph RAG can understand the relations between entities, equate knowledge graphs to large-scale vocabularies and better comprehend the intent of complex queries, leading to more accurate and relevant search results.

### Graph RAG vs. Text2Cypher 

Another interesting approach to knowledge graph-based LLM is Text2Cypher, which is a natural language generation graph query. This method does not rely on entity subgraph retrieval but translates tasks or questions into an answer-oriented graph query, which is essentially the same as what we commonly call Text2SQL.

Text2Cypher and Graph RAG differ mainly in their retrieval mechanisms. Text2Cypher generates graph pattern queries based on the knowledge graph schema and the given task, while (Sub)Graph RAG obtains relevant subgraphs to provide context. Both have their advantages, and you can get a more intuitive understanding of their characteristics through the following demo.

![Graph RAG vs. Text2Cypher](https://www-cdn.nebula-graph.io/nebula-website-5.0/images/blogs/2.gif)

- Results on the left: Text2Cypher 
- Results on the right: Graph RAG



From the above demo, it's evident that the two graph query modes exhibit pronounced differences in visualization. Retrieval using Graph RAG presents more comprehensive results. Users not only receive fundamental introductory information but also gain access to a range of outcomes based on associative searches and contextual inferences, such as "Peter Quill is the leader of the Guardians of the Galaxy," "This role implies that he will return in the sequel," and insights into the character's personality.

## NebulaGraph  : Build Your Enterprise-Specific Knowledge Graph Applications in One Step

**NebulaGraph database has seamlessly integrated with large language model frameworks like Llama Index and LangChain.**Therefore, developers can focus on LLM orchestration logic and pipeline design without having to deal with many details of abstraction and implementation and generate high-quality and low-cost enterprise-level large language model applications in one stop.

The advent of Graph RAG presents a breakthrough for processing and retrieving information on a massive scale. By fusing knowledge graphs and graph storage within the LLM stack, Graph RAG offers an unparalleled level of context learning. With the utilization of NebulaGraph, building Graph RAG is highly simplified and requires minimal effort, based on just three lines of code. Even more complex RAG logic, such as Vector RAG with graph can be easily integrated.

![Graph+Vector RAG](https://www-cdn.yueshu.cn/yueshu-website/images/blogs/%E8%AF%AD%E8%A8%80%E6%A8%A1%E5%9E%8B/demo-3.png)

As graph technology and deep learning algorithms continue to advance, the adoption of Graph RAG in data processing and retrieval is set to become increasingly widespread. We invite you to [contact us](https://www.nebula-graph.io/contact) for a free trial of NebulaGraph database and to effortlessly create your knowledge graph application!



NebulaGraph database's revolutionary Graph RAG (Retrieval-Augmented Generation) technique, which combines knowledge graphs with a large language model to provide more cost-effective, intelligent, and precise search results.

NebulaGraph Launches Industry-First Graph RAG: Retrieval-Augmented Generation with LLM Based on Knowledge Graphs

We’re thrilled to announce that Vesoft for its NebulaGraph, a leading [open-source distributed graph database](https://www.nebula-graph.io/) renowned for its exceptional management capabilities of datasets containing hundreds of billions of vertices and trillions of edges, has been recognized in the Gartner® Market Guide for Graph Database Management Systems as a Representative Vendor.

Graph databases are specialized systems in which interconnected data entities are stored as vertices, and their relationships as edges. This structure allows high-performance retrieval and querying. Given their superior query performance, flexible data structure, and intuitive presentation compared to traditional relational databases, graph technology is rapidly becoming essential in intelligent analysis and AI machine learning.

# Rapid Surge of Graph Technology

According to Gartner, “Based on the increasing usage, popularity and maturity of graph, Gartner estimates that the market for graph technologies, including graph database management systems (DBMSs), will grow to $3.2 billion by 2025 with a CAGR of 28.1%."
As a trailblazer in native distributed graph databases, NebulaGraph boasts a foundational storage architecture advantage. Its native graph storage ensures swift, real-time traversal of densely interconnected data, while its shared-nothing design guarantees scalability. Particularly in scenarios such as real-time recommendations and financial risk management, NebulaGraph empowers businesses to handle expansive and intricate datasets efficiently, promising real-time traversal query performance even amidst rapidly expanding data volumes.

# Standardizing Graph Query Languages

The establishment of a concise and standardized query language plays a pivotal role in optimizing the user experience of a database. Intense competition among [graph database query languages](https://www.nebula-graph.io/posts/graph-query-languages-you-should-know) has spurred significant product enhancements and continuous improvements, notably evidenced by the emergence of the GQL standard.

According to the research, “The longtime competition among languages has been a challenge. However, it has also resulted in both significant enhancements to product capabilities and continuing efforts to promote standards such as GQL. Vendors are supporting GraphQL as an API so that developers can access the graph data model without learning SPARQL or Gremlin to build queries. Moreover, vendors of RDF graph DBMSs are adding support for openCypher or Gremlin to support graph traversal." 

The eagerly awaited ISO/IEC Graph Query Language (GQL) and the associated SQL-to-property Graph (SQL/PGQ) standards—rare developments in decades—are poised to elevate graph database product usability. A multitude of vendors, including prominent enterprise database providers, are actively investing in this groundbreaking initiative. Notably, NebulaGraph stands out for its dedicated strides in advancing GQL-compatibility, with upcoming versions set to embrace the core features of GQL.

# Cloud Platforms Propel the Growth of the Graph Database Industry

Gartner says, “Interest in and use of graph have been increasing steadily. In 2020 and 2021, inquiries to Gartner data management analysts about graph rose substantially. “ With consistent revenue and channel growth, graph databases are drawing increased interest from vendors, a trend accelerated by cloud deployments. Cloud Service Providers (CSPs), like other DBMS market trailblazers, are incorporating graph functionalities into their databases and presenting competitive products.

”Gartner expects the percentage of revenue attributable to cloud in the overall DBMS market to exceed 50% by 2023” in the research. This overarching trend in the global database market is becoming distinctly visible in the cloud database sector.

NebulaGraph has been seamlessly integrated with platforms like Alibaba Cloud, Azure, and AWS, simplifying database deployment, performance optimization, and maintenance. As tools facilitating data migration from relational sources or rival graph vendors proliferate, end-users are keen on repurposing their existing data. The participation of cloud platform providers is set to lure a more expansive user base, recognizing the cloud as an ideal experimental platform.

# NebulaGraph: Crafting a Superior Native Graph Database

Graph databases can be bifurcated into Native DBMSs and Multi-model DBMSs. “Both native and multimodel graph databases can scale to meet enterprise production requirements, including stability, availability and security. However, native graph DBMSs offer performance gains when dealing with queries over very large graphs (typically billions of nodes).”

Moreover, NebulaGraph has tailored its offerings to domestic 
environments and fine-tuned for ARM hardware, ensuring unwavering performance. Hardware acceleration and hardware-based graph computation herald significant performance boosts. Cloud platforms, compared to private user deployments, are more inclined to adopt these enhancements. NebulaGraph's native integration with Amazon's renowned Deep Graph Library (DGL) furnishes users with an all-encompassing toolkit for graph storage, computation, and learning.

We believe being recognized in Gartner's Market Guide for Graph Database Management Systems symbolizes the industry's endorsement of NebulaGraph. As data scale and complexity surge in the future, the merits of graph data technology will become even more pronounced. NebulaGraph is unwavering in its dedication to continually honing its graph database product capabilities, striving to help more users extract the profound, interconnected value from their data.

For further information, please visit NebulaGraph or contact us to get a customized solution for your organization.

**Reference**:

 [1] Gartner, "Market Guide for Graph Database Management Systems", Merv Adrian, Afraz Jaffri, 30 August 2022.

---

*Gartner does not endorse any vendor, product or service depicted in its research publications, and does not advise technology users to select only those vendors with the highest ratings or other designation. Gartner research publications consist of the opinions of Gartner’s research organization and should not be construed as statements of fact. Gartner disclaims all warranties, expressed or implied, with respect to this research, including any warranties of merchantability or fitness for a particular purpose.


We’re thrilled to announce that Vesoft for its NebulaGraph has been recognized in the Gartner® Market Guide for Graph Database Management Systems as a Representative Vendor.

Vesoft (NebulaGraph) Recognized in the Gartner® Market Guide for Graph Database Management Systems

As AI applications, like ChatGPT, gain popularity globally, large language models (LLMs) have garnered significant attention from both enterprises and individual users across various industries. Graph databases, which structure and link information graphically, can enhance LLMs' understanding of the relationships between entities, thereby improving their expressive and reasoning capabilities. So, what kind of innovations might arise when LLMs and graph technology intersect in specific application areas?

Currently, NebulaGraph is collaborating with several globally-renowned LLM teams to integrate LLMs with graph databases. We are excited to reveal that NebulaGraph now supports Text2Cypher, a combined Graph + LLM technology that translates natural language into graph queries. Through a dialogue interface, users can effortlessly construct and query knowledge graphs using natural language. Additionally, we provide a turnkey enterprise-level service. For a firsthand experience with our next-generation Knowledge Graph application powered by NebulaGraph, please follow the link provided at the end of this article.

# How can LLMs make knowledge graphs smarter?

AS one of the most common applications in graph technology, knowledge graphs organize and represent knowledge in the form of a graph structure consisting of nodes and edges. [Knowledge graphs](https://www.nebula-graph.io/posts/fraud-detection-using-knowledge-and-graph-database) not only represent the relationships between entities (e.g., people, places, events, and concepts) but also contain the semantic meanings of these relationships. They vividly describe knowledge in the real world in a structured manner, enabling computers to understand and reason about this knowledge. Knowledge graphs are widely used in risk control, production and manufacturing, drug development, scientific research, and other fields.

Text2Cypher, as its name implies, converts natural language text into Cypher queries. One of the challenges that previously impeded the broader adoption of [graph databases](https://www.nebula-graph.io/) and knowledge graphs was the technical barrier associated with querying these databases. So, how did we manage this prior to the advent of large language models?

## Traditional Text2Cypher

Before the emergence of large language models, the most common application of knowledge graphs was to convert natural language text into Cypher queries. For example, the internal system of a KBQA (Knowledge Base Question Answering) system is essentially text2cypher.

When a question is submitted to the system, it initially conducts intent and entity recognition. Subsequently, it employs an NLP model or code to formulate a query statement based on the identified intent and entity. The system then queries the graph database and crafts a response based on the retrieved structure.

So, what are the challenges associated with this approach?

- Understanding intent from natural language: Which category of questions does the question correspond to?
- Identifying entities: What are the main entities involved in the question?
- Constructing a query statement based on intent and entities

This is not an easy development task. A truly implementable model or rule code must consider many boundary conditions.

## LLM-based Text2Cypher

In the era of large language models, the above-mentioned "smart" application scenarios that previously required specialized training or rule writing can now be completed using a general model and prompt engineering.

> Note: Prompt engineering refers to the use of natural language descriptions to enable generative models and language models to complete smart tasks.

NebulaGraph has undertaken extensive R&D validation to successfully integrate large language models with graph query languages. Now, when users submit a task, they can utilize natural language for schema acquisition, Cypher statement generation, prompts, and various other large language model (LLM) calls and result processing. **This offers a truly code-free, ready-to-use solution for knowledge graph construction and querying.**


# Easy Knowledge Graph Construction and Querying with NebulaGraph

With the integration of NebulaGraph and large language models, enterprise users can easily construct and query knowledge graphs. Not only can they complete high-accuracy searches and intuitive visualizations at a lower cost, but they also no longer need to invest a long time in learning how to obtain important insights from graphs.

Compared with the previous generation of knowledge graphs, the combination of NebulaGraph and large models enables enterprises to construct knowledge graphs based on massive data at a lower cost and with greater convenience. Additionally, users can directly use natural language for interactive questioning and querying, thereby reducing the threshold for enterprise use and lowering the learning curve for users.

# LLM + Knowledge Graph Demo

Click the [demo](https://www.nebula-graph.io/posts/build-knowledgegraph-via-natural-language-demo) for a firsthand experience of constructing and querying knowledge graphs using natural language. 
For more about NebulaGraph and to connect to the digital future with NebulaGraph, visit our [official website](https://www.nebula-graph.io/). 





NebulaGraph now supports Text2Cypher, a combined Graph + LLM technology that translates natural language into graph queries. 

Knowledge Graphs & LLMs: Integrating Large Language Models with NebulaGraph

![](https://www-cdn.nebula-graph.io/nebula-website-5.0/images/%20v3.6.0%20Release%20Note%20_%E7%94%BB%E6%9D%BF%201%20%E5%89%AF%E6%9C%AC%202.jpg)

The NebulaGraph Community Edition v3.6.0 has arrived! In this release, we have bolstered the full-text index capabilities and fine-tuned the performance of MATCH operations in select scenarios.

Let's take a quick look at the specific updates introduced in the new version 😄


# Features

- Enhance the full-text index. 
[#5567](https://github.com/vesoft-inc/nebula/pull/5567) [#5575](https://github.com/vesoft-inc/nebula/pull/5575) [#5577](https://github.com/vesoft-inc/nebula/pull/5577) [#5580](https://github.com/vesoft-inc/nebula/pull/5580) [#5584](https://github.com/vesoft-inc/nebula/pull/5584) [#5587](https://github.com/vesoft-inc/nebula/pull/5587)

# Optimizations

- Support variables when querying vertex id or property index in a match clause. [#5486](https://github.com/vesoft-inc/nebula/pull/5486) [#5553](https://github.com/vesoft-inc/nebula/pull/5553)

- Support parallel startup of RocksDB instances to speed up the startup of the Storage service. [#5521](https://github.com/vesoft-inc/nebula/pull/5521)

- Optimize the prefix search performance of the RocksDB iterator after the `DeleteRange` operation. [#5525](https://github.com/vesoft-inc/nebula/pull/5525)

- Optimize the appendLog sending logic to avoid impacting write performance when a follower is down. [#5571](https://github.com/vesoft-inc/nebula/pull/5571)

- Optimize the performance of the `MATCH` statement when querying for non-existent properties. [#5634](https://github.com/vesoft-inc/nebula/pull/5634)

# Bug fixes

- Fix the bug of meta data inconsistency. [#5517](https://github.com/vesoft-inc/nebula/pull/5517)

- Fix the bug that RocksDB ingest causes the leader lease to be invalid. [#5534](https://github.com/vesoft-inc/nebula/pull/5534)
- Fix the error in the statistics logic of storage. [#5547](https://github.com/vesoft-inc/nebula/pull/5547)

- Fix the bug that causes the web service to crash if a flag is set for an invalid request parameter. [#5566](https://github.com/vesoft-inc/nebula/pull/5566)

- Fix the bug that too many logs are printed when listing sessions. [#5618](https://github.com/vesoft-inc/nebula/pull/5618)

- Fix the crash of the Graph service when executing a single big query. [#5619](https://github.com/vesoft-inc/nebula/pull/5619)

- Fix the crash of the Graph service when executing the `Find All Path` statement. [#5621](https://github.com/vesoft-inc/nebula/pull/5621) [#5640](https://github.com/vesoft-inc/nebula/pull/5640)

- Fix the bug that some expired data is not recycled at the bottom level. [#5447](https://github.com/vesoft-inc/nebula/pull/5447) [#5622](https://github.com/vesoft-inc/nebula/pull/5622)

- Fix the bug that adding a path variable in the `MATCH` statement causes the `all()` function push-down optimization to fail. [#5631](https://github.com/vesoft-inc/nebula/pull/5631)

- Fix the bug in the `MATCH` statement that returns incorrect results when querying the self-loop by the shortest path. [#5636](https://github.com/vesoft-inc/nebula/pull/5636)

- Fix the bug that deleting edges by pipe causes the Graph service to crash. [#5645](https://github.com/vesoft-inc/nebula/pull/5645)

- Fix the bug in the `MATCH` statement that returns missing properties of edges when matching multiple hops. [#5646](https://github.com/vesoft-inc/nebula/pull/5646)

# Changes

Enhance full-text index features with the following changes:

- The original full-text indexing function has been changed from calling Elasticsearch's Term-level queries to Full text queries.

- In addition to supporting wildcards, regulars, fuzzy matches, etc. (but the syntax has been changed), support for word splitting (relying on Elasticsearch's own word splitter) has been added, and the query results include scoring results. For more syntax, see [official Elasticsearch documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/full-text-queries.html).

# Legacy versions

[Release notes of legacy versions](https://nebula-graph.io/posts/)



If you come across any problems while using NebulaGraph, please don't hesitate to seek solutions within the [NebulaGraph Database Manual](https://docs.nebula-graph.io/3.6.0/).  It records in detail the knowledge points and specific usage of the graph database NebulaGraph.


Join our [Slack channel](https://nebulagraph.slack.com/ssb/redirect#/shared-invite/email) if you want to discuss with the rest of the NebulaGraph community!


The NebulaGraph Community Edition v3.6.0 has arrived! In this release, we have bolstered the full-text index capabilities and fine-tuned the performance of MATCH operations in select scenarios.

NebulaGraph Database v3.6.0 Release Note

With the rapid development of AI technology and advancements in natural language processing, building powerful large language models has become increasingly important for enterprises. Graph database software, as a robust tool for handling complex data structures, provides strong support for constructing domain-specific large language models.
 
NebulaGraph Database, an [open-source distributed graph database](https://www.nebula-graph.io/) built for super large-scale graphs with milliseconds of latency, released its Graph + AI big models solution. It pioneered the Text2Cypher technology for building and querying knowledge graphs based on natural language, offering users powerful capabilities in data management, semantic understanding, and information extraction. This solution enables enterprises to achieve higher-performance domain-specific large language model applications at lower costs, resulting in more intelligent and precise human-computer interactive question-answering results.
 

# NebulaGraph Database: Introducing the Graph + AI Solution
 
Graph database is a novel type of database that represents entities as nodes and relationships between entities as edges, allowing efficient storage, retrieval, and analysis of complex multidimensional data. Practice has shown that constructing knowledge graphs using graph technology enhances In-Context Learning, providing users with more contextual information and enabling large language models to better comprehend relationships between entities and enhance their expressive and reasoning abilities. As a graph database vendor to adopt LangChain, NebulaGraph Database has successfully implemented the Graph In-Context Learning solution based on a Knowledge Graph + Vector DB. Moreover, NebulaGraph Database is dedicated to introducing GraphStore storage context into the Llama Index, incorporating external storage of knowledge graphs and creating a more efficient and user-friendly Graph + LLM solution.
 
In terms of interaction, NebulaGraph Database has already implemented Text2Cypher based on the Graph + LLM solution. Users can easily build and query knowledge graphs through natural language in the dialogue interface. With out-of-the-box enterprise-level services, enterprise users can import massive data into NebulaGraph Database and quickly construct domain-specific knowledge graphs. Leveraging the powerful querying capabilities and performance of NebulaGraph Database, users can accomplish highly accurate searches and intuitive visualizations at a lower cost. Moreover, they can directly interact with the system through natural language for interactive questioning and querying, significantly reducing the barriers to enterprise adoption.
 
# NebulaGraph AI Large Models Solution: Industry Use Cases
 
In the era of information explosion, enterprises need to handle vast amounts of natural language text from different channels and types to obtain valuable information and insights. Large language models (LLMs) tailored to specific industry domains are capable of understanding, analyzing, and generating text information related to the industry.
 
However, traditional training methods suffer from high costs, low efficiency, and insufficient context information, making it challenging to effectively implement large language models in production environments. NebulaGraph Database, with its ability to handle massive, diverse, and complex data scenarios, provides a solution that addresses these issues.
 
## Healthcare Industry

In the healthcare industry, effective management and analysis of vast amounts of medical literature, clinical data, and patient records are essential. With the assistance of NebulaGraph Database's graph technology, enterprises can construct large language models specific to the healthcare domain. By constructing a medical knowledge graph that models medical entities (such as diseases, drugs, treatment methods) and their relationships, large language models can acquire extensive medical knowledge.
 
Using NebulaGraph Database helps accurately link entities mentioned in medical texts to the knowledge graph, eliminating ambiguities and improving model accuracy. Large language models in the healthcare industry can be applied to intelligent diagnosis, disease prediction, and personalized healthcare recommendations, providing more precise and intelligent solutions.
 
## Financial Industry

In the financial sector, in-depth analysis and prediction of complex financial data are required. NebulaGraph Database can assist in building a knowledge graph specific to the financial domain, modeling financial entities (such as stocks, transactions, financial indicators) and their relationships. Language models built on top of NebulaGraph Database can acquire professional knowledge in the financial domain and play a vital role in financial data analysis, investment decision-making, and more.
 
Furthermore, using NebulaGraph's graph technology for relationship extraction and semantic understanding can help extract key information from financial news and research reports, aiding large language models in better understanding the dynamics and trends of the financial market. Large language models in the financial domain can be applied to investment analysis, risk management and intelligent customer service, and users can receive precise answers through natural language, providing more intelligent and efficient services for financial users.
 
## E-commerce retail industry

In the retail industry, businesses often need to deal with a large amount of product information, user reviews, sales data, and more. NebulaGraph Database can help build a knowledge graph for the retail industry, modeling entities such as products, brands, users, and their relationships. Domain-specific large language models in the retail sector can be applied to intelligent product recommendations, customer segmentation, market trend analysis, and more, providing a more intelligent and personalized shopping experience for retail companies.
 
At the same time, NebulaGraph Database's Graph + AI Large Models solution can also play a role in areas such as product recommendations and user-personalized services by leveraging professional knowledge in the retail industry. Entity linking and relationship extraction using graph technology can extract useful information from user reviews, helping the large language models better understand user demands and offer personalized shopping preferences. Users can receive targeted services using natural language, greatly enhancing the user experience.
 
# Future Outlook: Building more intelligent AI large model applications
 
With the continuous development of big data and artificial intelligence technology, the deep integration of graph technology and language models will become a future trend. NebulaGraph Database not only provides a richer knowledge base and semantic understanding capability to language models, helping them better understand industry knowledge and semantics, but also enables more efficient, flexible, and intelligent processing of massive complex relational data.
 
In the future, AI large models will be further developed in various industry domains, and NebulaGraph Database will continue to advance and improve its technological advantages, helping businesses better understand industry data, gain insights into market trends, optimize business decisions, and bring more opportunities and momentum for innovation and development.


This article demonstrates how the NebulaGraph database offers robust support for building domain-specific large language models.

NebulaGraph x LLM：Pioneering the New Paradigm of "Graph + AI" Applications

# LLM App Paradigms

As a big improvement in Cognitive intelligence, LLM had changed many industries, in a way that we didn’t expect to automate, accelerate or enable. Seeing new LLM-enabled applications being created every day, we are all still exploring new methods and use cases for leveraging this magic.

One of the most typical patterns to bring LLM into the loop is to ask LLM to understand things based on proprietory/ certain domain knowledge. For now, there are two paradigms we could add that knowledge to LLM: **fine-tuning and in-context learning**.

Fine-tuning refers to performing add-on training on large language model models with extra knowledge, whereas in-context learning is to adding some extra piece of knowledge to the query prompt. What we observe now is that in-context learning has gained popularity over Fine-tuning due to its simplicity.

And in this blog, I’ll share what we had been doing around the in-context learning approach.

# Llama Index: Interface between data and LLM

## In-context learning

The basic idea of in-context learning is to use existing large language model(not updated) to handle special tasks toward specific knowledge datasets.

For instance, to build an application to answer any questions about one person, or even act as one’s digital avatar, we can apply in-context learning to an autobiography book with LLM. In practice, the application will construct a prompt with the question from the user and some information “searched” from the book, then query the LLM for an answer.

```
┌───────┐         ┌─────────────────┐         ┌─────────┐
│       │         │ Docs/Knowledge  │         │         │
│       │         └─────────────────┘         │         │
│ User  │─────────────────────────────────────▶   LLM   │
│       │                                     │         │
│       │                                     │         │
└───────┘                                     └─────────┘
```

One of the most performant ways to enable this searching approach to get the related info from the Docs/Knowledge(the book in the above example) for the special task, is to leverage Embeddings.

## Embedding

The LLM embedding normally refers to a way to map real word things into a vector in a multidimensional space, for instance, we could map images into a space of (64 x 64) dimension, and if we are doing it well enough, the distance between the two images can reflect the similarity of them.

Another example of embedding is the word2vec algorithm, which literally maps every word into a vector, for instance, and if the embedding is good enough, we could have addition and subtraction on them, we may have:

* `vec(apple) + vec(pie) =~ vec("apple apie")`
Or the vector measure of `vec(apple) + vec(pie) - vec("apple apie") `tends to be 0:
*` |vec(apple) + vec(pie) - vec("apple apie")| =~ 0`
Similarly, we could have “pear” should be closer than “dinosaur” to “apple”:
* `|vec(apple) - vec(pear)| < |vec(apple) - vec(dinosaur)|`
With that, we could in theory search for pieces of the book which are more related to a given question. And the basic process is:
* Split the book into small pieces, create the embedding per each piece, and store them
* When a question comes, compute the embedding of the question
Find top-K similar embeddings of pieces of the book by calculating the distance
* Construct the prompt with both the question and the pieces of the book
* Query the LLM with the prompt

```
                  ┌────┬────┬────┬────┐                  
                  │ 1  │ 2  │ 3  │ 4  │                  
                  ├────┴────┴────┴────┤                  
                  │  Docs/Knowledge   │                  
┌───────┐         │        ...        │       ┌─────────┐
│       │         ├────┬────┬────┬────┤       │         │
│       │         │ 95 │ 96 │    │    │       │         │
│       │         └────┴────┴────┴────┘       │         │
│ User  │─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─▶   LLM   │
│       │                                     │         │
│       │                                     │         │
└───────┘    ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐  └─────────┘
    │          ┌──────────────────────────┐        ▲     
    └────────┼▶│  Tell me ....., please   │├───────┘     
               └──────────────────────────┘              
             │ ┌────┐ ┌────┐               │             
               │ 3  │ │ 96 │                             
             │ └────┘ └────┘               │             
              ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ 
```

## Llama Index

Llama Index is such an open-source toolkit to help in-context learning in best practice:

* It comes with [a bunch of data loaders](https://llamahub.ai/) to serialize docs/knowledge in a unified format, think of PDF, Wikipedia Page, notion, Twitter, etc, and we don’t have to deal with the preprocessing, split the data into pieces, etc, on our own.
* It helps create the Embedding(and some other form of the index) for us and stores the embeddings(in memory or [vector databases](https://github.com/openai/openai-cookbook/blob/main/examples/vector_databases/Using_vector_databases_for_embeddings_search.ipynb)), too, with one line of code.
* It comes out of the box with prompts and other engineering points, so that we don’t have to create and study from scratch, for instance, [create a chatbot on existing data with 4 lines of code](https://twitter.com/jerryjliu0/status/1663213212932902913).


# The problem of doc split and embeddings

The embedding and vector search worked well in many cases, while there are still challenges in some cases, and one of them is it could lose global context/cross-node context.

Think of we are asking “Please tell me things about the author and foo.”, and in this book, the piece with numbers: 1, 3, 6, 19~25, 30~44, and 96~99 are all about the topic of foo. In this case, the simple way of searching top-k embedding of the pieces of the book may not work well because we normally only take a few top-related pieces, which loses many contexts.

```
┌────┬────┬────┬────┐
│ 1  │ 2  │ 3  │ 4  │
├────┴────┴────┴────┤
│  Docs/Knowledge   │
│        ...        │
├────┬────┬────┬────┤
│ 95 │ 96 │    │    │
└────┴────┴────┴────┘

```

The mitigation for that, for instance with Llama Index is to create [composite indices](https://gpt-index.readthedocs.io/en/latest/how_to/index_structs/composability.html), where the VectorStore is only part of it, combining with that, we could define a summary index and/or a tree index, etc to [route different types of questions to different indices](https://gpt-index.readthedocs.io/en/latest/guides/tutorials/unified_query.html), thus to avoid risking the loss of global context when the question required it.

Or, with the help of Knowledge Graph, we could do something differently.

# Knowledge Graph

The term Knowledge Graph was initially coined by Google in May 2012 as part of its efforts to enhance search results and provide more contextual information to users. The Knowledge Graph was designed to understand the relationships between entities and provide direct answers to queries rather than just returning a list of relevant web pages.

A knowledge graph is a way of organizing and connecting information in a graph format, where nodes represent entities, and edges represent the relationships between those entities. The graph structure allows for efficient storage, retrieval, and analysis of data.

It looks like this:

![knowledge graph](https://www-cdn.nebula-graph.io/nebula-website-5.0/images/blogs/llm/llm04.png)

But how could Knowledge Graph help?

# Combination of LLM embeddings and Knowledge Graph

The general idea here is a knowledge graph, as the refined format of the information, can be queried/searched in way smaller granularity than the split we could do on raw data/docs. Thus, by not replacing the large pieces of the data, but combining the two, we can search queries that require global/cross-node context better.

See the following diagram, assume the question is about x, and 20 of all the pieces of the data are highly related to it. We could now still get the top 3 pieces of the doc(say, no. 1, 2, and 96) as the main context to be sent, apart from that, we ask for two hops of graph traversal around x from the knowledge graph, then the full context will be:

* The question “Tell me things about the author and `x`
* Raw doc from piece number 1, 2, and 96, in Llama Index, it’s called node 1, node 2, and node 96.
* Knowledge 10 triplets contain `x` in two-depths graph traversal:
* x -> y(from node 1)
* x -> a(from node 2)
* x -> m(from **node 4**)
* x <- b-> c(from **node 95**)
* x -> d(from node 96)
* n -> x(from **node 98**)
* x <- z <- i(from node **1 and node 3**)
* x <- z <- b(from node **1 and node 95**)

```
┌──────────────────┬──────────────────┬──────────────────┬──────────────────┐
│ .─.       .─.    │  .─.       .─.   │            .─.   │  .─.       .─.   │
│( x )─────▶ y )   │ ( x )─────▶ a )  │           ( j )  │ ( m )◀────( x )  │
│ `▲'       `─'    │  `─'       `─'   │            `─'   │  `─'       `─'   │
│  │     1         │        2         │        3    │    │        4         │
│ .─.              │                  │            .▼.   │                  │
│( z )─────────────┼──────────────────┼──────────▶( i )─┐│                  │
│ `◀────┐          │                  │            `─'  ││                  │
├───────┼──────────┴──────────────────┴─────────────────┼┴──────────────────┤
│       │                      Docs/Knowledge           │                   │
│       │                            ...                │                   │
│       │                                               │                   │
├───────┼──────────┬──────────────────┬─────────────────┼┬──────────────────┤
│  .─.  └──────.   │  .─.             │                 ││  .─.             │
│ ( x ◀─────( b )  │ ( x )            │                 └┼▶( n )            │
│  `─'       `─'   │  `─'             │                  │  `─'             │
│        95   │    │   │    96        │                  │   │    98        │
│            .▼.   │  .▼.             │                  │   ▼              │
│           ( c )  │ ( d )            │                  │  .─.             │
│            `─'   │  `─'             │                  │ ( x )            │
└──────────────────┴──────────────────┴──────────────────┴──`─'─────────────┘
```


And clearly, the refined information related to topic `x` that comes from both other nodes and across the nodes is included in the context to build the prompt of in-context learning.

# Progress of Knowledge Graph in Llama Index

The Knowledge Graph abstraction was initially introduced to Llama Index by [William F.H](https://github.com/jerryjliu/llama_index/pull/433). where the triplets in the knowledge graph were associated with the docs with keywords and stored in memory, then [Logan Markewich](https://github.com/jerryjliu/llama_index/pull/487) enhanced it by adding embedding per triplets, too.

Recently, in the last couple of weeks, I had been [working with the community](https://github.com/jerryjliu/llama_index/issues/1318) on bringing the “GraphStore” storage context to Llama Index and thus introducing external storage of Knowledge Graph, the first implementation is [NebulaGraph the Open-Source Distributed Graph Database](https://www.nebula-graph.io/) that I had been working on since 2021.

During the implementation of this, the option to traverse multiple hops of the graph, and the option to collect more key entities on top-k nodes(to search in the knowledge graph to enable more global context) was introduced, and we are still refining the changes.

With GraphStore introduced, it also makes it possible to perform in-context learning from an existing knowledge graph, combined with other indices, this is also quite promising due to the knowledge graph being considered with high Information density than other structured data.

# About NebulaGraph Database

As a high-performance native distributed graph database, NebulaGraph Database excels in handling mega data sets with hundreds of billions of nodes and trillions of edges, while maintaining millisecond query latency. Relying on its shared-nothing, distributed architecture and computation-and-storage separation, it is highly available, highly secure, and easy to scale out, largely meeting the security requirements of enterprises. Besides, it can be deployed on the public cloud and on-premises as needed.

# Talk to a Graph Database Expert

Get a customized solution for your organization and see how NebulaGraph can help you:

[Contact NebulaGraph](https://www.nebula-graph.io/contact)


NebulaGraph database helps industry-level large language model Applications by bringing the “GraphStore” storage context to Llama Index.

Posts

Tag