cohort_build
ChatGPTQueue a synthesis build of a cohort: generate its population's synthetic data and serve it as the cohort's Postgres schema. Builds are asynchronous and slow — poll cohort_check_build afterwards, and never queue a second while one is running (this tool refuses to). A build that rebuilds the version being served — of an unchanged cohort, or one whose SQL alone changed — replaces that data in place, so queries fail until it finishes; the response says when that applies, and an unchanged built cohort is refused unless forced. Requires edit access to the cohort's database, which must be attested.
cohort_check_build
ChatGPTPoll a cohort's build: whether it is never built, building (queued or running), built, failed, or deleted, whether it was edited since its last build, the draft and served versions, and the latest build's per-stage progress. Says plainly whether the cohort is queryable right now.
cohort_create
ChatGPTCreate a cohort — a named population over one database — in a workspace. Its name mints the Postgres schema it will be served as, permanently, so confirm the name and the population with the user before creating it. Requires edit access to an attested database. Nothing is queryable until you build it with cohort_build. SQL selecting the population: one column of entity IDs, matching the database's subject. Unlike everything else you query, this runs against the REAL source at build time, in the source's own SQL dialect, with bare table names (FROM patients, not a qualified path). A top-level LIMIT N caps how many synthetic entities are generated, while training still samples the full pool; use SELECT DISTINCT when the table has several rows per entity. Fewer than 250 entities cannot be synthesized. Saving it checks its syntax and that its tables exist; its columns and the population it selects are only checked when the build runs.
cohort_delete
ChatGPTDelete a cohort. Its schema stops being served, so any query or saved analysis targeting it stops working; its build history is kept. A database's default cohort cannot be deleted. Confirm with the user before deleting.
cohort_get
ChatGPTEverything about one cohort: its database and workspace, its population SQL, the Postgres schema it is served as, where it stands relative to synthesis (never built, building, built, failed, or edited since its last build) with the latest build's stage progress, what you may do with it (actions), and the columns its next build carries.
cohort_update
ChatGPTRename a cohort, replace its population SQL, or add and remove columns. Anything omitted is left as it is. Columns are a delta against its current membership (see cohort_get), not a replacement list. A rename changes the display name only, never the schema it is served as. SQL and column changes take effect on the next build — until you rebuild with cohort_build, queries return the previous build. SQL selecting the population: one column of entity IDs, matching the database's subject. Unlike everything else you query, this runs against the REAL source at build time, in the source's own SQL dialect, with bare table names (FROM patients, not a qualified path). A top-level LIMIT N caps how many synthetic entities are generated, while training still samples the full pool; use SELECT DISTINCT when the table has several rows per entity. Fewer than 250 entities cannot be synthesized. Saving it checks its syntax and that its tables exist; its columns and the population it selects are only checked when the build runs.
db_get_database_details
ChatGPTGet details for a specific database: description, source connector, queryability, its tables, and its cohorts — including the default cohort every database has, which is in no workspace. Synthetic data is served per cohort, so this is how to find the cohort_id to query a database's synthetic data by.
db_get_table_details
ChatGPTGet column details for a specific table: types, descriptions, sample values, foreign keys. Pass a cohort_id to see only the columns that cohort's synthetic data serves — a cohort carries a subset of its database's columns, and a query naming one it left out fails.
db_list_databases
ChatGPTList the databases available to you, with their IDs, descriptions, and whether each is queryable yet. Databases are the unit that both synthetic SQL access and Secure Compute analyses operate on.
db_list_tables
ChatGPTList all tables in a database with their names, namespaces, and source connector. Pass a cohort_id to list only the tables that cohort's synthetic data serves.
instructions
ChatGPTGetting-started guide for the Subsalt platform: its components (schema/metadata, workspaces and cohorts, synthetic data via PostgreSQL per cohort, and Secure Compute for de-identified answers on real data), when to use each, and the standard analyst workflow. Also lists your available databases. Call this first if your client did not show you the server instructions.
secure_compute_close_session
ChatGPTClose a Secure Compute session so nothing further can be submitted under it and anything not yet scheduled never will be. Sessions also expire on their own, so closing is a courtesy rather than a requirement.
secure_compute_create_grid
ChatGPTStart a new, empty draft grid over a cohort: one named set of questions that cohort can be asked. A cohort holds any number of grids and every analysis plan belongs to exactly one, so create one here (or pick an existing one from secure_compute_list_grids) before declaring anything. This does not create a cohort — that is cohort_create. The name is how answers are attributed to this grid, so choose one a reviewer will recognize; it must be unique within the cohort, ignoring case. Stores configuration only.
secure_compute_declare_analysis_plan
ChatGPTDeclare which variables a grid reports across and which crosses of them it may answer. This REPLACES the whole plan every time — send the complete set of variables and tables, not a delta; secure_compute_describe_analysis_plan gives you the current one to modify. Pass validate_only to check a plan without storing it. Declare the full cross you need rather than its margins: a grid answers a declared table and any subset of it, so one five-way cross also answers every margin inside it, while five separate pairwise tables answer none of the joint questions. Stores configuration only — nothing is counted until the plan is locked.
secure_compute_define_value_set
ChatGPTCreate a named set of codes for an In predicate clause to match against. The codes are compared VERBATIM against whatever column the clause names, so they must be what that column actually holds — OMOP concept ids on a condition_concept_id, ICD-10-CM codes on a raw claims table. code_system is recorded for human review and is never matched on. Nothing is validated against the data: no query runs against the source until the plan is locked. Value sets freeze when the plan locks.
secure_compute_describe_analysis_plan
ChatGPTEverything you need to author or review one grid's analysis plan: the cohort it counts over, the columns you may declare a variable on (with the fieldIdentityId a declaration names them by), the child tables an aggregate may read, the variables and tables declared so far, the value sets defined, and whether the grid is a draft, locked, or counted. Call this before declaring, and again before every edit — declaring replaces the whole plan, so you need the current one to modify it. Reads only stored schema and configuration; no query runs against the source data.
secure_compute_get_analysis_plan
ChatGPTGet the analysis plan a grid locked: the entity table a publication's base_table must name, the tables it can answer (and their margins), and each axis's name and declared base. Read this before building a publication — a cross the grid did not declare was never counted and cannot be answered. A cohort holds several grids; each answers only its own tables.
secure_compute_get_declaration
ChatGPTDEPRECATED — renamed to secure_compute_get_analysis_plan, which does exactly this. Prefer that name; this one is kept for one release so existing prompts keep working. Get the analysis plan a grid locked: the entity table a publication's base_table must name, the tables it can answer (and their margins), and each axis's name and declared base. Read this before building a publication — a cross the grid did not declare was never counted and cannot be answered. A cohort holds several grids; each answers only its own tables.
secure_compute_get_result
ChatGPTCollect the privacy-gated cells of a submitted publication, or a requested report. Holds for up to 30s waiting for the work, so a result usually arrives in one or two calls. Cells are legally de-identified under HIPAA — report banded values with their granularity, never as exact counts.
secure_compute_get_script_guide
ChatGPTHow to author a Secure Compute analysis: what a locked grid can answer, the publication wire format, what a plan cannot do, and how to read exact/banded/withheld cells. Read this before building a publication.
secure_compute_list_grids
ChatGPTList the secure-compute grids declared over one cohort — each grid's id, name, whether it is a draft or locked, and whether it can answer yet. A cohort holds any number of grids; use this to find the grid_id every other Secure Compute tool takes. Find a cohort_id with workspace_list, or db_get_database_details for a database's default cohort.
secure_compute_lock_analysis_plan
ChatGPTFreeze a grid's analysis plan and count it against the real data. THIS CANNOT BE UNDONE — there is no unlock, and a corrected plan means a new grid (secure_compute_create_grid on the same cohort), so check it with validate_only and state it back to the user in plain language before calling this. Locking is also the first time anything reads the source data for this grid. By default this waits for the counting to finish and reports whether the grid is answerable or the run failed; pass wait_for_counts false to return as soon as it is locked.
secure_compute_publish
ChatGPTSubmit a publication against a locked grid: the set of counts one study asks for, answered together. Its content is Guardrail's own wire format — what PlanBatch.to_dict() produces, {"ir_version": "2.0", "plans": [...]} — and is forwarded verbatim; see secure_compute_get_script_guide. Submit everything one study needs in a single publication: the release decision is made across the whole set, so splitting a study over several publications gets a weaker guarantee than sending it once. Answers come from counts the grid took when it locked, so no source rows are read. Returns a session ID immediately; collect the released cells with secure_compute_get_result.
secure_compute_recount_grid
ChatGPTCount a locked grid again after its latest counting run failed. Locking is one-way and a failed count is otherwise terminal, so this is how a transient failure is recovered. The new attempt counts the SAME locked plan at the SAME pinned cohort version — it does not change what the grid declared. Refused for a draft, while an attempt is still pending or running, and once counts have committed. By default this waits for the counting to finish, like locking does; pass wait_for_counts false to return as soon as it is enqueued. If a recount fails the same way, stop and tell the user rather than recounting again.
secure_compute_report
ChatGPTAsk what a grid counted and how each answerable table was decided — per table, its shape, its coordinates, and whether it releases exact or banded. Reports shapes and decisions, never counts. Returns a session ID; collect it with secure_compute_get_result.
secure_compute_set_public_release
ChatGPTMark a grid's results as ones the user plans to publish, or take the mark off. Published results get additional privacy review. Works on a draft or a locked grid and can be changed either way, because people often decide whether to publish only after seeing the results. Only call this when the user has said whether they will publish.
synthetic_get_connection_info
ChatGPTGet the PostgreSQL connection details (host, port, database, schema, username, password) for querying a cohort's synthetic data directly. Each built cohort is served as its own Postgres schema, and the response says how to put it on the search_path. The password is your MCP access token formatted as access_token:<jwt>, which the access point authenticates directly — no separate Subsalt credential needed. A direct connection is the preferred way to fetch synthetic data and the only one with no row cap. Also documents the fallback for a sandbox that cannot open the connection at all: synthetic_run_query, which runs the SELECT on this server and returns the rows through MCP.
synthetic_run_query
ChatGPTRun a single read-only SELECT against a cohort's synthetic data and get the rows back through MCP, capped at 1000. The query runs in the cohort's own Postgres schema, so name tables unqualified; the cohort must have been built (see cohort_check_build). Use this when your code cannot reach Subsalt directly — a sandbox that blocks non-HTTP(S) ports or private address space can still call this tool, because this server makes the query for you. Where a direct PostgreSQL connection is reachable, prefer synthetic_get_connection_info: it has no row cap. Because of the cap, sample with an explicit small LIMIT and compute aggregates (GROUP BY, count, avg) in SQL rather than fetching rows to aggregate yourself. RESPONSE FORMAT: {cohortId, databaseId, schemaName, columns, rows, rowCount, rowLimit, dropped, truncated, stale}, delivered two ways — as structuredContent, and serialized identically into the one fenced json block of the text, so read whichever your client gives you. "rows" is an array of arrays aligned positionally to "columns" (pd.DataFrame(rows, columns=columns) rebuilds it), every value a string or null, so cast numbers and dates yourself. Check "truncated": when true, rows were left out and the response is not the whole answer. "stale" is true when the cohort was edited since the build these rows came from, or is being rebuilt.
user_delete
ChatGPTRemove a user from your organization. They can no longer sign in. Confirm with the user before deleting.
user_list
ChatGPTList the users of your organization with their ID, email and organization role. Use it to find a user_id for user_update, user_delete or workspace_member_add. Needs the organization admin role.
user_update
ChatGPTChange a user of your organization: their name, their organization role, or both, and optionally reset their password. An omitted field is left as it is. A reset works only where your organization sends no email, and returns a temporary password to pass on privately.
workspace_create
ChatGPTCreate a workspace in your organization: a named place to keep related cohorts. It is visible to everyone in the organization.
workspace_delete
ChatGPTDelete an empty workspace. Refused while it still holds cohorts: delete those first with cohort_delete. Confirm with the user before deleting.
workspace_list
ChatGPTList the workspaces in your organization, each with its cohorts: name, ID, the database it selects from, the Postgres schema it is served as, and whether it is built. Start here to find a cohort_id. Every cohort listed is one you can query; editing or building one needs userdatabase.edit in its actions. Each database also has a default cohort outside any workspace, which db_get_database_details lists.
workspace_member_add
ChatGPTAdd a user of your organization to a workspace with a role. Refused if they are already a member; use workspace_member_update to change a role. Needs the workspace’s admin role or the organization admin role. A guest can only reach the workspaces they are added to.
workspace_member_remove
ChatGPTRemove a user from a workspace. They lose access to its cohorts and analysis plans, though their account stays in the organization. Confirm with the user first.
workspace_member_update
ChatGPTChange a workspace member’s role. Refused if the user is not a member; use workspace_member_add for that.
workspace_update
ChatGPTRename a workspace or change its description. An omitted field is left as it is; pass an empty description to clear it.