Apache HugeGraph Introduction

• 1: Introduction with HugeGraph

What Is Apache HugeGraph?

Apache HugeGraph is an easy-to-use, efficient, general-purpose open-source full-stack graph system (GitHub). It covers three major areas: graph databases (OLTP real-time queries), graph computing (OLAP large-scale analysis), and graph AI (GraphRAG and graph machine learning).

HugeGraph supports fast storage and queries for tens of billions of vertices and edges, with strong OLTP performance. Its graph engine is compatible with Apache TinkerPop 3 and supports both Gremlin and Cypher (the OpenCypher standard).

Typical use cases: deep relationship exploration, association analysis, path search, feature extraction, community detection, and knowledge graphs. Application areas: network security, telecom anti-fraud, financial risk control, advertising and recommendations, social networks, and intelligent Q&A.

Ecosystem Overview

┌────────────────────────────────────────────────────────────────────┐
│            Apache HugeGraph - Full-Stack Graph System             │
├──────────────────┬────────────────────┬────────────────────────────┤
│  Graph DB (OLTP) │    Graph Compute   │          Graph AI          │
│  HugeGraph       │  Vermeer (Memory)  │       HugeGraph-AI         │
│  Server          │  Computer (Dist.)  │     GraphRAG / GNN / Py    │
├──────────────────┴────────────────────┴────────────────────────────┤
│                       HugeGraph Toolchain                          │
│ Hubble | Loader | Client (Java/Go/Python; Rust WIP) | Spark | Tools│
└────────────────────────────────────────────────────────────────────┘

HugeGraph Server (OLTP Graph Engine)

HugeGraph Server is the OLTP engine and service entry point for the graph database. It handles property graph modeling, transaction processing, query execution, and API access. Graph data is stored in the configured RocksDB, HStore, or HBase backend.

• Property graph and schema: Manages VertexLabel, EdgeLabel, PropertyKey, and IndexLabel definitions
• Query languages: Supports Gremlin (TinkerPop 3) and Cypher (OpenCypher)
• REST API: Provides endpoints for schemas, graph data, queries, tasks, and operations
• Indexes and queries: Supports exact, range, and compound-condition queries
• Storage backends: Versions 1.7.0 through master primarily support RocksDB (standalone), HStore (distributed), and HBase

The main modules include hugegraph-core, the storage backend modules, and hugegraph-api. Core implements the graph model, transactions, and query logic; backend modules connect to specific storage systems; and the API module provides HTTP access. Current REST resource paths include the graph space and graph name, for example:

/graphspaces/{graphspace}/graphs/{graph}

Standalone deployments commonly use RocksDB. Distributed deployments use HStore: PD manages cluster metadata and partition scheduling, while Store persists graph data and replicas. HBase can be used as a separate storage backend.

• Server Quick Start
• PD Quick Start
• HStore Quick Start
• REST API

HugeGraph Toolchain

HugeGraph Toolchain provides clients, data import, visual management, Spark integration, and command-line operations. Together, these tools cover the main stages of a graph application’s lifecycle, from data ingestion to routine management.

Module	Purpose
Client	Wraps schema management, graph data reads and writes, Gremlin, and Traverser APIs; supports Java, Python, and Go, with a Rust client under development
Loader	Reads data from local files, HDFS, JDBC, Kafka, or another graph, converts it into vertices and edges, and imports it into HugeGraph in batches
Hubble	Provides a web management interface for graph connections, schemas, data import, Gremlin queries, and visual results
Spark Connector	Reads and writes HugeGraph data in Spark jobs for offline big-data processing
Tools	Provides command-line operations for deployment, graph management, backup and restore, and Gremlin execution

Graph Computing Engines (OLAP)

The HugeGraph-Computer repository provides two complementary OLAP graph computing engines:

