Upgrade RelationalAI

The RelationalAI (RAI) Native App upgrades itself every week. Existing reasoners upgrade separately, either on a schedule that you control or manually. This guide explains how upgrades work, how to check which versions you’re running, and how to manage reasoner upgrades.

Prerequisites

• The RAI Native App is already installed in your Snowflake account.
• You can run SQL in Snowflake with an active warehouse.
• To manage reasoner upgrades, you have the app_admin application role.

How upgrades work

The RAI Native App receives automatic updates every week. Reasoners provisioned after an update are created using the latest version. Existing reasoners created prior to the update must be upgraded to the latest version to access new features and improvements.

By default, outdated reasoners are automatically upgraded every Monday at 10:00 AM UTC.

While a reasoner is upgrading, in-progress transactions are cancelled and queries from RAI Python models using the reasoner will fail. Upgraded reasoners are available for use as soon as their upgrade is complete. See Get Reasoner Details for information on viewing a reasoner’s status.

You can manage reasoner upgrades in one of two ways:

• Keep automatic upgrades and change the upgrade schedule to a time that suits your workloads.
• Disable automatic upgrades and upgrade reasoners manually when you’re ready.

Check your app and reasoner versions

Check which app version is running and whether your reasoners have finished upgrading to it. Compare the app version with the release notes to see what changed.

Check the app version

Requires the app_user application role.

SQL

Call the app.get_release() function to get the version of the RAI Native App that’s running in your account:

SELECT relationalai.app.get_release();

Python

Create a client with connect_sync() and call the app.get_release() function:

from relationalai.client import connect_sync

with connect_sync() as client:
    sql = client.core.sql_executor
    assert sql is not None

    rows = sql.collect("SELECT relationalai.app.get_release()", operation="app.get_release")
    print(rows)

Check the reasoner upgrade status

Requires the app_admin application role.

SQL

Query the app.upgrade_reasoners_status view to see the most recent reasoner upgrade attempt:

SELECT * FROM relationalai.app.upgrade_reasoners_status;

Python

Create a client with connect_sync() and query the app.upgrade_reasoners_status view:

from relationalai.client import connect_sync

with connect_sync() as client:
    sql = client.core.sql_executor
    assert sql is not None

    rows = sql.collect(
        "SELECT * FROM relationalai.app.upgrade_reasoners_status",
        operation="app.upgrade_reasoners_status",
    )
    print(rows)

Note that:

• NA_VERSION is the app version that the upgrade attempt targets.
• STATE shows DONE when the attempt is complete and NotStarted if no attempt has started.
• REASONER_COUNT is the number of reasoners included in the attempt.

Manage the automatic upgrade schedule

Outdated reasoners upgrade automatically on a weekly schedule. View the current schedule, then change it if the default time conflicts with your workloads.

View the current reasoner upgrade schedule

Requires the app_admin application role.

SQL

To view the current reasoner upgrade schedule, call the app.upgrade_schedule_status() procedure:

-- View the current upgrade schedule and task status.
CALL relationalai.app.upgrade_schedule_status();

Python

To view the current reasoner upgrade schedule using Python, create a client with connect_sync() and call the app.upgrade_schedule_status() procedure:

from relationalai.client import connect_sync

with connect_sync() as client:
    sql = client.core.sql_executor
    assert sql is not None

    # View the current upgrade schedule and task status.
    rows = sql.collect("CALL relationalai.app.upgrade_schedule_status()", operation="app.upgrade_schedule_status")
    print(rows)

Set the reasoner upgrade schedule

Requires the app_admin application role.

SQL

To set or alter the reasoner upgrade schedule, call the app.schedule_upgrade() procedure with the day name and time in UTC:

-- Schedule upgrades for Wednesdays at 15:00 UTC
CALL relationalai.app.schedule_upgrade('WEDNESDAY', '15:00');

Output

+-------------------------------------+
| Upgrade task scheduled successfully |
+-------------------------------------+

Python

To set or alter the reasoner upgrade schedule using Python, create a client with connect_sync() and call the app.schedule_upgrade() procedure:

