<p>Nebula Graph v2.0.0-beta has just been released! This version supports full-text search and counting the number of nodes and edges within a graph space. Nebula Graph Studio, the graph visualization tool, and Go Importer, the data import tool, are both compatible with Nebula Graph 2.x.</p>
<blockquote>
  <p>Note: The compatibility of schema and graph data with Nebula Graph 1.x is still under development.</p>
</blockquote>
<h2 id="post-nebula-graph">Nebula Graph</h2>
<h3 id="post-compatible-with-more-ngql-10-queries">Compatible with more nGQL 1.0 queries</h3>
<ul>
<li><code>DESCRIBE TAG/EDGE INDEX</code> is to obtain information about the index. </li>
<li><code>REBUILD TAG/EDGE INDEX</code> is to rebuild an index.</li>
<li><code>SHOW TAG/EDGE INDEXES</code> is to list the created indexes.</li>
<li><code>SHOW TAG/EDGE INDEXES STATUS</code> is to return the created index status.</li>
</ul>
<h3 id="post-new-features">New features</h3>
<ul>
<li>Full-text search, allows users to write queries that match terms anywhere within the indexed string properties.</li>
<li><code>LOOKUP ON TAG/EDGE</code> is to get all vertices of a tag or edges of an edge type.</li>
<li><code>SUBMIT JOB STATS</code>  & <code>SHOW STATS</code> is to get all vertices and edges in the current space.</li>
<li>Support more openCypher Clauses.
-- Partially supported <code>MATCH</code> clause
-- <code>RETURN</code>  & <code>DISTINCT</code>
-- <code>LIMIT</code>  & <code>SKIP</code>  </li>
<li>Add more built-in functions.
-- Predicate functions
-- Scalar functions
-- List functions
-- Aggregating functions
-- Mathematical functions
-- String functions
-- Temporal functions</li>
</ul>
<h2 id="post-clients">Clients</h2>
<ul>
<li><a href="https://github.com/vesoft-inc/nebula-clients/tree/master/cpp">CPP Client</a></li>
</ul>
<h2 id="post-nebula-graph-studio">Nebula Graph Studio</h2>
<ul>
<li>Compatible with Nebula Graph 2.x，refer to <a href="https://github.com/vesoft-inc/nebula-web-docker">Studio</a>.</li>
</ul>
<h2 id="post-tools">Tools</h2>
<ul>
<li>Go Importer: Compatible with Nebula Graph 2.x, refer to <a href="https://github.com/vesoft-inc/nebula-importer">Nebula Importer</a>.</li>
</ul>
<h2 id="post-how-to-upgrade">How to Upgrade</h2>
<p>Please note that you cannot directly upgrade to Nebula Graph v2.0.0-beta from Nebula Graph 1.x. Follow the steps below to upgrade from v2.0,0-alpha to the beta version:</p>
<ol>
<li>Stop all Nebula services <ol>
<li>Execute scripts/nebula.service stop all on each machine </li>
<li>Execute scripts/nebula.service status all to confirm all services are stopped</li></ol></li>
<li>Install the new RPM package on each machine according to the OS you are using <ol>
<li>Get package: https://github.com/vesoft-inc/nebula-graph/releases/tag/v2.0.0-beta </li>
<li>Uninstall the original RPM package <code>rpm -e nebula-graph-2.0.0-alpha.el6.x86_64.rpm</code></li>
<li>Install package: nebula-graph-2.0.0-beta.el6.x86_64.rpm</li></ol></li>
<li>Start Nebula <ol>
<li>Execute scripts/nebula.service start all on each machine </li>
<li>Execute scripts/nebula.service status all to confirm Nebula services are started on each machine</li></ol></li>
</ol>
<p>If you encounter any problem during the upgrade, please feel free to leave your comment below!</p>

Nebula Graph v2.0.0-beta has just been released! This version supports full-text search and counting the number of nodes and edges within a graph space. Nebula Graph Studio, the graph visualization tool, and Go Importer, the data import tool, are both compatible with Nebula Graph 2.x

features

system-testing

dev-log

performance

use-cases

community

Deployment

tools

query-language

graph-computing

tech-talk

release-notes

architecture

news

source-code

user-review

knowledge-graph

Nebula Graph v2.0.0-beta Release Note

