RelationalAI Graph Reasoner

The RelationalAI Graph Reasoner lets you build graph representations from your model and run algorithms to uncover structure, measure influence, and extract insights from relationships between entities.

How It Works

Create a Graph from your RAI model.

import the graphs module from the relationalai.std package and use the Graph class to create a graph object:

import relationalai as rai
from relationalai.std import graphs

# Define your model.
model = rai.Model("SocialNetwork")

# Declare entity and relationship types.
Person = model.Type("Person")
Follows = model.Type("Friends")
Follows.person1.declare()
Follows.person2.declare()

# Define sample data.
24 collapsed lines
with model.rule():
    Person.add(name="Alice")
    Person.add(name="Bob")
    Person.add(name="Carlos")
    Person.add(name="Diana")
    Person.add(name="Eve")

with model.rule():
    person = Person()
    with person.name == "Alice":
        Follows.add(person1=person, person2=Person(name="Bob"))
        Follows.add(person1=person, person2=Person(name="Carlos"))
        Follows.add(person1=person, person2=Person(name="Diana"))
    with person.name == "Bob":
        Follows.add(person1=person, person2=Person(name="Alice"))
        Follows.add(person1=person, person2=Person(name="Eve"))
    with person.name == "Carlos":
        Follows.add(person1=person, person2=Person(name="Alice"))
    with person.name == "Diana":
        Follows.add(person1=person, person2=Person(name="Alice"))
        Follows.add(person1=person, person2=Person(name="Eve"))
    with person.name == "Eve":
        Follows.add(person1=person, person2=Person(name="Bob"))
        Follows.add(person1=person, person2=Person(name="Diana"))

# Create a graph from the model.
# NOTE: By default, graphs are directed. Set undirected=True to create an
# undirected graph.
graph = graphs.Graph(model)

Define the graph’s nodes.

Graph objects have a .Node type that represents the nodes in the graph. You can assign entities to this type to use entities from the model as nodes in the graph:

import relationalai as rai
from relationalai.std import graphs

# Define your model.
model = rai.Model("SocialNetwork")

31 collapsed lines
# Declare entity and relationship types.
Person = model.Type("Person")
Follows = model.Type("Friends")
Follows.person1.declare()
Follows.person2.declare()

# Define sample data.
with model.rule():
    Person.add(name="Alice")
    Person.add(name="Bob")
    Person.add(name="Carlos")
    Person.add(name="Diana")
    Person.add(name="Eve")

with model.rule():
    person = Person()
    with person.name == "Alice":
        Follows.add(person1=person, person2=Person(name="Bob"))
        Follows.add(person1=person, person2=Person(name="Carlos"))
        Follows.add(person1=person, person2=Person(name="Diana"))
    with person.name == "Bob":
        Follows.add(person1=person, person2=Person(name="Alice"))
        Follows.add(person1=person, person2=Person(name="Eve"))
    with person.name == "Carlos":
        Follows.add(person1=person, person2=Person(name="Alice"))
    with person.name == "Diana":
        Follows.add(person1=person, person2=Person(name="Alice"))
        Follows.add(person1=person, person2=Person(name="Eve"))
    with person.name == "Eve":
        Follows.add(person1=person, person2=Person(name="Bob"))
        Follows.add(person1=person, person2=Person(name="Diana"))

# Create a graph from the model.
graph = graphs.Graph(model)

# Define the graph's nodes.
with model.rule():
    person = Person()
    person.set(graph.Node)  # All Person entities are nodes.

Define the graph’s edges.

The Graph object has an .Edge type that represents the edges in the graph. Assign nodes to its .from_ and .to properties to define the graph’s edges:

import relationalai as rai
from relationalai.std import graphs

# Define your model.
model = rai.Model("SocialNetwork")

31 collapsed lines
# Declare entity and relationship types.
Person = model.Type("Person")
Follows = model.Type("Friends")
Follows.person1.declare()
Follows.person2.declare()

# Define sample data.
with model.rule():
    Person.add(name="Alice")
    Person.add(name="Bob")
    Person.add(name="Carlos")
    Person.add(name="Diana")
    Person.add(name="Eve")

with model.rule():
    person = Person()
    with person.name == "Alice":
        Follows.add(person1=person, person2=Person(name="Bob"))
        Follows.add(person1=person, person2=Person(name="Carlos"))
        Follows.add(person1=person, person2=Person(name="Diana"))
    with person.name == "Bob":
        Follows.add(person1=person, person2=Person(name="Alice"))
        Follows.add(person1=person, person2=Person(name="Eve"))
    with person.name == "Carlos":
        Follows.add(person1=person, person2=Person(name="Alice"))
    with person.name == "Diana":
        Follows.add(person1=person, person2=Person(name="Alice"))
        Follows.add(person1=person, person2=Person(name="Eve"))
    with person.name == "Eve":
        Follows.add(person1=person, person2=Person(name="Bob"))
        Follows.add(person1=person, person2=Person(name="Diana"))