• Vermeer: Written in Go, it uses a master-worker architecture and primarily performs in-memory computation. It provides REST APIs, gRPC, and a web UI, and is suitable for fast small- and medium-scale graph analysis.
• Computer: Written in Java, it implements the distributed BSP/Pregel computing model and can run on Kubernetes, YARN, or local processes. It can spill data to disk when memory thresholds are exceeded and is suitable for larger graph computing workloads.

Both engines can read HugeGraph data, but their runtime architectures, resource requirements, configuration, and algorithm interfaces differ.

• Vermeer Quick Start
• Computer Quick Start

HugeGraph-AI (Graph + AI)

HugeGraph-AI connects graph technology with large language models and graph machine learning frameworks. The repository uses Python 3.10 or later and manages its workspace with uv. Its main modules are:

• hugegraph-llm: Provides GraphRAG, knowledge graph construction, natural-language queries, and Text2Gremlin
• hugegraph-ml: Provides models for node classification, graph classification, graph embeddings, link prediction, and fraud detection
• hugegraph-python-client: Manages schemas, graph data, and Gremlin queries from Python
• vermeer-python-client: Calls Vermeer graph computing services from Python

HugeGraph-AI Quick Start

Deployment Modes

Mode	Core Components	Suitable Scenarios	Data Scale
Standalone (OLTP)	Server + RocksDB	Development, testing, and small to medium-scale data	≤ 2 TB
Distributed (OLTP)	Server + PD + Store (HStore)	Production, horizontal scaling, and multi-replica deployment	≤ 1 PB

Graph computing is an OLAP workload. Its capacity and resource requirements depend on the selected engine, graph structure, and algorithm, and do not use the OLTP storage capacity figures above.

Where to Start

Goal	Documentation
Start the graph database and run queries	Server Quick Start
Import data in batches	Loader
Manage graphs through a web interface	Hubble
Run graph algorithms	Vermeer and Computer
Build GraphRAG or graph machine learning applications	HugeGraph-AI

Community

• GitHub Issues
• Developer mailing list: dev@hugegraph.apache.org
• How to subscribe to the mailing list
• Security reports: security@hugegraph.apache.org
• WeChat public account: Apache HugeGraph

1 - Introduction with HugeGraph

Summary

Apache HugeGraph is an easy-to-use, efficient, general-purpose open-source graph database system (Graph Database, GitHub project address), implementing the Apache TinkerPop3 framework and fully compatible with the Gremlin query language, With complete toolchain components, it helps users easily build applications and products based on graph databases. HugeGraph supports fast import of more than 10 billion vertices and edges, and provides millisecond-level relational query capability (OLTP). It also supports large-scale distributed graph computing (OLAP).

Typical application scenarios of HugeGraph include deep relationship exploration, association analysis, path search, feature extraction, data clustering, community detection, knowledge graph, etc., and are applicable to business fields such as network security, telecommunication fraud, financial risk control, advertising recommendation, social network, and intelligence Robots, etc.

Features

HugeGraph supports graph operations in online and offline environments, batch importing of data and efficient complex relationship analysis. It can seamlessly be integrated with big data platforms. HugeGraph supports multi-user parallel operations. Users can enter Gremlin query statements and get graph query results in time. They can also call the HugeGraph API in user programs for graph analysis or queries.

This system has the following features:

• Ease of use: HugeGraph supports the Gremlin graph query language and a RESTful API, providing common interfaces for graph retrieval, and peripheral tools with complete functions to easily implement various graph-based query and analysis operations.
• Efficiency: HugeGraph has been deeply optimized in graph storage and graph computing, and provides a variety of batch import tools, which can easily complete the rapid import of tens of billions of data, and achieve millisecond-level response for graph retrieval through optimized queries. Supports simultaneous online real-time operations of thousands of users.
• Universal: HugeGraph supports the Apache Gremlin standard graph query language and the Property Graph standard graph modeling method, and supports graph-based OLTP and OLAP schemes. Integrate Apache Hadoop and Apache Spark big data platforms.
• Scalable: supports distributed storage, multiple copies of data, and horizontal expansion, built-in multiple back-end storage engines, and can easily expand the back-end storage engine through plug-ins.
• Open: HugeGraph code is open source (Apache 2 License), customers can modify and customize independently, and selectively give back to the open-source community.