Benchmarking the Mainstream Open Source Distributed Graph Databases at Meituan: NebulaGraph vs Dgraph vs JanusGraph

Graph Database vs Relational Database: What to Choose?

Difference Between Relational and Non Relational Database

Use cases of graph databases in real-time recommendation

Graph RAG has been revolutionizing the industry since its [joint introduction](https://www.nebula-graph.io/posts/graph-RAG) with NebulaGraph and LlamaIndex in August 2023, capitalizing on the momentum of LLM and RAG (Retrieval-augmented Generation). In this blog post, we will walk you through what Graph RAG is, why it is revolutionizing, and how to build your Graph RAG that draws on data context to answer complex, multi-part questions with NebulaGraph.

# Understanding Graph RAG and Its Rising Popularity

This cutting-edge technology has garnered widespread interest due to its capability to harness knowledge graphs alongside LLMs, thereby offering a more comprehensive contextual understanding for search engines. This results in more cost-efficient, intelligent, and precise search outcomes. Beyond providing more accurate responses to build user trust, this technology has surmounted the primary obstacles of traditional search augmentation techniques: the absence of context comprehension and data training. Consequently, these advanced retrieval enhancement techniques are poised to expand their reach into various industries, such as medical diagnosis assistance, content creation and recommendation, interactive gaming, and knowledge graph construction.

Microsoft underscored the importance of Graph RAG in the blog post [GraphRAG: Unlocking LLM Discovery on Narrative Private Data](https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/), authored by Jonathan Larson, Senior Principal Data Architect, and Steven Truitt, Principal Program Manager. They illustrated the effectiveness of Graph RAG by contrasting it with a baseline RAG system, concluding that the Graph RAG approach enables the LLM to anchor itself in the graph, resulting in a superior answer that includes provenance through original supporting text. Meanwhile, the baseline RAG struggles with queries that necessitate aggregation of information across the dataset to formulate an answer.

# Building Your Graph RAG with NebulaGraph

NebulaGraph database has integrated with LLM frameworks such as [LlamaIndex](https://www.llamaindex.ai/) and [LangChain](https://www.langchain.com/); you could simply focus on LLM orchestration logic and pipeline design without worrying about complex implementation. You could take a trial to check whether the Graph RAG performs as awesome as it is said with simply 4 steps before exploring further to integrate it into applications or other scenarios. 

***Note:*** 

*As LlamaIndex evolves rapidly, the recent refactor/break change has led to some of the Graph RAG tutorials becoming non-runnable. This blog is here for the updated tutorials of Graph RAG so that you can hands on it without errors.*

*We have been exploring so many in-house approaches before we upstream them later. We believe the basic concept of Graph + RAG in LlamaIndex is worth exploring, so we put the original workshop and notebooks in the reference chapter.*

## Set up your NebulaGraph cluster

You could start with any one of the three methods below to quickly set up a NebulaGraph cluster:

- start the NebulaGraph cluster via [NebulaGraph Lite](https://github.com/nebula-contrib/nebulagraph-lite) in Google Colab
- [deploy the cluster with Docker extension](https://www.nebula-graph.io/posts/nebulagraph-database-on-docker-desktop)
- instantiate a [NebulaGraphStore](https://docs.llamaindex.ai/en/stable/examples/index_structs/knowledge_graph/NebulaGraphKGIndexDemo/)

```
import os
from llama_index.core import KnowledgeGraphIndex, SimpleDirectoryReader
from llama_index.core import StorageContext
from llama_index.graph_stores.nebula import NebulaGraphStore

os.environ["NEBULA_USER"] = "root"
os.environ["NEBULA_PASSWORD"] = "nebula"
os.environ["NEBULA_ADDRESS"] = "127.0.0.1:9669"


space_name = "paul_graham_essay"
edge_types, rel_prop_names = ["relationship"], ["relationship"]  # default, could be omit if create from an empty kg
tags = ["entity"]  # default, could be omit if create from an empty kg

graph_store = NebulaGraphStore(
    space_name=space_name,
    edge_types=edge_types,
    rel_prop_names=rel_prop_names,
    tags=tags)

storage_context = StorageContext.from_defaults(graph_store=graph_store)
```

Now, with your NebulaGraph cluster set up, you could hands on the knowledge graph building section. **Please make sure to run all the steps below in the Jupyter environment.**

## Dependencies
The implementation of Graph RAG requires the below dependencies.

```
pip install llama-index
pip install llama-index-llms-ollama
pip install llama-index-graph-stores-nebula
pip install ipython-ngql
pip install llama-index-embeddings-huggingface
```

## Create a LlamaIndex Knowledge Graph Index

`KnowledgeGraphIndex` handles automated knowledge graph construction from unstructured text as well as entity-based querying. You need to set up a LlamaIndex Knowledge Graph Index Before creating a Graph RAG query engine. In this example, we 
will demonstrate how to build KG from textual data by creating a document object before moving on to create an index.

```
from llama_index.core import (
    VectorStoreIndex,
    SimpleDirectoryReader,
    KnowledgeGraphIndex,
)

graph_store.query("SHOW HOSTS")

Settings.chunk_size = 512

documents = SimpleDirectoryReader(
    "data"
).load_data()
```

```
kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    storage_context=storage_context,
    max_triplets_per_chunk=10,
    space_name=space_name,
    edge_types=edge_types,
    rel_prop_names=rel_prop_names,
    tags=tags,
    max_knowledge_sequence=15,
)
```

## Create A Naive Graph RAG Retriever
The last step comes to creating a Graph RAG retriever, on top of which the query engine will be built so that you could query with natural language questions.

```
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.retrievers import KnowledgeGraphRAGRetriever

graph_rag_retriever = KnowledgeGraphRAGRetriever(
    storage_context=storage_context,
    verbose=True,
)

query_engine = RetrieverQueryEngine.from_args(
    graph_rag_retriever,
)
response = query_engine.query("What's the relationship between Bob and Alice")
```

Now, you’ve tried Graph RAG and if you’d like to explore more on how to retrieve via both GraphStore and VectorStore, you could find more demo examples here: [https://www.siwei.io/tutors/GraphRAG/101.html](https://www.siwei.io/tutors/GraphRAG/101.html).

Join our RAG discussion and let us know how your Graph RAG goes in our [Slack channel](https://join.slack.com/t/nebulagraph/shared_invite/zt-2h51ct4t0-IlXFaU01mpb3t2WgQ8qqNA).

Reference:

- [https://bit.ly/graph-rag-workshop](https://bit.ly/graph-rag-workshop)
- [https://siwei.io/graph-enabled-llama-index/kg_and_vector_RAG.html](https://siwei.io/graph-enabled-llama-index/kg_and_vector_RAG.html)
- [https://siwei.io/demo-dumps/graph-rag/GraphRAG.html](https://siwei.io/demo-dumps/graph-rag/GraphRAG.html)






This blog will walk you through what Graph RAG is, why it is revolutionizing, and how to build your Graph RAG that draws on data context to answer complex, multi-part questions with NebulaGraph.

Implementing Graph RAG with NebulaGraph

ISO/IEC released the [international standard of Graph Query Language (GQL)](https://www.iso.org/standard/76120.html) on April 12th, 2024. This publication establishes the foundations for property graphs, covering their creation, maintenance, and control, along with the data they comprise. It also standardizes the data management language for outlining and modifying the structure of these graphs and their collections.

# Why the International Standard of GQL Matters
The standardization of a language plays an instrumental role in its adoption and application. The standardization of SQL in the 1980s led to its global acceptance by relational databases, thereby propelling the growth of relational databases.

Similarly, the standardization of GQL will have far-reaching impacts on the industry. GQL standards will ensure data portability and manipulation across GQL implementations, and compatibility with programming languages and database tools. It will foster a dynamic graph database ecosystem and lower the entry barrier for this technology, enabling more enterprises to effectively utilize graph databases for complex relational data.

# NebulaGraph Enterprise v5.0 Now Offers Native GQL Support
As a member of Linked Data Benchmark Council, Vesoft (NebulaGraph) actively participates in the formulation and promotion of GQL standards and announces its GQL native support in NebulaGraph Enterprise v5.0.

In addition to the outperforming horizontal scalability, high availability and HPA capability, NebulaGraph Enterprise v5.0 stands as the first distributed graph database to natively support GQL. Unlike systems that are just compatible or adapted to GQL, NebulaGraph Enterprise v5.0 has been redesigned to support GQL at the overall architecture level: it is built on and designed for GQL. This enhancement offers superior data compatibility and interoperability, thereby amplifying the business value of graph databases across various scenarios.

# Why Enterprises Should Adopt the Graph Database with Native Support for GQL

Choosing a graph database with native support for GQL means that enterprises can directly take the following advantages of GQL benefits.

- Enhanced Interoperability

Adopting a graph database with native support for GQL enables seamless data migration between different systems and platforms. This freedom reduces dependence on a single database provider, making it easy to switch between solutions and enabling simultaneous use of multiple data systems.

- Improved Stability

Enterprises embracing GQL will no longer rely on independent tools or software layers to be compatible with GQL statements. Therefore, they can enjoy the simplified system with less likelihood of errors and ease of operation and maintenance.

- Enhanced Security

GQL has a robust security framework that offers mature security control. Systems that do not natively support GQL may require additional development to achieve similar security features, potentially leading to risks such as data leaks and non-compliance with regulations.

- Cost-Efficient Maintenance

Adopting graph databases with native support for GQL enables companies to quickly adapt to market changes, which can directly reduce the complexity and expense of future system upgrades and maintenance for enterprises.

In conclusion, the release of GQL marks a significant milestone of graph database technology, fostering innovation and widespread adoption of graph databases as well as the overall growth of the industry. As the first distributed graph database that natively supports GQL, NebulaGraph Enterprise v5.0 aligns with GQL standards and will continue to refine its performance and stability to empower various industries, such as financial services, technology, e-commerce and manufacturing, to unlock the value of complex relational data.

If you’re interested in embracing GQL with NebulaGraph Enterprise v5.0, feel free to [reach out](https://www.nebula-graph.io/contact) for a free trial.

The release of GQL marks a significant milestone of graph database technology and  NebulaGraph Enterprise v5.0 announces native GQL support. 

NebulaGraph Enterprise v5.0: The First Distributed Graph Database to Offer Native GQL Support

Graph databases are becoming increasingly prominent in the DBMS market for its advantages in uncovering important relationships of multiple datasets. Thus, they are ideal for use cases such as real-time recommendations, fraud detection and  knowledge graph constructions. Neo4j has been a leader since the early stage of the development of graph databases, therefore widely adopted by numerous organizations. However, with the explosion of data growth, organizations find sharding Neo4j too complicated and time-consuming, and looking for a solution to replace it. 

To help organizations with Neo4j’s challenges of operations and performance at scale  to make the critical decision of replacement, we hereby present a Neo4j alternative that is not only powerful but also open source, distributed, and fast. We also illustrate why big established companies are migrating to NebulaGraph. Welcome to the world of NebulaGraph.

# NebulaGraph: Open-Source, Distributed and Lighting Fast
NebulaGraph has cemented its name in the DBMS market as a lightning fast graph database with millisecond latency. Extremely huge quantities of graph data can be processed at speeds, which is a delight to any data scientist or developer.

As we lay out the following strengths that make NebulaGraph standout as a go-to alternative to Neo4j, you will notice that the strengths that make NebulaGraph a better alternative are those very qualities that those who work with data crave to see in a DBMS. 

From flexibility to efficiency that dazzles, let's see why NebulaGraph is finding wide acceptance as a perfect alternative and a solution to the challenges that many users encounter with Neo4j. 

Top strengths of NebulaGraph over Neo4j
- Shared-nothing distributed architecture
- Excellent at processing ultra large-scale connected data sets that have hundreds of billions of nodes and trillions of edges
- No bottleneck whatsoever when it comes to single-master write
- Supports linear expansion of reading and writing

Let’s now get into the details; 

## 1. Performance

NebulaGraph is highly performant thanks to RocksDB, the powerful storage engine that offers high throughput plus low latency read and write. The design is best described as state of the art, capable of achieving the following:

- Fast graph traversals (including complex graph traversals)
- Efficient memory use
- Real-time write performance
- Concurrent user access at very high levels
- Fast batch data import
- Efficient  n-hop query performance

Fact: Of all the open source graph database options in the market today, NebulaGraph is the only one that is capable of processing graph data that contains trillions of edges and vertices.

Read: [Why the Meituan team selected NebulaGraph as their graph storage engine after they performed intensive comparison tests](https://www.nebula-graph.io/posts/benchmarking-mainstraim-graph-databases-dgraph-nebula-graph-janusgraph).

## 2. High availability
This is another advantage that accrues from the horizontal scalability capability. Even in the midst of failures, you can be sure that NebulaGraph will be available.

An in-built [snapshot feature](https://www.nebula-graph.io/posts/nebula-graph-snapshot-introduction) makes it possible to capture snapshots of instances. You can then use these snapshots to restore data to any specific point in time. In case of data loss, the snapshots will come in handy.

What will happen if an instance fails? NebulaGraoh will get the failed instance out of the cluster, then create a new instance based on the snapshot. This new one will replace the failed instance. Remember all this happens automatically in real-time, and you can see everything, which is important for transparency.

## 3. Horizontal scalability
When it comes to scalability, NebulaGraph provides linear scalability - thanks to a shared nothing architecture. With this, you are able to add more and more nodes as well as services to the cluster without fearing a likelihood to compromise performance.

Additionally, you need not make any changes to the configurations of the nodes whenever you want to scale horizontally - as long as the bandwidth is enough.  It’s the best scalable graph database out here. 

## 4. Efficiency
NebulaGraph uses its own query language known as nGQL. The good thing with this query language is that it's very easy to understand, learn how it works and use. The greatest highlight of nGQL is that it transforms complex SQL queries to simple, brief queries. This single feature introduces significant efficiency that you will find hard to come by in Neo4j.

NGQL is also compatible with ISO-GQL and openCypher. With this level of compatibility, you are able to cut down on costs associated with learning and migration (more on migration shortly). Compatibility is another huge win for efficiency.

## 5. Flexibility
NebulaGraph works perfectly well wherever you take it. On-premises, macOS/Windows, public cloud, or hybrid cloud, NebulaGraph will work smoothly all the way.

Additionally, it comes with visualization tools that are so easy to use from the browser. This kind of flexibility unchains users and enables them to apply the database in creative ways.

## 6. Graph RAG (Retrieval-Augmented Generation)
NebulaGraph's [Graph RAG](https://www.nebula-graph.io/posts/graph-RAG#post-what-is-graph-rag) is the first of its kind in the industry. It combines [knowledge graphs with LLMs](https://www.nebula-graph.io/posts/graph-RAG) to enhance search results, meaning the results are intelligent, accurate and the process is cost-effective.

This is a welcome relief from the traditional methods which depend on keyword matching which is not effective especially when it comes to long tail queries.

Also Read:  [Graph RAG vs. Graph + Vector RAG](https://www.nebula-graph.io/posts/graph-RAG#post-demo-graph-rag-vs-vector-rag-vs-text2cypher)

## Visualization

Visualization is a key pillar of graph databases, and NebulaGraph offers multiple amazing visualization tools, including:
- [Nebula Dashboard](https://www.nebula-graph.io/products/dashboard)
- [Nebula Studio](https://www.nebula-graph.io/products/studio) (Community edition)
- [Nebula Explorer](https://www.nebula-graph.io/products/explorer) (Enterprise edition only)

## 8. Algorithm
The Nebula Algorithm is a GraphX- based Spark application that submits a Spark task to perform computing on data in a NebulaGraph database.

It's also possible to use the algorithm programmatically under the lib repository to accomplish graph computing on dataframe.

Please go through the overview of the [NebulaGraph algorithm](https://docs.nebula-graph.io/3.4.1/graph-computing/nebula-algorithm/).

## 9. Zero Learning Curve
nGQL, the query language for NebulaGraph, is gradually compatible with openCypher. This means new adopters can simply get started without worrying about the learning curve.

This is a very important quality because it means developers can get started with no complications, while operations professionals can equally work with Nebula Graph without being intimidated on the technical side. 

Here is a quick glance at what [nGQL](https://docs.nebula-graph.io/3.6.0/3.ngql-guide/1.nGQL-overview/1.overview/) supports:

- Graph traversals
- Aggregation
- Access control
- Composite queries
- Index

nGQ is constantly being improved and new features added to ensure the best experience for users.

## 10. A vibrant open-source community
The ever vibrant NebulaGraph community, through Nebula Contrib, boasts many contributions from members. Many tools have been contributed so far, including these that have recently been embraced:

- [NebulaGraphQL](https://github.com/nebula-contrib/NebulaGraphQL): Supports graph queries
- [nebulagraph-docker](https://github.com/nebula-contrib/nebulagraph-docker-ext): An extension that makes it possible to launch NebulaGraph Docker services in 10 seconds only.
- [testcontainers-nebula](https://github.com/nebula-contrib/testcontainers-nebula): To support  containerized testing

## Use cases for NebulaGraph

NebulaGraph is versatile in application with following use cases:

- [Fraud detection](https://www.nebula-graph.io/posts/fraud-detection-with-graph-analytics)
- [Real-time recommendation systems](https://www.nebula-graph.io/posts/use-cases-of-graph-databases-in-real-time-recommendation)
- [Social networking](https://www.nebula-graph.io/posts/social-networks-with-graph-database-1)
- [Knowledge graph](https://www.nebula-graph.io/posts/how-to-build-knowledge-graph)
- [Graph analytics and algorithms](https://docs.nebula-graph.io/3.5.0/graph-computing/nebula-analytics/)
- [Graph Embedding](https://www.nebula-graph.io/posts/graph-embeddings)
- [Artificial intelligence](https://www.nebula-graph.io/posts/graph-ai)
- [Network Security](https://www.nebula-graph.io/posts/intrusion-detection-with-graph-technology)
- [Anti money laundry](https://www.nebula-graph.io/posts/financial-fraud-detection-one-of-the-best-practices-of-knowledge-graph)

# Case Study

We have seen many users migrating from Neo4j to NebulaGraph for better operation and performance at scale. [Guotai Junan Securities](https://en.wikipedia.org/wiki/Guotai_Junan_Securities) is one of those looking for horizontal scalability, better graph inquiry and computing capabilities as well as enterprise support. Guotai Junan adopted Neo4j in 2018 for knowledge graphs for the corporation itself and industrial supply chain. However, in face of the changing business scenarios and needs, they decided to migrate to an alternative which excels at elastic capabilities of expansion and contraction. Meanwhile, as the business scenarios involve equity penetration, ultimate beneficiary as well as other business-related algorithms, the alternative needs to handle at least 10,000 API calls a day with second-level latency requirement. 

After the thorough evaluation of all the alternatives in the market, they finally chose to migrate to NebulaGraph Enterprise edition in 2023. With the successful migration, Guotai Junan Securities‘ graph platform based on NebulaGraph has a significant improvement in terms of overall performance and stability, effectively creating more value for the business development.

# Migrating from Neo4j to NebulaGraph

It's easy to [migrate data from Neo4j to NebulaGraph](https://www.nebula-graph.io/posts/how-to-import-data-from-neo4j-to-nebula-graph), thanks to NebulaGraph Exchange. This is NebulaGraph's migration tool that uses Spark to support the importation and high performance of huge datasets.

Here is an easy [guide](https://www.nebula-graph.io/posts/how-to-import-data-from-neo4j-to-nebula-graph) to help you migrate from Neo4j to NebulaGraph. Please [contact us](https://www.nebula-graph.io/contact) should you experience difficulties in understanding any part.

It's common knowledge that a good number of companies went to Neo4j for graph-related  use cases. However, at present, these companies are discovering it's no longer meeting their constantly changing needs especially on scalability and performance.

In fact, many enterprise customers of NebulaGraph confess that they made the decision because they were looking for alternatives to Neo4j and finally chose NebulaGraph.

# Conclusion
Big corporations in key industries have tested and compared NebulaGraph against Neo4j. The results have been amazing and this explains the reason a good number are migrating to Nebula Graph.

As the NebulaGraph ecosystem and community continues to grow at record speed, the team behind this powerful graph database is focussed on delivering a graph database landscape where users will spend more time deriving value as opposed to solving challenges.

Try NebulaGraph [free](https://www.nebula-graph.io/choose-a-cloud-vendor), available in both AWS and Microsoft Azure.


Explore an open-source, distributed, and fast Neo4j alternative, NebulaGraph, addressing operational and performance challenges. Discover why major companies are transitioning to NebulaGraph.