from relationalai.client import connect_sync

with connect_sync() as client:
    sql = client.core.sql_executor
    assert sql is not None

    # Schedule upgrades for Wednesdays at 15:00 UTC
    sql.collect(
        "CALL relationalai.app.schedule_upgrade('WEDNESDAY', '15:00')",
        operation="app.schedule_upgrade",
    )

Upgrade reasoners manually

Requires the app_admin application role.

RAI Native App updates are mandatory. However, you can disable automatic reasoner upgrades and manually upgrade reasoners at your convenience.

1. Disable automatic reasoner upgrades

   SQL

   To disable automatic reasoner upgrades, call the app.unschedule_upgrade() procedure:

   -- Disable automatic upgrades.
   CALL relationalai.app.unschedule_upgrade();

   Output

   +-------------------------------------+
   | Upgrade task cancelled successfully |
   +-------------------------------------+

   Python

   Create a client with connect_sync() and call the app.unschedule_upgrade() procedure:

   from relationalai.client import connect_sync
   
   with connect_sync() as client:
       sql = client.core.sql_executor
       assert sql is not None
   
       # Disable automatic upgrades.
       rows = sql.collect("CALL relationalai.app.unschedule_upgrade()", operation="app.unschedule_upgrade")
       print(rows)

   To re-enable automatic reasoner upgrades, set a new upgrade schedule.

2. Upgrade reasoners

   SQL

   To start the reasoner upgrade process, call the app.upgrade_reasoners() procedure:

   -- Start the upgrade process.
   CALL relationalai.app.upgrade_reasoners();

   Output

   +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | Upgrade started. Monitor the reasoner upgrade status using the app.upgrade_reasoners_status view to verify that all reasoners have been upgraded. select * from relationalai.app.upgrade_reasoners_status;   |
   +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

   While a reasoner is upgrading, in-progress transactions are cancelled and queries from RAI Python models using the reasoner will fail. Upgraded reasoners are available for use as soon as their upgrade is complete. See Get Reasoner Details for information on viewing a reasoner’s status.

   Python

   Create a client with connect_sync() and call the app.upgrade_reasoners() procedure:

   from relationalai.client import connect_sync
   
   with connect_sync() as client:
       sql = client.core.sql_executor
       assert sql is not None
   
       # Start the reasoner upgrade process.
       rows = sql.collect("CALL relationalai.app.upgrade_reasoners()", operation="app.upgrade_reasoners")
       print(rows)

3. Verify reasoners have finished upgrading

   SQL

   The status of the reasoner upgrade can be viewed in the app.upgrade_reasoners_status view:

   SELECT * FROM relationalai.app.upgrade_reasoners_status;

   Output

   +-------------------------+---------+-------+----------------+-------------------------------+-------------------------------+
   | NA_VERSION              | ATTEMPT | STATE | REASONER_COUNT | STARTED_AT                    | LAST_UPDATE                   |
   |-------------------------+---------+-------+----------------+-------------------------------+-------------------------------|
   | 2026.02.27-e829e39d     | 1       | DONE  | 9              | 2026-02-27 08:11:32.490 -0700 | 2026-02-27 08:17:45.108 -0700 |
   +-------------------------+---------+-------+----------------+-------------------------------+-------------------------------+

   The upgrade is complete once the STATE column shows DONE.

   Python

   Create a client with connect_sync() and query the app.upgrade_reasoners_status view:

   from relationalai.client import connect_sync
   
   with connect_sync() as client:
       sql = client.core.sql_executor
       assert sql is not None
   
       rows = sql.collect(
           "SELECT * FROM relationalai.app.upgrade_reasoners_status",
           operation="app.upgrade_reasoners_status",
       )
       print(rows)

   The upgrade is complete once the STATE column shows DONE.

After the upgrade finishes, you can check your app and reasoner versions at any time.

Where to go next

• Release notes to see what’s new in each release.
• Operate RelationalAI to start, monitor, and stop the app.
• Understand costs to see what drives app costs.
• Monitor reasoner usage to track reasoner memory, CPU, and demand.