The functions of this system include but are not limited to:

• Supports batch import of data from multiple data sources (including local files, HDFS files, MySQL databases, and other data sources), and supports import of multiple file formats (including TXT, CSV, JSON, and other formats)
• With a visual operation interface, it can be used for operation, analysis, and display diagrams, reducing the threshold for users to use
• Optimized graph interface: shortest path (Shortest Path), K-step connected subgraph (K-neighbor), K-step to reach the adjacent point (K-out), personalized recommendation algorithm PersonalRank, etc.
• Implemented based on the Apache TinkerPop3 framework, supports Gremlin graph query language
• Support attribute graph, attributes can be added to vertices and edges, and support rich attribute types
• Has independent schema metadata information, has powerful graph modeling capabilities, and facilitates third-party system integration
• Support multi-vertex ID strategy: support primary key ID, support automatic ID generation, support user-defined string ID, support user-defined digital ID
• The attributes of edges and vertices can be indexed to support precise query, range query, and full-text search
• The storage system adopts a plug-in method, supporting RocksDB (standalone/cluster), Cassandra, ScyllaDB, HBase, MySQL, PostgreSQL, Palo and Memory, etc.
• Integrated with big data systems such as HDFS, Spark/Flink, GraphX, etc., supports BulkLoad operation to import massive data.
• Supports HA(high availability), multiple data replicas, backup and recovery, monitoring, distributed Trace, etc.

Modules

• [HugeGraph-Store]: HugeGraph-Store is a distributed storage engine to manage large-scale graph data by integrating storage and computation within a unified system.
• [HugeGraph-PD]: HugeGraph-PD (Placement Driver) manages metadata and coordinates storage nodes.
• HugeGraph-Server: HugeGraph-Server is the core part of the HugeGraph project, containing Core, Backend, API and other submodules;
  • Core: Implements the graph engine, connects to the Backend module downwards, and supports the API module upwards;
  • Backend: Implements the storage of graph data to the backend, supports backends including Memory, Cassandra, ScyllaDB, RocksDB, HBase, MySQL and PostgreSQL, users can choose one according to the actual situation;
  • API: Built-in REST Server provides RESTful API to users and is fully compatible with Gremlin queries. (Supports distributed storage and computation pushdown)
• HugeGraph-Toolchain: (Toolchain)
  • HugeGraph-Client: HugeGraph-Client provides a RESTful API client for connecting to HugeGraph-Server, currently only the Java version is implemented, users of other languages can implement it themselves;
  • HugeGraph-Loader: HugeGraph-Loader is a data import tool based on HugeGraph-Client, which transforms ordinary text data into vertices and edges of the graph and inserts them into the graph database;
  • HugeGraph-Hubble: HugeGraph-Hubble is HugeGraph’s Web visualization management platform, a one-stop visualization analysis platform, the platform covers the whole process from data modeling, to fast data import, to online and offline analysis of data, and unified management of the graph;
  • HugeGraph-Tools: HugeGraph-Tools is HugeGraph’s deployment and management tool, including graph management, backup/recovery, Gremlin execution and other functions.
• HugeGraph-Computer: HugeGraph-Computer is a distributed graph processing system (OLAP). It is an implementation of Pregel. It can run on clusters such as Kubernetes/Yarn, and supports large-scale graph computing.
• HugeGraph-AI: HugeGraph-AI is HugeGraph’s independent AI component, providing training and inference functions of graph neural networks, LLM/Graph RAG combination/Python-Client and other related components, continuously updating.

Contact Us

• GitHub Issues: Feedback on usage issues and functional requirements (quick response)
• Feedback Email: dev@hugegraph.apache.org (subscriber only)
• Security Email: security@hugegraph.apache.org (Report SEC problems)
• WeChat public account: Apache HugeGraph, welcome to scan this QR code to follow us.

{width=“300” height=“94”}