[opensourcedex]

Raphtory is a free, open source databases project written in Rust and released under GPL-3.0. It has 650 GitHub stars, 70 forks and 196 open issues, and was last pushed 10 hours ago. On this registry it ranks #202 of 206 tracked projects in Databases, with 5 head-to-head comparisons available. It gained 6 stars over the last 30 tracked days.

What is Raphtory?

Raphtory is a scalable graph analytics database powered by a multithreaded, vectorised temporal engine written in Rust, intended for developers and data teams who need to analyse how relationships change over time rather than only how they stand at the present moment.

What it is

Raphtory is an in-memory, vectorised graph database written in Rust, with Python APIs layered on top. It lives in the Rust and Python ecosystems, shipping as the raphtory crate on crates.io and the raphtory package on PyPI, and it falls under the Infrastructure and Operations / Databases category of this registry. It can run embedded inside a host process or as a server instance exposing GraphQL. Its topic list covers analytics, graph databases, embedded databases, OLAP, temporal data, and time series, which reflects its position between a graph store and a temporal analytics engine. The licence is GPL-3.0, and the project publishes through the website at raphtory.com alongside documentation, a tutorial, and a Slack channel.

The concrete problem it solves is time. A conventional graph database stores the current shape of a network, so answering questions about how a node's degree evolved, or what an edge property was at a given instant, requires external bookkeeping: snapshots, event logs, or separate time-series tooling stitched onto the graph store. Raphtory models time as a first-class dimension of the graph itself, so rolling windows, point-in-time reads, and property histories are answered by the engine. The README frames it as something that drops into existing pipelines with pip install raphtory, and the same engine handles advanced analytics such as automatic risk detection, dynamic scoring, and temporal motifs instead of leaving them to downstream scripts.

Key capabilities

  • Embedded or server deployment, the latter hosting the data behind a GraphQL endpoint for integration with other applications.
  • Python API usable from version 3.8 upward, with graph construction through Graph(), add_node, and add_edge, and algorithm access through from raphtory import algorithms as algo.
  • Rust crate available from version 1.77 upward and added with cargo add raphtory.
  • Time travel over graph history, demonstrated with graph.rolling(window=1), point-in-time edge reads such as cb_edge.at(2), and temporal property access through cb_edge.properties.temporal.get("weight").items().
  • Built-in analytics, shown by algo.pagerank(graph).top_k(5).max_item(), alongside automatic risk detection, dynamic scoring, and temporal motifs.
  • Full-text search and multilayer modelling within the same graph structure.
  • Out-of-memory (on-disk) scaling, offered through the subscription model.

Who uses it and how

  • Analysts working interactively on a laptop, where the README states the engine scales to hundreds of millions of edges without a cluster.
  • Data engineers embedding it inside an existing Python pipeline, since ingestion is an import and a pip install rather than a separate service to stand up.
  • Application teams running Raphtory as a server and consuming graph analytics over GraphQL, so non-Python services can query the same data.
  • Researchers and modellers whose questions depend on history, such as degree counts within a rolling window, the weight history of a single edge, or the change in that weight between two timestamps.
  • Contributors, who are directed to the open issue list, the bounty board, and Slack.

Getting started

For Python 3.8 or higher, install with pip install raphtory; for Rust 1.77 or higher, add the crate with cargo add raphtory. A step-by-step walkthrough of graph creation is linked from the README at the raphtory.com user guide.

How it compares

This registry entry names no comparable graph or temporal analytics tools, and the facts supply no list of paid products that Raphtory replaces, so it stands alone among the entries documented here. Its distinguishing axes are the GPL-3.0 licence, embedded or self-hosted deployment with no managed service required, local ownership of graph data, and a cost model where the core install is free while out-of-memory on-disk scaling sits behind a subscription.

When to use it — and when not to

The footprint is small: no external database, storage layer, or mail service is mentioned, so a self-hoster mainly needs a matching Python or Rust toolchain and, for server mode, a GraphQL endpoint to operate. The caveats are real, however — the expensive scaling path is subscription-gated, GPL-3.0 is copyleft and may not suit every organisation, and the repository carries a large open issue count alongside a README that is closer to a quickstart than to operational documentation. Teams that need a permanently on-disk engine under a permissive licence, or that want a static graph store rather than a temporal one, should look elsewhere first.

