Native App
Version 2026.9.26-0821a55 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Fixed an issue where incremental maintenance, an opt-in preview feature, could return incorrect results or fail with DeltaProcessingError or FDError.
Fixed a bug where predictive reasoner tasks ignored the ICLConfig.random_state seed.
Python SDK
Version 1.33.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now install the relationalai package on Python 3.14. It supports Python 3.10 through 3.14.
You can now apply your own Snowflake masking policies and projection policies to the columns of a model you deploy to Snowflake, in addition to the row access policies added in the previous release. A deployment now validates every configured policy up front and reports any that are missing or inaccessible. See Configure access policies for setup instructions.
Here is an example configuration for applying masking and projection policies to a deployed output:
deployment:
outputs:
overrides:
- objects: [CUSTOMERS] # the deployed output to protect
policies:
masking_policies: # mask values for some roles
- fqn: GOVERNANCE.POLICIES.PII_MASK
columns: [EMAIL, PHONE]
projection_policies: # hide a column from some roles
- fqn: GOVERNANCE.POLICIES.HIDE_SSN
columns: [SSN]
Installing relationalai no longer includes OpenTelemetry by default. If you already use its optional handler with the older v0 PyRel API to send traces for troubleshooting, run pip install 'relationalai[otel]' when you upgrade to keep tracing working. Otherwise, you don't need the extra.
Running several queries on one model at the same time, such as calling to_df() from multiple threads, no longer fails with an "Unground Variable" error, returns empty results, or hangs. You still cannot change the model while these queries run, and running an export or an optimization solve at the same time is also unsupported.
If a concept inherits from more than one concept, or uses identify_by with more than one property, its queries and exports no longer put values in the wrong columns or return empty results. These problems only showed up for models deployed to Snowflake, which is a Public Preview feature.
Fixed a bug that caused local copies of a shared model to diverge from the original when collaborating with rai models pull and rai models merge. These commands are in Public Preview.
When your Snowflake connection does not specify a database, deployment now uses the database in a fully qualified deployment.schema instead of failing with Database '"default"' does not exist or not authorized. Set the option to <DATABASE>.<SCHEMA>; if neither the connection nor this setting specifies a database, deployment reports a clear configuration error.
You can now deploy a model into a Snowflake transient database or schema without an Unknown domain: TRANSIENT error. Set oplog.table_type: standard in your configuration first, because Snowflake cannot create the default Hybrid Tables in a transient location.
If the role set by the deployment.role configuration option cannot set Snowflake's trace level, the deploy warning now tells you to grant MODIFY TRACE LEVEL.
The rai debugger no longer freezes or crashes on large traces or refresh logs. Big traces render as plain, scrollable text, the Refresh Log handles bigger dependency graphs and shows an error instead of going blank when one is too large, and it opens on the timeline view instead of the graph.
Native App
Version 2026.9.19-cde4001 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
With incremental maintenance enabled, the logic reasoner no longer recomputes a query from scratch when you redefine a rule it depends on without changing the source data. Incremental maintenance is a preview feature.
If a model is deleted while a transaction is running against it, that transaction now fails with a clear reason (such as "database not found") instead of a generic internal error.
Running many queries at the same time no longer crashes the logic reasoner while it compiles them.
Python SDK
Version 1.32.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
count directly to a decision variable is now rejected because it counts rows rather than the values the solver chooses. A few others still build but now describe a different problem. To check them, print the problem with Problem.display() and confirm the formalized constraints and objectives match what you intended.You can now use the percentile and median aggregates to summarize your data. You can group either one with per() like any other aggregate.
When you deploy a model to Snowflake, you can now apply your own existing Snowflake object tags to every object the deploy creates by listing them under deployment.tags. On a redeploy, each object keeps only the tags you list.
deployment:
tags:
GOVERNANCE.TAGS.COST_CENTER: engineering
You can now attach an existing Snowflake row-access policy to the tables, views, and dynamic tables a deploy creates by adding a per-output policies override under deployment.outputs. RelationalAI does not fully check the policy first, so an invalid one can still fail when the deploy runs.
deployment:
outputs:
overrides:
- objects: [ORDERS]
policies:
row_access_policy:
fqn: GOVERNANCE.POLICIES.TENANT_ACCESS
columns: [TENANT_ID]
You can now point RelationalAI at a Snowflake tag you already created for object ownership with deployment.managed_tag. A governed account can then deploy a model without the Snowflake CREATE TAG privilege. The deploying role needs APPLY on the tag and USAGE on the database and schema that hold it.
deployment:
managed_tag: GOVERNANCE.TAGS.RELATIONALAI_MANAGED
You can now open a rai doctor report in the rai debugger offline, without access to the Snowflake account it came from. The trace, Refresh Log, and deployment graphs all work from the unzipped report.
A model with a wide concept, roughly 43 or more nullable properties, that failed to deploy with a RecursionError now deploys again. This fixes a regression introduced after version 1.29.1.
Fixed an issue that caused some models to fail to deploy with an "object already exists" error.
If you place a model's metadata and operation log in a custom schema with deployment.meta_schema, RelationalAI now uses that location consistently for deploys, teardown, and branch operations. Changing the setting later does not move existing metadata, so set it before your first deploy.
Redeploying a model now recreates every changed Snowflake object consistently, and it preserves the grants you added to its procedures and functions. Because objects are recreated rather than altered, you may need to restore other object-level state yourself.
Deploying a model to Snowflake is faster, because RelationalAI now runs its two metadata setup phases in parallel.
Two deployment records that claim the same model identity no longer break rai models listing or teardown for the whole database. The conflicted model stays listed with a warning that explains how to repair it.
For models deployed to Snowflake, the variance and variance_samp aggregates no longer lose precision on whole-number input. Expressions that raise a value to a power with **, such as math.haversine, no longer fail. This does not fix geometric_mean over negative input on Snowflake, which is still unsupported.
For models deployed to Snowflake, comparing two entity types with == no longer errors when their identities are stored differently, for example a generated hash versus an integer identify_by key. Because the two kinds of identity can never be equal, the comparison now returns False.
A where() filter whose condition is a Python builtin call with a literal argument, such as abs(-1) == 2, now filters when the condition is false, as expected.
For models deployed to Snowflake, queries that compute several aggregate measures over the same grouping now run in a single pass instead of re-scanning the data once per measure. The results are unchanged.
Calling inspect() or to_df() on a define or require fragment now raises a clear error, "Cannot inspect a define" instead of crashing. A define or require adds to your model rather than running as a query, so there is nothing to inspect.
When a configuration file that RelationalAI discovers automatically, such as ~/.rai, the Snowflake CLI config, or a dbt config, fails to load, RelationalAI now reports the real error and names the file that failed, instead of a generic "no configuration found" message. A commented-out {{ env_var(...) }} line is also no longer evaluated, so it can no longer fail on an unset variable.
Native App
Version 2026.9.11-438c741-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
The model is currently locked by active write transaction(s) and includes the RAI CLI command to cancel the blocking transaction.Incremental maintenance no longer fails with a DeltaProcessingError or reads back the wrong string value for a relationship with a functional dependency whose values come from more than one rule and include long strings.
Prescriptive problems that repeat a decision variable or coefficient are now rejected with an InvalidModel error instead of silently solving a different problem than the one you defined. Re-run any such problems solved before this version to confirm their results.
In a prescriptive problem, a count over something other than conditions the solver decides, such as decision variables directly, now fails with a clear InvalidModel error instead of an opaque OTHER_ERROR.
Python SDK
Version 1.31.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
RELATIONALAI_MANAGED_SCHEMA tag, which simplifies setup for administrators who pre-create tags for a restricted deploy role.require(unique(Subscription.account, Subscription.phone)), now deploys to Snowflake instead of failing with a table-creation error.Python SDK
Version 1.31.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
variance and variance_samp aggregates to measure how spread out your data is. variance returns the population variance and variance_samp returns the sample variance, and you can group either one with per() like any other aggregate.Python SDK
Version 1.30.4 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now use the geometric_mean aggregate to average rates and ratios, and group it with per() like any other aggregate. It expects non-negative numbers.
Run the new rai config check command to catch configuration mistakes before they cause errors later. It checks that your configured reasoners have valid names and sizes for your Snowflake account's cloud.
Queries in a deployed model that read from a Snowflake source table now run faster automatically. RelationalAI no longer sorts the table when your query doesn't use its row order.
Aggregates over a relationship chain, such as min(Customer.transaction.pay_date).per(Customer), now run faster automatically. RelationalAI no longer adds an unnecessary join.
You can now deploy a model into a Snowflake schema named after a SQL reserved word, such as ORDER or SCHEMA. Before this release, the deploy failed with an error saying the object did not exist.
You can now deploy a model with a Snowflake role that only has USAGE on a schema your administrator created for you, with its tags already in place. RelationalAI no longer creates an account-wide management schema.
If your deploy role can't create a schema it needs, the deploy now stops early with a clear error that gives you the exact grants and CREATE SCHEMA statements to run, instead of failing partway through.
Redeploying a model now keeps the Snowflake grants and compatible object and column tags you applied to its tables. Before this release, a redeploy could drop them.
math.haversine now returns the correct distance. Before this release, it returned a wrong value, so recompute any distances you calculated with it.
A select whose only content is a single function call on a literal, such as select(parse_number("abc", 19, 0)), now returns one row with a null value when the call produces nothing, instead of no rows. If any of your logic treats an empty result as a signal, review it, since these queries now return a null row you can handle with null-safe logic.
When you deploy a model, a rule whose condition matches no rows no longer adds any facts. Before this release, a rule that defined two or more fixed facts added them anyway, leaving facts in your model that shouldn't be there.
When you deploy a model, a grouped aggregate whose default value sits behind an unreachable branch no longer duplicates rows. Before this release, it could return two rows per group instead of one.
Deploying, branching, and pulling a model through its op log is more reliable. A model that uses a standard-library function, such as parse_float, now loads consistently in any Python session, and a model that sets the preserve_column_case deployment option no longer regenerates invalid Python.
Python SDK
Version 1.30.3 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now sign in to Snowflake two new ways. Pass your private key to JWTAuth in memory with a new private_key field instead of saving it to a file, or inject your own Snowpark session into create_config with snowflake_session=.
Refreshing a deployed model is now faster when some of its outputs are independent of each other, because those outputs refresh in parallel instead of waiting for unrelated ones. This happens automatically.
The rai debugger can now show how long each part of a refresh took, so you can find the slow ones. Open a finished refresh run and select View Timeline to see the whole refresh and its parts laid out on a timeline.
Added the floats module to the public std namespace, making its functions available like other standard-library modules. You can now use std.floats.float() to convert a value to a float, or std.floats.parse_float() to turn a string into a float.
An aggregate like a count or sum now respects a union filter, or a unary relationship, applied to it in where(). Before this release, the aggregate ignored that filter and ran over every row, so it could return a wrong total or count with no error.
aggregates.limit now returns only the number of rows you asked for when you order it by the grouping keys of another aggregate in the same query. Before this release, it ignored the limit in that case and returned every row.
A query that aggregates over a cycle of relationships, such as A knows B, B knows C, and C knows A, now returns a result. Before this release, a query like this could fail to complete, because the reasoner could not settle on a way to order it and gave up instead of returning a result.
Deploying a model that reads a relationship on a concept with a composite key now works. Before this release, the deploy could fail or the relationship could come back empty.
Deploying a model no longer fails when one of its output column names contains a hyphen, a space, or a reserved word. Before this release, the refresh stopped with an invalid identifier error.
Filtering by calling a relationship with a value, such as order.status("open"), now raises a clear AmbiguousRelationshipRead error when the name matches more than one relationship, and tells you to compare with == instead, as in order.status == "open". Before this release, it failed with a confusing internal error.
Deploying a model no longer prints warnings that did not mean anything was wrong. A warning still appears when you force an output to a Snowflake object type it cannot use, and tells you how to fix it: set the output to table or remove the override.
Redeploying a healthy model that sets deployment.suspend_after_mins no longer suspends the refresh tasks it just created, so the model keeps refreshing after a deploy. The tasks still auto-suspend once the configured number of minutes has passed since the deploy.
Deploying a model while someone is querying it no longer fails at the final step with an error asking you to pull and retry. Those queries write harmless background metadata that used to block the deploy, which now finishes on its own.
A deploy that is rejected before it applies its changes no longer leaves the model's schema behind in Snowflake for you to clean up, because RelationalAI now creates Snowflake objects only when the deploy goes ahead.
Deploying into a schema or with ownership tags that already exist now reuses them instead of failing to re-create them, and errors only if creating something genuinely fails.
Native App
Version 2026.9.6-b010153 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
When an export to a Snowflake-managed Iceberg table fails because a column's type doesn't match the destination column, the error now names the destination column's type instead of showing a generic message. This tells you which type to match so you can fix the export.
Functional dependency violation errors now name the relationship involved, even when the violation is found during parallel execution on the Logic Reasoner. Previously, these errors could appear with no relationship named, leaving no way to trace the violation to its source.
Native App
Version 2026.8.31-3a37425 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Loading data into the Logic Reasoner is now faster. Internal benchmarks show first-time load times cut roughly in half, with the largest loads improving the most.
Solvers now give a clearer error when one of their backend-specific parameters has the wrong type, naming the parameter and the type they expect.
Queries over data that contains empty strings now return results instead of stopping the whole transaction with an internal error.
Upgrading the app no longer fails on Snowflake accounts whose default table type is set to Iceberg.
Updated the app's bundled third-party components to versions that resolve known security vulnerabilities.
Python SDK
Version 1.30.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
When you deploy a model, RelationalAI now checks the generated SQL first and stops with a clear error instead of letting the deploy succeed and then potentially fail later on its first refresh. The check is on by default. Set deployment.validate_sql to false to skip it.
You can now deploy a model that contains a prescriptive Problem, and have Snowflake solve it on each scheduled refresh without keeping a Python session open. It runs under a Snowflake identity you configure with the new deployment.pat_user and deployment.pat_warehouse settings.
Python SDK
Version 1.30.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
union() could fail with Unsupported subquery type cannot be evaluated. Aggregates now compute over their whole group instead of a single row. This applies to count(), sum, max, and avg, including when grouped with .per().Python SDK
Version 1.29.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
rai models deploy is now faster. PyRel creates your tables, views, and dynamic tables at the same time instead of one by one, while still respecting how they depend on one another. It's on by default and produces the same result, so you don't need to change anything.Filters that compare a value to Python None now keep the correct rows instead of silently dropping the ones where the value is missing, in both Model.where with == None or != None, and Concept.filter_by(prop=None).
Models with rules that divide numbers with decimal places now deploy instead of failing with a numeric-precision error.
Sharing a model through rai models pull or rai models merge now regenerates a more accurate shared_model.py. It keeps parts of your model that earlier versions could drop or silently break, such as joins between different number types, counts of a column or property, and concepts that extend Any or AnyEntity.
The PyRel debugger's Trace tab again shows the steps PyRel runs to build your model. A recent change had collapsed them into a single "no changes" row.
Python SDK
Version 1.29.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Queries that use path() to find paths in a graph now compile and run faster, especially patterns that repeat a step a bounded number of times with .repeat(min, max). In one benchmark, compiling a large repeated pattern dropped from over a minute to under a second, with no change to results.
Display strings for constraints and objectives now work when the model runs in Snowflake: the prescriptive reasoner renders them inside the model instead of in the Python client. The rendered text is available as a display_string property. Call install_display_strings() on a Problem before you deploy it (interactive use installs it automatically on the first display()).
Deploying a model that schedules automatic refreshes with rai models deploy now warns you when the Snowflake role that owns the refresh tasks lacks the account-level EXECUTE TASK privilege. Before, the deploy reported success but the refresh never ran, so the tables stayed empty with no explanation. The warning names the role and the exact grant needed to fix it.
In a deployed model, several aggregate queries that used to fail with the message Unsupported subquery type cannot be evaluated or return wrong results now work correctly. This includes grouped aggregates (.per()), aggregates capped with aggregates.limit, and aggregates used inside a not_() check.
In a deployed model, rank() now groups rows correctly when the same definition also contains an unrelated aggregate that uses a fallback value. Before, every row could land in its own group, so the rank was 1 for every row. This produced silently wrong results with no error.
After you deploy with op log recording turned off, rai models list and the related branch, switch, and teardown commands now work as expected.
rai models deploy --wait now makes a new model version visible to other users of the model as soon as its Snowflake objects are installed, rather than after the first data refresh finishes.
Deploying a model no longer fails when a concept has multiple identifying properties and one of them has no values. That property now deploys as an empty table.
When you set deployment.outputs.reasoner on a model that also defines a prescriptive Problem, the deploy no longer skips outputting the problem. It keeps the solver's outputs in place, routes only the outputs it can, and warns about the ones it left alone.
Querying a model in a Snowflake notebook no longer shows stray error cards (such as [Invalid iteration] Cannot iterate over Chain objects.) underneath a query that actually succeeded. These came from the notebook inspecting PyRel objects left in the namespace. Real errors from your own code still appear.
Calling AnyEntity.ref() no longer raises an UnresolvedType error and now works as expected.
Deploying a model whose objects are Snowflake dynamic tables and that also uses the logic reasoner no longer shows warnings about dynamic tables or rebuilds them as regular tables.
Problem.display() no longer accepts part= or where=. Passing either now raises a TypeError. To filter what you see, first render the display text with install_display_strings(), then read the new display_string property from the constraint (or other expression) you want, just like any other field:
problem.install_display_strings()
# capacity_constraint is a constraint you defined when building the problem
model.select(capacity_constraint.name, capacity_constraint.display_string).where(capacity_constraint.name == "cap_3")
Output is now sorted as plain text instead of natural number order, so x_1, x_2, x_10 now appears as x_1, x_10, x_2.
all_different now takes a single argument.
Native App
Version 2026.8.23-6e405e5 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Loading a Snowflake-managed Iceberg table now stops with a clear error when a column's data type doesn't match the table's declared data type, instead of silently returning incomplete results. Update the column's declared data type to match the source.
Fixed an issue that could prevent changes to a Snowflake-managed Iceberg table from being picked up, so your queries could keep returning data from an earlier version of the table.
Python SDK
Version 1.28.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
PyRel now records your model's change history automatically every time you deploy to Snowflake with rai models deploy. This history is called the op log, and it's what makes rai models branch, pull, and merge work, so those commands now work right away with no setup. To turn recording off, set oplog.enabled: false in raiconfig.yaml.
When you deploy a model, a concept and its subconcepts (declared with extends=) can now be built by different reasoners at the same time. For example, one subconcept can load straight from a Snowflake table while another is derived by rules. Querying the parent concept returns rows from all of its subconcepts together. Previously, every subconcept had to use the same reasoner.
Instead of writing separate SQL queries to explore a Snowflake database table by table, you can now run rai explore schema to capture its full structure (column types, primary and foreign key candidates, and value distributions) as a single JSON file. This helps when you're building a semantic model from an existing database and want to understand it first. It supports Snowflake sources only for now.
For example:
rai explore schema --database DEMO_TELCO --schema RAW --out schema.json
You can now define more than one decision problem on the same model, each as its own Problem. Once a model has more than one, give each Problem a unique name using the name parameter so PyRel can tell them apart, and match each one to the same problem every time you redeploy.
You can now use aggregates.string_join in models deployed to Snowflake. Use index= to control the order the values are joined in, or leave it out to join them in ascending order by value.
If your deployed model's target schema also holds tables or views you didn't create with PyRel, tearing down the model no longer removes them. rai models teardown now deletes only the objects RelationalAI created, and never drops the schema itself, even with --force. If RelationalAI created the schema, teardown reports it separately, along with the SQL needed to remove it.
Deploying a model no longer crashes with ExtractionError: Property owner must be user schema object when it adds a property to a built-in concept. This came up in many common models, such as any model that uses the graph or prescriptive reasoner, or that simply calls Error.new(message=...). If you set oplog.enabled: false only to work around this crash, you can now remove that setting.
In a deployed model, grouped aggregate queries now return correct results when a grouped aggregate (using .per()) shares a variable with another aggregate or lookup in the same rule. Some of these queries previously returned wrong rows, too few rows, or were rejected. Only deployed models were affected.
In a deployed model, an aggregate combined with a fallback value using | (for example, count(C).per(C.grp) | 0) now returns one correct row per group. Before, it could return wrong rows, or the deploy could fail on Snowflake with Unsupported subquery type cannot be evaluated. Only deployed models were affected.
A query that uses union() to express an OR condition across differently filtered joins no longer fails to deploy to Snowflake with Unsupported subquery type cannot be evaluated.
In a deployed model, a concept with a property derived from another of its own properties no longer fails to deploy when nothing else in the model creates that concept. It now deploys with zero rows, which matches the fact that nothing populates it.
A model no longer fails to deploy to Snowflake with an error like invalid identifier '__VAR_N' when a filtered, grouped aggregate is used to classify an existing entity, such as model.where(R(x), c := per(x).count(y), c > 1).define(Flag(x)).
A model with a concept that uses implicit identity no longer silently drops rows when the same data is read more than once during deploy. No model changes are needed. Redeploying applies the fix.
Compiling a model with a large union(), such as hundreds of filter fragments feeding one rule, is now much faster. A compile that used to take over a minute now finishes in a few seconds.
If your deployment role can't change Snowflake log or trace levels, deploying no longer shows a false Deploy Step Skipped warning when your role already inherits a sufficient level from the account, database, or schema. The warning still appears when the level really is too low, which you can fix by granting your role the MODIFY LOG LEVEL and MODIFY TRACE LEVEL privileges.
Python SDK
Version 1.27.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Graph with 200,000 edges took about 41 seconds to build. That same graph now takes about 1 second.Python SDK
Version 1.27.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
When a concept or relationship is built directly from your source Snowflake tables — without any additional computation in PyRel — model deployment now creates it as a SQL view instead of a table, which avoids unnecessary storage and refresh work. If you need it stored as a table, set type: table for that output under deployment.outputs.overrides. See Choose how outputs are materialized for details.
Redeploying a model now keeps existing deployed tables' data and Snowflake grants where possible, instead of dropping and recreating the tables. Views and dynamic tables are still recreated, but their grants are now preserved too. Some changes, such as changing an output column's type, can still require recreating a table.
Model deployment now tags each schema it creates as RAI-managed, which supports safer cleanup later. If your deployment role can't apply that tag, deployment now stops with a clear error telling you to grant APPLY on the tag (or APPLY TAG on the account) instead of leaving an untagged schema behind.
Temporary tables created by PyRel when deploying a model now live in the deployment's _META schema instead of appearing next to your model outputs, keeping the target schema limited to your model's objects.
common.hash() now produces different values than in earlier releases. This matters mainly when a hash is saved rather than computed on the fly — for example, when a deployed model materializes a property or relationship whose value comes from a hash, or when you export query results that include a hash to a table. Before upgrading, search your model code for common.hash( and plan to recompute any stored hashes that must stay stable.
In a deployed model, common.parse_uuid() now works consistently. A UUID that you parse and then compare against an entity in your model now matches instead of silently returning no rows, and common.uuid_to_string() applied to a parsed UUID now returns a plain 32-character value instead of dashed UUID text. Pass UUIDs in the standard dashed form, and update anything that expected the dashed output.
A query that uses one select() inside another expression now returns the correct rows. Previously, a nested selection could drop rows or ignore its own filter.
Selecting a constant value in a query no longer fails with a GROUP BY term out of range error when combined with other properties and relationships, and now returns the expected rows.
Definitions that negate a union() with not_() or supply fallback values with | no longer fail to compile when deploying a model.
If you force two deployment outputs that depend on each other onto different reasoners, deployment now fails with a clear ConflictingForcedReasoners error that names the outputs and how to fix them, instead of a raw internal error. You set an output's reasoner with deployment.outputs.overrides.
When rai models list can't read the model-management schema because of your role's privileges, the error now recommends the correct GRANT USAGE statements instead of an APPLY ON TAG grant that didn't fix the problem.
After running the rai models teardown CLI command with the --force option, the follow-up message no longer points you to unnecessary or unavailable commands.
Calling a concept with keyword arguments, such as Movie(title="The Matrix") instead of Movie.lookup(title="The Matrix"), now raises a clear Invalid usage error right away instead of failing at query time with a confusing AssertionError.
Deploying a concept whose identity includes another concept that has a composite (multi-field) identity key no longer drops part of that key. Previously the deploy could fail with a NULL result in a non-nullable column error, or store incomplete identities.
When you create a decision variable with Problem.solve_for() for a concept that has no identify_by key, querying that variable's solved values now returns the matching rows instead of nothing.
Native App
Version 2026.8.17-c5208f8 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Iceberg tables are not supported for CDC data streams.
Previously, the stream was created but Snowflake quarantined it, so changes were never processed.
See Prepare your data sources for the source objects that data streams support.The new api.cleanup_stale_data_streams() procedure lets you delete data streams that haven't been accessed for longer than a time-to-live (TTL) you specify.
It takes a TTL in minutes and runs in dry-run mode by default, reporting the data streams it would delete without removing anything.
Pass DRY_RUN => FALSE to delete them.
The api.data_streams view now includes a last_accessed column that shows when each data stream was last accessed by a transaction.
The value is NULL for a data stream that has never been accessed.
Fixed a rare issue where two internal computations could overwrite each other and affect a query's results.
Writing to a Snowflake-managed Iceberg table no longer fails with an Invalid parquet file: non-nullable column ... has null values according to file statistics error.
The app now reconnects to Snowflake on its own when its internal access token expires, so operations like reasoner creation no longer get stuck and fail.
Fixed an issue that prevented custom aggregations over decimal values, such as FixedDecimal, from returning results.
Prediction jobs submitted by PyRel to a predictive reasoner no longer fail with an index out of range in self error when your data contains a category that wasn't seen during training.
A query that runs while a model's internal data store is being deleted now reports the accurate error The database does not exist. instead of the misleading Database was closed and this transaction was discarded. Note that "database" here refers to an internal database used by the native app and not a Snowflake database visible in your Snowflake account.
Native App
Version 2026.8.9-8d1935f-6 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.26.2 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
The new rai usage command reports your account's RAI consumption and estimated cost, broken down by compute pool, with date filters and table, JSON, CSV, or HTML output. Cost figures exclude storage and are estimates rather than invoices, and totals are lower bounds when PyRel can't identify a compute pool's machine family.
For example, write a July 2026 usage report to a CSV file:
rai usage --start 2026-07-01 --end 2026-07-31 --format csv --output-file usage.csv
:::note
The Snowflake role for your active profile needs access to SNOWFLAKE.ACCOUNT_USAGE in order to run the rai usage command.
:::
Model deployment now builds large models faster by removing redundant work. In one model, the initial build was about 2.4× faster. Savings depend on your model and the size of your Snowflake warehouse.
A query that computes a value (such as a sum or a true/false flag) in one select() step and selects that same value again in a later select() now returns the correct rows. Previously, it could return too few rows or fail with an error.
In a deployed model, computing an aggregate value (such as a sum) and then filtering on it now returns the correct result. Previously, if the definition used a union to combine several alternatives, the value could be inflated due to over-counting.
If you compute an aggregate with .per() and use it only to filter rows without also selecting it, the query now returns the expected rows. Previously, it could return no rows at all.
Some not_() checks in a deployed model are now much faster. In one case, a query that ran for over 13 minutes now finishes in about 13 seconds.
PyRel now raises a clear UnsupportedOperation error when Louvain, Infomap, and label propagation algorithms are used in a deployed model. These algorithms are currently not supported.
Grouping an aggregate by a key that has no values now raises a clear GroupKeyHasNoDomain error instead of unexpectedly combining your per-group results into one overall total.
Deploying a model that uses quoted, case-sensitive Snowflake names no longer fails with an "Object does not exist or not authorized" error.
When more than one Snowpark session is active, PyRel now surfaces Snowflake's multiple-active-sessions error (1409) instead of quietly opening a new connection, so you can choose which session to use.
If you pass your own Snowpark session to create_config(), deployment now uses that session when it switches Snowflake roles, instead of creating a separate one.
Explicitly setting reasoners.logic.incremental_maintenance to "off" in Python now takes effect. Previously, PyRel could reset it to "auto", which turned incremental maintenance on.
Some match (|) expressions that used to fail with an is unground error (for example, 'pet' is unground) now work correctly.
Fixed a bug that could cause concept tables in a deployed model to be updated on the wrong schedule.
Fixed an edge case where a query could mix up similarly named properties on different kinds of entities.
Fixed an edge case where a deployed model could apply a definition even when its condition wasn't met.
Fixed an edge case where matching an entity by its identifying property could return a match even when no such entity existed.
Fixed an edge case where an equality between two values in a query condition could incorrectly return no rows.
Native App
Version 2026.8.9-8d1935f of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.26.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Your first rai models deploy on a new branch now works without a manual rai models pull first. rai models switch pulls the branch for you. A bare rai models pull also now defaults --path to the model.path in your raiconfig.yaml.
Tearing down a parent branch now removes its child branches too, instead of leaving them orphaned and unable to pull or merge. As a safeguard, rai models teardown --allow-children stops when a child has unmerged changes until you also pass --allow-unmerged. rai models list and rai doctor report now flag any branches orphaned by an earlier teardown.
The rai models commands now recognize when the schema you name is already your active model branch, instead of acting as if it changed. rai models switch no longer prints a false "Switched" message, rai models branch tells you to pick a different name instead of erroring, and rai models list marks your active schema with a *.
Fixed a bug that caused queries using union() to run slowly and, in some cases, hang indefinitely.
Fixed a bug that could cause aggregates grouped with per() to evaluate incorrectly when used solely as a filter and not selected in the query results.
Fixed a bug that caused aggregates grouped by an entity with a composite key to evaluate incorrectly.
Fixed an issue that could cause an "invalid identifier" error when deploying a model.
Fixed a bug that could case an "Object does not exist" error when deploying a model to a case-sensitive schema name.
Fixed a bug where a deploy could fail when a Snowflake view or dynamic table (an auto-refreshing Snowflake table) was created before another object it reads from.
Fixed a bug where deploying an unedited rai models init project could fail immediately with a "Symbol ... is already registered" error.
Fixed a bug that could cause redeploying a model without any changes could fail.
Fixed an issue that prevented model re-deploys from picking up changes to a data sources Snowflake object.
Fixed a model deployment bug that ignored a user-supplied Snowpark session passed to create_config(), which is supposed to override any auto-detected Snowpark session.
Fixed a bug that could cause rai models pull or rai models merge to generate a runnable shared_model.py file. If you encountered this bug, pull or merge again to regenerate a corrected shared_model.py.
Python SDK
Version 1.26.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now deploy a model from Python with model.deploy() as a programmatic alternative to the CLI. It relies on the operation log, which is off by default, so set oplog.enabled to true to turn it on.
If you run PyRel inside Snowpark Container Services (SPCS) and connect via OAuth, use the new host option in your Snowflake connection configuration to the container's SNOWFLAKE_HOST endpoint. OAuth tokens in your configuration are validated against this host.
You can now cap how long PyRel waits for a reasoner to become ready or a query to finish by setting data.poll_timeout_mins in your raiconfig to a number of minutes so it raises a clear timeout error instead of hanging forever. It is off by default and only stops your Python client, not any work already running in Snowflake.
If your Snowflake account cannot use hybrid tables, such as a Tri-Secret Secure account, you can now set oplog.table_type: standard in your raiconfig to provision the operation log as a standard table instead of the hybrid default. Note that changing this setting after your first deployment does not update the existing oplog table. You'll need to delete the table and re-deploy in order for it to take effect.
The product() aggregation function, which multiplies values together, is now supported in deployed models.
The rai debugger has a new Refresh Log view that shows a deployed model's install plan and refresh history as a diagram, so you can watch a refresh as it runs. You can also start it with --no-show to skip opening a browser window when you restart it.
PyRel now catches a conflicting implicit_properties setting when you deploy, branch, merge, or pull with the operation log enabled, raising ModelConfigMismatchError when your current setting differs from the one recorded at the model's deploy, instead of letting the conflict break the model later. This setting (part of ModelConfig) controls whether using an undeclared property creates it or raises an error. To resolve the error, match the recorded setting or pass --force to override and record the new one.
Improved performance for refreshing a deployed model.
Improved generated output table name in deployed models. For example, tables with generated names like Number_38_0_datapoints will now be saved as simply datapoints. If downstream queries or dashboards referenced the old name, update them after you redeploy.
Improved the error message you get when a deploy can't start because another is already in progress.
Fixed a model deployment bug where a model that used Model.Enum() failed to deploy with the errorValueError: No SQL type for column 'x'.
Fixed a bug where ranking or limiting rows over a concept with a composite key in a query or definition would fail with an invalid identifier error.
PyRel now internally sorts entities with composite keys differently than it used to. You may see results for queries that involve rank() or top() return rows where the rank is tied in a slightly different order.
Fixed a model deployment bug where calling re.findall() or strings.split() on a Table column produced extra rows in the output table.
Fixed a bug where a query computed two count(...).per(key) values over the same text key, one for values in a list and one for values not in it. The in-list count silently returned NULL on every row. Both counts now return the correct number.
Fixed a bug that caused some aggregations over properties that are set for some entities but not others to include values from entities that should have been excluded.
Fixed a model deployment issue that caused some models to fail with aSQL object_name collision error when deployed.
Fixed a bug where an unresolved chained reference in a query (a multi-step property or relationship lookup that was never given a value) could silently produce incorrect query results. PyRel now raises an error.
Fixed a bug in the prescriptive reasoner where a count or a summed objective (a total or a tally aggregated over rows) could silently drop rows that shared a value, so the solver optimized the wrong total. For example, with costs of 5, 5, and 7, the two 5s collapsed into one, giving 12*x instead of 17*x. Each row now contributes its own term.
The prescriptive reasoner now rejects a non-numeric value, such as a text or date property, used where a number is expected, with a clear error when you build the problem. Before, the problem built successfully and failed only during the solve, with a confusing internal error.
Fixed several problems with tearing down a deployed model using rai models teardown. Leftover local state could be wrongly reused on a later redeploy, and a partial teardown could not be completed by re-running it. Teardown now cleans up reliably and can be safely re-run after a partial failure.
Fixed a bug where rai models teardown and rai models merge could act on a malformed schema. Both commands now always reject a malformed or ambiguous schema name with a clear error.
Native App
Version 2026.8.3-49c7820 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Fixed an issue that caused data streams to be quarantined during brief pauses in the CDC service.
Fixed an issue that could stop a data stream from syncing when the app's routine cleanup removed part of the internal data store that the CDC service uses to load your data.
Prevented the app from leaving Snowflake compute resources running indefinitely when an internal engine fails to start.
Python SDK
Version 1.25.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now tear down a deployed model from Python with model.teardown(), which is the cleanup counterpart to model.deploy(), so you can remove a model you no longer need without leaving your script or notebook.
Called with no arguments, model.teardown() only shows what it would remove and deletes nothing.
When you pass force=True, the call actually performs the teardown.
This drops the model's deployed schema in Snowflake, along with its meta schema and operation log, which is the same thing the rai models teardown CLI command does:
model.teardown() # preview: lists what would be dropped, drops nothing
model.teardown(force=True) # drop the deployed model for real
Teardown cannot be undone, so check the preview before you use force=True.
Your local model files, including the generated shared_model.py, are left in place.
Running rai doctor report now shows which shared_model.py file it used, as a new "Shared model file" entry in the report summary. This lets you confirm PyRel picked up the file you expected, which matters when a stray copy in a parent directory could otherwise be used without you noticing.
Fixed a bug where a query that placed a union(...) next to another filter in the same where(...) could return incorrect results.
For example, the status == "open" filter below was ignored for one region, so results could include orders that were not open.
The filter now applies to both branches of the union:
where(
Order.status == "open",
union(Order.region == "US", Order.region == "EU"),
).select(Order.id).to_df()
Fixed a bug that could cause an "invalid identifier" error when you deployed a model to Snowflake.
Fixed a bug that could crash Snowflake's SQL compiler with an out-of-memory error when deploying a model.
Fixed a bug that caused a Snowflake "invalid regular expression" or "named groups not supported" error when calling re.sub, re.search, or re.match on certain patterns, such as re.sub(r"\D", "", text).
Reading table rows into a concept no longer exposes the internal __row_id_* fields it uses to tell identical rows apart. They previously appeared as public properties when you inspected your model, and are now kept internal.
When rai models deploy fails, you now see a short, readable error message instead of a long Python traceback. It also exits with a nonzero exit code, so scripts and CI pipelines can detect the failure and stop instead of continuing as if the deploy worked. This also applies to --wait, which is the option that keeps the command running until the deploy finishes.
The first deploy of a large model no longer fails with an OplogAppendTooLargeError, which used to stop the deploy with no way around it when it needed to write more than about 900 KB at once to the model's operation log. The operation log is the running record of changes PyRel keeps for a deployed model. The deploy now completes with no change to your model.
A model no longer fails to deploy with an [Unground Variable] error when a concept is identified by both a reference to another concept and a plain-value field from the same source table, for example a LineItem identified by its Order and a line number.
Running rai models pull more than once on a shared live branch, one that several people deploy to and pull from, now gives consistent results. Before, a second pull could quietly change the model definition you ended up with, so collaborators could drift out of sync. To get the fix, upgrade every collaborator to 1.25.0 before anyone runs the first pull, because afterward an older version of PyRel can no longer write to that branch.
In the rai debugger, you can now expand a compiler pass for one block of a deployed model without the same pass opening in every other block, so the view stays focused on the block you are inspecting.
Native App
Version 2026.7.27-74739c9 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Exporting query results no longer fails when one of the exported columns has the same value in every row. Previously, these exports failed the entire transaction with an internal error.
A query that reads from a Snowflake source through a data stream no longer fails if that stream is being deleted and rebuilt while the query runs. Data streams keep your PyRel models in sync with their Snowflake sources, and PyRel sometimes rebuilds one to refresh it. Previously, a query caught in that window failed with a The provided data streams do not exist (RAIERR:1000) error, even though the stream was being replaced, not removed. Now the query finishes once PyRel rebuilds the stream.
Python SDK
Version 1.24.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
PyRel now warns you when your raiconfig.yaml file contains a key it doesn't recognize, so a typo no longer passes unnoticed.
For example, misspelling account as accont raises a warning that names the unknown key and suggests the closest valid one.
Valid configuration produces no warnings, and existing files keep working because this is a warning, not an error.
The inspect module for examining a model's concepts, relationships, tables, enums, and definitions without an engine connection is now included in the API reference.
The module shipped in an earlier release. This change makes its documentation discoverable on the docs site and in your IDE.
The spcs_privatelink_zone connection option is now documented and included as a commented setting in the rai init config template.
Set it when you enable Direct Access on a Snowflake PrivateLink account. Omit the leading wildcard from that value.
The rai debugger now groups a deployed model's compiler passes by block, instead of showing one flat list, so you can tell blocks apart and compare the same pass across them.
A new Group by pass toggle flips the view to show every block nested under each pass.
Queries now run in Snowflake Workspace notebooks instead of crashing.
Before this release, any query in that environment failed with OSError: [Errno 95] Operation not supported because PyRel tried to write its trace and log files to the notebook's locked-down filesystem.
Queries now run and return results there with no configuration needed.
Models that use model.Enum(...) to map a messy raw column onto a fixed set of allowed values now deploy to Snowflake and refresh correctly.
This is a common data-cleaning pattern, but on versions 1.22.0 and 1.23.0 it failed to deploy. The only workaround was to drop the enum and store the value in a plain string property instead, which gave up both the fixed set of allowed values and the type safety it provides. That workaround is no longer needed.
For example, the model below defines a Region enum, then tags every site whose raw region text matches a known spelling with the canonical Region.Americas value:
Region = model.Enum("Region", ["Americas", "EMEA", "APAC"])
Site.region = model.Property(f"{Site} has region {Region}")
# Sites whose raw region text is one of these spellings become Region.Americas.
model.where(Site.region_raw.in_(["amer", "americas", "north america"])).define(
Site.region(Region.Americas)
)
You would add a similar definition for EMEA and APAC. On 1.22.0 and 1.23.0 this model failed to deploy to Snowflake, but it now deploys and refreshes cleanly.
A composite-key entity is one identified by more than one key. When your model is deployed to Snowflake, PyRel now builds faster, simpler SQL for reading several properties of such an entity. This is SQL that PyRel generates itself, both when it deploys or refreshes your model. It used to re-read the entity's table once for every property, which was slower. Single-key entities are unaffected.
When a definition sets a property whose value is a composite-key entity, that property's values are now saved correctly when the model is deployed to Snowflake and refreshed. For example, a property might link each product to its supplier, where a supplier is identified by a company name and a country. Before this release, the refresh reported success but silently dropped rows, so a definition that later read the property saw incomplete data.
Setting a property on an entity that is identified partly by another composite-key entity now works as expected when the model is deployed to Snowflake, instead of failing with a NotImplementedError.
For example, a shipment might be identified by a date and a route, where the route is itself identified by two cities.
Reading a property that points from one entity to another no longer adds an all-NULL row for entities that have no value when the model is deployed to Snowflake.
For example, if a property links each employee to their manager, an employee with no manager is now left out instead of appearing as a blank row.
Defining a table source from a schema that lists two keys that name the same physical Snowflake column now behaves predictably. Snowflake treats names like a and A as one column, so PyRel collapses the two keys into one column when they share a type, or raises a clear error when their types differ, instead of silently adding a phantom column to the Table object.
Refreshing a deployed model that reads from a Snowflake source table whose name requires quoting now succeeds instead of failing during refresh. This includes names with a space, like DB.SCHEMA."SOURCE B".
rai models pull on a live branch now rejects a merge that would create a cycle in column types with a clear ConflictError that names the cycle, instead of quietly producing a broken model that fails later. Such a cycle happens when, for example, table T1 is typed by T2 while T2 is typed by T1.
Redeploying a model with rai models deploy is more reliable: a model containing two identical definitions no longer fails to deploy, and annotations on a newly added concept or relation now apply on the first deploy.
Reordering definitions, and concepts that extend a built-in type, also no longer produce spurious changes on redeploy.
Recovering an interrupted model merge is now reliable: re-running a merge after a conflict no longer duplicates concepts already promoted to the parent, the resume information survives an intervening pull or deploy, and model status now shows when a merge is mid-recovery.
The error message shown when your shared_model.py file has been edited since the last pull or deploy now accurately describes what --force does: it pushes your local edits to the shared model and regenerates the file while keeping a backup, rather than discarding your edits.
Branch safeguard messages during a pull now distinguish a missing sync baseline from a branch that is genuinely behind, report the actual synchronized position, and make clear that a pull with no model changes still updates your local state.
rai doctor report now includes your model's local-state directory in the diagnostic bundle when your connection sets rai_app_name but no explicit database, instead of leaving it out.
Direct Access connections that use JWT-based key-pair authentication now automatically retry when the app's service endpoint becomes stale during token exchange, so the connection can recover on its own.
Regenerating a shared model through a pull, merge, or deploy now preserves DECIMAL and other number column types, instead of demoting them to a plain concept.
Python SDK
Version 1.23.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
rai models init now deploys to Snowflake without you having to add a refresh schedule by hand.
Before this release, rai models deploy failed on a brand-new project with an Unscheduled Outputs error, because the generated raiconfig.yaml didn't say how often to refresh the deployed tables and views.
The config now includes a default refresh schedule with interval_s: 0, which refreshes the outputs each time you deploy but not on a fixed interval, so the deploy succeeds.If you haven't filled in your Snowflake connection details yet, PyRel now stops with a clear error message naming the values you need to fill in, instead of a confusing raw Snowflake error.
For example, a new project's raiconfig.yaml might still have the placeholder account: myorg-myaccount.
PyRel runs this check the first time it opens a Snowflake connection, so you see the message early, whether you run a script, run a query, or deploy your model.
The rai debugger can now open the logs from large programs without freezing.
The debugger also has a new Collapse all button that closes every open section at once, and opening one section no longer expands the other sections with the same name.
Pulling or merging a shared model now correctly rebuilds models that earlier releases could rebuild incorrectly.
When you run rai models pull or rai models merge, PyRel regenerates the shared model's code from your team's changes.
Before this release, pull and merging a shared a model could sometimes result in models that failed to build.
You can now call solve() again on the same prescriptive Problem while asking for fewer of its optional sensitivity and conflict results.
Before this release, re-solving without a sensitivity or conflict result you had requested earlier raised an error.
Now the re-solve succeeds. On current RelationalAI platform versions, it also clears the results you no longer request, so you don't see stale numbers from an earlier solve.
You still can't switch between a plain solve and a sensitivity or conflict solve on the same Problem. Create a new Problem for that.
Python SDK
Version 1.23.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now keep the capitalization of your column names when you deploy a model to Snowflake.
By default, PyRel converts unquoted column names to all upper case, so a property named EntityId deploys as the column ENTITYID.
To keep the case you declared instead, set preserve_column_case: true in the deployment section of your raiconfig.yaml (DeploymentConfig):
deployment:
preserve_column_case: true # default: false
This applies to column names only, not table names.
With the option on, PyRel quotes the columns, so the names become case-sensitive in Snowflake.
Query them with the exact case and quotes, such as "EntityId".
You can now name a relationship field that holds more than one kind of entity using the pipe operator | or the union() function.
This is useful when a field can point to instances of different concepts, such as an account owned by either an Individual or an Organization:
Account.owner = m.Relationship(f"{Account} owned by {(Individual | Organization):owner}")
# equivalently:
Account.owner = m.Relationship(f"{Account} owned by {union(Individual, Organization):owner}")
Each option must be a concrete entity type, such as Individual or Organization, rather than a value type like a number or string. A union must list at least two.
Fixed a bug that caused some model deployments to fail with a NotImplementedError and produce incomplete output tables.
Fixed a bug that caused the refresh task for some deployed models to fail with a Snowflake error or to produce empty tables.
Fixed queries that read two fields from the same multi-field Property in one select(), such as select(invoice.total["currency"], invoice.total["amount"]), when invoice comes from a nested select() that returns more than one invoice.
Before 1.23.0, PyRel could mix rows across invoices, returning every invoice's field values for each invoice instead of only its own. Now each invoice returns only its own values. This bug only affected Property instances, not Relationship instances, which always return the stored pairs correctly.
# `invoice` comes from an inner select(), then an outer select() reads
# two fields of the same multi-field property:
invoice = model.where(Invoice.overdue).select(Invoice)[0]
model.select(invoice.total["currency"], invoice.total["amount"])
rai models pull no longer blocks a pull just because your branch has its own local changes.
Before this release, PyRel could mistake those local changes for a conflict and block the pull.
Now a pull is blocked only when your changes actually conflict with the shared history.
Native App
Version 2026.7.21-f60cc22-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Queries that process large amounts of text now run faster on the Logic Reasoner.
You can now clear all the data loaded from a Snowflake source table by emptying that table. The data is removed on the next sync. Previously, empty tables were skipped during syncing, so the original data stayed in the app.
You can now recover a data stream export task that keeps timing out by increasing its warehouse size or timeout. Each data stream uses a Snowflake serverless task to export its processed changes, and a large or costly export can exceed the default limits. Adjust them with two new SQL procedures, intended for exceptional cases and usually done with RelationalAI support:
Certain queries no longer fail while returning their results, most notably some prescriptive reasoning workloads. Previously, a recent change to the query engine could cause these queries to crash with an internal error.
You can now generate predictions immediately after training a Predictive Reasoning model. Previously, this could crash when an earlier training run had left data behind.
Deleting a model no longer interrupts queries that are still running against it. Previously, deleting a model while it was still in use could fail those in-progress queries with a Database was closed and this transaction was discarded error.
A logic reasoner assigned from warm capacity now works reliably as soon as it starts. Previously, such a reasoner could reject its first transactions with connection errors, or briefly appear under a different name than the one you requested.
App upgrades are now more reliable on accounts where services are slow to restart: the app now waits up to 20 minutes for them to come back online, up from 10.
Every upgrade now automatically restores a permission that older apps need to run queries, so upgrading no longer risks leaving an app unable to respond. Previously, an app installed before that permission existed could lose it during an upgrade and stay unavailable until it was restored manually.
transformers library to version 5.12.1. Upgrading the app applies the fix, so there is no action required on your part.Python SDK
Version 1.22.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now share your Snowflake connections, and other settings, across projects instead of copying them into every project's raiconfig.yaml.
PyRel now discovers a home-level ~/.rai/raiconfig.yaml configuration file and merges it with each project's raiconfig.yaml, so you define shared settings once.
Previously, a project file that only named a shared connection (default_connection: my_conn) failed, because PyRel couldn't find where that connection was defined.
For example, define a connection once in the home file, then reference it by name from any project:
# ~/.rai/raiconfig.yaml — define the connection once
connections:
my_conn:
account: MY_ACCOUNT
user: MY_USER
role: MY_ROLE
warehouse: MY_WH
default_connection: my_conn
# raiconfig.yaml — in a project; no connection details needed here
default_connection: my_conn
Anything you set in a project file still wins, so per-project overrides keep working.
Not sure where a setting is coming from? Run rai config:explain to trace each value to its file.
You can now deploy a model from Python code by passing a config to Model, instead of deploying from a raiconfig.yaml file.
For those deploys, the rai doctor report troubleshooting report is now accurate.
Before this release, it could show parts of your deployment as missing.
Now it reflects the configuration your deploy actually used.
Improved performance for queries against deployed models that compute several aggregates grouped by the same key with per.
Before this release, PyRel compiled these queries to SQL that repeated the same grouping join far more times than needed, so they ran slower while still returning correct results.
Now the generated SQL is much smaller and runs faster.
Fixed how PyRel references a Snowflake database, schema, or table used as a data source whose quoted name contains a period, such as a table named "CoNNec.tioNs".
Before this release, PyRel split the name on every period and produced an incorrect table reference.
Now it keeps the quoted name intact.
Python SDK
Version 1.21.4 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
identify_by.
Before this release, PyRel always added a hashed _ID key column to deployed concept tables and joined on it. Now it uses the declared key columns directly, so each refresh does less work and returns the same results.Fixed a correctness problem in deployed models where you identify a concept by a source column whose values can repeat, such as an Order identified by an order id that appears on many line-item rows.
Before this release, that concept's deployed table could contain duplicate rows for the same Order, so some queries over it could return wrong results.
The table now keeps one row per entity, so those queries return correct results.
Fixed Model.Table] so that you can access Snowflake source columns whose names contain spaces.
Before this release, accessing such a column by the name you declared (for example, orders["customer id"]) raised a KeyError even though the column existed. Now it resolves to that column.
Python SDK
Version 1.21.3 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Improved deployed model refresh performance for models with a concept whose identity comes from columns in more than one table. Before this release, if that concept had several properties, PyRel re-read and re-joined those tables once for every property on each refresh, which was slow over large tables. Now PyRel reads and joins them once and fills in all the concept's properties from a single pass, so each refresh does less repeated work and returns the same results.
Improved status reporting for the REFRESH_STATUS procedure.
Python SDK
Version 1.21.2 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Improved the errors you get when deploying a model that uses reasoning not yet supported in deploy mode.
Before this release, deploying a model that used prescriptive optimization (Problem) or predictive (GNN) reasoning could fail in a confusing way.
Now PyRel raises a clear NotImplementedError explaining that these reasoners are not yet supported in deploy mode and telling you to remove the deployment configuration if you need them.
The starter project created by rai models init now runs its deploy step with rai models deploy --wait, so the first deployment finishes before you query.
Before this release, the generated project could return empty results if you queried before that first deployment completed.
Fixed a crash when re-deploying a model with rai models deploy where a rule reads a column from a table loaded without an explicit schema.
Before this release, re-deploying such a model failed with a ValueError: Cannot translate removal of <column>, even though no column had actually been removed.
Now PyRel recognizes that the model is unchanged and the re-deploy completes successfully.
PyRel now reports an error when a concept inherits conflicting identities from more than one parent concept.
Before this release, PyRel accepted this and could build a model that behaves incorrectly.
Now PyRel raises an Incompatible identify_by relations error that names the two conflicting parents.
To fix it, define the identity once on a shared parent that both concepts extend:
from relationalai.semantics import Model, String
m = Model("Demo")
# Rejected: X and Y each define their own identity, so Z cannot inherit both.
X = m.Concept("X", identify_by={"x_id": String})
Y = m.Concept("Y", identify_by={"y_id": String})
# PyRel raises:
# Concept Z has supertypes with incompatible identify_by relations: X vs Y
Z = m.Concept("Z", extends=[X, Y])
# Fixed: define the identity once on a shared parent, Base.
# A and B inherit their identity from Base, so C gets one consistent identity.
Base = m.Concept("Base", identify_by={"id": String})
A = m.Concept("A", extends=[Base])
B = m.Concept("B", extends=[Base])
C = m.Concept("C", extends=[A, B])
Fixed rai models pull so it reports a conflict instead of building an invalid model.
Before this release, pulling branch changes into a shared model could introduce duplicate property names and cause an error at query time.
Now pull raises a conflict error when a branch would introduce a property-name collision, so you can resolve the conflict before continuing.
Fixed std.re.findall() when you call it on a table column.
For each row's value, findall() returns every match together with its position (1, 2, 3, and so on) in the value.
Before this release, the position counted up across the whole column instead of restarting for each row, and rows with no match were dropped.
Now the position restarts at 1 for each row, and rows with no match are kept.
Python SDK
Version 1.21.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Reduced query startup time for deploy mode users running in manual mode (auto_deploy=False in deploy mode configuration).
PyRel now skips a pre-run deployment check, so queries begin sooner.
In manual mode, you will no longer see NO_DEPLOY_STATE or MATCHING_DEPLOY_FAILED during query preparation.
This change reduces query latency, but should only be used in development since queries may return stale results because of the skipped check.
Improved troubleshooting in rai doctor for Private Link accounts that use Direct Access.
Before this release, many failures looked like generic token-exchange errors.
Now doctor output includes a dedicated direct_access_privatelink section with specific categories such as jwt_claim_error, endpoint_routing_error, and grant_error so you can identify the next fix quickly.
For example, run:
rai doctor --format json
Then check this output fragment:
{
"direct_access_privatelink": {
"checked": true,
"ok": false,
"error_type": "endpoint_routing_error"
}
}
Use error_type to choose your next step:
endpoint_routing_error: verify Private Link endpoint routing.
jwt_claim_error: verify JWT claim formatting.
grant_error: verify grants and scopes.
Fixed an issue in the deploy mode workflow (rai models deploy) where deployment could produce an incomplete model in some cases.
Before this release, deploy could finish successfully but still miss expected deployed tables or views, causing results to differ from the model you defined.
Now deployed outputs fully reflect the model definition.
Fixed issues in deploy mode's shared-model synchronization workflow, where rai models pull and rai models deploy regenerate model source and string logic could change.
This affected string expressions, including std.strings.contains() and std.strings.split().
Before this release, filters could be dropped and values derived from split() could fail after export and reload, so results could differ between the original and reloaded model.
Now those expressions are preserved after export and reload, so the reloaded model behaves like the original.
# In an existing model with Person.name and Person.part,
# these expressions should still behave the same after export and reload.
idx, part = std.strings.split(Person.name, ",")
m.where(Person, std.strings.contains(Person.name, "x")).define(Person.part(part))
# Quick check after export and reload:
# Compare the number of Person rows matching contains("x") before vs. after export and reload.
# Expected outcome: the counts are equal.
Python SDK
Version 1.21.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
PyRel 1.21.0 introduces a new public preview feature called deploy mode that lets you deploy a PyRel model to a Snowflake schema as SQL tables and views. For more information, see Deploy a model.
Improved the clarity of error messages when you define membership between concept types that do not match in Model.define().
Before this release, m.define(Target(Source)) could fail with a generic type-mismatch message that did not tell you how to fix the model.
Now the error explains compatible fixes, such as making Target a subtype of Source or using AnyEntity when you intentionally allow heterogeneous membership.
This example shows one invalid definition and two valid fixes:
from relationalai.semantics import AnyEntity, Model
m = Model("Demo")
SourceConcept = m.Concept("Order")
# Invalid: TargetConcept does not extend SourceConcept.
TargetConcept = m.Concept("NeedsReview")
m.define(TargetConcept(SourceConcept))
# Valid fix 1: make the target concept a subtype of SourceConcept.
TargetSubtype = m.Concept("OrderThatNeedsReview", extends=[SourceConcept])
m.define(TargetSubtype(SourceConcept))
# Valid fix 2: use AnyEntity when membership should accept mixed concept types.
TargetAnyEntity = m.Concept("NeedsReviewAny", extends=[AnyEntity])
m.define(TargetAnyEntity(SourceConcept))
Native App
Version 2026.7.13-470c23f of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Fixed a bug that occurred when two PyRel programs interacted with the same model at the same time. Previously, data synchronization could stall for an extended period of time before failing with a cryptic error. Now when this happens, data synchronization fails fast with a clear "model is busy" error.
Fixed a bug where engines recreated after a service restart could remain in the PENDING state indefinitely. Provisioning now stops when it reaches the timeout limit. When that happens, the attempt fails with a timeout error instead of hanging forever.
Python SDK
Version 1.20.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Fixed a bug where ReasonersClient.ensure() and ReasonersClientSync.ensure() could silently reuse an existing prescriptive reasoner even after your configured settings had changed.
Before this release, calling ensure("PRESCRIPTIVE") after changing your reasoner size or settings could return the old, mismatched reasoner without any warning.
Now PyRel compares your configured settings against the existing reasoner before reusing it, and raises ReasonerConflictError when they do not match so you can resolve the conflict explicitly.
Fixed a bug where querying certain Snowflake columns returned NULL or a SQL error instead of your data.
This affected columns whose names use capital letters, special characters such as ., or a word that SQL reserves for its own use, such as ORDER.
Before this release, PyRel changed a name like PrimaryAssetId to all uppercase (PRIMARYASSETID) under the hood. Snowflake treats those as two different columns, so it looked for a column that didn't exist and returned NULL.
Now PyRel uses the column name exactly as it is stored, so these queries return the correct values.
Fixed a bug where a negated comparison could silently apply a different condition than the one you wrote.
Before this release, an expression such as not_(Person.age > 18) could be stored and re-evaluated as not_(Person.age) instead. That selects entities with no recorded age, not entities under 18, and PyRel gave no indication that the condition had changed.
Now the comparison is always preserved exactly as written.
Fixed a NameError that could occur when using Model.union() to collect values from multiple properties.
Before this release, a union such as m.union(Employee.email, Employee.phone) could fail with NameError: name 'Any' is not defined.
Now this expression executes correctly and returns the combined values.
Native App
Version 2026.7.3-57280fc of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
App activation now checks for Snowflake account-level settings that prevent the application from functioning correctly. If an incompatible setting is detected — for example, PREVENT_UNLOAD_TO_INTERNAL_STAGES = TRUE, which blocks the app from writing to its own internal stage — relationalai.app.activate() blocks activation and explains how to resolve the conflict. For recovery steps, see Fix app activation errors caused by Snowflake account settings. You can run the following to skip these checks and proceed anyway:
CALL relationalai.app.activate(ERROR_ON_UNSUPPORTED_ACCOUNT_FLAG => FALSE);
The application now cleans up unused references in the application's internal records of which Snowflake tables and views are configured as data stream sources. When a data stream is removed or reconfigured, its records can be left behind as orphans, causing them to accumulate over time and eventually prevent new data streams from being configured. New procedures are also available to inspect and remove these unused references manually:
app.finalize_upgrade() procedure. Upgrade finalization is now handled automatically, so there is no replacement. If you call app.finalize_upgrade() in custom automation, remove those calls to avoid errors.Python SDK
Version 1.20.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Multiple Cortex agents can now share the same Snowflake schema by assigning each a unique prefix. Previously, each agent required its own schema, leading to schema sprawl and management overhead. Now you can keep related agents together:
from relationalai.agent.cortex import DeploymentConfig
# Customer service agent
service_config = DeploymentConfig(
database="APPS",
schema="AGENTS",
agent_name="customer_service",
prefix="service", # stored procedures: service_RAI_*
)
# Sales agent in the same schema
sales_config = DeploymentConfig(
database="APPS",
schema="AGENTS",
agent_name="sales",
prefix="sales", # stored procedures: sales_RAI_*
)
Existing deployments without a prefix continue to work unchanged.
Unsupported operators in prescriptive problems now raise clearer error messages. When you use an operator like % or // in a Problem expression, you get a helpful message that points you to fix the operator:
# Now raises a NotImplementedError because % is not supported
problem.add_constraint(quantity % 2 == 0)
Python SDK
Version 1.19.4 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Predictive dataset diagrams are now easier to render and save.
Before this release, you had to call visualize_dataset() and manually render the returned object.
Now you can call display_dataset_diagram() to show the diagram in a notebook, or save_dataset_diagram(path) to save it directly to a file such as schema.svg.
Removed the snowflake-ml-python dependency from the relationalai package because one of its transitive dependencies is not compatible with Python 3.13.
The snowflake-ml-python dependency was only included if you installed relationalai with the [gnn] extra, such as with pip install relationalai[gnn].
rai config:explain output is now easier to scan.
Before this release, fields were listed in declaration order.
Now fields are sorted alphabetically across top-level, nested, dictionary, and profile sections.
Python SDK
Version 1.19.3 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Fixed a regression in 1.19.2 that broke exports into Snowflake destination tables with Table targets when you call .into(Table(...)) on a query result.
This now works as expected.
Fixed an issue that caused expressions like where(x | y).define(...) to raise an Unused variable declared error when both sides of the | operator contained calculated values.
These expressions now evaluate to the expected value.
Native App
Version 2026.6.29-a85c9fc of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Fixed an issue that caused CDC service suspensions during transient failures, helping prevent unexpected interruptions to stream syncing.
Fixed an unhandled error that occurred when attempting to delete a non-existent engine.
Fixed error propagation in reasoner management APIs so that meaningful diagnostic details are returned when an operation fails, rather than an empty error response.
jupyter-server to version 2.20.0 to address a cross-site scripting (XSS) vulnerability in predictive reasoners' notebook server conversion handlers.Python SDK
Version 1.19.2 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
rai reasoners create.
Invalid names are now rejected earlier with a clearer message, instead of failing later during provisioning.
This makes naming mistakes easier to spot before reasoner setup starts.rai reasoners create --name.
Before 1.19.2, an invalid default reasoner name from configuration (for example, a username-derived fallback) could still block a valid explicit --name value.Python SDK
Version 1.19.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Fixed queries against Snowflake tables declared with Table when the table name or stored column spelling requires quoting, including case-sensitive names and names that contain spaces, punctuation, and Unicode characters.
For example, the following query now resolves both the quoted table name and the quoted column name correctly:
from relationalai.semantics import Model
m = Model("demo")
orders = m.Table('"table with spaces"')
m.select(orders["id"], orders["column one"]).to_df()
Previously, this could raise a RAIException such as [Unknown Table] Failed to fetch schema for table '"table with spaces"'.
Python SDK
Version 1.19.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Property in one select(), such as select(invoice.total["currency"], invoice.total["amount"]).
Before 1.19.0, PyRel could incorrectly return every combination of the fields' values instead of keeping the original pairs together.
This bug only impacted Property instances and not Relationship instances, which always return the stored pairs correctly.Python SDK
Version 1.18.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
rai doctor report now generates a deterministic diagnosis.md summary and shows the same diagnosis in the debugger report browser.
Before 1.18.0, you had to inspect the collected artifacts yourself to identify likely configuration, Snowflake, deploy, schema-cache, trace, or collection problems.
PyRel now fails fast on undefined config references instead of ignoring them or failing later at runtime.
For example, a typo in active_profile such as active_profile: localm now raises a clear validation error during config loading.
Fixed math.clip() so it returns the clipped value instead of NULL when the input falls below, within, or above the requested bounds.
Fixed how reasoner names are generated.
If you don't set custom reasoner names in your configuration, provisioning could previously fail when your username starts with a digit because the generated reasoner name was invalid.
PyRel now sanitizes the generated name automatically, for example by turning 12345 into user_12345.
Fixed nested select() values inside union and match branches, and fixed aggregates over scalar subquery values, so those query shapes return the expected rows instead of raising internal compiler or validation errors.
Fixed rank() queries that also return a related value in the same result.
Those queries now return the expected table and use NULL when the related value is missing instead of failing validation.
PyRel now raises an Ambiguous concept usage error when one rule reuses the same concept name as both a variable and a concept type in the same line.
For example, the following code now raises an error instead of silently misinterpreting the second line:
from relationalai.semantics import Model, String
m = Model("ambiguous")
A = m.Concept("A")
B = m.Concept("B", extends=[A])
C = m.Concept("C", extends=[A])
D = m.Concept("D", extends=[B, C])
A.id = m.Property(f"{A} is identified by {String}")
A.identify_by(A.id)
m.define(A.new(m.data([
{"id": "w"},
{"id": "x"},
{"id": "y"},
{"id": "z"},
]).to_schema()))
m.define(B(A)).where(A.id.in_(["w", "x", "z"]))
m.define(C(A)).where(A.id.in_(["w", "y", "z"]))
# Unambiguous: B is a variable in both places.
m.define(D(B)).where(C(B))
# Ambiguous: B is variable in D(B) but a concept type in B(C).
m.define(D(B)).where(B(C)) # now raises "Ambiguous concept usage"
Previously, PyRel would silently define every entity of type B as a D in this case because the type expression B(C) doesn't constrain the variable B in .define() in any way.
Python SDK
Version 1.17.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Added keyword field binding for Relationship calls.
For example, if a relationship has src, transfer, and dst fields, you can write:
Account.transferred_to(src=source, transfer=transfer, dst=destination)
In addition to not having to pass fields in order, you also get clearer errors for missing fields and unknown fields.
Added support for per(...).product(...) to create a grouped product.
Before 1.17.0, only product(...).per(...) was supported.
Combined more rai doctor report troubleshooting information into one zip file.
Before 1.17.0, support cases could require both doctor_report_*.zip from rai doctor report and a separate oplog_report_*.zip from rai doctor report-oplog.
Now rai doctor report includes that extra information in doctor_report_*.zip.
Fixed cases where duplicated values in prescriptive sum() and count() expressions inside a Problem were counted once in the aggregate instead of multiple times as expected.
Fixed Direct Access for Snowflake Private Link accounts.
Fixed handling for cross-model mix-ups when code uses objects from one Model inside another Model.
Some of these cases previously resulted in empty results or confusing errors.
PyRel now raises a clear, direct error instead.
Improved the error shown when top(), bottom(), or limit() is used in places that require a single value, such as comparisons or property values.
Native App
Version 2026.6.22-cd93f88 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.16.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
OplogConfig to opt in to model oplog recording during deploys.
Set oplog.enabled: true so a successful rai models deploy records the change in the model oplog.
That record then lets you use rai models pull, rai models branch, and rai models merge for that model.
Before 1.16.0, the public Python API docs did not expose this config section or this opt-in deploy behavior.Python SDK
Version 1.15.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
alias() to give any value an output alias, including Python literals such as 1, which can't call .alias() directly.
Before 1.15.0, there was no top-level helper in relationalai.semantics to alias literal values.Native App
Version 2026.6.14-4f4ec3d of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
transaction_attributes column to api.transactions so you can filter transactions by query attributes such as environment tags.Python SDK
Version 1.14.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
rai jobs create now send background job guidance to stderr instead of stdout.
This keeps stdout cleaner for scripts. If your automation relied on those guidance lines, you may need to capture or redirect stderr.Python SDK
Version 1.13.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now use std.re regex queries with the SQL backend, including match(), search(), fullmatch(), findall(), and sub().
Before 1.13.0, the SQL backend did not support these regex operations.
The ZIP archive from rai doctor:report now includes a readable summary.md file so you can quickly review status and key diagnostics.
Before 1.13.0, you had to inspect raw JSON, YAML, and CSV artifacts for that overview.
rai doctor now warns earlier when you use direct_access: true with an unsupported Snowflake authenticator and tells you how to fix it.
Before this fix, you might instead hit a later raw token-exchange error.
Deployments and refresh tasks now use the Snowflake role you set in DeploymentConfig.role.
Before this fix, PyRel could ignore that setting and use a different role.
Python SDK
Version 1.12.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now use aggregates.product() to compute the product of numeric values in PyRel queries.
Before 1.12.0, the standard aggregates module did not include a built-in product aggregate.
rai doctor:report now includes expanded diagnostics.
Python SDK
Version 1.11.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Python SDK
Version 1.10.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now use stddev_samp() in PyRel queries to compute sample standard deviation.
Before 1.10.0, you had to compute it outside PyRel or build it from lower-level operations.
rai doctor:report now provides more detail when you troubleshoot deployment-role issues or share environment details with support.
It adds Snowflake task execute privilege diagnostics and richer version metadata.
Imports for the prescriptive and predictive reasoner packages now work on Python 3.11 or later. Before this fix, imports could fail because of an invalid dataclass default.
SQL-backed select() queries no longer return unexpected duplicate rows when you use distinct().
Some Snowflake deployments no longer fail when models read Snowflake-backed data sources through CDC. Before this fix, deployments could materialize those inputs as unsupported dynamic tables instead of CDC-compatible tables with change tracking.
Native App
Version 2026.6.7-1a518f4-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Added new views in the observability_preview schema that expose metrics for monitoring predictive and prescriptive reasoners.
New predictive reasoner views:
PREDICTIVE_REASONER__CPU_UTILIZATIONPREDICTIVE_REASONER__MEMORY_UTILIZATIONPREDICTIVE_REASONER__GPU_UTILIZATIONPREDICTIVE_REASONER__GPU_MEMORY_UTILIZATIONPREDICTIVE_REASONER__ACTIVE_JOBSNew prescriptive reasoner views:
PRESCRIPTIVE_REASONER__CPU_UTILIZATIONPRESCRIPTIVE_REASONER__MEMORY_UTILIZATIONPRESCRIPTIVE_REASONER__ACTIVE_JOBSSee the observability_preview SQL API reference for columns, example queries, and related views.
Improved error messages for failures when using Iceberg tables as data sources.
Concurrent exports to Iceberg tables now produce a conflict error instead of silently writing duplicate data.
Fixed an issue that caused missing predictive reasoner logs.
Fixed a bug where predictive reasoners would not be automatically suspended after a service restart.
Fixed an issue where predictive reasoner startup could fail if a warehouse grant step failed.
Python SDK
Version 1.9.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
filter_by() on Concept or Ref, it now emits a Python DeprecationWarning in 1.9.0.
Your existing code still works in 1.9.0.
Use .lookup() instead of filter_by() going forward.Prescriptive solve() now helps you inspect solved models and diagnose infeasible ones.
Use solve(sensitivity=True) after solving to inspect solve diagnostics such as reduced costs and constraint sensitivity.
Use solve(conflict=True) to identify infeasibility conflicts, then check solve_info().conflict_status.
PyRel 1.9.0 improves CLI diagnostics.
rai doctor now prints live health checks, and doctor:report collects diagnostic artifacts for support.
Fixed a bug where queries using top(), bottom(), or limit() could fail with a SQL parser error.
When raiconfig.yaml contains placeholders, rai doctor now identifies the missing configuration instead of failing with a raw connection error.
If you use grouped optional aggregates over stored relationships, those Snowflake-backed queries now run correctly.
Before this fix, they could fail with Unsupported subquery type cannot be evaluated.
Native App
Version 2026.6.1-38f8bad-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.8.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
LogicReasonerConfig.readonly_queries config option that can help improve performance when you run multiple queries against the same model.
It is disabled by default.Native App
Version 2026.5.24-a67d5bb of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.8.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
A standard relationalai install now includes the packages needed for predictive reasoning workflows.
You no longer need to install using pip install relationalai[gnn].
If a model contains multiple exports to Snowflake tables, independent exports are now run concurrently.
gnn.dataset.tables indices are now deterministic across runs.Python SDK
Version 1.7.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Fixed a bug that prevented the creation of concepts with spaces and other special characters in their names.
Fixed a bug that caused some users to see the following error:
Uncaught exception of type 'STATEMENT_ERROR' on line 88 at position 6 : Uncaught exception of type 'STATEMENT_ERROR' on line 46 at position 0 : SQL compilation error:
Window function type [ROW_NUMBER] requires ORDER BY in window specification.
Python SDK
Version 1.7.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
authenticator="oauth_client_credentials" for app-to-app OAuth flows. See OAuthClientCredentialsAuth for configuration details.rai reasoners sizes to inspect available reasoner sizes.Native App
Version 2026.5.17-26db430-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.6.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
rai clean:rai clean cache removes the local schema cache file.rai clean debugger removes debugger run directories and trace logs.Python SDK
Version 1.5.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Added diagnostics CLI commands under rai doctor, including doctor:report and doctor:cache:check for cache checks.
PyRel now accepts optional Snowflake connector and session settings in its Snowflake connection config, including client_session_keep_alive, login_timeout, network_timeout, socket_timeout, and session_parameters.
Before this change, you could not set these options through PyRel config and had to rely on Snowflake connector defaults.
Now you can tune long-running or idle-sensitive Snowflake connections from PyRel config.
cumsum_asc() now handles multiple sort keys correctly.
Before this change, cumulative sums could be wrong when you ordered by more than one sort key.
Graph validation now catches a few edge cases earlier. Before this change, some invalid node types were not caught until later in the execution path. Now you'll see those errors earlier.
Fixed a bug that caused weighted Jaccard or cosine similarity to behave inconsistently for zero-weight edges.
Python SDK
Version 1.4.2 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
rai config use now supports interactive profile selection.
In non-interactive runs, the command still requires an explicit profile.config.model.keep = False on a Model now deletes the RAI resources on exit as intended.
Before this fix, the v1 execution path could silently keep the resources even when cleanup was requested.Python SDK
Version 1.4.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Added a new predictive reasoning API under relationalai.semantics.reasoners.predictive.
It includes GNN for training, loading, registering, and predicting with Graph Neural Networks.
rai init now gives clearer step-by-step terminal guidance.
New config templates also default to browser-based Snowflake authentication instead of password placeholders.
For interactive Snowflake sign-in, see Configure external browser authentication.
Fixed prescriptive aggregate correctness bugs when defining a Problem.
Fixed a recursion error caused by some expressions like model.where(count(B) >= 0).define(C.new(val=B)).
rai reasoners:list and the interactive reasoner picker no longer fail if the backend returns unknown reasoner types.
Problem.solve() now sends numeric type metadata to the solver service.
This prevents float-valued MiniZinc solves from falling back to an integer-only path and failing with inexact conversion errors.
Native App
Version 2026.5.11-57723fa of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.3.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Concept.new() could treat entities with different identity field names as the same entity if the values matched.Python SDK
Version 1.3.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Added three CLI commands for troubleshooting and environment checks:
rai version for a quick version check or --verbose output with runtime and install details.rai whoami to confirm which identity and profile the CLI is using, or --resolve to compare that with the server-resolved user.rai diagnose to capture version, config, and connectivity diagnostics in one command, with optional JSON or YAML output for automation and support workflows.Problem.display() now supports where= and limit= arguments so you can inspect a filtered subset of rows or cap the output instead of printing the full problem summary.
Python SDK
Version 1.2.2 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
More RAI CLI commands now support JSON and YAML output options, and these output formats has been standardizes across commands for easier integration with automation scripts.
The following commands now all support --output json and --output yaml:
Added a new rai reasoners wait command that blocks until a reasoner is READY.
In addition, the rai reasoners create and rai reasoners resume commands now support --wait and --no-wait options.
Cortex agent deployment diagnostics now help you validate your Snowflake setup before deployment:
CortexAgentManager.preflight() to surface missing permission grants and source objects in one pass.CortexAgentManager.print_setup_sql() to generate the matching GRANT block.python -m relationalai.agent.cortex.diagnostics to perform the same checks from the command line.Python SDK
Version 1.2.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
PyRel now makes configuration profiles easier to use from the CLI:
--profile option or the RAI_PROFILE environment variable.rai config profiles to list available profilesrai config current to check which profile is activerai config use to change the active_profile in your config fileThe CLI also gives clearer feedback when:
active_profile in your configNative App
Version 2026.5.4-535f669-3 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.2.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
The rai CLI now supports space-separated subcommands such as rai jobs list and rai reasoners list.
Existing rai jobs:list-style commands still work, but interactive shells now show a one-time deprecation hint so you can migrate at your own pace.
rai completion install adds shell completion setup for bash, zsh, and fish, and rai commands gives you a browsable view of the available CLI command tree.
Graph.cosine_similarity() now supports directed graphs.
In scripts, CI, and other non-interactive runs, PyRel now shows the full error details before the final RAIException when type inference or similar compiler checks fail.
Before, these failed checks could stop with only a generic see above for details message with the real diagnostic missing.
Problem.solve_for() now works when you solve for an inherited property or relationship.
Prior to this fix, if a Parent concept defines a Parent.foo property and the Sub concept inherits it by extending Parent, solve_for(Sub.foo) could raise a TypeError.
Python SDK
Version 1.1.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
rai jobs:list and rai reasoners:list now make pagination explicit when you use --limit and --offset.
Before, paginated table output could look like a complete result set even when it only showed one slice.
Now the CLI adds a footer when needed, including a copyable next-page command when more results may be available and a clearer message when an offset is past the end of the result set.
rai now checks whether a newer PyRel release is available and shows an upgrade prompt when your installed version is behind.
Standard CLI invocations refresh a cached check in the background, and rai --version checks synchronously so the notice can appear immediately.
The notice is suppressed for JSON output, CI, non-interactive runs, and by setting RAI_NO_UPDATE_CHECK=1 in your environment variables.
Native App
Version 2026.4.27-2ba1778 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.1.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Graph.jaccard_similarity() now supports directed graphs, including weighted directed graphs.JobsClient.list() and commands such as rai jobs:list.
Before, if you ran them with the reasoner type set to Predictive or Prescriptive, the output could leave out matching jobs when PyRel was configured for Direct Access.
Now those jobs are included, as expected.Python SDK
Version 1.0.19 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Graph.is_acyclic() is now much faster on many large graphs, especially large trees and grids.
In benchmarks for the change, the runtime for the largest tested grid graph dropped from about 751 seconds to 47 seconds.Removed unsupported std.re APIs.
These APIs would raise errors if you tried to use them.
All documentation pertaining to std.re has also been removed.
Fixed active profile selection so that the RAI_ACTIVE_PROFILE environment variable takes precedence over active_profile in raiconfig.yaml.
Fixed prescriptive models that combined filtered aggregates in one expression. Before, PyRel could leak one aggregate's filter into another, so objectives and constraints could silently drop instead of being sent to the solver. For example:
from relationalai.semantics import Float, Integer, Model
from relationalai.semantics.reasoners.prescriptive import Problem
model = Model("ScopedAggregates")
X = model.Concept("X", identify_by={"i": Integer})
X.v = model.Property(f"{X} has {Float:v}")
model.define(X.new(i=1), X.new(i=2))
problem = Problem(model, Float)
problem.solve_for(X.v, name=["v", X.i], lower=0, upper=10)
v = Float.ref()
problem.satisfy(model.require(sum(v).where(X.v(v), X.i == 1) == 1.0))
problem.satisfy(model.require(sum(v).where(X.v(v), X.i == 2) == 4.0))
# The bug was triggered by combining two filtered aggregates in one expression.
problem.minimize(sum(X.v).where(X.i == 1) + sum(X.v).where(X.i == 2))
problem.satisfy(model.require(sum(X.v).where(X.i == 1) <= sum(X.v).where(X.i == 2)))
problem.solve("highs")
print(model.select(problem.num_min_objectives().alias("objective_count")).to_df())
print(model.select(problem.num_constraints().alias("constraint_count")).to_df())
print("objective_value:", problem.solve_info().objective_value)
Output before the fix:
objective_count
0 0
constraint_count
0 2
objective_value: 0.0
Output after the fix:
objective_count
0 1
constraint_count
0 3
objective_value: 5.0
Fixed model.data() calls created on the same source line, such as inside a loop.
model.data() creates a temporary data source each time you call it.
Before, if two calls happened on the same line, PyRel could mistake them for the same source.
That could make later queries fail even when the input data was valid.
For example:
from relationalai.semantics import Integer, Model, String
m = Model("DataLoop")
Item = m.Concept("Item", identify_by={"id": Integer, "name": String})
batches = [
pd.DataFrame([(1, "a"), (2, "b")], columns=["id", "name"]),
pd.DataFrame([(3, "c"), (4, "d")], columns=["id", "name"]),
]
for batch in batches:
m.define(Item.new(m.data(batch).to_schema()))
print(m.select(Item.id, Item.name).to_df())
Output before the fix:
RelQueryError: Query error
Output after the fix:
id name
0 1 a
1 2 b
2 3 c
3 4 d
Now PyRel gives each same-line data source its own deterministic sequence number, so queries compile and run correctly.
Python SDK
Version 1.0.18 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
You can now pass an existing Snowpark session to create_config() with snowflake_session=.
For example:
from snowflake.snowpark import Session
from relationalai.config import create_config
snowflake_connection_parameters = {...}
snowpark_session = Session.builder.configs(snowflake_connection_parameters).create()
config = create_config(snowflake_session=snowpark_session)
assert config.get_session() is snowpark_session
:::note
If you already load config from raiconfig.yaml or another supported config source, queries use the injected session instead of the Snowflake connection from that config.
:::
This change makes it easier to use PyRel in environments where you already have a Snowpark session.
Fixed nested lookups that could drop rows when the inner lookup had no match.
Before, PyRel could skip rows instead of keeping the row and showing NULL for the missing value.
For example:
from relationalai.semantics import Integer, Model, String
m = Model("CustomerModel")
Customer = m.Concept("Customer", identify_by={"id": Integer})
Customer.name = m.Property(f"{Customer} has name {String:name}")
ReferralCode = m.Relationship(f"{Integer:customer_id} maps to {String:referral_code}")
m.define(
Customer.new(id=1, name="Alice"),
Customer.new(id=2, name="Bob"),
ReferralCode(1, "ABC123")
)
customer_id = Integer.ref()
code = String.ref()
q = (
m.where(
Customer.id == customer_id,
referral_code := m.where(ReferralCode(customer_id, code)).select(code),
)
.select(Customer.name, referral_code.alias("referral_code"))
)
print(q.to_df())
Output before the fix:
name referral_code
0 Alice ABC123
Output after the fix:
name referral_code
0 Alice ABC123
1 Bob NULL
Fixed datetime.date.range() and datetime.datetime.range() when the end value comes from a DSL value like a Concept, Property or Relationship instead of a regular Python date or datetime.
Before, the query could return one combined date range instead of a separate date range for each entity.
For example:
from relationalai.semantics import Date, Integer, Model, define, select, std
m = Model("dates")
Foo = m.Concept("Foo", identify_by={"id": Integer})
Foo.end_date = m.Property(f"{Foo} has {Date:end_date}")
define(
Foo.new(id=1, end_date=dt.date(2020, 1, 2)),
Foo.new(id=2, end_date=dt.date(2020, 1, 4)),
)
select(
std.datetime.date.range(dt.date(2020, 1, 1), Foo.end_date, freq="D")
).to_df()
Before, that query could return one combined date range instead of a separate date range for each Foo row:
# Before the fix:
result
0 2020-01-01
1 2020-01-02
2 2020-01-03
3 2020-01-04
Now there are duplicate dates because both Foo rows contribute to the result:
# After the fix:
result
0 2020-01-01
2 2020-01-02
3 2020-01-02
4 2020-01-03
5 2020-01-04
Fixed inferred field naming for numeric aliases such as Integer.
Before, if you let PyRel infer a field name from one of those types, it would generate a name like number_38_0 instead of integer, so string lookups such as Scores["integer"] would fail with a KeyError exception.
For example:
from relationalai.semantics import Integer, Model, String
m = Model("scores")
# The Integer field is unnamed here, so PyRel infers its field name.
Scores = m.Relationship(f"{String:name} has {Integer}")
# Prior to the fix, this lookup would raise a KeyError.
m.select(Scores["integer"]).to_df()
Now PyRel infers the correct field name, so Scores["integer"] resolves to the Integer field.
Python SDK
Version 1.0.17 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
PyRel now supports math.round().
You can round to the nearest integer or to a specified number of decimal places inside semantics expressions.
rai debugger now makes compiler output easier to inspect.
You can choose which compiler steps to show in one dialog, see clearer color coding, and view job IDs directly in the UI.
Before, you had to toggle those steps one by one and query cards did not show the job ID.
You can no longer create a property or relationship on a concept named Relationship, Property, Concept, or Table.
If you try to use one of these names, PyRel raises an error such as:
'Relationship' is a reserved name and cannot be used as a relationship name on concept 'Person'.
For example:
from relationalai.semantics import Model, String
m = Model()
Person = m.Concept("Person")
# Allowed
Person.relationship = m.Property(f"{Person} has {String:relationship}")
# Raises the reserved-name error
Person.Relationship = m.Property(f"{Person} has {String:relationship}")
Fixed a slowdown when you ran the first query on a second model in the same Python process. Before, PyRel could check data sources from all models instead of only the model you were querying. Now each model keeps its own data sources, so queries check only the relevant ones.
Fixed exports to Snowflake tables when you declare the destination schema with Model.Table().
Before, if the destination schema had more columns than the current export produced, PyRel could leave out the extra declared columns.
Now it keeps those columns and fills missing values with NULL, so later writes to the same table can still succeed.
For example:
from relationalai.semantics import Integer, Model, String
m = Model("MyModel")
Order = m.Concept("Order", identify_by={"id": Integer})
Order.status = m.Property(f"{Order} has {String:status}")
# This query exports only order_id and status.
q = m.select(Order.id.alias("order_id"), Order.status)
# The destination schema also declares shipped_at.
out = m.Table(
"ANALYTICS.PUBLIC.ORDER_EXPORT",
schema={
"order_id": Integer,
"status": String,
"shipped_at": String,
},
)
q.into(out).exec()
# In 1.0.17, shipped_at stays in the exported Snowflake table and is filled with NULL.
Fixed fully qualified Snowflake names that use quoted lowercase or mixed-case object names.
Before, PyRel could strip the quotes from names such as ANALYTICS.PUBLIC."orders" or ANALYTICS.PUBLIC."SalesSummary".
That could make Snowflake read them as ANALYTICS.PUBLIC.ORDERS or ANALYTICS.PUBLIC.SALESSUMMARY, which might be different objects or might not even exist.
Now PyRel preserves those quotes.
Python SDK
Version 1.0.16 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Repeated Graph API calls are now faster.
When you call the same graph method with the same arguments, PyRel reuses the earlier graph relationship instead of rebuilding it.
This applies to methods such as reachable(), degree and neighbor methods, and several similarity, clustering, and centrality methods.
See Run a graph algorithm and the Graph API reference for details.
Problem.solve() now omits variable and expression when sending jobs to the prescriptive reasoner.
This helps avoid exposing business data through generated names.
If you need those names in printed solver output, set print_format to a format such as lp, mps, or moi.
Fixed property lookups in concept hierarchies with multiple parents. Before, when implicit properties were enabled, PyRel could create the property on the wrong parent and return missing or incorrect data. Now it uses the declared property instead. See Declare relationships and properties.
PyRel now warns about possible typos in implicitly created properties.
Before, a near-match property name could silently create a new property.
Now PyRel points out the likely mistake sooner. For example, if you access Person.friend after declaring Person.friends, PyRel warns Did you mean: friends.
Fixed supertype membership for derived subtypes. Before, some subtype facts did not propagate all the way up the inheritance chain, so counts and membership queries on parent concepts could be incomplete.
Native App
Version 2026.4.19-001506c-3 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.0.15 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
RAI_ACTIVE_PROFILE environment variable as a way to select the active profile.
You can now set the active profile with RAI_ACTIVE_PROFILE=<profile_name> in addition to active_profile in raiconfig.yaml.
See Use profiles to manage multiple configurations for details.Reduced Model.Table() overhead on large Snowflake schemas.
Before, PyRel could scan the whole schema on each lookup.
Now PyRel fetches metadata one table at a time, which reduces cold-start overhead when a model touches many tables in a large schema.
For background on declaring Snowflake sources, see Declare data sources.
Improved behavior on read-only notebook and container file systems. Before, PyRel could fail while writing caches or trace files with misleading errors. Now it falls back to a writable temporary directory in those environments.
Fixed Snowflake authentication failures that could surface as a misleading No default Session error.
PyRel now reports the underlying Snowflake auth failure when it cannot create a new session.
Fixed a startup crash in rai debugger.
Before, some launches could fail with RuntimeError: You must call ui.run() to start the server.
Now the debugger starts without that reload-related crash.
Fixed Model.data() so rows with mixed integer and floating-point columns preserve integer values.
Before, some integer fields could be upcast and show up as values like 1.0 in query results.
Python SDK
Version 1.0.14 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Improved notebook support. Before, rerunning notebook cells could leave behind earlier model state, and diagnostics were less notebook-aware. Now PyRel cleans up prior model declarations more reliably across reruns and renders diagnostics inline in notebooks when possible.
Added reasoner-specific connection overrides in raiconfig.yaml.
You can now set reasoners.<type>.connection so a specific reasoner uses a different connection than the global default_connection.
For broader reasoner configuration, see Configure reasoners.
Added the rai debugger CLI command.
Added pagination to jobs:list and reasoners:list.
Use --limit and --offset to control large result sets.
Fixed model.data() so DataFrame columns with PyRel Int128 extension dtypes are inferred as Integer instead of falling back to Any.
Before, DataFrames with those columns could fail type inference after round-tripping results back into model.data().
Now those inputs compile without requiring a manual cast.
Fixed correctness issues in unary relationships. Before, queries against unary relationships could produce incorrect results, such as over-counting.
Fixed rank_asc() and rank_desc() when used with distinct().
Before, duplicate values were not always deduplicated before ranking, so repeated values could still be ranked separately instead of once as unique values.
Now queries that use these ranking functions with distinct() reliably rank unique values after deduplication.
Fixed an issue where property names could get renamed in query results if the property name contains spaces or special characters like parentheses.
This happened when a property was auto-created from a table column name with spaces or parentheses, like height(cm) or full name.
Previously, these names could get transformed to height_cm or full_name in results columns, which could cause confusion when working with the results.
Now, property names are preserved as-is in results.
Native App
Version 2026.4.13-d558733 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Native App
Version 2026.4.6-dde787d of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.0.13 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Expanded graph APIs:
Graph.adamic_adar() now supports weighted and directed graphs.Graph.is_acyclic() adds a built-in DAG check for directed graphs.Added cumsum_asc() for cumulative sums over ascending keys.
Added global --json and --no-color options to the rai CLI to make output easier to handle in automation.
--json returns structured output for reasoners:list, reasoners:get, jobs:list, and jobs:get.
For example:
rai --json jobs:list
rai --no-color reasoners:list
Updated rai CLI wait flows so they make fewer unnecessary backend status and result checks before returning.
These flows occur when you use --wait with commands like rai reasoners:create and rai reasoners:resume:
rai reasoners:create --type Logic --name my_reasoner --wait
rai reasoners:resume --type Logic --name my_reasoner --wait
The same improvements also apply when PyRel waits on jobs and reasoners.
If you work with multiple prescriptive solutions, keep the ProblemVariable returned by problem.solve_for(...) and query it directly instead of calling Problem.variable_values(). For example:
var = problem.solve_for(...)
sol_idx = Integer.ref()
value = Float.ref()
model.select(sol_idx, value).where(var.values(sol_idx, value))
This returns (sol_idx, value) pairs, so you can inspect every solution or filter to one specific solution index. Problem.variable_values() still works, but it is deprecated and no longer preferred.
Problem.load_point() still works as a deprecated no-op for load_point(0), but load_point(k) for k > 0 is no longer supported.
Native App
Version 2026.3.29-58b69bc-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Native App
Version 2026.3.29-58b69bc of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.0.12 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
tables section in raiconfig.yaml so you can set defaults and named sources and export targets.
See Use a Snowflake table with Model.Table(). and Export results to Snowflake tables for details and examples.Python SDK
Version 1.0.11 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
direct_access: true is used with an unsupported authenticator.
Before, the warning could use older terminology that did not match the v1 config fields.
Now the warning uses v1 naming, explains the fallback to direct_access: false, and lists the supported authenticator names.
For direct access configuration details, see Enable Direct Access.Python SDK
Version 1.0.10 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
repr(), str(), and .pprint().
Before, inspecting concepts, expressions, fragments, aggregates, refs, fields, and models showed generic values like <ClassName object at 0x...>.
Now those representations show the object structure directly, which makes debugging and interactive inspection easier..in_() inside select() queries so they no longer create temporary data tables or mutate model state.
Before, filters like Person.name.in_(["Alice", "Bob"]) could register extra model state as a side effect.
Now those select() filters compile as literal unions, leave the model unchanged, and still return the expected results.Python SDK
Version 1.0.9 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Added RAI_CONFIG_FILE_PATH support so PyRel can load a specific config file instead of auto-discovering one.
PyRel now checks that path first, raises a clearer error when the override is invalid, and shows the active config file when you run rai config:explain.
Restored Snowflake OAuth authorization-code sign-in for Direct Access. This restores the interactive browser callback and token-exchange sign-in flow that Direct Access workflows use. For setup, see Create an OAuth Security Integration for Direct Access.
Added weighted-graph support to Graph.preferential_attachment().
The graph docs now also clarify how self-loops contribute to degree() and weighted_degree().
Graph.diameter_range() to raise explicit unsupported-graph errors for directed and weighted graphs.
Before, those graph types were documented as supported.
Now PyRel fails early with an explicit error instead of implying that those modes are available.Python SDK
Version 1.0.8 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Fixed .into(table).exec() when exporting to a destination table that does not yet exist.
Before, exporting to a new table could fail during setup because PyRel treated the destination as an existing table.
Now PyRel treats the destination as a new export target during setup.
Improved the error PyRel raises when you use a concept, relationship, or chain from one non-library model in another model.
Before, these references could fail later with an unclear error.
Now PyRel raises Cross-model concept usage at the call site.
Concepts from library models are still allowed.
Improved the error PyRel raises when you access a relationship field with dot syntax instead of bracket indexing.
Before, an expression such as relationship.foo could produce an unhelpful error when foo was a field name rather than a relationship.
Now PyRel raises Invalid field access and tells you to use indexing such as relationship["foo"] instead.
Native App
Version 2026.3.23-7c6ad4c-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.0.7 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Added Relationship.ref() for relationships declared directly, not attached to a concept attribute.
Before, if you used the same standalone relationship twice in one query, PyRel treated both uses as the same query occurrence, so they could not match independently.
Now, Relationship.ref() gives you a second occurrence of the same relationship definition, similar to Chain.ref().
Debugger UI packages are now optional.
Before, a standard PyRel install included nicegui even if you did not use the debugger.
Now a standard install stays smaller, and if you do use the debugger without its extra packages, PyRel tells you to install relationalai[debugger].
select() with not_() so select(not_(expr)) evaluates to a boolean result.
Before, selecting a negated expression did not behave the same way as selecting other boolean expressions such as x == 2.
Now select(not_(expr)) works like a normal boolean selection.auto_suspend_mins and await_storage_vacuum are no longer managed in raiconfig.yaml.
Before, these reasoner lifecycle settings could appear in raiconfig.yaml, and rai init --migrate could carry them over when converting raiconfig.toml to raiconfig.yaml.
Now PyRel warns if they appear in config and leaves them out of the generated raiconfig.yaml during migration.
Manage auto_suspend_mins with rai reasoners:alter.
Set await_storage_vacuum when you create a reasoner with rai reasoners:create.
For broader reasoner configuration, see Configure reasoners.Python SDK
Version 1.0.6 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Fixed require() checks that reference columns from data().
Before, a .require() condition that used model.data() columns could emit a warning even when the input rows satisfied the requirement.
Now PyRel warns only when the condition is actually violated.
Fixed std.math.isclose() so that it correctly evaluates an absolute-tolerance comparison.
Before, std.math.isclose() could silently produce the wrong result in filters and selections.
Fixed lookups on subtypes such as Manager, a subtype of Employee.
Before, a lookup such as Manager.approves_budget could use the wrong relationship or raise a type mismatch.
Now PyRel resolves the subtype before resolving the relationship.
Improved reserved-name diagnostics for concepts and tables.
Before, if you used a reserved name such as alias, new, or require, the error could be unclear or point to the wrong place.
Now PyRel points the error at the call site.
For reserved table column names, the message also tells you to use table indexing, such as table["alias"].
The use_direct_access config option is now deprecated. Use the top-level direct_access setting instead.
Preferred configuration:
connections:
snowflake:
account: my-account
user: my-user
password: ${SNOWFLAKE_PASSWORD}
database: MY_DB
schema: PUBLIC
warehouse: COMPUTE_WH
direct_access: true
Deprecated configuration:
connections:
snowflake:
account: my-account
user: my-user
password: ${SNOWFLAKE_PASSWORD}
database: MY_DB
schema: PUBLIC
warehouse: COMPUTE_WH
use_direct_access: true
Existing use_direct_access entries still work.
PyRel warns that they are deprecated and maps them to the top-level direct_access setting.
For details, see Configure reasoners.
Native App
Version 2026.3.16-75ea12b-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.0.5 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Added explicit schema= support to data() and Model.data().
Before, PyRel always inferred column types from the in-memory rows or DataFrame you provided, which made empty inputs and ambiguous columns harder to control.
Now you can declare some or all column types explicitly, and the returned Data object preserves those types even when the input is empty.
For example:
from relationalai.semantics import Date, Integer, Model, String
m = Model("OpsModel")
# A daily exceptions feed can legitimately be empty, but downstream logic
# still needs stable column types.
shipment_exceptions = m.data(
[],
schema={
"order_id": Integer,
"warehouse": String,
"reason": String,
"requested_ship_date": Date,
},
)
# You can still use the schema in model logic, even with no rows.
ShipmentException = m.Concept("ShipmentException")
m.define(ShipmentException.new(shipment_exceptions.to_schema()))
PyRel now supports batching multiple pending table exports into a single model execution.
Before, export-heavy workflows had to execute table exports separately.
Now you can queue multiple .into() exports and submit them together with m.exec():
# Create two export fragments.
m.select(Customer.id, Customer.name).into(customer_table)
m.select(Product.id, Product.name).into(product_table)
# Execute both exports together in a single model execution.
m.exec()
Improved dtype inference for pandas float columns.
Before, dataframe float columns could be inferred as a more generic numeric type.
Now PyRel maps pandas float columns to Float, which keeps inferred schemas closer to the original dataframe types.
Fixed table-based schema and column mapping when model.implicit_properties is disabled.
model.implicit_properties controls whether PyRel creates undeclared properties automatically.
Before, when you turned this option off, Table objects could still implicitly create properties.
Now Table objects respect the model.implicit_properties setting, so you can disable implicit properties for tables as well as concepts.
Fixed use of std.datetime.datetime.now() in queries and filters.
Before, using the current date and time in a query or filter could fail with an argument error.
Now you can use std.datetime.datetime.now() directly in PyRel logic, including in time-based derived definitions.
For example:
from relationalai.semantics import DateTime, Integer, Model, std
from relationalai.semantics.std.datetime import datetime
m = Model("OpsModel")
# Declare the base shipment concept.
Shipment = m.Concept("Shipment", identify_by={"id": Integer})
# Add the promised ship timestamp.
Shipment.promised_ship_at = m.Property(f"{Shipment} promised ship at {DateTime}")
OverdueShipments = m.Concept("OverdueShipments", extends=[Shipment])
# Define some shipment entities.
m.define(
Shipment.new(id=1, promised_ship_at=datetime(2026, 3, 17, 9, 0)),
Shipment.new(id=2, promised_ship_at=datetime(2026, 3, 28, 9, 0)),
)
# Define overdue shipments using the current time.
m.define(OverdueShipments(Shipment)).where(
Shipment.promised_ship_at < std.datetime.datetime.now(),
)
Fixed ProgrammaticAccessTokenAuth so PAT-based Snowflake authentication includes the required user field and expands ~ in token_file_path.
Before, Snowflake could reject the PAT as invalid, and token files referenced with ~ could fail with FileNotFoundError.
Now PAT authentication works in both cases.
Fixed Problem.solve() so it uses the app name from the model config.
Before, Problem.solve() could ignore a custom rai_app_name in the model config.
Now it reuses the configured app name.
Fixed create_config() for PyRel running inside an existing Snowflake session, including notebooks, stored procedures, and SPCS containers.
Before, the returned config could fail when PyRel later needed a Snowflake SQL connection.
Now configs created from active sessions work correctly in those environments.
Fixed notebook diagnostics so notebook users see all collected PyRel diagnostics in a single exception. Before, earlier diagnostics could be easy to miss, so you often saw only the final failure. Now notebook exceptions include the diagnostic context that led to the error.
Python SDK
Version 1.0.4 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Added a new rai config:explain command to inspect the active configuration and where each value came from.
Now you can inspect the active config directly from the CLI and optionally show full provenance details with --verbose:
rai config:explain
rai config:explain --verbose
Improved dtype inference for pandas columns with object dtype when PyRel derives concept types from data.
PyRel now does a better job recognizing numbers in pandas object columns.
For example, if a column contains decimal values, PyRel now treats it as numeric instead of treating it as text.
Fixed an issue with rai connect where invalid Snowflake warehouse names could pass basic connectivity checks.
The command now validates the configured warehouse.
Fixed a bug that caused select() to raise a ValueError when selecting a Match object.
Fixed a bug where PyRel would warn about graph validation whenever you selected a Graph.Edge entity.
You can now select or inspect Graph.Edge without triggering validation warnings.
PyRel waits to validate until you run a graph operation that actually needs it.
Fixed a bug that could cause the client to get disconnected during long-running graph algorithms or other work if a jobs polling attempt was delayed or missed. The maximum polling delay is now short enough to prevent accidental disconnects from transient polling issues.
Fixed a bug that could affect results in some queries involving values that could match multiple types.
Native App
Version 2026.3.9-4685f01-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Added app.set_warm_reasoners() so app admins can configure multiple warm reasoners for the same reasoner type and size.
Added new SQL APIs for managing jobs, including:
Python SDK
Version 1.0.3 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Added a new reasoner library for prescriptive reasoning. See the prescriptive reasoning guides. For API reference docs, see std.reasoners.prescriptive.
Improved typing support for Graph.
Graph.__init__() now has overloads so IDEs and static type checkers can catch incorrect combinations of graph constructor parameters.
Made Graph attributes directed and weighted read-only.
Mutations to these attributes had no effect on graph behavior.
They are now immutable to avoid confusion.
Improved configuration and authentication diagnostics.
create_config() now includes the active profile name in YAML validation errors when available.
Improved CLI diagnostics for Snowflake authentication failures. The CLI now surfaces clearer guidance for login and SSO failures.
Added support for the await_storage_vacuum reasoner setting in configuration.
You can now set this in raiconfig.yaml under reasoners.*.
Use it when you want a reasoner to wait for storage vacuum work to finish before suspending.
:::caution
This guidance applies only through PyRel 1.0.6.
As of PyRel 1.0.7, you no longer manage reasoner lifecycle settings in raiconfig.yaml.
Instead, set await_storage_vacuum when you create a reasoner with rai reasoners:create.
For current guidance, see Configure reasoners or What's New in Version 1.0.7.
:::
Made field access by name in relationships case-insensitive.
For example, Thermometer.readings["time"] and Thermometer.readings["Time"] now refer to the same field.
rai init --migrate now produces cleaner raiconfig.yaml output when migrating from raiconfig.toml.
Generated YAML no longer includes spurious default fields, places reuse_model under model, and formats profiles and connections more readably.
Fixed ProgrammaticAccessTokenAuth so token_file_path works correctly in v1 configuration.
You can now provide either a literal token string or a file path to a Programmatic Access Token in raiconfig.yaml.
Improved type checking for relationships and properties. If a field's target type can't be inferred, PyRel now raises a type mismatch error.
DataConfig.data_freshness_mins is now capped at 30240 minutes (3 weeks).
If you set a larger value, PyRel clamps it to 3 weeks and emits a warning during config creation.Native App
Version 2026.3.2-62ce088 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Python SDK
Version 1.0.2 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
raiconfig.toml is deprecated, and PyRel now reliably emits a visible warning when it loads a raiconfig.toml config.
The warning points you to rai init to migrate or create a raiconfig.yaml.
Fixed an issue in Snowflake stored procedures where importing your package could fail or behave unexpectedly if it triggered config auto-discovery at import time.
This could attempt to read config files in a restricted runtime, and raise errors such as ConfigFileNotFoundError.
If your code relied on implicit config loading, update it to construct a Config explicitly and pass it into the SDK objects you create.
For example: cfg = create_config(...).
In stored procedures, prefer creating the config inside the stored procedure handler rather than at module import time.
See create_config() for the supported config sources and defaults.
Python SDK
Version 1.0.1 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Improved concurrent call handling for ReasonersClient.ensure() and ReasonersClientSync.ensure().
When multiple processes try to create or resume the same reasoner at the same time, ensure() will wait for the in-progress operation to complete instead of failing with a conflict error.
Improved the error raised when a logic reasoner job is aborted because the client disconnected.
If that happens, JobsClient.wait() / JobsClientSync.wait() raises JobClientDisconnectedError:
from relationalai.services.jobs.errors import JobClientDisconnectedError
try:
job = await client.jobs.wait("LOGIC", job_id)
except JobClientDisconnectedError:
# The client disconnected before the job completed.
# Retry after restoring connectivity.
...
rai reasoners:create, could fail with an ImportError.Python SDK
Version 1.0.0 of the relationalai Python package is now available!
To upgrade, activate your virtual environment and run the following command:
pip install --upgrade relationalai
Version 1.0.0 is a major update of the Python SDK that introduces:
PyRel, a new modeling and query DSL organized around Concept, Property, and Relationship classes, and new chainable query methods like define, where, and select.
See Build a semantic model for an introduction to the new modeling and query patterns.
Improved configuration management with a new raiconfig.yaml format.
The v1 SDK treats raiconfig.toml as deprecated, so if you have an existing raiconfig.toml, you should migrate to YAML using rai init --migrate.
See Configuring PyRel for details on new configuration patterns.
A new CLI with updated commands for managing reasoners, which were previously called engines, and job, which were previously called transactions. Check out the CLI reference for details on the new CLI commands and syntax.
:::note
For docs on the v0.x versions of the Python SDK and CLI, check out https://v0.docs.relational.ai.
:::
Treat this upgrade as a migration. You should expect to make non-trivial changes to your codebase when upgrading from v0.x to v1.0.0. If you need help, contact RelationalAI support for assistance.
Protect existing workflows.
Make sure existing production and staging environments install relationalai in a way that doesn't break existing code until you're ready to migrate.
For example, if you use pip, you can specify the version in your requirements.txt or setup.py to avoid accidentally upgrading to v1.0.0 before you're ready.
You can pin your project to the latest v0.x version with:
relationalai==0.14.3
Or, you can use a version specifier to allow the latest v0.x but prevent upgrading to v1.0.0 until you're ready:
relationalai>=0.14.0,<1.0.0
Native App
Version 2026.2.23-91bdaf5-1 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Native App
Version 2026.2.17-f9af1b6 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Native App
Version 2026.2.8-e6a1f8a of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
WARM_PROVISION column to the api.engines view and to the table returned by api.get_engine() procedure, which indicates whether or not an engine was provisioned off a warm engine.Native App
Version 2026.2.2-51ae489 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Native App
Version 2026.1.26-ba18c9d-2 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
api.show_warm_engines() which shows information about all currently existing warm engines.Native App
Version 2026.1.17-e94e8cc-6 of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Native App
Version 2026.1.11-d4d9cef of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
Native App
Version 2026.1.4-301050f of the RelationalAI Native App is now available!
Note that RelationalAI Native App upgrades are applied automatically and require no action on your part, unless you have opted-in to manual upgrades.
enable_warm_engine and disable_warm_engine, which replace set_warm_engines. These endpoints let you pre-provision a logic engine, so a "warm" engine is ready to use immediately when you create or resume an engine. This reduces provisioning time to just a few seconds. Keeping a warm engine running increases costs, as one engine of the chosen size stays active in the background.