GC AI

Finish an upload started with `start_file_upload`, after you have PUT the file bytes to its `upload_url`. Verifies the uploaded bytes, stores and processes the file (text extraction + embeddings), and returns the file record. Poll readiness with `get_files({ id })` until `status` is "ready" (then use the file) or "failed" (then `extraction_error` explains why).

finish_file_upload

List files. Pass `id` to fetch one file (and poll its upload `status`), `q` to search files you can access (optionally narrowed by `scope`), or `project_id` to list a project's files (add `q` to search within them). Always returns a `files` array — empty when nothing matches. Calling with none of `id`, `q`, or `project_id` is an error: there is no full file listing, only lookup, search, and per-project listing.

get_files

List or fetch playbooks. Pass `id` to fetch one playbook including its full `guide` text. Otherwise returns a page of playbooks you can access (those you created, org-visible, shared with you, and official ones); narrow with `q` and page with `cursor`/`limit`. Always returns a `playbooks` array (empty when nothing matches) and a `next_cursor` (null on the last page).

get_playbooks

List or fetch projects. Pass `id` to fetch one project. Otherwise returns a page of projects you can access (those you created, open projects, and ones shared with you); narrow with `q` and page with `cursor`/`limit`. Always returns a `projects` array (empty when nothing matches) and a `next_cursor` (null on the last page).

get_projects

List or fetch skills. Pass `id` to fetch one skill including its full `content`. Otherwise returns a page of skills you can access (those you created, org-visible, shared with you, and official ones) as summaries without `content`; narrow with `q` and page with `cursor`/`limit`. Always returns a `skills` array (empty when nothing matches) and a `next_cursor` (null on the last page).

get_skills

List the columns of a vault: what GC AI extracts from every document in it. Read this before `get_vault_documents` so you know which `field_key` to filter and sort on and what each value means. `kind` says who owns the column: `built_in` and `system` columns come from GC AI and cannot be changed, and `custom` columns belong to this vault. Only a column with `editable: true` can be changed with `update_vault_column`.

get_vault_columns

Read a vault's table: one row per document, with the value GC AI extracted for every column. This is the tool for questions the table can answer directly, such as which contracts expire this quarter, which name a counterparty, or which are missing a value. Narrow with `filters` and `sort` rather than paging everything. `values` is keyed by column `field_key`; read the keys, labels, and types from `get_vault_columns` first. A value is a string, and structured columns carry JSON in it: a currency holds `{"amount","currency"}`, a date holds `YYYY-MM-DD`, a multi-select holds a JSON array. `null` means the scan found no value. A document appears here once its first scan writes values, a few minutes after upload, so a row missing right after `upload_file` is not lost. To answer from the text inside the documents rather than the extracted columns, use `ask_gcai` with this vault instead.

get_vault_documents

List or fetch Contract Intelligence vaults. A vault holds a set of contracts that GC AI has read, with the extracted fields the team tracks. Pass `id` to fetch one vault. Otherwise returns a page of the vaults you can access; narrow with `q` and page with `cursor`/`limit`. Always returns a `vaults` array (empty when nothing matches) and a `next_cursor` (null on the last page). Use a returned `id` as `vault_id` when adding a document with `upload_file` or `start_file_upload`, or to ground `ask_gcai` in that vault's documents. Archived vaults are not listed. `document_count` is the number of documents that have finished scanning and can lag a fresh upload; confirm an upload with `get_files({ id })`, not with this count.

get_vaults

Run a playbook (by `id`) against uploaded files (`file_ids`) and get structured check results. Files must be uploaded and `ready` first; the playbook must be `completed`. Pass `check_ids` to run a subset of checks, or omit to run all. Returns a job envelope, not final results: while `status` is `pending` or `running`, keep polling `run_playbook_status` with the returned `job_id` until `status` is `succeeded` (then `result` holds the check results).

run_playbook

Save an `ask_gcai` chat into GC AI history and return a shareable deep link. API chats stay out of history until saved. Pass `project_id` to also file the chat into a project you can edit. Idempotent: saving a chat that is already saved (and already in that project) returns the same link with no side effects.

ask_gcai_save_chat

Start uploading a file that only exists in your local/sandbox filesystem (use this when no host-attached file reference is available, e.g. on Claude). Returns a short-lived signed `upload_url`: PUT the file bytes straight to it from your sandbox, for example `curl -X PUT --upload-file <path> "<upload_url>"`. Then call `finish_file_upload` with the returned `file_id` to register and process the file. Target with `project_id`, `vault_id`, or `scope` (mutually exclusive, default "my-files"). If the host already populates a file reference, prefer `upload_file` instead.

start_file_upload

Update a playbook you can write to. Only the fields you pass change. Pass `checks` to replace the whole check set (read it first, edit, send it back); omit `checks` to leave them. Returns the playbook and its checks.

update_playbook

Update a project you can write to. Only the fields you pass change; omit a field to leave it, or pass null to `description`/`custom_instructions` to clear it. Membership is managed with the attach/detach tools, not here.

update_project

Update a skill you can write to. Only the fields you pass change; omit a field to leave it. `file_ids` replaces the whole attachment set. Visibility is not editable here — manage skill sharing in the GC AI app.

update_skill

Change a vault's name, description, who can see it, or whether it is archived. Send only what should change. Archiving hides the vault and stops changes to it without deleting anything, and restoring brings it back with its documents intact. Only a vault owner can do any of this. Deleting a vault permanently is not available here; that is done in the app or on the REST API.

update_vault

Change a vault column's heading, extraction instructions, type, or options. Send only what should change. Only a `custom` column can be changed; GC AI owns the built-in and system columns and refuses. Changing the type of an AI column re-reads the documents that already have a value for it, which counts against the daily re-analysis limit, so the result says what happened to that re-scan.

update_vault_column

Correct one extracted value on one document, the way a person would fix a cell in the vault table. Pass `value` to set it, or `revert: true` to undo an earlier hand edit and put the AI value back. An edit wins over any scan that lands afterwards, so there is no need to wait for a scan to finish. A column GC AI manages, and a value outside a select column's options, are both refused.

update_vault_document_cell

Upload a file the user has attached into GC AI. To upload, just call this tool: the host populates the `file` argument automatically. Do not read or pass a local/sandbox path (e.g. /mnt/data/...) and do not construct `file.download_url` yourself. The bytes are fetched, stored, and processed (text extraction + embeddings) in place. Poll readiness with `get_files({ id })` until `status` is "ready" (then use the file) or "failed" (then `extraction_error` explains why). Target the upload with `project_id` (into a project), `vault_id` (as a document in a Contract Intelligence vault), or `scope` ("my-files" / "organization"); the three are mutually exclusive and default to "my-files".

upload_file