GraphForge

Embedded graph execution environment

Local graphs.Zero servers.Better reasoning. Faster reasoning. Cheaper reasoning.

Open-source, openCypher-compatible graph tooling with a Rust core, Arrow results, and Parquet persistence. Built for research, investigation, and data workflows.

Get Started Star on GitHub1

100%openCypher TCK3,897/3,897 full corpus

0Servers requiredembedded in your process

128MEdges tested up to8.0M nodes · fixed-hop engine

Py + NodeLanguage bindingsone Rust-owned engine

258 msCold first resultstandard Colab CPU

Why GraphForge

Built for analysts who think in graphs.

No provisioning. No driver ceremony. No hidden execution service. A durable graph environment that lives beside your data and your code.

Built for Analysts

Rank influence, uncover communities, compare entities, trace paths, and search the graph with methods shaped around analytical questions.

No server. Ever.

Install the library and start modeling. No daemon, connection string, cluster, or cloud account between you and the graph.

Fast execution in Rust

Run queries, graph algorithms, and search inside a native Rust engine, in the same process as your analysis.

Portable Arrow Results

Every query and analysis returns Apache Arrow, ready to move into pandas, Polars, and the broader data ecosystem.

Compatible Queries

Use familiar openCypher patterns shared across major graph databases, so your query knowledge transfers without learning a proprietary language.

Works Where You Do Already

Use GraphForge from Python notebooks, data scripts, Node applications, or VS Code without moving your work into a separate platform.

Projects That Travel

Keep graphs in ordinary project folders you can close, move, and reopen without database exports or server migrations.

One Project, Many Views

Move between ontology, knowledge, Cypher results, Arrow tables, and graph views without rebuilding context in another tool.

A different model

Moving beyond server-first graph databases?

Use a graph execution environment inside notebooks, scripts, and applications—with local persistence and Arrow-native results.

Explore the guide

Measured performance

Fast to start. Fast to analyze. Light as a complete system.

One embedded engine handles local persistence, Cypher, graph algorithms, full-text and vector retrieval, and Arrow results—without a server or network hop.

Standard Google Colab CPU

25,000-node local analysis profile

GraphForge 0.5.1

analysis nodes: 25K
graph edges: 125K
searchable docs + vectors: 1K

Project open → first Arrow resultcold start
258 ms
PageRank25K rows · warm median
301 ms
Louvain communities25K rows · warm median
323 ms
Hybrid search20 results · warm median
132 ms

Observed timings, not an SLO. Dataset built and persisted in 7.12s.

Run the exact notebook yourself.Public, version-pinned, and fully executed on Colab.

Run in Google Colab Methodology + source

True parity

Real engine. Real analytical workflows.

GraphForge does not delegate core behavior to Python or Node libraries. The native engine owns the work and every binding shares the result.

Cypher compiler

A typed Rust pipeline turns openCypher into plans and Arrow results without sending work to a remote service.

TCK-COMPATIBLE

Graph algorithms

PageRank, Louvain, similarity, paths, and analysis run inside the engine and return consistent typed tables.

RUST EXECUTION

Hybrid search

Combine structured graph filters with text and vector retrieval while bringing your own embeddings.

TEXT + VECTOR

Atomic publication

Durable project state is published as a coherent snapshot so readers never observe half-written graph data.

SNAPSHOT SAFETY

Arrow interchange

Move results into pandas, Polars, or downstream analytics without converting through bespoke row objects.

ZERO-COPY READY

Parquet persistence

Store graph projects in portable columnar files that fit local research, automation, and reproducible workflows.

LOCAL-FIRST

Python API

Use GraphForge naturally from notebooks and scripts while keeping all graph semantics in the native core.

PYTHON 3.10+

Node API

Bring embedded graph execution to modern Node applications with the same behavior and Arrow result model.

NODE 20+

Project portability

Close a project, move its directory, and reopen it without provisioning infrastructure or exporting a database.

NO DAEMON

Binding parity

One core. Every surface aligned.

Python and Node adapt arguments and Arrow data while execution, errors, identity, and persistence remain Rust-owned.

ENGINE

Rust core with one source of truth

Query planning, execution, algorithms, persistence, and search stay in the native engine so behavior cannot drift by language.

Typed Cypher compilation and execution
Arrow-native result tables
Parquet-backed durable projects
Atomic graph publication
Public UUID identity

PYTHON

Notebook-native analysis

Build and investigate graphs beside the rest of your data workflow with familiar Python ergonomics and native performance.

