logo
Enterprise

NebulaGraph Database Adopters

adopter
adopter
adopter
adopter
adopter

NebulaGraph v3.3.0 released !

Optimized the performance of k-hop and GO statement, and fixed some bugs.

Because a graph database should be open

Proudly open source

Free as in freedom

Free as in freedom

NebulaGraph adopts the Apache 2.0 license, one of the most permissive free software licenses in the world. Free as in freedom, because, under the Apache 2.0 license, you can use, copy, modify and redistribute NebulaGraph, even for commercial purposes, all without asking for permission.

Open to contributions

Open to contributions

We believe that great open source projects are not built in isolation, but rather by a community of contributors. We welcome contributions to Nebula Graph from anyone regardless of skill level or background in software development. If you have an idea for a feature you would like to see added, or you have identified a bug that needs fixing, please don't hesitate to submit an issue to our Github repository.

Open integration

Open integration

NebulaGraph comes with a wide range of data visualization tools, including NebulaGraph Dashboard, NebulaGraph Explorer, and NebulaGraph Studio. Using tools like NebulaGraph Algorithm and NebulaGraph Analytics, you can easily integrate NebulaGraph with other open source big data frameworks like Spark GraphX, Flink, and Tencent Plato, to enhance your graph computing ability.

4.4K+
Pull request

8.1K+
Github stars

9.0K+
Posts

150+
Contributors

An Open Source 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

Architecture

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 = "127.0.0.1:9669";
    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::exit(static_cast<int>(cbResult.errorCode));
        }
        std::cout << *cbResult.data;
        complete.store(true);
    });

    while (!complete.load()) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    session.release();
    return 0;
}
import (
	"fmt"

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

const (
	address = "127.0.0.1"
	// 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 {
			fmt.Print(err.Error())
			return
		}
		checkResultSet(createSchema, resultSet)
	}
	// Drop space
	{
		query := "DROP SPACE IF EXISTS basic_example_space"
		// Send query
		resultSet, err := session.Execute(query)
		if err != nil {
			fmt.Print(err.Error())
			return
		}
		checkResultSet(query, resultSet)
	}

	fmt.Print("
")
	log.Info("Nebula Go Client Basic Example Finished")
}
NebulaPoolConfig nebulaPoolConfig = new NebulaPoolConfig();
nebulaPoolConfig.setMaxConnSize(10);
List<HostAddress> addresses = Arrays.asList(new HostAddress("127.0.0.1", 9669),
        new HostAddress("127.0.0.1", 9670));
NebulaPool pool = new NebulaPool();
pool.init(addresses, nebulaPoolConfig);
Session session = pool.getSession("root", "nebula", false);
session.execute("SHOW HOSTS;");
session.release();
pool.close();
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([('127.0.0.1', 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')
print(result)

# release session
session.release()

# 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')
    print(result)

# close the pool
connection_pool.close()
// 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 Database 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

Architect

  • 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