Contact Us



NebulaGraph v3.6.0 released !

Enhance the full-text index and optimize MATCH performance in some scenarios.

Why choose NebulaGraph Database

Proudly open source

 Flexible deployment

Flexible deployment

Take NebulaGraph Database wherever you want, on-premises, public cloud, hybrid deployment, or even on macOS/Windows. Plus, with easy-to-use browser-based visualization toolkits, you can take graph technology to the next level.

High-speed data processing

High-speed data processing

NebulaGraph's powerful native graph engine enables lightning-fast QPS and TPS with millisecond latency. With high concurrency, efficient graph traversals, and optimized memory usage, you can process sheer volumes of graph data blazingly fast.

Intuitive efficiency

Intuitive efficiency

NebulaGraph simplifies data queries with nGQL, a query language that is easy to learn and use, efficiently transforming complex SQL queries into brief graph queries. And with compatibility for openCypher and ISO-GQL, you can cut down learning and migration costs while maximizing efficiency.

Pull request

Github stars



A graph database made for the cloud

The graph database following the cloud-native way

Highly performant

NebulaGraph leverages the powerful storage engine RocksDB to provide low-latency read and write and high throughput. It uses a state-of-the-art design that delivers highly concurrent access, fast graph traversals, and efficient use of memory. NebulaGraph is the only open source graph database that can store and process graphs with trillions of edges and vertices.

Learn more
Highly performant

openCypher compatible

NebulaGraph’s nGQL query language is gradually compatible with openCypher. This enables openCypher users to easily get started with NebulaGraph with a zero learning curve.

Learn more
openCypher compatible

Horizontally scalable

With a shared-nothing distributed architecture, NebulaGraph offers linear scalability, meaning that you can add more nodes or services to the cluster without affecting performance. It also means that if you want to horizontally scale out NebulaGraph, you don’t need to change the configuration of the existing nodes. As long as the network bandwidth is sufficient, you can add more nodes without changing anything else.

Learn more
Horizontally scalable

Resilient to failures

With horizontal scalability and a snapshot feature, NebulaGraph guarantees high availability even in case of failures. The snapshot feature allows users to take snapshots of a NebulaGraph instance at any point in time so that they can use them to restore data at that specific time. If a disaster occurs, NebulaGraph can be recovered from snapshots without data loss. When an instance fails, NebulaGraph will first remove this instance from the cluster and create a new one based on the snapshot to replace this failed instance. This process is fully automatic and transparent to clients.

Learn more
Resilient to failures

Production ready

NebulaGraph is mature, stable, and production-ready. NebulaGraph has been widely used in production by large internet companies including Meituan, Tencent, WeBank, Boss Zhipin, and Zhihu. These companies are using NebulaGraph in their production environments for real-world applications like knowledge graph, recommendation systems, and fraud detection.

Learn more
Production ready

Distributed graph database system


Use your favorite programming languages

Welcome to NebulaGraph Community

#include <atomic>
#include <chrono>
#include <thread>

#include <nebula/client/Config.h>
#include <nebula/client/ConnectionPool.h>
#include <common/Init.h>

