<p><img src="https://user-images.githubusercontent.com/57335825/115350948-49593600-a1e8-11eb-9162-06941ff5edd5.png" alt="NebulaGraph v1.2.1 release note" /></p>
<p>NebulaGraph v1.2.1 mainly has enhanced the <code>LOOKUP</code> statement and improved the performance. And also has fixed some bugs.</p>
<h2 id="post-new-features">New Features</h2>
<ul>
<li><code>YIELD</code> clause supports <code>DISTINCT</code> <a href="https://github.com/vesoft-inc/nebula/pull/2368">https://github.com/vesoft-inc/nebula/pull/2368</a></li>
<li>Add <code>lookup_concurrently</code> option. <code>LOOKUP</code> supports traversing all partitions concurrently, which improves the performance significantly. <a href="https://github.com/vesoft-inc/nebula/pull/2417">https://github.com/vesoft-inc/nebula/pull/2417</a></li>
<li><code>LOOKUP</code> clause supports <code>DISTINCT</code>. <code>LOOKUP ON</code> supports returning srcid and dstid of an edge. <a href="https://github.com/vesoft-inc/nebula/pull/2415">https://github.com/vesoft-inc/nebula/pull/2415</a></li>
</ul>
<h2 id="post-bugfix">Bugfix</h2>
<ul>
<li>Fix the issue that <code>YIELD -1*1</code> may result in an overflow. <a href="https://github.com/vesoft-inc/nebula/pull/2411">https://github.com/vesoft-inc/nebula/pull/2411</a></li>
<li>Fix the issue that leader election may be unstable when RPC times out. <a href="https://github.com/vesoft-inc/nebula/pull/2419">https://github.com/vesoft-inc/nebula/pull/2419</a></li>
<li>Fix UnaryExpression bug which causes storaged crash. <a href="https://github.com/vesoft-inc/nebula/pull/2412">https://github.com/vesoft-inc/nebula/pull/2412</a></li>
<li>Fix the issue <code>LIMIT</code> and <code>OFFSET</code> do not return the expected result. <a href="https://github.com/vesoft-inc/nebula/pull/2428">https://github.com/vesoft-inc/nebula/pull/2428</a></li>
<li>Fix the issue that partial results may return after the leader change. <a href="https://github.com/vesoft-inc/nebula/pull/2465">https://github.com/vesoft-inc/nebula/pull/2465</a></li>
<li>Fix the issue that executing <code>FETCH PROP ON *</code>  may lead to graphd crash after altering schema. <a href="https://github.com/vesoft-inc/nebula/pull/2461">https://github.com/vesoft-inc/nebula/pull/2461</a></li>
</ul>
<h2 id="post-changelog">Changelog</h2>
<ul>
<li>Remove option <code>check_leader</code>. Metaclient always gets the meta info from the leader server. <a href="https://github.com/vesoft-inc/nebula/pull/2403">https://github.com/vesoft-inc/nebula/pull/2403</a>，<a href="https://github.com/vesoft-inc/nebula/pull/2423">https://github.com/vesoft-inc/nebula/pull/2423</a></li>
</ul>
<h2 id="post-upgrade-steps">Upgrade Steps</h2>
<ul>
<li>Stop all Nebula services<ul>
<li>Execute <code>scripts/nebula.service stop all</code> on each machine</li>
<li>Execute <code>scripts/nebula.service status  all</code> to ensure that all processes have exited</li></ul></li>
<li>Install the new RPM package on each machine per your system environment<ul>
<li>Get the package：<a href="https://github.com/vesoft-inc/nebula/releases/tag/v1.2.1">https://github.com/vesoft-inc/nebula/releases/tag/v1.2.1</a></li>
<li>Install the package</li></ul></li>
<li>Start Nebula<ul>
<li>Execute <code>scripts/nebula.service start all</code> on each machine</li>
<li>Execute <code>scripts/nebula.service status all</code> to ensure that all processes have started properly</li></ul></li>
</ul>
<p>Note: If you are currently using NebulaGraph v1.0.0-RC3 or a previous version, please re-load your data after upgrading to v1.2.1.</p>
<p>Here is the GitHub repo of NebulaGraph: <a href="https://github.com/vesoft-inc/nebula">https://github.com/vesoft-inc/nebula</a>. Please feel free to try the latest version. </p>
<p>If you encounter any problem, please ask on our <a href="https://github.com/vesoft-inc/nebula/discussions">Discussions:</a></p>

NebulaGraph v1.2.1 has just been released. This version mainly has enhanced the `LOOKUP` statement and improved the performance. And also has fixed some bugs.

Features

System-testing

Dev-log

Performance

Use-cases

Community

Deployment

Tools

Query-language

Graph-computing

Tech-talk

Release-notes

Architecture

News

Source-code

Success-stories

Knowledge-graph

NebulaGraph v1.2.1 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


# Summary


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

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

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

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


# Platform architecture and components





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



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

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


## Service component


NebulaGraph Cloud is composed of two main parts:


### Control Plane


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


### Data Plane


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


## Cost-optimized design


Illustrated with a sample database configuration:


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


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

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



## Specification adjustments

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

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

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





## Horizontal expansion and contraction


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

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

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

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

## Automatic elastic expansion and contraction


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

The Elastic Scaling Service architecture is as follows:

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

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


# Design for Efficiency Improvement





## Network security access

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

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

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






## Backup and recovery


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

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

Backup data catalog structure:


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


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




## High availability


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

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

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

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


# Practical exercises on the cloud




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

## Visualization tools

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

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

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

## network whitelisting

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


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

## Privatelink private network connection

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

Run the command to create the Endpoint:


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


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

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


# Summary and outlook


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

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

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

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




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

NebulaGraph Cloud on AWS：Auto Scale, Start Free

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

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


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

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

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

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

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Ready to Elevate Your Knowledge Management into RAG Apps?

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

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