Easy graph development in Python

Zef is an open source, data-oriented toolkit for graph data. It combines the access speed and local development experience of an in-memory data structure with the persistence and full-versioning of a distributed, immutable database. Create your first database in a few lines:

Copied to clipboard!

from zef import *
from zef.ops import *

# Create a new database
g = Graph()

# Add an entity
p1 = ET.Person | g | run

# Add "fields" (source, relation, target)
(p1, RT.FirstName, "Yolandi") | g | run

# Traverse your nodes through time and space
p1 | now | Out[RT.FirstName] | value | collect # -> "Yolandi"

In Zef, we overloaded the "|" pipe so users can chain together values, Zef operators (ZefOps), and functions in sequential, lazy, and executable pipelines where data flow is left to right.

Go to Zef docs

DEVELOP WITH ZEF

(g
| now                                # At the latest time slice
| all[ET.Person]                     # Get all ET.Person nodes
| filter[F.Name | equals["Yolandi"]] # Filter on the value of the field RT.Name
| single                             # Confirm only a single Person named Yolandi
| collect)                           # Make entire pipeline eager and return value

Powerful Python operators

Pipe together queries or pipelines directly in Python with a pre-built library of lazy operators. Work with your graphs like local data structures.

# View this entity 2 time slices ago relative to its slice
p1 | time_travel[-2] | collect

# View the graph at this absolute time
absolute_t = Time('2021 December 4 15:31:00 (+0100)')
g | time_travel[absolute_t] | collect

# View all graph transactions
first_tx = g | all[TX] | first | collect

# View events in any given Transaction
first_tx | events | collect

Fully versioned graphs

An in-memory, immutable database means fully versioned graphs out-of-the-box. Time travel with ease to any previous time slice.

# Autogenerate the actions to create a GraphQL backend
actions = auto_generate_gql(g)

# Apply the actions on a graph
tx_receipt = actions | transact[g] | run

# Get the schema root from tx_receipt dict
my_schema = tx_receipt["schema_root"]

# Construct an Effect which starts a GraphQL server
Effect({
        "type": FX.GraphQL.StartServer,
        "schema_root": my_schema,
        "path": '/my-api',
        "port": 6000,
}) | run

Native GraphQL support

Automatically generate a GraphQL schema and explore with the GQL playground. Launch a GraphQL server with just a few lines of code.

Easy graph deployment in real-time

ZefHub automatically persists, synchronizes, and distributes graphs across its network in real-time. Any update on a graph will be mapped almost instantaneously into the local memory of all other machines with graph access.

DEPLOY WITH ZEFHUB

# Make a graph fully synced and distributed in real-time
g | sync[True] | run

Infra with 1 line of code

Access storage and real-time, distributed infrastructure instantly. No config or maintenance needed, so you can focus on development.

# Tag a graph with a label
g | tag["awesome-analysis"] | run

# Grant view access to a friend
"friend@abcxyz.com" | grant[KW.view][g] | run

Share graphs with others

Send your graph’s tag or UID to another ZefHub user. Others with access will see all graph changes happening on their local machines, in real-time.

# Retrieve a graph with this tag from ZefHub
graph_tag = 'user/awesome-analysis'
g = Graph(graph_tag)

# Subscribe to be informed any time a new Entity is added
g | on[Instantiated[ET]] | subscribe[print]

Retrieve graphs instantly

Pull graphs onto any machine’s local memory. Subscribe and be informed of any specific changes with the option of locking on a specific time slice.

From prototype to production in days

Move from whiteboard to prototype to production in just days. With no separate query language, no ORM, versioned history out-of-the-box, and hassle-free infra, experience smoother, faster development and a data model that’s as close to the real-world as ever before.

Use Cases

Digital twins
360° data views
Monte Carlo simulations
Real-time optimizations
Recommendation engines
Fraud detection
GraphQL API

Sample Projects

Worduel

Duel friends back-and-forth on the popular Wordle game

Web

Ikura

Track and organize personal budgets and expenses

Coming soon!

Pricing

FREE

$0 /month

500 MB storage
2 GB network traffic
Basic shared compute
Community support

Get Started

PRO

$19 /month

2 GB storage
10 GB network traffic
Priority shared compute
Email support

ENTERPRISE

*Additional metered pricing available upon request

FAQ

Is ZefHub a hosted service for graph DBs?
ZefHub is a persistence, synchronization, and distribution service designed specifically to work with Zef graphs. Zef combines the access speed and local development experience of an in-memory data structure with the persistence and full-versioning of a distributed, immutable graph database. ZefHub takes care of your real-time, distributed infrastructure so you can focus on core development!
Is Zef a graph DB?
Zef is a toolkit of modules, one of which is ZefDB, an immutable, in-memory database. ZefDB models data into Relations (RT), Entities (ET), and Atomic Entities (AET). This lends itself most naturally to a graph structure of nodes and edges. Visit the Zef GitHub repo in the nav bar above to learn more!
Which query language does Zef natively use?
These is no separate query language! You query Zef like your native data structures in Python (more languages coming soon). Zef contains a library of lazy operators called ZefOps, which you can compose together sequentially with "|" directly in your Python code and mixed with your own custom code for queries and pipelines.
What's the relationship between ZefHub and Zef?
ZefHub is a venture-backed company and the creator and primary maintainer of the open source project Zef.

GRAPH DATA
FOR A DISTRIBUTED, REAL-TIME WORLD