# Create a graph from the model.
graph = graphs.Graph(model)

# Define the graph's nodes.
with model.rule():
    person = Person()
    person.set(graph.Node)  # All Person entities are nodes.

# Define the graph's edges.
with model.rule():
    follows = Follows()
    ## Create edges from Follows relationship entities.
    graph.Edge.add(from_=follows.person1, to=follows.person2)

Use graph algorithms to augment your model.

You can compute various graph algorithms through the Graph objects .compute namespace. For example, you can use the .distance() method to compute the “degree of separation” between two people:

import relationalai as rai
from relationalai.std import graphs

# Define your model.
model = rai.Model("SocialNetwork")

5 collapsed lines
# Declare entity and relationship types.
Person = model.Type("Person")
Follows = model.Type("Friends")
Follows.person1.declare()
Follows.person2.declare()

# Declare a new relationship type.
DegreesOfSeparation = model.Type("DegreeOfSeparation")
DegreesOfSeparation.person1.declare()
DegreesOfSeparation.person2.declare()
DegreesOfSeparation.distance.declare()

25 collapsed lines
# Define sample data.
with model.rule():
    Person.add(name="Alice")
    Person.add(name="Bob")
    Person.add(name="Carlos")
    Person.add(name="Diana")
    Person.add(name="Eve")

with model.rule():
    person = Person()
    with person.name == "Alice":
        Follows.add(person1=person, person2=Person(name="Bob"))
        Follows.add(person1=person, person2=Person(name="Carlos"))
        Follows.add(person1=person, person2=Person(name="Diana"))
    with person.name == "Bob":
        Follows.add(person1=person, person2=Person(name="Alice"))
        Follows.add(person1=person, person2=Person(name="Eve"))
    with person.name == "Carlos":
        Follows.add(person1=person, person2=Person(name="Alice"))
    with person.name == "Diana":
        Follows.add(person1=person, person2=Person(name="Alice"))
        Follows.add(person1=person, person2=Person(name="Eve"))
    with person.name == "Eve":
        Follows.add(person1=person, person2=Person(name="Bob"))
        Follows.add(person1=person, person2=Person(name="Diana"))

# Create a graph from the model.
graph = graphs.Graph(model)

# Define the graph's nodes.
with model.rule():
    person = Person()
    person.set(graph.Node)  # All Person entities are nodes.

# Define the graph's edges.
with model.rule():
    follows = Follows()
    ## Create edges from Follows relationship entities.
    graph.Edge.add(from_=follows.person1, to=follows.person2)

# Define DegreesOfSeparation entities using the distance between two people
# in the graph to define the degrees property.
with model.rule():
    person1, person2 = Person(), Person()
    sep = DegreesOfSeparation.add(person1=person1, person2=person2)
    sep.set(degrees=graph.compute.distance(person1, person2))

Insights driven by the graph can then be queried:

# What's the degree of separation between Bob and Diana?
with model.query() as select:
    bob = Person(name="Bob")
    diana = Person(name="Diana")
    sep = DegreesOfSeparation(person1=bob, person2=diana)
    response = select(sep.degrees)

print(response.results)
#    degrees
# 0        2

Guides

Dive deeper into the RelationalAI Graph Reasoner with these guides:

Working with Graphs Learn how to build graphs in RAI using the Python API to model and explore relationships between entities in your data.

Visualizing Graphs Use the RAI Python API to create, style, and export interactive graph visualizations with custom layouts, 3D views, and more.

Running Graph Algorithms Learn how to create graphs and run algorithms like PageRank, Jaccard similarity, and Louvain community detection using RelationalAI.

Sample Notebooks

Explore example notebooks that walk through building graphs and applying algorithms with hands-on code.

Betweenness Centrality Discover bridge nodes in a social network using betweenness centrality with RAI. Visualize and query a graph built from your model.

Degree Centrality Find the most connected individuals in your network using degree centrality in RAI. Analyze and visualize social influence at a glance.

Degree Analyze node connectivity in your graph with RAI. Compute degree, in-degree, and out-degree to surface structural insights.

Eigenvector Centrality Go beyond connection counts—use eigenvector centrality in RAI to identify the most influential nodes in your graph network.

Infomap Discover subgroups in your social graph using Infomap in RAI. Visualize how shared traits form distinct network communities.

Jaccard Similarity Find overlap in node relationships with Jaccard similarity in RAI. Highlight pairs with the most in common in your graph.

Label Propagation Find natural clusters in your network with RAI’s label propagation algorithm. Compare results across weighted and unweighted graphs.

Louvain Explore hierarchical clustering in RAI using Louvain. Discover social groups and see how weights refine community detection.

PageRank Apply PageRank in RAI to explore how influence flows through your graph. Identify nodes that gain authority from key connections.

Triangle Community Identify core clusters in your graph with RAI’s triangle detection. Perfect for spotting strongly linked communities.

Weakly Connected Components Detect loosely connected groups with RAI’s weakly connected components. Nodes are grouped if any path connects them, regardless of direction.