project readme (upstream, from github) — read inline

Raphtory

Test and Build Latest Release Issues Crates.io PyPI PyPI Downloads Launch Notebook

🌍 Website   📒 Documentation   Pometry   🧙Tutorial   🐛 Report a Bug   Join Slack


Raphtory is an in-memory vectorised graph database written in Rust with friendly Python APIs on top. It is blazingly fast, scales to hundreds of millions of edges on your laptop, and can be dropped into your existing pipelines with a simple pip install raphtory.

It can be ran embedded or as a server instance using GraphQL, supports time traveling, full-text search, multilayer modelling, and advanced analytics beyond simple querying like automatic risk detection, dynamic scoring, and temporal motifs. With the subscription model, Raphtory also supports out-of-memory (on-disk) scaling with no performance loss!

If you wish to contribute, check out the open list of issues, bounty board or hit us up directly on slack. Successful contributions will be reward with swizzling swag!

Installing Raphtory

Raphtory is available for Python and Rust.

For python you must be using version 3.8 or higher and can install via pip:

pip install raphtory

For Rust, Raphtory is hosted on crates for Rust version 1.77 or higher and can be included in your project via cargo add:

cargo add raphtory

Running a basic example

Below is a small example of how Raphtory looks and feels when using our Python APIs. If you like what you see, you can dive into a full tutorial here.

from raphtory import Graph
from raphtory import algorithms as algo
import pandas as pd

# Create a new graph
graph = Graph()

# Add some data to your graph
graph.add_node(timestamp=1, id="Alice")
graph.add_node(timestamp=1, id="Bob")
graph.add_node(timestamp=1, id="Charlie")
graph.add_edge(timestamp=2, src="Bob", dst="Charlie", properties={"weight": 5.0})
graph.add_edge(timestamp=3, src="Alice", dst="Bob", properties={"weight": 10.0})
graph.add_edge(timestamp=3, src="Bob", dst="Charlie", properties={"weight": -15.0})

# Check the number of unique nodes/edges in the graph and earliest/latest time seen.
print(graph)

results = [["earliest_time", "name", "out_degree", "in_degree"]]

# Collect some simple node metrics Ran across the history of your graph with a rolling window
for graph_view in graph.rolling(window=1):
    for v in graph_view.nodes:
        results.append(
            [graph_view.earliest_time, v.name, v.out_degree(), v.in_degree()]
        )

# Print the results
print(pd.DataFrame(results[1:], columns=results[0]))

# Grab an edge, explore the history of its 'weight'
cb_edge = graph.edge("Bob", "Charlie")
weight_history = cb_edge.properties.temporal.get("weight").items()
print(
    "The edge between Bob and Charlie has the following weight history:", weight_history
)

# Compare this weight between time 2 and time 3
weight_change = cb_edge.at(2)["weight"] - cb_edge.at(3)["weight"]
print(
    "The weight of the edge between Bob and Charlie has changed by",
    weight_change,
    "pts",
)

# Run pagerank and ask for the top ranked node
top_node = algo.pagerank(graph).top_k(5).max_item()
print(
    "The most important node in the graph is",
    top_node[0].name,
    "with a score of",
    top_node[1],
)

Output:

Graph(number_of_edges=2, number_of_nodes=3, earliest_time=1, latest_time=3)

|   | earliest_time | name    | out_degree | in_degree |
|---|---------------|---------|------------|-----------|
| 0 | 1             | Alice   | 0          | 0         |
| 1 | 1             | Bob     | 0          | 0         |
| 2 | 1             | Charlie | 0          | 0         |
| 3 | 2             | Bob     | 1          | 0         |
| 4 | 2             | Charlie | 0          | 1         |
| 5 | 3             | Alice   | 1          | 0         |
| 6 | 3             | Bob     | 1          | 1         |
| 7 | 3             | Charlie | 0          | 1         |

The edge between Bob and Charlie has the following weight history: [(2, 5.0), (3, -15.0)]

The weight of the edge between Bob and Charlie has changed by 20.0 pts

The top node in the graph is Charlie with a score of 0.4744116163405977

GraphQL