int main(int argc, char* argv[]) {
    nebula::init(&argc, &argv);
    auto address = "";
    if (argc == 2) {
        address = argv[1];
    std::cout << "Current address: " << address << std::endl;
    nebula::ConnectionPool pool;
    pool.init({address}, nebula::Config{});
    auto session = pool.getSession("root", "nebula");
    if (!session.valid()) {
        return -1;

    auto result = session.execute("SHOW HOSTS");
    if (result.errorCode != nebula::ErrorCode::SUCCEEDED) {
        std::cout << "Exit with error code: " << static_cast<int>(result.errorCode) << std::endl;
        return static_cast<int>(result.errorCode);
    std::cout << *result.data;

    std::atomic_bool complete{false};
    session.asyncExecute("SHOW HOSTS", [&complete](nebula::ExecutionResponse&& cbResult) {
        if (cbResult.errorCode != nebula::ErrorCode::SUCCEEDED) {
            std::cout << "Exit with error code: " << static_cast<int>(cbResult.errorCode)
                      << std::endl;
        std::cout << *cbResult.data;

    while (!complete.load()) {

    return 0;
import (

	nebula "github.com/vesoft-inc/nebula-go/v3"

const (
	address = ""
	// The default port of NebulaGraph 2.x is 9669.
	// 3699 is only for testing.
	port     = 3699
	username = "root"
	password = "nebula"

// Initialize logger
var log = nebula.DefaultLogger{}

func main() {
	hostAddress := nebula.HostAddress{Host: address, Port: port}
	hostList := []nebula.HostAddress{hostAddress}
	// Create configs for connection pool using default values
	testPoolConfig := nebula.GetDefaultConf()

	// Initialize connection pool
	pool, err := nebula.NewConnectionPool(hostList, testPoolConfig, log)
	if err != nil {
		log.Fatal(fmt.Sprintf("Fail to initialize the connection pool, host: %s, port: %d, %s", address, port, err.Error()))
	// Close all connections in the pool
	defer pool.Close()

	// Create session
	session, err := pool.GetSession(username, password)
	if err != nil {
		log.Fatal(fmt.Sprintf("Fail to create a new session from connection pool, username: %s, password: %s, %s",
			username, password, err.Error()))
	// Release session and return connection back to connection pool
	defer session.Release()

	checkResultSet := func(prefix string, res *nebula.ResultSet) {
		if !res.IsSucceed() {
			log.Fatal(fmt.Sprintf("%s, ErrorCode: %v, ErrorMsg: %s", prefix, res.GetErrorCode(), res.GetErrorMsg()))

		// Prepare the query
		createSchema := "CREATE SPACE IF NOT EXISTS basic_example_space(vid_type=FIXED_STRING(20)); " +
			"USE basic_example_space;" +
			"CREATE TAG IF NOT EXISTS person(name string, age int);" +
			"CREATE EDGE IF NOT EXISTS like(likeness double)"

		// Excute a query
		resultSet, err := session.Execute(createSchema)
		if err != nil {
		checkResultSet(createSchema, resultSet)
	// Drop space
		query := "DROP SPACE IF EXISTS basic_example_space"
		// Send query
		resultSet, err := session.Execute(query)
		if err != nil {
		checkResultSet(query, resultSet)

	log.Info("Nebula Go Client Basic Example Finished")
NebulaPoolConfig nebulaPoolConfig = new NebulaPoolConfig();
List<HostAddress> addresses = Arrays.asList(new HostAddress("", 9669),
        new HostAddress("", 9670));
NebulaPool pool = new NebulaPool();
pool.init(addresses, nebulaPoolConfig);
Session session = pool.getSession("root", "nebula", false);
session.execute("SHOW HOSTS;");
from nebula3.gclient.net import ConnectionPool
from nebula3.Config import Config

# define a config
config = Config()
config.max_connection_pool_size = 10
# init connection pool
connection_pool = ConnectionPool()
# if the given servers are ok, return true, else return false
ok = connection_pool.init([('', 9669)], config)

# option 1 control the connection release yourself
# get session from the pool
session = connection_pool.get_session('root', 'nebula')

# select space
session.execute('USE nba')

# show tags
result = session.execute('SHOW TAGS')

# release session

# option 2 with session_context, session will be released automatically
with connection_pool.session_context('root', 'nebula') as session:
    session.execute('USE nba')
    result = session.execute('SHOW TAGS')

# close the pool
// ESM
import { createClient } from '@nebula-contrib/nebula-nodejs'

// CommonJS
// const { createClient } = require('@nebula-contrib/nebula-nodejs')

// Connection Options
const options = {
  servers: ['ip-1:port','ip-2:port'],
  userName: 'xxx',
  password: 'xxx',
  space: 'space name',
  poolSize: 5,
  bufferSize: 2000,
  executeTimeout: 15000,
  pingInterval: 60000

// Create client
const client = createClient(options)

// Execute command
// 1. return parsed data (recommend)
const response = await client.execute('GET SUBGRAPH 3 STEPS FROM -7897618527020261406')
// 2. return nebula original data
const responseOriginal = await client.execute('GET SUBGRAPH 3 STEPS FROM -7897618527020261406', true)

NebulaGraph is for you

Whether you are a DBA, architect, or data scientist

DevOps & DBA

  • Visualized graph database and cluster management tool
  • Effortless scale in and scale out
  • Enterprise-grade security
  • Automatic disaster recovery without downtime
  • Deploy in single machines or clusters


  • Integrations with popular languages and tools
  • No cloud vendor lock-in
  • Shared-nothing architecture
  • Low-latency read and write and high throughput
  • Open source under Apache 2.0.

Data scientist

  • Powerful data visualization and graph exploration tools
  • Deploy in your local computer
  • SQL-like query language
  • Visualized data import tools
  • Connect to GraphX and Flink using NebulaGraph Connector