MCP App Store
by KeenEthics
Fibery icon

Fibery MCP Server for Claude and ChatGPT

By Fibery

Overview

Fibery is an operating system for orgs run by nerds: a modular work platform where you build the tools your team runs on. Startups, agencies, enterprises and non-profits use it for everything from product roadmaps and customer feedback to sales CRM, hiring, OKRs and client projects. Everything can link to everything else, so work never gets lost between teams. This plugin connects Claude to your workspace and teaches it how to build in Fibery. Describe how your team works, and Claude builds it. Sprints and bug tracking, a content calendar, a company wiki, or a process no template covers: explain it in your own words, or start from a process doc or a ready-made recipe like Shape Up. Claude asks what it needs to know, then sets up the databases, workflows, views and automations, with sample data to try it on. Want a priority field or a board grouped by stage? Just ask. Happy with the result? Save it as a recipe for the next team. When views aren’t enough, ask for an app. Claude can build a custom app on your Fibery data, like a step-by-step intake form or a dashboard your CEO actually reads. Your data stays in Fibery, with its permissions and history intact. Ask the way you’d ask a colleague. “Which customers asked for the features we shipped last month?” “What happened with the Acme deal this week?” “Who’s still waiting on interview feedback?” Claude searches records, documents, comments and activity history to answer, and turns the answers worth keeping into live reports. Let routine work run itself. Set up rules and buttons in plain words: when a deal is won, create the onboarding project; when a bug turns critical, assign it and set a due date. Put your data to work. Draft release notes from what shipped this month, write a client update from open tasks, turn meeting notes into assigned tasks, or update a hundred records at once.

How to connect

  1. Claude: Open the Fibery listing in the Claude connectors directory and choose Connect. Claude listing Fibery exposes 101 tools here.
  2. ChatGPT: Open the Fibery listing in the ChatGPT app directory and choose Connect. ChatGPT listing Fibery exposes 85 tools here.

Tools

add_chart_tab

ChatGPT
Appends 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

ChatGPT
Adds 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_comment

ChatGPT
Adds a comment, or a reply (via parentCommentId), on an entity whose database has a comments/comments field. Markdown content; author is always the current user. A reply's parent must belong to the same entity. For inline comments (on document), call get_fibery_skill({skill: "documents"}). Call get_fibery_skill({skill: "data"}) for content/callout details and how to find existing comment ids. Prerequisites: schema_detailed to confirm the database supports comments; query/search to find the entity id.

add_file_from_url

ChatGPT
Attaches 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_inline_comments

ChatGPT
Adds inline comments to text inside ONE block. The matched text becomes the highlighted range; block content is NOT changed. The author is the current user. Call read_document first to get block ids. Call get_fibery_skill({skill: "documents"}) for more details. For entity-level comments (the Comments field of an entity), use add_comment instead. Example `` { secret: "123", comments: [{blockId: "456", exact: "comprehensive test suite", content: "Which suites exactly? Consider linking them."}] } ``

add_metric_tab

ChatGPT
Appends 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_suggestion_comments

ChatGPT
Adds inline comments anchored to pending suggestions (tracked changes). The thread covers the suggestion's range and follows it until the suggestion is accepted or rejected; after that it lives on as an ordinary text comment. It does NOT change the document and does NOT resolve the suggestion. Call read_document first — the suggestions section lists pending suggestions with their ids. Call get_fibery_skill({skill: "documents"}) for the suggestion workflow. Use this to discuss someone's suggestion (question it, explain a concern) instead of accepting/rejecting it. To comment on regular text, use add_inline_comments. To attach a rationale to a suggestion you are making yourself, pass comment on the suggest-mode editing call instead — no second call needed.

add_table_tab

ChatGPT
Appends 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

ChatGPT
Attaches 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

ChatGPT
Enables 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_comments_fields

ChatGPT
Enables comments on entities in one or more databases. Creates a "comments/comments" field automatically. Call get_fibery_skill({skill: "schema"}) for the schema-building workflow. Prerequisites: schema to get database names.

create_custom_app

ChatGPT
Create 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

ChatGPT
Issue 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Enables 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Creates a new space in the workspace. Call get_fibery_skill({skill: "schema"}) for naming rules. Prerequisites: schema to check existing spaces.

create_spaces

ChatGPT
Creates one or more spaces in the workspace. Call get_fibery_skill({skill: "schema"}) for naming rules. Prerequisites: schema to check existing spaces.

create_view

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Creates 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

ChatGPT
Disables 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_comments_fields

ChatGPT
Disables comments on entities in one or more databases by deleting the "comments/comments" field. Restorable by the user via the Activity Log. Call get_fibery_skill({skill: "schema"}) for deletion semantics. Prerequisites: schema_detailed to verify the comments field exists.

delete_databases

ChatGPT
Deletes 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

ChatGPT
Deletes 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

ChatGPT
Deletes 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

ChatGPT
Deletes 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

ChatGPT
Disables 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

ChatGPT
Deletes 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

ChatGPT
Deletes 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

ChatGPT
Delete 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

ChatGPT
Deletes 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

ChatGPT
Deletes 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

ChatGPT
Deletes 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

ChatGPT
Returns 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

ChatGPT
Get 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

ChatGPT
Returns 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

ChatGPT
Fetches 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

ChatGPT
Reads 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

ChatGPT
Fetches 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

