Simple Start

Experience level: Beginner
Reasoning types: Graph
Industry: General
Tags: getting-startedgraphsbetweenness-centrality

What this template is for

This template is a minimal, runnable notebook designed to help you get up and running with RelationalAI against Snowflake. It walks through a small end-to-end example: create a Snowflake table, model it as a graph in RelationalAI, and compute a basic graph metric.

Who this is for

Anyone new to RelationalAI who wants a quick win with a notebook
Users comfortable running Jupyter and making small edits

What you’ll build

A working notebook that connects to Snowflake via your RelationalAI configuration
A small graph model built from a Snowflake CONNECTIONS table
A queryable graph representation
Betweenness centrality scores for each station

What’s included

Model: Station and Connection concepts, plus a derived graph edge relation
Runner: simple-start.ipynb as the primary notebook
Sample data: a small Snowflake table created by the notebook
Outputs: pandas DataFrames with table preview, edge list, and betweenness centrality

Prerequisites

Python >= 3.10
A Snowflake account with the RelationalAI Native App installed
A Snowflake user and role that can:
- Create schemas and tables or write into a schema you control
- Create and refresh a stream into the RelationalAI app, as prompted by the notebook

Quickstart

Download the ZIP file for this template and extract it:
Terminal window
```
curl -O https://docs.relational.ai/templates/zips/v1/simple-start.zip
unzip simple-start.zip
cd simple-start
```
You can also download the template ZIP using the “Download ZIP” button at the top of this page.
Create and activate a virtual environment

From the template folder, which is v1/simple-start if you cloned the full repository:
Terminal window
```
python -m venv .venv
source .venv/bin/activate
python -m pip install -U pip
```
Install dependencies
Terminal window
```
python -m pip install .
```
Configure credentials

This notebook reads data from Snowflake and executes RelationalAI queries, so you need a working RelationalAI and Snowflake configuration.

If you use the RelationalAI CLI, run:
Terminal window
```
rai init
```
If you have multiple profiles, set one explicitly:
Terminal window
```
export RAI_PROFILE=<your_profile>
```
Start Jupyter
Terminal window
```
jupyter notebook
```
Run the template

Open simple-start.ipynb and run the cells top-to-bottom or “Run All”.
Expected output

You should see:
- A preview of the Snowflake CONNECTIONS table.
- An edge list DataFrame, with one row per connection.
- A DataFrame of betweenness centrality values, sorted in descending order.

How it works

At a high level, the notebook:

Creates and populates the CONNECTIONS table in Snowflake.
Defines Station and Connection concepts and loads them from the Snowflake source table.
Builds an undirected graph from the station connectivity relation.
Lists the resulting edges as a table.
Computes betweenness centrality and queries the scores into a pandas DataFrame.

Customize this template

Use your own data:

Replace RAI_DEMO.SIMPLE_START.CONNECTIONS with your own edge table.
Ensure your table has two columns that represent the endpoints of each edge.

Extend the model:

Add node attributes (for example, station type, capacity, region) and join them to Station.
Add additional graph analytics supported by the Graph reasoner.

Troubleshooting

Jupyter can’t import relationalai or uses the wrong environment

Confirm your virtual environment is active: which python should point to .venv.
Reinstall dependencies: python -m pip install ..
In Jupyter or VS Code, select the kernel that points to the .venv interpreter.

Authentication or configuration fails when the notebook runs queries

Make sure your RelationalAI and Snowflake configuration is present and correct.
If you use the RelationalAI CLI, run rai init to create or update your config.
If you have multiple profiles, set RAI_PROFILE to the one you want.

The notebook can’t create the demo table or schema

Ensure your Snowflake role can create schemas and tables in the target database.
Alternatively, edit the notebook to write into a database or schema you control.