As part of the python APIs you can host your data within Raphtory's GraphQL server. This makes it super easy to integrate your graphy analytics with web applications.

Below is a small example creating a graph, running a server hosting this data, querying it with our GraphQL client, or visualising your data in the UI.

from raphtory import Graph
from raphtory.graphql import GraphServer
import pandas as pd
import os

# URL for lord of the rings data from our main tutorial
url = "https://raw.githubusercontent.com/Raphtory/Data/main/lotr-with-header.csv"
df = pd.read_csv(url)

# Load the lord of the rings graph from the dataframe
graph = Graph()
graph.load_edges(df,"time","src_id","dst_id")

#Create a working_dir for your server and save your graph into it 
#You can save any number of graphs here or create them via the server ones its running
os.makedirs("graphs/", exist_ok=True)
graph.save_to_file("graphs/lotr_graph")

# Launch the server and get a client to it.
server = GraphServer(work_dir="graphs/").start()
client = server.get_client()

#Run a basic query to get the names of the characters + their degree
results = client.query("""{
             graph(path: "lotr_graph") {
                 nodes {
                    list{
                        name
                        degree
                       }   
                    }
                 }
             }""")

print(results)

Output:

Loading edges: 100%|██████████████| 2.65K/2.65K [00:00<00:00, 984Kit/s]
Playground: http://localhost:1736
{'graph': 
    {'nodes': 
        [{'name': 'Gandalf', 'degree': 49}, 
         {'name': 'Elrond', 'degree': 32}, 
         {'name': 'Frodo', 'degree': 51}, 
         {'name': 'Bilbo', 'degree': 21}, 
         ...
        ]
    }
}

GraphQL Playground

When you host a Raphtory GraphQL server you get a web playground bundled in, accessible on the same port within your browser (defaulting to 1736). Here you can experiment with queries on your graphs and explore the schema. An example of the playground can be seen below, running the same query as in the python example above.

GraphQL Playground

Graph Visualisation and Explorations

Once the GraphQL server is running, you can access the UI directly. If the server is hosted on port 1736, the UI will be available at http://localhost:1736. The UI allows you to search for data in Raphtory, explore connections, and visualise the graph effortlessly.

Graph User Interface

Getting started

To get you up and running with Raphtory we provide a full set of tutorials on the Raphtory website:

If API documentation is more your thing, you can dive straight in here!

Community

Join the growing community of open-source enthusiasts using Raphtory to power their graph analysis!

  • Follow Slack for the latest Raphtory news and development

  • Join our Slack to chat with us and get answers to your questions!

Contributors

Bounty board

Raphtory is currently offering rewards for contributions, such as new features or algorithms. Contributors will receive swag and prizes!

To get started, check out our list of desired algorithms which include some low hanging fruit (🍇) that are easy to implement.

Benchmarks

We host a page which triggers and saves the result of two benchmarks upon every push to the master branch. View this here

License

Raphtory is licensed under the terms of the GNU General Public License v3.0 (check out our LICENSE file).

Citations

To cite Raphtory in your work refer to our paper 'Raphtory: The temporal graph engine for Rust and Python'.

@article{Steer2024, doi = {10.21105/joss.05940}, url = {https://doi.org/10.21105/joss.05940}, year = {2024}, publisher = {The Open Journal}, volume = {9}, number = {95}, pages = {5940}, author = {Steer, Ben and Arnold, Naomi A. and Tidiane, Cheick and Lambiotte, Renaud and Yousaf, Haaroon and Jeub, Lucas and Murariu, Fabian and Kapoor, Shivam and Rico, Pedro and Chan, Rachel and Chan, Louis and Alford, James and Clegg, Richard G. and Cuadrado, Felix and Barnes, Matthew Russell and Zhong, Peijie and Pougué-Biyong, John and Alnaimi, Alhamza}, title = {Raphtory: The temporal graph engine for Rust and Python}, journal = {Journal of Open Source Software} }

Frequently asked questions

Is Raphtory free to use?

Raphtory is open source under the GPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Raphtory do?

Scalable graph analytics database powered by a multithreaded, vectorized temporal engine, written in Rust

What is Raphtory written in?

Raphtory is primarily written in Rust. Its source is publicly available at https://github.com/Pometry/Raphtory, and it has 650 GitHub stars.