ChatGPT
Fetches 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

ChatGPT
Finds 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

ChatGPT
Get 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

ChatGPT
List 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

ChatGPT
Shows 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_mention

ChatGPT
Builds 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

ChatGPT
Load 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

ChatGPT
Lists 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_me

ChatGPT
Get information about the current user such as their fibery/id, name, email and role in the workspace.

get_report

ChatGPT
Fetch 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

ChatGPT
List 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

ChatGPT
Lists 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

ChatGPT
Builds 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

ChatGPT
Inserts 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

ChatGPT
Moves 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

ChatGPT
Uploads 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: ![alt](/api/files/<secret>) 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

ChatGPT
Run 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

ChatGPT
Queries 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

ChatGPT
Reads 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

ChatGPT
Removes 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

ChatGPT
Removes 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

ChatGPT
Removes 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

ChatGPT
Renames 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

ChatGPT
Renames 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

ChatGPT
Replaces 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

ChatGPT
Replaces 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.

reply_document_comment

ChatGPT
Adds replies to existing inline comment threads in a document. The reply author is the current user. Call get_fibery_skill({skill: "documents"}) for the comment thread model. Example `` { secret: "123", replies: [{commentId: "456", content: "Done — rewrote the section above."}] } ``

resolve_document_suggestions

ChatGPT
Accepts 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

ChatGPT
Retrieves 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

ChatGPT
Displays 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_guide

ChatGPT
Fetches 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

ChatGPT
Searches 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

ChatGPT
Merges 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

ChatGPT
Rewrites 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

ChatGPT
Sets 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

ChatGPT
Sets 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

ChatGPT
Updates 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

ChatGPT
Updates 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

ChatGPT
Updates 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

ChatGPT
Updates 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

ChatGPT
Updates 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

ChatGPT
Updates 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

ChatGPT
Updates 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

ChatGPT
Updates 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

ChatGPT
Changes 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

ChatGPT
Updates 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

ChatGPT
Updates 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

Claude

add_collection_items

Claude

add_comment

Claude

add_file_from_url

Claude

add_inline_comments

Claude

add_metric_tab

Claude

add_suggestion_comments

Claude

add_table_tab

Claude

append_document_content

Claude

attach_files

Claude

convert_date_fields

Claude

convert_number_fields

Claude

convert_relation_fields

Claude

convert_select_fields

Claude

create_automation

Claude

create_avatars_fields

Claude

create_comments_fields

Claude

create_custom_app

Claude

create_custom_app_dev_token

Claude

create_databases

Claude

create_entities

Claude

create_files_fields

Claude

create_formula_field

Claude

create_icon_fields

Claude

create_multi_select_fields

Claude

create_primitive_fields

Claude

create_relation_fields

Claude

create_report

Claude

create_schema

Claude

create_single_select_fields

Claude

create_space

Claude

create_spaces

Claude

create_view

Claude

create_whiteboard_elements

Claude

create_workflow_field

Claude

create_workflow_fields

Claude

delete_automation

Claude

delete_avatars_fields

Claude

delete_comments_fields

Claude

delete_databases

Claude

delete_document_blocks

Claude

delete_entities

Claude

delete_fields

Claude

delete_icon_fields

Claude

delete_space

Claude

delete_spaces

Claude

delete_views

Claude

delete_whiteboard_elements

Claude

delete_workflow_field

Claude

delete_workflow_fields

Claude

display_automations_schema

Claude

display_entity_capabilities_via_sharing

Claude

display_report_schema

Claude

display_schema_capabilities

Claude

download_file

Claude

execute_code

Claude

execute_whiteboard_commands

Claude

fetch

Claude

fetch_by_url

Claude

fetch_view_data

Claude

find_document_blocks

Claude

get_app_accounts

Claude

get_automation

Claude

get_automations

Claude

get_connected_app_accounts

Claude

get_connectors_list

Claude

get_custom_apps_list

Claude

get_databases

Claude

get_documents_content

Claude

get_entity_mention

Claude

get_fibery_skill

Claude

get_files_meta

Claude

get_me

Claude

get_report

Claude

get_reports_list

Claude

get_spaces

Claude

get_tool_reference

Claude

get_user_mention

Claude

insert_document_blocks

Claude

move_document_blocks

Claude

prepare_file_upload

Claude

query

Claude

query_automations

Claude

query_views

Claude

read_document

Claude

remove_collection_items

Claude

remove_dimension

Claude

remove_tab

Claude

rename_databases

Claude

rename_fields

Claude

rename_spaces

Claude

replace_block_text

Claude

replace_document_blocks

Claude

reply_document_comment

Claude

resolve_document_suggestions

Claude

schema

Claude

schema_detailed

Claude

search_guide

Claude

search_history

Claude

set_block_attrs

Claude

set_block_text

Claude

set_default_field_values

Claude

set_document_content

Claude

set_required_fields

Claude

set_state

Claude

submit_feedback

Claude

update_automation

Claude

update_databases

Claude

update_dimension

Claude

update_entities

Claude

update_fields

Claude

update_formula_field

Claude

update_multi_select_fields

Claude

update_report

Claude

update_single_select_fields

Claude

update_spaces

Claude

update_tab

Claude

update_view

Claude

update_whiteboard_elements

Claude

update_workflow_field

Claude

update_workflow_fields

Claude

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/fibery"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/fibery)