add_chart_tab
ChatGPTAppends a new chart tab to an existing Fibery report. Prerequisite: You need a reportId from create_report or get_reports_list. Call display_report_schema first to discover valid field expressions for the report's sources. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
add_collection_items
ChatGPTAdds items to an entity's collection field. Call get_fibery_skill({skill: "data"}) for how to work with Fibery data. Prerequisites: schema_detailed for the collection field name; query to find the owner entity id and the item ids.
add_file_from_url
ChatGPTAttaches a file to an entity's file field (not a document field) by downloading a publicly-reachable URL server-side. If the URL can't be fetched the call fails with "upload from url failed". There is no retry, so verify reachability first. Call get_fibery_skill({skill: "data"}) for how to work with Fibery data. Prerequisites: schema_detailed for the file field name; query/search to find the entity id.
add_metric_tab
ChatGPTAppends a new metric tab to an existing Fibery report. Prerequisite: You need a reportId from create_report or get_reports_list. Call display_report_schema first to discover valid field expressions for the report's sources. Scalar expressions only: Every metric expression must be a scalar aggregate (e.g. COUNT([ID])). Raw field references are not valid here. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
add_table_tab
ChatGPTAppends a new table tab to an existing Fibery report. Prerequisite: You need a reportId from create_report or get_reports_list. Call display_report_schema first to discover valid field expressions for the report's sources. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
attach_files
ChatGPTAttaches files that are already stored in Fibery to an entity's file field (not a document field), by the files' fibery/id. Use it for a file uploaded with prepare_file_upload (its curl response contains fibery/id), a file the user attached in chat, or a file from another entity's file field. A single-file field takes exactly one file id, which replaces its current file. Call get_fibery_skill({skill: "data"}) for how to work with Fibery data. Prerequisites: schema_detailed for the file field name; query/search to find the entity id.
create_avatars_fields
ChatGPTEnables avatar/profile picture attachments on entities in one or more databases. Creates an "avatar/avatars" field automatically. Call get_fibery_skill({skill: "schema"}) for the schema-building workflow. Prerequisites: schema to get database names.
create_custom_app
ChatGPTCreate an empty Fibery custom app from the starter template (no app code is generated). For the development loop call get_fibery_skill({skill: "custom-apps-dev"}). Examples: - "create a custom app 'Roadmap' in the Product space" → {name: "Roadmap", kind: "view", spaceName: "Product"} - "add an entity view / custom tab to Bugs" → {name: "Bug health", kind: "layout", databaseName: "SoftDev/Bug"}
create_custom_app_dev_token
ChatGPTIssue a short-lived (~1 hour) access token for developing a custom app locally. The token authenticates only the app's get-source-files / update-source-files endpoints, passed as the custom-app-dev-token query parameter — see get_fibery_skill({skill: "custom-apps-dev"}) for the full development loop.
create_databases
ChatGPTCreates one or more databases within a space. Call get_fibery_skill({skill: "schema"}) for naming rules and the auto-created system fields (do NOT add them manually). Prerequisites: schema to check existing spaces and databases.
create_entities
ChatGPTCreates entities. Handles primitive and single relation/select fields only — collections, workflow/state, and document fields have dedicated tools (error thrown if set here). Never pass arrays or objects as a field value; pass a single relation/select as the bare id string. Call get_fibery_skill({skill: "data"}) for field value formats and which tool handles which field type. Prerequisites: schema / schema_detailed to get database and field names.
create_files_fields
ChatGPTCreates one or more file attachment fields in databases. Each files field is a reference to the built-in fibery/file database. Call get_fibery_skill({skill: "schema"}) for naming rules. Prerequisites: schema_detailed to check existing fields.
create_formula_field
ChatGPTCreates a formula field in a database. The formula expression is generated automatically from the provided description — be precise about the inputs and the expected result. Call get_fibery_skill({skill: "schema"}) for naming rules and formula field semantics. Prerequisites: schema_detailed to see available fields in the database.
create_icon_fields
ChatGPTEnables emoji icons on entities in one or more databases. Creates an "icon/icon" field automatically. Call get_fibery_skill({skill: "schema"}) for the schema-building workflow. Prerequisites: schema to get database names.
create_multi_select_fields
ChatGPTCreates one or more multi-select fields with predefined options. Prefer selects to bare text fields. Call get_fibery_skill({skill: "schema"}) for the option shape, colors, and naming rules. Prerequisites: schema_detailed to check existing fields.
create_primitive_fields
ChatGPTCreates one or more primitive fields (text, number, checkbox, date, location, rich text) in databases. Avoid bare text fields — prefer select/relation fields, or a text field with specific meta (email, url, phone). Call get_fibery_skill({skill: "schema"}) for the field type catalog with meta options. Prerequisites: schema_detailed to check existing fields — creating an already-existing field is an error.
create_relation_fields
ChatGPTCreates one or more relation fields between databases. Each relation creates a field in BOTH the source and target databases. Call get_fibery_skill({skill: "schema"}) for cardinality semantics and naming rules. Prerequisites: schema_detailed to check existing fields.
create_report
ChatGPTCreates a Fibery report with sources and a title. The report is placed in the user's private space unless spaceName is provided. Prerequisites: call schema to discover valid database names; call display_report_schema to discover field expressions before configuring dimensions. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
create_schema
ChatGPTCreates a whole schema in ONE call: spaces, their databases, and every field kind (primitive, single/multi select, relations, files, workflow, comments, icon, avatars). Prefer it over the per-kind create tools whenever you create more than a couple of fields. Example: ``json {"databases": { "Work/Project": {"fields": {"Budget": "money", "Website": "url"}, "workflow": ["Planned", "Active", "Done"]}, "Work/Task": {"comments": true, "fields": { "Estimate": "int", "Priority": {"select": ["High", "Medium", "Low"]}, "Tags": {"multiSelect": ["UI", "API"]}, "Project": {"relation": "Work/Project", "back": "Tasks", "cardinality": "many-to-one"}, "Assignees": {"relation": "fibery/user", "back": "Assigned Tasks", "cardinality": "many-to-many"}, "Files": "files"}}}} ` - Databases are keyed by "Space/Database"; missing spaces are created. Use spaces only to give a new space a description or color. - fields maps each short field name to a type name, or to an object for selects, relations, or a type with extra meta (e.g. {"type": "money", "meta": {"ui/number-currency-code": "EUR"}}). - Select options and workflow states can be plain names. Workflow state types follow position (first "Not started", last "Finished", others "Started") and the first state is the default; use a state object to override type, color or default. Use a workflow (not a select) for status. - Relations may point to databases created in the same call, to any database that already exists in the workspace (any space), or to built-in "fibery/user" for people. To link an existing database to a new one, add the existing database's key with just the new relation field. Declare each relation once, on one side; back is the field created on the target. Cardinality is read from this database: many-to-one means many of these link to one target (e.g. Task.Project), many-to-many means many on both sides. - Existing spaces, databases and fields with the same name are skipped and listed in unchanged, so sending the spec again is safe. To extend a database, send only what to add. Changing or deleting existing items needs the update/rename/delete tools. - The spec is validated before anything changes; every problem is returned at once. - Every database gets Name and Description fields automatically; do not add them. - Formulas are not supported here: create them afterwards with create_formula_field` if needed.
create_single_select_fields
ChatGPTCreates one or more single-select fields with predefined options. Prefer selects to bare text fields; for status-like fields use create_workflow_field instead. Call get_fibery_skill({skill: "schema"}) for the option shape, colors, and naming rules. Prerequisites: schema_detailed to check existing fields.
create_space
ChatGPTCreates a new space in the workspace. Call get_fibery_skill({skill: "schema"}) for naming rules. Prerequisites: schema to check existing spaces.
create_spaces
ChatGPTCreates one or more spaces in the workspace. Call get_fibery_skill({skill: "schema"}) for naming rules. Prerequisites: schema to check existing spaces.
create_view
ChatGPTCreates a View in the Fibery workspace — a saved data visualization (grid, list, board, timeline, calendar, map, feed, gallery, gantt, embed), a form, a standalone document, or a whiteboard (canvas). For anything more complex than a flat grid/list with no filters, no orderBy, no grouping, and no color coding — call `get_fibery_skill({skill: "views"})` FIRST. That reference covers per-view-type config shapes, the FilterNode operator matrix, conditional color coding, multi-database axes, hierarchy via groupBy, dependency rules for timeline/gantt, form defaultValue formats, and worked examples. Skipping it on non-trivial views leads to invalid configs and retries. Prerequisites: call schema (and schema_detailed for field details) to discover database and field names. Trivial example — flat grid, no filter or ordering: ``json { "viewType": "grid", "name": "All Features", "config": { "items": [{ "database": "Product/Feature", "fields": [{"field": "Product/Name"}, {"field": "Product/Status"}] }] } } ` Document view — no config. The view is created empty; its body is not set here. Edit the body separately with the document tools (get_fibery_skill({skill: "documents"})): `json { "viewType": "document", "name": "Meeting Notes" } ` Canvas (whiteboard) view — no config; the board is created empty. Only use it when a user asks to create a new Whiteboard. To work with it, call get_fibery_skill({skill: "whiteboard"}) first: `json { "viewType": "canvas", "name": "Sprint Retro", "description": "Retro board for sprint 42" } ``
create_whiteboard_elements
ChatGPTCreates elements (shapes, text, links, sticky notes, sections, pictures, videos, freehand pen strokes) on a Fibery Whiteboard and returns a link to the whiteboard view. Call `get_fibery_skill({skill: "whiteboard"})` first — it covers every element type's full property set, the coordinate system, placeholder-ID resolution, and styling/placement conventions. Skipping it leads to invalid or overlapping elements. Element IDs may be placeholders you invent (e.g. "node1") — they resolve to real numeric IDs automatically within the call, including cross-references between the elements you create (a Link's points[].nodeID, a label's parent, sectionID). The returned idMap gives you the real ID for each placeholder. Use those numeric IDs with update_whiteboard_elements and delete_whiteboard_elements; placeholder mappings are not retained across calls. Results reference Fibery objects by url: use it when referencing the object.
create_workflow_field
ChatGPTCreates a workflow (state) field for tracking entity status through stages — do NOT use a single-select for status-like fields. Only ONE workflow field can exist per database; it is always named "workflow/state". Call get_fibery_skill({skill: "schema"}) for option types, colors, and default option rules. Prerequisites: schema_detailed to verify no workflow field exists yet (otherwise use update_workflow_field).
create_workflow_fields
ChatGPTCreates workflow (state) fields, one per database and several databases in one call, for tracking entity status through stages — do NOT use a single-select for status-like fields. Only ONE workflow field can exist per database; it is always named "workflow/state". Call get_fibery_skill({skill: "schema"}) for option types, colors, and default option rules. Prerequisites: schema_detailed to verify no workflow field exists yet (otherwise use update_workflow_fields).
delete_avatars_fields
ChatGPTDisables avatar/profile picture attachments on entities in one or more databases by deleting the "avatar/avatars" field. Restorable by the user via the Activity Log. Call get_fibery_skill({skill: "schema"}) for deletion semantics. Prerequisites: schema_detailed to verify the avatars field exists.
delete_databases
ChatGPTDeletes one or more databases from a space. Restorable by the user via the Activity Log. Call get_fibery_skill({skill: "schema"}) for deletion semantics. Prerequisites: schema to get database names.
delete_document_blocks
ChatGPTDeletes blocks from a document, each with all its children. Call read_document first to get block ids. Call get_fibery_skill({skill: "documents"}) for the block model and the editing workflow. Delete a table only by the whole table block's id — table_row, table_cell and table_header CANNOT be deleted, adding/removing rows or columns is not supported. Example `` { secret: "123", deletions: [{blockId: "456"}, {blockId: "789"}] } ``
delete_entities
ChatGPTDeletes entities by their fibery/id values. Can be undone only by the user in the Activity tab (history icon at the bottom of the sidebar). Call get_fibery_skill({skill: "data"}) for how to work with Fibery data. Prerequisites: query to find the entity ids.
delete_fields
ChatGPTDeletes one or more fields from their databases. Deleting a relation field also removes its paired field in the related database. Restorable by the user via the Activity Log. Call get_fibery_skill({skill: "schema"}) for deletion semantics. Prerequisites: schema_detailed to get field names.
delete_icon_fields
ChatGPTDisables emoji icons on entities in one or more databases by deleting the "icon/icon" field. Restorable by the user via the Activity Log. Call get_fibery_skill({skill: "schema"}) for deletion semantics. Prerequisites: schema_detailed to verify the icon field exists.
delete_space
ChatGPTDeletes a space with all its databases. The built-in fibery space cannot be deleted. Restorable by the user via the Activity Log. Call get_fibery_skill({skill: "schema"}) for deletion semantics. Prerequisites: schema to get space names.
delete_spaces
ChatGPTDeletes one or more spaces with all their databases. The built-in fibery space cannot be deleted. Restorable by the user via the Activity Log. Call get_fibery_skill({skill: "schema"}) for deletion semantics. Prerequisites: schema to get space names.
delete_views
ChatGPTDelete Fibery Views by their IDs. The data present on the views WILL NOT be deleted. This action can be undone by the user via the Activity Log (by selecting the view and restoring it). Prerequisites: use query_views to find view IDs. Example `` { "ids": ["123"] } ``
delete_whiteboard_elements
ChatGPTDeletes elements from a Fibery Whiteboard by their numeric IDs (from the idMap of create_whiteboard_elements, or from query_views with viewType: "canvas"). Links attached to a deleted element, and their labels, are deleted with it. Also returns a link to the whiteboard view. Never delete the board itself (ID 1). Results reference Fibery objects by url: use it when referencing the object.
delete_workflow_field
ChatGPTDeletes the workflow (state) field from a database. Restorable by the user via the Activity Log. Call get_fibery_skill({skill: "schema"}) for deletion semantics. Prerequisites: schema_detailed to verify the workflow field exists.
delete_workflow_fields
ChatGPTDeletes the workflow (state) field from one or more databases. Restorable by the user via the Activity Log. Call get_fibery_skill({skill: "schema"}) for deletion semantics. Prerequisites: schema_detailed to verify the workflow field exists.
display_entity_capabilities_via_sharing
ChatGPTReturns per-entity capabilities derived from sharing for the requested Fibery databases. Use this when the user wants to know what access they have at the entity level (not just space- or database-level). For each database, the response includes the entities they can reach and how they reach them. Three access paths are covered: 1. Direct sharing — the entity was explicitly shared with the user, returned in entityLevelGrants. 2. Propagated sharing — access was inherited from a related entity, returned in indirectEntityLevelGrants. 3. Assignment rules — the user appears in a People-field rule on the entity type, returned in assigneeGrants. Capabilities from every source (space-level, database-level, per-entity grants, propagation from other databases) ACCUMULATE — they NEVER override. To compute effective capabilities on a specific entity, take the UNION of all sources. Limitations for assignee grants: sample only (up to 10 entities per rule) Per-database result fields: - spaceLevelCapabilities — capabilities granted at the space level. - databaseLevelCapabilities — capabilities granted at the database level. - entityLevelGrants — per-entity grants from direct sharing. - indirectEntityLevelGrants — grants propagated from related entities. - assigneeGrants — grants derived from assignment rules on People-type fields. If a database can't be resolved in the schema, its entry is {database, error} instead.
display_report_schema
ChatGPTGet the vizydrop report source schema for one or more Fibery databases. This is distinct from the Fibery type/relation schema returned by schema or schema_detailed. Returns the flat set of fields and enum values usable in report dimension/metric expressions and filter conditions. Call this before configuring chart, table, or metric dimensions so you know the valid field names and types. `sourceMode`: current (default) for live entity state; historical for modification events (time-in-state data). When multiple databases are specified, a synthetic Entity Database field is added to allow splitting results by source. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
display_schema_capabilities
ChatGPTReturns the current user's access info per space and per database in the Fibery workspace. Use this when explaining what the user can/cannot do, or before suggesting an action that requires specific access. URL conventions: - For spaces: user will see anything if they have ANY access to the space. - For databases: user will see anything only if they have architect-level access; otherwise it will render as "No Access". Capabilities from every source (space-level, database-level, per-entity grants, propagation from other databases) ACCUMULATE — they NEVER override. To compute the user's effective capabilities on a specific entity, take the UNION of all sources. The response shape: - accessInfo.spaces — map keyed by space namespace. - accessInfo.databases — map keyed by Space/Database name. Each entry value is one of: - 'no-access' — the user has no access. - 'entity-level' — no space/database-level grant, but the user has access to at least one entity via an entity-level access template. - {level, templateId, isDefault, url} — standard template-based access. level is the template name with the app.access/ / type.access/ prefix stripped. isDefault: false indicates a custom template. - 'derived-per-field' — applies only to fibery/file and comments/comment; access is granted via per-field grants on the owning database, not at the type level. - levelInfo.space and levelInfo.database — keyed by level (the same string as above); each value carries the template's full title, description, and capability set so the caller can explain what a level grants.
download_file
ChatGPTFetches a Fibery file attachment by its secret and returns a signed download URL valid for ~60 minutes, along with file metadata. For small images and text-ish files, the file contents are also delivered inline so the model can read or analyze them directly without any extra step. The URL expiration timestamp is included in the response. What the model receives inline - Images ≤ 5 MB, Text-ish files ≤ 256 KB: included in tool's response (you should be able to see them directly) - Everything else (PDFs, Office documents, archives, larger files, or unsupported types): only the signed download URL is returned (which is valid for an hour). Prerequisites You must already know the file secret. Call get_files_meta with the entity ID to discover available files and their secrets. Example ``json { "secret": "<secret>" } ``
fetch
ChatGPTReads one Fibery entity or view by its fibery/id (e.g. the id of a search result) and returns its content as markdown in text: an entity's fields and rich text, a document's content, or a view's settings with up to 1000 of its rows. id is a fibery/id, not a URL or a public id.
fetch_by_url
ChatGPTFetches entity or view data from a Fibery URL and renders it as markdown. Accepts URLs in these formats: - Entity: https://{account}.fibery.io/{Space}/{Type}/{Entity-Title}-{id} - View: https://{account}.fibery.io/{Space}/{View-Title}-{id} Returns formatted markdown with entity fields, document content, or view data including a table of items. Examples `` { "url": "https://myteam.fibery.io/Project_Management/Feature/My-Feature-42" } ` ` { "url": "https://myteam.fibery.io/Project_Management/Backlog-7", "limit": 50 } ``
fetch_view_data
ChatGPTFetches actual entity data from a Fibery View by executing the view's query. This is different from query_views which returns view configuration. fetch_view_data executes the view's query against the database and returns the entities that the view would display, respecting the view's filters, field selection, and sort order. Prerequisites: call query_views first to find the view's publicId. Examples `` { "publicId": "42", "limit": 50 } ``
find_document_blocks
ChatGPTFinds the blocks of a single document whose text contains the given text, case-insensitive and regardless of formatting. Returns them in the same shape as read_document, with their ids, so you can edit a passage of a long document without reading all of it. A block matches only when the whole text is inside it; text spread over several blocks is not found. Call `get_fibery_skill({skill: "documents"})` FIRST for how to find document secrets and edit blocks.
get_connectors_list
ChatGPTGet a list of available connectors (built-in integrations) in Fibery. Fibery Connectors are built-in integrations that allow users to directly import or continuously sync data from external sources (like Trello, Notion, CSV files and others) into their Fibery workspace. Each connector has a name, id and abilities to import and/or continuously synchronize data. In case the user asks to import data from a source not yet supported, go for CSV option as default — offer to extract data from there and import in Fibery using CSV.
get_custom_apps_list
ChatGPTList the custom apps the user can see. Custom apps are small React apps. kind: "view" (App view in a space) or "layout" (Entity View tab on entity pages). Use the id to work on an app's source code with the custom-app development flow — call get_fibery_skill({skill: "custom-apps-dev"}) for the full guide.
get_databases
ChatGPTShows the given databases, grouped by space, with their fields. Database names that don't exist are listed in notFound. - Every field has its full name (Space/Field), the key queries, views, automations and entity writes use, and its type. title: true marks the field that names entities. - Selects list their options, and a database with a workflow lists its states under workflow (field workflow/state), each with its id. - A field with more than 1000 options lists the first 1000; query optionsDatabase for the rest. - Relations show relatedDatabase, relatedField and cardinality: a ...-to-many relation holds a collection. dependency: true marks the relations timeline and gantt views draw as dependencies. Formulas and lookups show their formula and the resultType they compute. - readOnly: true marks a field whose settings no tool changes. Formula and lookup values are computed, never written. By default it shows every setting, with the keys and values the schema write tools take: read a setting, change it and pass it back as it is. Fields are listed in the order the entity page shows them. Pass forQuerying: true to write a query, view, automation or entity values: the same keys, without the settings only schema changes need. Call get_fibery_skill({skill: "schema"}) for which tool changes which setting. Call get_spaces for the database names.
get_entity_links
ChatGPTGenerates Fibery web links for entities based on their public IDs. Public IDs are human-friendly auto-incrementing identifiers (e.g., "42"), different from fibery/id UUIDs. You can get public IDs using query tool by selecting the "fibery/public-id" field. Examples `` { "database": "Project Management/Feature", "entityPublicIds": ["42", "43"] } ``
get_entity_mention
ChatGPTBuilds a mention for an entity. Rendered by Fibery, it becomes a "live" mention: current name, clickable, and it survives renames. Never construct a Fibery URL instead. Use the returned string as-is in content passed to the document editing tools (insert_document_blocks, set_block_text, comment bodies). Call get_fibery_skill({skill: "documents"}) for the markdown reference in documents. entityId is the fibery/id UUID. If you only have a public id (e.g. "42"), resolve it first: query the database for "fibery/id" where "fibery/public-id" matches. Works for meta databases too: pass database: "fibery/view" with a view id, "fibery/type" with a database id, or "fibery/app" with a space id to mention a view, database, or space. Example `` { database: "SoftDev/Task", entityId: "b1f2a3c4-...", label: "Fix login bug" } ``
get_fibery_skill
ChatGPTLoad the full guide for a Fibery skill domain. Call this tool when you need the complete reference for a domain that spans multiple tools. Each skill covers the full model, expression syntax, configuration shapes, conditions, and workflow for its related tools.
get_files_meta
ChatGPTLists file attachments on one or more Fibery entities. For each entity, returns every file's meta-information. Prerequisites: you must already know the database name and the entity IDs. Use schema / schema_detailed to discover database and field names, and query or search to retrieve entity IDs. Next step: pass a returned secret to download_file to retrieve the actual file or signed url. Examples 1. List all files on two tasks: ``json { "database": "SoftDev/Task", "entityIds": ["<uuid1>", "<uuid2>"] } ` 2. Narrow to a single file field: `json { "database": "Product Management/Feature", "entityIds": ["<uuid1>"], "field": "Attachments" } ``
get_manual_import_link
ChatGPTForm a link to the import page for the user. Prerequisites: use get_connectors_list to get available connector IDs first. IMPORTANT: before using this tool, make sure you have answers to ALL these questions (if not, ask user to provide them): 1. Where is the data coming from (CSV, Notion, etc.)? 2. Is it one-time import or continuous sync? 3. Is it import to new or existing Space or Database? - If existing, which one? - If new, check schema first. If specified Space or Database does not exist, ask the user to create one first. In case the user asks to import data from a source not yet supported, go for CSV option as default. Examples 1. Single-time import from CSV to already-existing space ``json { "spaceName": "Project Management", "isSync": false, "connectorId": "csv-connector" } ` 2. Continuous sync from Notion `json { "spaceName": "Notion", "isSync": true, "connectorId": "notion-app", "dbName": "Task" } ``
get_me
ChatGPTGet information about the current user such as their fibery/id, name, email and role in the workspace.
get_report
ChatGPTFetch a Fibery report (vizydrop view) by its UUID, including its tabs, sources, schema, and dimension configuration. Use get_reports_list first to discover available report IDs. The response includes tabId, tabType, and per-dimension id values needed by update_tab, update_dimension, and remove_dimension. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
get_reports_list
ChatGPTList all vizydrop report views in the Fibery workspace. Returns an array of report summaries with id and title. Use the id field with get_report to fetch full details including tab structure and dimension IDs. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
get_spaces
ChatGPTLists every space you can see with its databases, and your access to each. Call it first, before any tool that needs a database name, then get_databases for the fields of the databases you need. systemDatabases are the Fibery databases every workspace has: files, users and comments. access is your access level: - On a space: architect (configures databases and views), owner, editor, commenter or viewer for the space's docs, whiteboards and views. A trailing + (e.g. editor+) grants the same level on every entity of the space. - On a database: architect, owner, editor, commenter, viewer for all its entities, submitter (creates entities, can't see them), or user-manager on the users database (manages users). - entity-level: you see only the entities shared with you. no-access: you can't read it. derived-per-field: files and comments follow the access to the entity they belong to. custom: a custom set of permissions. - Missing when access couldn't be read. Access levels are cached for up to 1 hour. Spaces and databases are always current. Pass refreshAccess: true when the user says their access changed, or when the data you read contradicts a level shown.
get_user_mention
ChatGPTBuilds an inline user mention for document markdown, works the same as get_entity_mention, but for the fibery/user database. When the document is shown, it renders as a "live" user mention. Embed the returned string into content passed to the document editing tools (insert_document_blocks, set_block_text, comment bodies). Get user ids via query from the fibery/user database, or your own id via get_me. Call get_fibery_skill({skill: "documents"}) for the markdown reference. Example `` { userId: "123", label: "Alice" } ``
insert_document_blocks
ChatGPTInserts new blocks into a document from markdown. Call get_fibery_skill({skill: "documents"}) first. It covers the full markdown reference (headings, lists, tables, code, math, images/videos, callouts, highlights, entity references), content adaptation rules, and the editing workflow. Call read_document for block ids to anchor to (not needed when inserting at the document root with parent: {blockId: null, ...}). Example Append a section to the end of a document: `` { secret: "123", inserts: [{parent: {blockId: null, position: "end"}, content: "## Next steps\n\n- [ ] review\n- [ ] deploy"}] } ``
move_document_blocks
ChatGPTMoves blocks (each with all its children) to a new position in the document. Call read_document first to get block ids. Call get_fibery_skill({skill: "documents"}) for the block model and the editing workflow. Moves cannot be proposed as suggestions (tracked changes). Example Move a block to the end of the document: `` { secret: "123", moves: [{blockId: "456", parent: {blockId: null, position: "end"}}] } ``
prepare_file_upload
ChatGPTUploads a file from the user's LOCAL machine to Fibery. Use it only when you can run shell commands and the file is on local disk. For a file at a public URL, call add_file_from_url instead. 1. Call this tool. It returns a secret and a curlCommand. 2. Run curlCommand in your shell, replacing <LOCAL_FILE_PATH> with the path of the local file. The file goes straight to Fibery, not through this conversation, and keeps its local file name. Run it before expiresAt. 3. On success curl prints the created file as JSON. The file is not attached anywhere yet: - File field: attach_files with its fibery/id from that JSON. - Document:  in the markdown of insert_document_blocks, replace_document_blocks or set_block_text. - Whiteboard: imgSrc of a Picture or videoSrc of a Video set to /api/files/<secret> in create_whiteboard_elements. Each upload is for one file; call this tool again for every file.
query
ChatGPTRun a structured Fibery query: select fields, filter, order, paginate and aggregate the data. Rows queried from a regular database automatically carry a link to their entity. Call get_fibery_skill with {skill: "query"} for advanced/uncommon patterns or when uncertain about syntax — it returns the exhaustive operator list, type definitions, and edge-case rules. Results reference Fibery objects by url: use it when referencing the object. Example Query `` { "query": { "q/from": "Product Management/Feature", "q/select": { "Name": ["Product Management/Name"], "Description": ["Product Management/Description"], "Priority": ["Product Management/Priority", "enum/name"], "Status": ["workflow/state", "enum/name"], "CreationDate": ["fibery/creation-date"], "Assignees": { "q/from": "Product Management/Assignees", "q/select": { "Name": ["user/name"], "Email": ["user/email"] }, "q/limit": 50 } }, "q/where": [ "q/and", [">", ["fibery/creation-date"], "2023-12-01T00:00:00Z"], ["q/equals-ignoring-case?", ["workflow/state", "enum/name"], "In Progress"] ], "q/order-by": [[["fibery/creation-date"], "q/desc"]], "q/limit": 100 } } ` Count entities in a database: ` { "query": { "q/from": "Product Management/Feature", "q/select": ["q/count", "fibery/id"] } } ``
query_views
ChatGPTQueries views (saved configurations like boards, grids, timelines, etc.) in the workspace. All parameters are optional filters. Returns matching views with their type, name, description, space, config details (filters and color-coding rules come back as human-readable descriptions), and, in case of document view, their content. For viewType: "canvas" (whiteboards), each result additionally includes whiteboardElements — the board's current elements as JSON. Examples `` { "viewType": "board", "text": "sprint" } ` ` { "publicId": "42" } ` ` { "viewType": "canvas", "text": "retrospective" } ``
read_document
ChatGPTReads a single document as a flat list of addressable blocks with stable ids. Call this before any document editing tool — the returned block ids are required by all of them. Call `get_fibery_skill({skill: "documents"})` FIRST — it covers how to find document secrets (via query or search), the snapshot anatomy, the block model, inline comments, and the whole editing workflow. Returns a TOON-encoded snapshot: version, rootBlockIds (ordered top-level ids), blocks in document order (each with id, type, parentId — null = top level, attrs, content, index), plus a comments section when the document has inline comment threads and a suggestions section when it has pending suggestions (tracked changes) — those also show inline in block content as <ins>/<del> annotations.
remove_collection_items
ChatGPTRemoves items from an entity's collection field. Call get_fibery_skill({skill: "data"}) for how to work with Fibery data. Prerequisites: schema_detailed for the collection field name; query to find the owner entity id and the item ids.
remove_dimension
ChatGPTRemoves a single dimension from a tab in a Fibery report. Use get_report to find the tabId, tabType, and the dimension id (from result.tabs[].x[].id, .y[].id, .columns[].id, .metrics[].id, etc.). This action is irreversible — the dimension is permanently removed from the tab's specification. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
remove_tab
ChatGPTRemoves a tab from an existing Fibery report. Use get_report to find the tabId of the tab you want to remove (each tab object in result.tabs has an id field). This action is irreversible — the tab and all its dimensions/conditions will be permanently deleted. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
rename_databases
ChatGPTRenames one or more databases; changing the space prefix moves a database to another space. Fibery auto-updates references in formulas and relations, but external integrations or API scripts using the old name may break. Call get_fibery_skill({skill: "schema"}) for naming rules. Prerequisites: schema to get current database names.
rename_fields
ChatGPTRenames one or more fields within their databases. Call get_fibery_skill({skill: "schema"}) for naming rules. Prerequisites: schema_detailed to get current field names.
replace_block_text
ChatGPTReplaces one occurrence of exact text inside a block, leaving the rest untouched. The preferred tool for small fixes — surrounding formatting and inline comments survive. Call read_document first to get block ids. Call get_fibery_skill({skill: "documents"}) for selector semantics, the block model, and the editing workflow. exact is the block's text as shown in read_document. Plain text matches regardless of formatting; inline markdown adds a formatting requirement (**text** matches only the bold occurrence). replacement supports inline markdown too — it is applied and defines the formatting of the inserted range (~~x~~ inserts struck-through text); a replacement without markup inherits the formatting of the matched range. Escape markers (\*\*) to insert them literally; in raw-text blocks (code_block, math_display) both strings are always literal. Example `` { secret: "123", replacements: [{blockId: "456", exact: "teh", replacement: "the"}] } ``
replace_document_blocks
ChatGPTReplaces a block — with all its children — by the blocks its markdown converts to, in the same place. Use it to rewrite a block as something other than one text block: a paragraph into a heading plus a list, a list into prose, a callout into plain paragraphs. Call read_document first to get block ids. Call get_fibery_skill({skill: "documents"}) for the markdown reference, content adaptation rules and the editing workflow. A table is replaceable only as a whole, not by row or cell.
resolve_document_suggestions
ChatGPTAccepts or rejects pending suggestions (tracked changes) in a document. Resolving changes the document directly: accepting a deletion removes the content, rejecting it keeps it; accepting an insertion keeps the inserted content, rejecting it removes it. Call read_document first — the suggestions section lists every pending suggestion with its id, author and the blocks it touches. Call get_fibery_skill({skill: "documents"}) for the suggestion workflow.
schema
ChatGPTRetrieves the high-level structure of the Fibery workspace, showing all spaces and databases without field details. Use it to understand available data structure before performing anything specific to this Fibery workspace. Recommended first step before calling schema_detailed or any other tool that requires a database name.
schema_detailed
ChatGPTDisplays Fibery databases schema with fields and related databases in YAML format. The structure is the following: ``yaml {space}/{database}: Database description fields: {fieldName}: {fieldType} metadata comments (collection, UI title, read-only, default value, etc.) values: Only for enum types - id: {enumId} name: {enumName} color: {enumColor} icon: {enumIcon} ` Metadata comments include: - collection: Field is a collection of references - UI title: Field is used as the display title - read-only: Field value cannot be modified - default: Default value for the field - dependency/dependency start: Field is part of dependency relationships - formula: Field is calculated via formula. Formula is always read-only - values: Available enum values (for enum fields) Use it to explore fields and relations of a database. Prerequisites: call schema` first to discover available database names.
search
ChatGPTSearches workspace content using BM-25 keyword matching. Finds entities and views where titles, descriptions, document content, or comments contain the search terms. Returns matching items with their kind (entity or view), title, score, and highlight showing what matched. Examples `` { "query": "login bug", "database": "Projects/Task", "limit": 10 } ` ` { "query": "quarterly report" } ``
search_guide
ChatGPTFetches information directly from the Fibery User Guide based on provided query. Use it to answer specific questions about Fibery platform functionality. The tool searches across all User Guide sections and returns a sorted list (by score in descending order) of relevant text fragments. Feel free to make a couple of tool calls to search for different adjacent information to user's query to get the best answer. IMPORTANT: Use other tools if user asks to look for information in their workspace -- guide will NEVER include information from user's workspace (which you can access via other tools such as query) Examples of queries when this tool should be called - How do I set up automations in Fibery? - What are the different view types available in Fibery? - Can I integrate Fibery with Slack? - How do formulas work in Fibery?
search_history
ChatGPTSearches the workspace activity history. Returns a list of history events showing entity creates, updates, deletes, and other changes. All parameters are optional. By default, returns the last 24 hours of history (up to 50 items). Important behavior - Time range max: until - since cannot exceed 12 months. Default range is the last 24 hours. - Pagination — results may be partial: a single call returns up to limit items (default 50, max 100). If the response has hasNext: true, you've only seen a slice. To continue, call again with sinceItem set to the previous response's sinceItem cursor. Repeat until hasNext: false. - `database` must be the exact full `Space/Database` name (e.g., "Projects/Task", not "Task" and not a different space). Call schema first to confirm the name; mistakes fail with Database "X" not found. - Automatic changes are filtered out by default (changes from automations, integrations, formulas, auto-linking). For databases created by an integration, all results would be filtered out — pass excludeAutomaticChanges: null to include them. Examples Recent changes in a database by user: `` { "database": "Projects/Task", "actions": ["created", "updated"], "since": "2025-01-01T00:00:00Z", "authorUserId": "<uuid>", "limit": 20 } ` Pagination using sinceItem cursor from previous result: ` { "database": "Projects/Task", "sinceItem": "last-item-id-from-previous-result", "limit": 50 } ` Include automatic changes for integration databases: ` { "database": "Email/Email", "since": "2025-01-01T00:00:00Z", "excludeAutomaticChanges": null, "limit": 50 } ` Investigate a disappeared entity (check deletions and archives): ` { "database": "Projects/Task", "actions": ["deleted", "archived"] } ` Full history of a specific entity by public ID: ` { "entityPublicId": "42", "database": "Projects/Task" } ` Schema changes only (field/database/space additions or removals): ` { "schemaChange": ["fieldChange"] } ``
set_block_attrs
ChatGPTMerges attributes into blocks' attrs (e.g. heading level, task state, code block language, callout icon). Call read_document first to get block ids. Call get_fibery_skill({skill: "documents"}) for the per-block-type attrs catalog. Attribute changes cannot be proposed as suggestions (tracked changes). Example Turn a heading into level 3 and mark a task done: `` { secret: "123", blocks: [ {blockId: "456", attrs: {level: 3}}, {blockId: "789", attrs: {state: "DONE"}} ] } ``
set_block_text
ChatGPTRewrites the inline content of text blocks from markdown. Keeps each block's type, attrs and id. Call read_document first to get block ids. Call get_fibery_skill({skill: "documents"}) for the block model, the inline markdown reference, and the editing workflow. Prefer `replace_block_text` for small fixes — it touches only the matched text and preserves surrounding formatting and comments. Use this tool to rewrite a whole block. Each content must resolve to a single top-level block — it replaces one block's inline content, it does NOT add blocks. Multi-block markdown (heading + paragraph, several paragraphs, a list, ---) is rejected. To add blocks use insert_document_blocks; to change a block's type use set_block_attrs. Exception: raw-text blocks (code_block, math_display) take content as literal source text — no markdown parsing, newlines allowed; one outer code fence is dropped and its language is NOT applied (use set_block_attrs for language). Example `` { secret: "123", blocks: [{blockId: "456", content: "Updated **summary** of findings"}] } ``
set_state
ChatGPTSets an entity's workflow/state. No field name needed — only one workflow field can exist per database. Pass state as the state title (e.g. "Done"). Call get_fibery_skill({skill: "data"}) for how to work with Fibery data. Prerequisites: schema_detailed for valid state titles; query to find the entity id.
update_databases
ChatGPTSets or removes the descriptions of databases, changes their color, and adds comments, avatar, icon, documents or whiteboards on each entity. Rename or move them with rename_databases. Call get_fibery_skill({skill: "schema"}) for the color palette and what comments, avatar, icon, documents and whiteboards add. Prerequisites: schema to get current database names.
update_dimension
ChatGPTUpdates an existing dimension in a report tab. Use get_report to find the tabId, tabType, and per-dimension id values. Each dimension object in the tab's axis arrays (x, y, columns, metrics, etc.) has an id field — pass that as dimensionId. `changes` is a partial object: only the keys you provide will be merged into the existing dimension. Omit keys you do not want to change. To add or remove dimensions entirely, use remove_dimension or recreate the tab with the add-tab tools. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
update_entities
ChatGPTUpdates entities — only the fields you include change; each entity MUST include its id (fibery/id is also accepted as an input alias). Handles primitive and single relation/select fields only; collections, workflow/state, document, and read-only fields error if set here. Call get_fibery_skill({skill: "data"}) for field value formats and which tool handles which field type. Prerequisites: schema / schema_detailed for field names; query to find entity ids.
update_formula_field
ChatGPTUpdates an existing formula field's expression. A new formula is generated from the provided description and must produce a type compatible with the existing field (e.g., a number formula cannot start returning text). Call get_fibery_skill({skill: "schema"}) for formula field semantics. Prerequisites: schema_detailed to see existing formula fields and their names.
update_multi_select_fields
ChatGPTUpdates options of one or more existing multi-select fields — full replacement (options) or incremental (addOptions / updateOptions / removeOptions). Call get_fibery_skill({skill: "schema"}) for the two update modes, execution order, and match-by-name rules. Prerequisites: schema_detailed to see existing field options.
update_report
ChatGPTUpdates an existing Fibery report's title and/or sources. At least one of `title` or `sources` must be provided. Use get_report to retrieve the current report state and reportId before calling this tool. Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
update_single_select_fields
ChatGPTUpdates options of one or more existing single-select fields — full replacement (options) or incremental (addOptions / updateOptions / removeOptions). Call get_fibery_skill({skill: "schema"}) for the two update modes, execution order, and match-by-name rules. Prerequisites: schema_detailed to see existing field options.
update_tab
ChatGPTUpdates scalar properties of an existing tab in a Fibery report. Use get_report to find the tabId and tabType of the tab to update. What this tool can change: title, type / palette (chart tabs only), fieldConditions / dimensionConditions (replaces the tab's filter set entirely). What this tool cannot do: Add or remove dimensions (use update_dimension / remove_dimension or recreate the tab). Change tabType (recreate the tab instead). Reports are a specialized domain — call get_fibery_skill with skill: "reports" for the full report model, expression syntax, palettes, conditions, and workflow.
update_view
ChatGPTUpdates an existing View in the Fibery workspace. All parameters except viewType and id are optional — only provided fields are updated. For anything beyond renaming or editing description/space — call `get_fibery_skill({skill: "views"})` FIRST to get the config schema for the view's viewType (same shape as create). Without the reference, config edits often produce invalid shapes. NOTE: config replaces the previous one entirely. For example, if the view has color coding (see colorCoding in query_views output), rebuild those rules in the new config or they will be lost. Prerequisites: call query_views to find the view's id. A document view's body cannot be edited here — use the document tools (get_fibery_skill({skill: "documents"})) for that. A canvas (whiteboard) view's elements cannot be edited here; config is ignored. Use execute_whiteboard_commands after loading get_fibery_skill({skill: "whiteboard"}). Rename a view: ``json { "viewType": "grid", "id": "a1b2c3d4-...", "name": "Renamed View" } ``
update_whiteboard_elements
ChatGPTChanges existing elements on a Fibery Whiteboard: moves, resizes, restyles or rewrites them and returns a link to the whiteboard view. Give each element its numeric ID (from the idMap of create_whiteboard_elements, or from query_views with viewType: "canvas") plus only the properties to change. Call `get_fibery_skill({skill: "whiteboard"})` first for the properties of each element type. Results reference Fibery objects by url: use it when referencing the object.
update_workflow_field
ChatGPTUpdates an existing workflow (state) field's options — full replacement (options) or incremental (addOptions / updateOptions / removeOptions). Fails if the database has no workflow field (use create_workflow_field then). Removing or replacing the current default option requires setting defaultOption in the same call. Call get_fibery_skill({skill: "schema"}) for update modes and which option properties can be changed. Prerequisites: schema_detailed to see existing option names.
update_workflow_fields
ChatGPTUpdates existing workflow (state) fields' options, one entry per database and several databases in one call — full replacement (options) or incremental (addOptions / updateOptions / removeOptions). Fails if the database has no workflow field (use create_workflow_fields then). Removing the current default option (including leaving it out of a full replacement) requires setting defaultOption in the same call. Call get_fibery_skill({skill: "schema"}) for update modes and which option properties can be changed. Prerequisites: schema_detailed to see existing option names.
add_chart_tab
Claudeadd_collection_items
Claudeadd_file_from_url
Claudeadd_metric_tab
Claudeadd_table_tab
Claudeappend_document_content
Claudeattach_files
Claudeconvert_date_fields
Claudeconvert_number_fields
Claudeconvert_relation_fields
Claudeconvert_select_fields
Claudecreate_automation
Claudecreate_avatars_fields
Claudecreate_custom_app
Claudecreate_custom_app_dev_token
Claudecreate_databases
Claudecreate_entities
Claudecreate_files_fields
Claudecreate_formula_field
Claudecreate_icon_fields
Claudecreate_multi_select_fields
Claudecreate_primitive_fields
Claudecreate_relation_fields
Claudecreate_report
Claudecreate_schema
Claudecreate_single_select_fields
Claudecreate_space
Claudecreate_spaces
Claudecreate_view
Claudecreate_whiteboard_elements
Claudecreate_workflow_field
Claudecreate_workflow_fields
Claudedelete_automation
Claudedelete_avatars_fields
Claudedelete_databases
Claudedelete_document_blocks
Claudedelete_entities
Claudedelete_fields
Claudedelete_icon_fields
Claudedelete_space
Claudedelete_spaces
Claudedelete_views
Claudedelete_whiteboard_elements
Claudedelete_workflow_field
Claudedelete_workflow_fields
Claudedisplay_automations_schema
Claudedisplay_entity_capabilities_via_sharing
Claudedisplay_report_schema
Claudedisplay_schema_capabilities
Claudedownload_file
Claudeexecute_code
Claudeexecute_whiteboard_commands
Claudefetch
Claudefetch_by_url
Claudefetch_view_data
Claudefind_document_blocks
Claudeget_app_accounts
Claudeget_automation
Claudeget_automations
Claudeget_connected_app_accounts
Claudeget_connectors_list
Claudeget_custom_apps_list
Claudeget_databases
Claudeget_documents_content
Claudeget_entity_links
Claudeget_entity_mention
Claudeget_fibery_skill
Claudeget_files_meta
Claudeget_manual_import_link
Claudeget_me
Claudeget_report
Claudeget_reports_list
Claudeget_spaces
Claudeget_tool_reference
Claudeget_user_mention
Claudeinsert_document_blocks
Claudemove_document_blocks
Claudeprepare_file_upload
Claudequery
Claudequery_automations
Claudequery_views
Clauderead_document
Clauderemove_collection_items
Clauderemove_dimension
Clauderemove_tab
Clauderename_databases
Clauderename_fields
Clauderename_spaces
Claudereplace_block_text
Claudereplace_document_blocks
Clauderesolve_document_suggestions
Claudeschema
Claudeschema_detailed
Claudesearch
Claudesearch_guide
Claudesearch_history
Claudeset_block_attrs
Claudeset_block_text
Claudeset_default_field_values
Claudeset_document_content
Claudeset_required_fields
Claudeset_state
Claudesubmit_feedback
Claudeupdate_automation
Claudeupdate_databases
Claudeupdate_dimension
Claudeupdate_entities
Claudeupdate_fields
Claudeupdate_formula_field
Claudeupdate_multi_select_fields
Claudeupdate_report
Claudeupdate_single_select_fields
Claudeupdate_spaces
Claudeupdate_tab
Claudeupdate_view
Claudeupdate_whiteboard_elements
Claudeupdate_workflow_field
Claudeupdate_workflow_fields
Claude