pandas and Polars interchange
Analyst verbs for rank and cluster
In-memory or persistent projects
Full openCypher query surface
No server lifecycle to manage

NODE

Embedded graphs for applications

Use the same Rust-owned engine from Node without introducing a remote graph service or a second behavioral contract.

Thin N-API binding
Arrow-compatible results
Shared project format
Consistent error taxonomy
Parity with Python behavior

GraphForge for VS Code

Think with the graph, inside your editor.

Open a local GraphForge project, run Cypher or analyst verbs, and inspect ontology, knowledge, and result graphs without leaving VS Code.

Works with your coding agent
Tested with Cursor, Codex, and Claude for agent-assisted graph exploration and analysis.
Data first. Code second.
Explore the entities, relationships, and shape of your data before deciding what to query, transform, or build.
Reasoning support
Use ontology and knowledge features to give analysts and their agents better context for exploration, evidence, and reasoning.

Install for VS Code Open VSX

Extension documentation

GraphForge capabilities

The graph toolkit, in one process.

Browse the Cypher language and analyst verbs, then jump directly to the relevant command documentation.

MATCHRead and filter OPTIONAL MATCHRead and filter WHERERead and filter RETURNProject and page ORDER BYProject and page LIMITProject and page SKIPProject and page CREATECreate and upsert MERGECreate and upsert SETUpdate properties REMOVEUpdate properties DELETEDelete graph data DETACH DELETEDelete graph data UNWINDRows and chaining WITHRows and chaining UNIONSet operations UNION ALLSet operations NODEGraph patterns RELATIONSHIPGraph patterns PATH VARIABLESGraph patterns CASEExpressions NULLExpressions BOOLEANExpressions COMPARISONExpressions STRINGFunctions MATHFunctions LISTFunctions AGGREGATIONFunctions GRAPHFunctions DATETemporal values TIMETemporal values DATETIMETemporal values DURATIONTemporal values $PARAMETERSParameters and subqueries EXISTS {}Parameters and subqueries rank()Rank nodes PAGERANKRank nodes BETWEENNESSRank nodes CLOSENESSRank nodes EIGENVECTORRank nodes ARTICLE RANKScore structure HITSScore structure K-COREScore structure TRIANGLE COUNTScore structure ADAMIC-ADARScore structure cluster()Cluster communities LOUVAINCluster communities LEIDENCluster communities LABEL PROPAGATIONCluster communities WALKTRAPCluster communities paths()Find paths BFSFind paths DIJKSTRAFind paths A*Find paths BELLMAN-FORDFind paths YEN'SFind paths MAX FLOWFlow and traversal MIN CUTFlow and traversal DFSFlow and traversal RANDOM WALKFlow and traversal REACHABILITYFlow and traversal analyze()Analyze graphs SPANNING TREEAnalyze graphs DAGAnalyze graphs COLORINGAnalyze graphs MATCHINGAnalyze graphs PLANARITYAnalyze graphs similar()Compare nodes JACCARDCompare nodes COSINECompare nodes OVERLAPCompare nodes find()Search and retrieve TEXTSearch and retrieve VECTORSearch and retrieve HYBRIDSearch and retrieve index()Search and retrieve

Cypher language Analyst verbs

Quick start

Up and querying in seconds.

Choose your language, install the package, and create an in-process graph with a familiar openCypher query surface.

1 · Install GraphForge

uv add graphforge

2 · Build and query

from graphforge import GraphForge

forge = GraphForge()

alice = forge.add_node("Person", name="Alice", age=30)
bob = forge.add_node("Person", name="Bob", age=25)
forge.add_edge(alice, "KNOWS", bob, since=2020)

table = forge.execute("""
  MATCH (p:Person)-[:KNOWS]->(friend)
  RETURN p.name AS person, friend.name AS friend
""")

print(table.to_pandas())

Open a persistent project

from pathlib import Path

Path("research").mkdir(exist_ok=True)
forge = GraphForge("research/")

Analyst verbs

forge.rank("Person", by="pagerank")
forge.cluster("Person", by="louvain", via="KNOWS")
forge.find("graph neural networks", label="Paper")

Move results downstream

table.to_pandas()
polars.from_arrow(table)
table.to_pylist()

Examples

Real workflows. Local graph.

From expressive Cypher to analyst-first operations, keep graph work close to the notebook or application that needs it.

MATCH (p:Paper)-[:CITES]->(source)
WHERE p.year >= 2024
WITH source, count(p) AS citations
RETURN source.title, citations
ORDER BY citations DESC
LIMIT 10