MCP App Store
by KeenEthics
Port Agent Skills (US) icon

Port Agent Skills (US) MCP Server for ChatGPT

By Port

Overview

Help platform engineers work with Port: model blueprints and a connected context lake, configure integrations, build workflows and dashboards, manage access, and use Terraform. Includes reusable skills and an optional authenticated Port MCP connection for US tenants. MCP actions follow the permissions of the connected Port account. Review proposed changes before applying them.

How to connect

  1. ChatGPT: Open the Port Agent Skills (US) listing in the ChatGPT app directory and choose Connect. ChatGPT listing Port Agent Skills (US) exposes 66 tools here.

Tools

apply_integration_mapping

ChatGPT
Apply and activate a new integration mapping for an existing integration. Always run test_integration_mapping first with representative examples for every mapped kind, review the output, and only call this tool after the test results are valid and complete. Use this tool only when you are ready to apply the mapping changes.

create_markdown_image_upload

ChatGPT
Start uploading a local image (e.g. a screenshot) so it can be embedded in a Port markdown property or markdown widget. Workflow: 1. Call this tool with the file's path, MIME type and exact size in bytes (wc -c < <file>). 2. Run the returned curlCommand on the machine that has the file. It uploads straight to storage, so the image never passes through this conversation. The upload link expires after expiresInSeconds. 3. Call finalize_markdown_image_upload with the returned key and name to get the markdown snippet. Without a shell, send a multipart/form-data POST to uploadUrl with every entry of fields, followed by the file as the last form field, named file. Limits: PNG, JPEG, GIF, WebP, APNG or AVIF, up to 10 MB. Video isn't supported; use an animated GIF or WebP instead.

delete_blueprint

ChatGPT
Permanently delete a blueprint by identifier. This cannot be undone. Confirm with the user before calling. The delete fails if the blueprint still has entities — check with list_entities and delete or move those entities first. Also removed with this blueprint: its scorecards and actions; relations on other blueprints that involve it; on those other blueprints, mirror properties and inherited ownership that use the removed relations; and aggregation properties whose target is this blueprint. Check list_blueprints for those dependents before proceeding.

delete_entity

ChatGPT
Permanently delete one entity. This cannot be undone. Confirm with the user before calling. This tool does not cascade (delete_dependents is always false). The delete fails only when other entities point at this one through a required relation — optional relations do not block it. Remove those required dependents first, or read the error if the call fails because of them. Do not delete every related entity; optional relations can stay. blueprintIdentifier is the blueprint (the data model) this entity belongs to. entityIdentifier is the record to delete.

delete_page

ChatGPT
Delete a page by its identifier. This will permanently remove the page from the sidebar.

delete_plugin

ChatGPT
Permanently delete a plugin by identifier. Calls DELETE /v1/plugins/:identifier on the Port API. Use list_plugins first to confirm the target plugin identifier. This removes the plugin registration and its stored HTML. It does not remove widgets that reference the plugin — update or delete those separately.

delete_scorecard

ChatGPT
Delete scorecard by identifiers

delete_sidebar_folder

ChatGPT
Delete a folder from the sidebar. Pages and nested folders inside it are also deleted.

delete_widget

ChatGPT
Delete a widget from a dashboard, home, or entity page by its ID.

delete_workflow

ChatGPT
Delete a workflow by its identifier. This will permanently remove the workflow and all its run history.

describe_user_details

ChatGPT
Describe the user, which organization he is connected to and what teams he is a member of and more information regarding the user. Call this FIRST when the user asks to create a dashboard, catalog page, or page with tables — before ask_user_questions, planning, upsert_dashboard_page, or upsert_catalog_page. Read pagePermissions.guidance.workflow and follow it exactly. If pagePermissions.canCreatePages is false, stop and tell the user to contact their admin — do not ask questions and do not suggest entity page updates or other workarounds unless pagePermissions.canUpdatePages is true and the user explicitly asks to customize an existing entity page. If pagePermissions.shouldAskVisibility is false, use pagePermissions.defaultVisibility and do not ask visibility questions. When the request is an ambiguous "page with a table", resolve catalog vs dashboard first (catalog = full-page blueprint table; dashboard = layout that contains a table) — ask once if unclear; do not default to dashboard. When explaining permission issues, relay pagePermissions.guidance in plain language; do not quote internal field names.

duplicate_page

ChatGPT
Duplicate a dashboard page. Creates an identical copy with the same widgets, layout, page filters, icon, and description. The new page is placed immediately after the source page in the sidebar (or in the private pages section for private dashboards). The title is "{original title} (copy)" and the identifier is "{original}_copy" (with numeric suffix if needed). Always use this tool to duplicate a dashboard — do not rebuild the page with get_page + upsert_dashboard_page. Manual recreation can change widget order, drop page filters, or use a different icon. Only dashboard pages (type "dashboard") are supported. Entity pages cannot be duplicated.

finalize_markdown_image_upload

ChatGPT
Finish an image upload started with create_markdown_image_upload, once its curlCommand has succeeded. Returns the image url and a ready markdown snippet (![alt](url)). Put the snippet into a markdown property with upsert_entity, or into a markdown widget. The image is validated and stripped of metadata, so this fails if the file wasn't uploaded, isn't a valid image or is too large. The URL only renders inside Port, for members of this organization; use get_markdown_image to look at the image yourself.

get_blueprint_permissions

ChatGPT
Get entity RBAC permissions for a blueprint: read, register, update, unregister, updateProperties, and updateRelations policies.

get_integration_event_logs

ChatGPT
Fetch event logs for an integration. Default filter is ERROR-level logs (pass levels to include other severities). Pass event_id to limit results to one sync/resync run; when omitted, logs are not scoped to a single run. Supports etl_phases and kinds filters. Pagination uses timestamp and log_id from the previous response.

get_integration_kinds_with_examples

ChatGPT
Fetch all kinds (data types) that an integration ingests, along with raw data examples for each kind. For example, a GitHub integration might have kinds like "pull_request", "issue", and "repo".

get_integration_port_app_config_schema

ChatGPT
Fetch the JSON Schema describing the port-app-config (mapping) for a given integration. Use this to understand what fields and structures are valid when authoring or editing an integration mapping.

get_integration_sync_metrics

ChatGPT
Fetch sync metrics for an integration. Returns detailed metrics including status, number of items handled in each phase of the integration pipeline (extract, transform, load, delete), and per-kind statistics. When the data source processor is enabled, returns aggregate metrics per kind plus reconciliation and resync session metrics (use resyncId as correlationId), including resyncMetric.massDeletionAnalysis when present. It also returns mapping for that resync when a snapshotted mapping exists.

get_integration_test_connection_result

ChatGPT
Get the current status and results of an integration test-connection probe. Call after run_integration_test_connection with the returned probeId. If isComplete is false, the probe is still running — call this tool again with the same probeId to poll for completion. Returns the health result document.

get_markdown_image

ChatGPT
View an image that was uploaded to Port and embedded in markdown, such as a screenshot on a work item. These URLs look like https://<asset-domain>/organizations/<orgId>/markdown_image/<file>. Port asset URLs are private, so they can't be fetched directly; this tool returns the image itself. Only this organization's images can be read, and only PNG, JPEG, GIF or WebP files up to 3.75 MB (5 MB once base64-encoded).

get_page

ChatGPT
Get a specific page by identifier. Returns full page details including widgets configuration. For dashboard and home pages, returns flat widgets and layout from the root dashboard-widget. For entity pages (type "entity"), returns a "tabs" array with each tab's title, widgets, layout, and reserved flag. Tabs are returned in display order.

get_port_knowledge_documents

ChatGPT
Fetch full documents from the documentation and other knowledge sources of Port by their source URL, as search results return them. Returns a markdown representation of the full content of each matched document; results may be empty if none of the requested URLs match. Long documents are truncated; increase max_chars_per_document to fetch more of a single document. The results are paginated. Use this tool when you simply want to look up the content of one or more specific documents.

get_run

ChatGPT
Get the full details and current status of a workflow run by its ID. Returns the run status, result, and per-node nodeRuns details. Common use cases: - Polling for completion after triggering a workflow run - Inspecting a specific run from list_runs results - Checking node-level execution details - Reading what a pending INPUT node asks for: its node run's output.evaluatedConfig holds the evaluated description, userInputs form and userInputs.buttons to use with submit_input_node_response Use list_runs first to discover run IDs.

get_sidebar

ChatGPT
Get the software catalog sidebar structure including pages and folders.

get_workflow

ChatGPT
Get the full definition of a single workflow by identifier. Returns the complete workflow including all nodes, connections, and configurations. Prefer this over list_workflows when you need details for one workflow; it is easier for tools and models to discover and use.

give_port_feedback

ChatGPT
Report a problem you hit while working with Port so the Port team can fix it. Use this when the Port documentation is missing, unclear, outdated, wrong, or contradicts itself; when Port itself has a bug, a limitation, or a missing feature; when a tool from Port's own MCP server fails or behaves unexpectedly; or when the search or document tools on this server fail or misbehave. Say what you were doing, what you expected and what happened, and name the pages, endpoints, or tools involved. Only call this for a concrete problem: not to test the tool, not to say there is nothing to report, and not for problems with tools or services unrelated to Port. Include identifiers from Port that would help reproduce the problem, such as request IDs, error codes, or object IDs, but leave out credentials, personal data, and details of your own organization such as people, customers, or internal ticket references.

install_library_plugin

ChatGPT
Install a plugin from the Port Plugins Library into your organization by pluginName (port-plugins repo folder name; discover via list_available_library_plugins). Returns installed plugin metadata. Returns alreadyInstalled: true if the plugin is already in the org. Not for custom or uploaded plugins — use upsert_plugin instead.

list_available_library_plugins

ChatGPT
List plugins available in the Port Plugins Library — the curated catalog from the public port-plugins repository. Each entry includes pluginName, title, version, description, identifier (org plugin id after install), preview image, readmeContent, and readmeUrl. Not the same as list_plugins, which lists plugins already installed in your organization.

list_blueprints

ChatGPT
List blueprints in the organization. When to use: you need to discover which blueprints exist, or you need one blueprint's property types, enum values, or relation targets before filtering entities, calling upsert_entity, or editing a blueprint. To create or change a blueprint, use upsert_blueprint. Without identifiers: summary (identifier, title, description, property/relation names). With identifiers: full details including property definitions, schemas, relations, and enum values. Use full details when you need: - Property types for constructing filters - Enum values for properties - Relation target blueprints

list_entities

ChatGPT
Query entities from a blueprint. All parameters are composable. FILTERING: - identifiers: Pre-select specific entities by ID - query: Apply filter rules (can combine with identifiers). Max one nested level; nested groups contain only leaf rules, e.g. { combinator: "and", rules: [ruleA, { combinator: "or", rules: [ruleB, ruleC] }] }. OUTPUT OPTIONS (composable): - groupBy: Get value distribution grouped by property/relation - countOnly: Include total count in response - Can request multiple: e.g., groupBy + countOnly returns both groups and total count RESPONSE includes: - entities + hasMoreEntities: when listing (no groupBy) - groups + hasMoreGroups: when groupBy is set - count: when countOnly is true ⚠️ Ensure you have the blueprint schema before filtering or using include. Call list_blueprints if you don't already have it from this session. Required for: 1. FILTERING: property types, enum values, relation targets 2. INCLUDE: use only exact property KEY names from schema.properties / relations — never guess, never use title/label fields (e.g. "affected_service" not "Affected Service") ❌ COMMON FAILURES: - Wrong enum value casing (e.g., "open" instead of "Open") - Wrong relation target (using service ID for a _user relation) - Wrong operator for type (e.g., "contains" on non-array) - Guessed or invented include names — any identifier not in the schema fails the entire call with a 422 INCLUDE PARAMETER: - Copy exact KEYS from schema.properties, relations, and scorecards in the list_blueprints response - NOT categories: "properties", "relations", "scorecards" SEARCHING BY NAME: - Use "contains" on BOTH $identifier AND $title with "or" combinator - Use single words (e.g., "payment" not "payment gateway") DATE FILTERING: - Range: { "property": "created_at", "operator": "between", "value": { "from": "ISO_DATE", "to": "ISO_DATE" } } - Comparison: { "property": "created_at", "operator": ">=", "value": "ISO_DATE" } USER IDENTIFIERS: - _user blueprint uses EMAIL as identifier - Filter by user: { "relation": "creator", "operator": "=", "value": "john@company.com" } FILTERING BY RELATIONS: - Use "relation" key, NOT "property": { "relation": "assignee", "operator": "=", "value": "..." } - Single relations: use "=" - Array relations: use "contains" or "containsAny" SORTING: - Use "order": "asc" or "desc" (NOT "direction")

list_external_interface_apps

ChatGPT
List the external interface apps (public/PKCE Auth0 clients) registered for your organization.

list_integrations

ChatGPT
List integrations in your organization. Without identifiers: Returns summary list (identifier, type, title, version, resync state). Use resyncState.status to see whether a resync is in progress before changing mappings. With identifiers: Returns full integration details including complete config with mapping configuration. Use this before update_integration_mapping to fetch the current resources array you need to preserve.

list_plugins

ChatGPT
List plugins in your organization. A plugin is an HTML UI file registered in Port — shown as a custom widget on dashboards or entity pages to enrich how data is presented (wired via pluginId + paramValues; not a blueprint or integration). Call when the user wants to know what plugins are available, or before proposing or building a new custom plugin — check for an existing plugin to reuse on the dashboard. Without identifiers: Returns summary list (identifier, title, description, size, param keys, updatedAt). With identifiers: Returns full plugin details including complete parameter definitions.

list_runs

ChatGPT
List recent workflow runs. Returns a flat list sorted by creation time (newest first). Common use cases: - "List my runs" → call with no filters - "What is waiting for my input" → call with waitingForApproval: true, which matches WAITING_FOR_INPUT — the run is blocked on an input node. Getting full details of a specific run: use get_run with the run's id.

list_scorecards

ChatGPT
List scorecards in your organization. Without identifiers: Returns summary list (identifier, title, blueprint, levels, compacted rules). With identifiers: Returns full scorecard details including complete rule configurations.

list_self_service_triggers

ChatGPT
List the self-service workflow triggers you are allowed to run, with their input schemas. Use this tool whenever the user wants to perform a task that Port may already support. If the user says "triage bug X", "rotate credentials for service Y", or "onboard a new developer" — search here first. There may already be a workflow configured for exactly that. Returns one item per triggerable workflow: the workflowIdentifier to pass to trigger_run, and the userInputs schema describing what that workflow expects. Use this as the discovery step before `trigger_run` for workflows. It replaces calling list_workflows and then get_workflow for each result — one call returns both the identifier and the inputs, without the full node graph. Results are already scoped to what you can execute, so an empty list means there is nothing you are permitted to run. Pass includeNonExecutable: true to also see triggers you cannot run, each marked with permitted. Filtering: - Pass query to keyword-search across workflow identifier, title, and description (e.g., query: "jira" to find all Jira-related triggers). - Pass blueprintIdentifier (optionally with entityIdentifier) to narrow to triggers that act on a specific entity. Only self-service triggers are returned. Event and schedule triggers fire automatically and cannot be invoked manually.

list_workflows

ChatGPT
List the workflows in your organization. Filtering: pass query to keyword-search across identifier, title, and description (e.g., query: "jira" to find all Jira-related workflows). Getting full details: This tool returns lean summaries. Use get_workflow with a workflow identifier to retrieve the full definition.

load_skill

ChatGPT
Load specialized guidance for a domain-specific task. Skills provide step-by-step instructions for common workflows. Load a skill BEFORE starting a specialized task to ensure consistent, thorough handling. Available Skills: - action-permissions-helper: Help users configure permissions for classic self-service actions, with focus on dynamic permission policies. Does not apply when the org sets settings.disableClassicActions to true, since the classic action tools are unavailable there. Use when users need help with execute/approve permissions, JQ conditions, or catalog queries for access control. - catalog-page-helper: Guide for creating and updating catalog pages (type blueprint-entities) with a single table-entities-explorer. Use when creating a catalog page, listing blueprint entities in the sidebar, or filtering/grouping/sorting/columns on a catalog table. For dashboards use dashboard-page-helper; for entity pages (type entity) use entity-page-helper. - create-port-plugin: Build Port custom plugins and widgets from scratch, or reuse and verify existing ones in the repo, as self-contained React/TypeScript iframe plugins (@port-labs/plugins-sdk, port-plugins-cli) uploaded via CLI. Use for greenfield scaffolding, copying/adapting plugins, recommending an existing match, or auditing upload-params.json and per-plugin README. Do not use for installing curated Plugins Library entries into an org (load_skill install-library-plugin + install_library_plugin), Ocean integrations, generic Port admin without plugin code, or blueprint-only catalog work with no widget implementation. - dashboard-page-helper: Guide for creating dashboard pages with widgets and plugins. Custom-widget upsert requires a paramValues confirmation turn before upsert_widget/upsert_dashboard_page. Use when creating or updating dashboard or home pages. For catalog pages (type "blueprint-entities"), use catalog-page-helper. For entity pages (type "entity"), use entity-page-helper instead. - entity-page-helper: Guide for updating entity pages (blueprint entity pages with tabs). Use when creating tabs, renaming tabs, reordering tabs, or updating widgets on entity pages. For catalog list pages (type "blueprint-entities"), use catalog-page-helper. For dashboards, use dashboard-page-helper. - fix-pages-api-validation: Fix/repair/provide valid page JSON for dashboard, home, entity, or blueprint-entities. First: validate_page({ identifier }). Loop validate_page({ page }) until valid:true. Read-only. - install-library-plugin: Browse, discover, or install curated plugins from the Port Plugins Library. Use when the user asks what is in the Plugins Library, what plugins are available, or wants to install, add, or enable a widget from the port-plugins repo. ALWAYS load this skill before list_available_library_plugins or install_library_plugin. Not for Ocean data-source integrations (install_integrations), custom plugin builds (create-port-plugin / create-html-port-plugin), or org-installed plugins (list_plugins only). - mapping-assistant: Help users create, modify, or troubleshoot integration mapping configurations. Use when users ask about mapping, JQ expressions, or data transformation for integrations. - port-blueprints: Model a Port context lake data model using blueprints, defining identifiers, titles, icons, properties, relations, and calculation, mirror, or aggregation properties, then author them with the raw Port API. Use when asked to create a Port blueprint, define a Port data model, add a property to a blueprint, relate two blueprints, add a calculation property, add a mirror property, or add an aggregation property. - port-context-lake: Design and build a Port context lake: a connected, semantically-rich data model of blueprints, relations, and mirror/aggregation properties that AI agents, scorecards, and workflows can query and act on, not just a plain software catalog. Use when asked to 'build a context lake', 'design a Port data model for AI agents', 'set up the engineering intelligence data model', 'connect services to teams and orgs in Port', 'model …

load_widget_schema

ChatGPT
Get the JSON schema for a dashboard widget type. Call this before upsert_dashboard_page, upsert_widget, or update_entity_page. Custom-widget schema requires org admin permissions and is rejected at call time for members.

move_page

ChatGPT
Move a page to a different location in the sidebar. Use "parent" to move the page into a folder (or set to null for sidebar root). Use "after" to position the page after another item (or set to null for the beginning).

restore_integration_mapping

ChatGPT
Restore an integration to the previous successful mapping snapshot and trigger recovery. Use trigger: "manual" to restore and run full resync, or trigger: "apply_mapping" to restore and run apply mapping. Do not call this for source_fetch_issue and do not call it before clearly warning that properties/relations not written by this integration will not be restored.

resync_integration

ChatGPT
Trigger a full resync of an installed integration. A resync fetches fresh data from the connected tool and updates the software catalog. Entities that no longer exist in the source may be permanently removed. Use list_integrations first to get the exact identifier. After triggering, use get_integration_sync_metrics to track progress and get_integration_event_logs to inspect errors.

revoke_external_interface_app

ChatGPT
Revoke (permanently delete) an external interface app registration, including its underlying Auth0 client. Any UI built against it will immediately lose the ability to authenticate.

run_integration_test_connection

ChatGPT
Run a shallow test-connection probe for an installed integration. Returns a probeId you can pass to get_integration_test_connection_result to check progress and read results. Test connection is asynchronous — after running, call get_integration_test_connection_result with the returned probeId. If status is pending or in_progress, call again to poll for completion.

search_audit_logs

ChatGPT
Search entity audit logs with flexible filters. FILTER FIELDS: - status: SUCCESS or FAILURE (=, !=, in, notIn) - operation: audit action such as CREATE, UPDATE, DELETE (=, !=, in, notIn) - type: trigger origin such as UI, API, WEBHOOK (=, !=, in, notIn) - date: timestamp range using between with { "from": "<ISO timestamp>", "to": "<ISO timestamp>" } - error: text search on failure message - runId, installationId, webhookId: exact token match - entity, blueprint: filter by entity or blueprint (use identifiers when historicalData is true) PAGINATION: - Use limit and offset. TIP: Set historicalData to true (default) when filtering by blueprint or entity identifier.

search_port_knowledge_sources

ChatGPT
Perform semantic retrieval over the documentation and other knowledge sources of Port and return the most relevant chunks for a given query. A "chunk" is a short, self-contained snippet of text taken from a single page or item within these sources (for example, part of a documentation page) and includes its source URL and markdown content. Chunks are returned in descending order of relevance to the query, and the tool always returns a fixed number of chunks (top-k). If the knowledge sources do not contain information relevant to the query, the returned chunks may be only weakly related or entirely unrelated. Use this tool anytime you need information about Port.

simulate_blueprint_permissions

ChatGPT
Simulate blueprint entity permissions for a user. Use list mode to discover all accessible entities for an operation, or detail mode (with entityIdentifier) to inspect decision checks for a specific entity.

submit_input_node_response

ChatGPT
Submit a response to a workflow INPUT node run that is waiting for input, on behalf of the current user. The available buttons and the form to fill come from the INPUT node's configuration, evaluated for this run. Follow this flow: 1. Get the workflow run identifier (wfr_...) and the node run identifier (wfnr_...) from the user (e.g. from the input notification or a run link). 2. Call get_run with the workflow run identifier and find the INPUT node run in nodeRuns. 3. Read its output.evaluatedConfig: description explains what is being asked, userInputs is the form (properties, required) and userInputs.buttons lists the buttons you can submit. 4. Confirm the chosen button and inputs with the user, then call this tool. Only users configured as responders on the node can submit, and each responder can respond once. The node completes only after the configured number of responders chose the same button.

test_integration_mapping

ChatGPT
Test an integration mapping against raw data examples. Validates the mapping, checks for errors, and returns the mapped results or error messages. Use get_integration_port_app_config_schema to discover valid kinds and per-kind selector fields for the integration.

trigger_auto_discovery

ChatGPT
Start an auto-discovery process to find and suggest entities for a blueprint. Use this tool when the user wants to discover, create, import, or add entities to their catalog. Do NOT create entities manually — always use this tool instead. You MUST call list_blueprints first to get the exact blueprint identifier before calling this tool. Ask the user for context before triggering.

trigger_run

ChatGPT
Trigger a workflow run. DISCOVERY FIRST: Before triggering, use list_self_service_triggers — it returns the workflowIdentifier, the nodeIdentifier, and the userInputs in one call, scoped to what you can execute. Pass both identifier (the workflowIdentifier) and nodeIdentifier back here verbatim. A workflow can expose several self-service triggers with different inputs, so omitting nodeIdentifier is rejected as ambiguous unless there is exactly one. Event and schedule triggers fire automatically and cannot be invoked manually. After triggering: workflow runs are asynchronous — use get_run with the returned run ID to poll for completion.

update_blueprint_permissions

ChatGPT
Update entity RBAC permissions for a blueprint. Partially merges read, register, update, unregister, updateProperties, and updateRelations policies.

update_entity_page

ChatGPT
Update an existing entity page's tabs, tab names, tab order, page metadata, or page filters. Entity pages are auto-generated per blueprint — they cannot be created manually. When to use this tool: - Add a new custom tab to an entity page - Rename a tab (provide previousTitle + title, no widgets/layout) - Delete a custom tab (omit it from tabOrder; reserved tabs cannot be deleted) - Reorder tabs (provide tabOrder with every remaining tab title in the desired display order) - Update page metadata (title, description, icon) - Add or update multiple widgets/layout on a tab at once - Create, update, or remove page-level filters (pageFilters) When NOT to use this tool: - Updating a single widget → use upsert_widget with tabTitle instead - Dashboard or home pages → use upsert_dashboard_page / upsert_widget - Catalog pages (type "blueprint-entities") → use upsert_catalog_page - Never use upsert_dashboard_page on entity pages Load the entity-page-helper skill for full guidance. Entity page identifier is "{blueprintIdentifier}Entity" (e.g. "serviceEntity"). If the user's current context mentions a page identifier or blueprint, use it — do not ask the user which page to modify. First call get_page to see tabs. Only call load_widget_schema when the user explicitly asked for widgets. Custom widgets require org admin permissions and are rejected at call time for members. Rules: - Only change what the user asked for — do not add placeholder widgets, icons, or layout unless requested - To add an empty tab, provide only { title: "Tab Name" } — widgets and layout are optional - Tabs omitted from input are preserved (including Overview and reserved tabs) - Runs, Audit Log, and Related Entities cannot be provided or renamed — they are preserved automatically - Overview widgets may be updated via this tool or upsert_widget; Overview cannot be renamed or removed - Reserved tab names (Overview, Runs, Audit Log, Related Entities) cannot be used as rename targets - For renames: { previousTitle: "Old Name", title: "New Name" } — do not include widgets or layout - pageFilters replaces the entire filter list when provided; omit to leave filters unchanged; pass an empty array to clear all filters Available widget types for entity page dashboards: - table-entities-explorer: Display entities in a table with filtering, sorting, and grouping - board: Kanban/board view of entities grouped into columns by one property or relation (aliases: kanban, kanban board, board view). Requires blueprint and exactly one groupBy field. - entity-details: Show details of a specific entity (for dashboard pages) - action-card-widget: Display action buttons in a card - workflow-card-widget: Display workflow self-service triggers in a card - action-runs-table-widget: Display action run history in a table - links-widget: Display a collection of links - ai-agent: Embed an AI agent chat interface - markdown: Render markdown content - iframe-widget: Embed an external URL in an iframe - entities-number-chart: Display a numeric metric (count, sum, average, etc.) - entities-pie-chart: Display entity distribution as a pie chart - bar-chart: Display entity distribution as a bar chart - multi-line-chart: Display trends over time as a multi-line chart - custom-widget: Display a custom view using a port plugin to see your data when native widgets are not enough

update_integration_mapping

ChatGPT
Update the mapping configuration of an existing integration. Replaces the entire resources array — any kinds not included will be removed. To preserve existing mappings, first retrieve the current config using list_integrations, modify the desired entries, then pass the full resources array here. Use get_integration_port_app_config_schema to discover valid kinds and per-kind selector fields for the integration. Before applying, use test_integration_mapping to validate the new mapping and check for errors.

update_plugin_metadata

ChatGPT
Update plugin metadata (title, description, and/or params) without changing HTML. Calls PATCH /v1/plugins/:identifier on the Port API. Use list_plugins first to discover identifiers. Provide at least one of title, description, or params. To update HTML, use upsert_plugin instead.

upsert_blueprint

ChatGPT
Create or update a blueprint. A blueprint is the data model for one kind of catalog record: its properties and relations. When to use: the user wants a new blueprint, or a change to an existing blueprint's title, icon, schema, relations, or other definition. To create or update catalog records, use upsert_entity. To read the current definition, use list_blueprints. If the blueprint already exists, this PATCHes with a deep merge. Send only the fields to add or change — title, icon, and schema are not required, so a relations-only change is valid. Omitted fields stay as they are. This tool cannot remove fields. If the blueprint does not exist, identifier, title, and schema are required to create it. blueprint.identifier selects which blueprint to update or create.

upsert_catalog_page

ChatGPT
Create or update a catalog page (type "blueprint-entities") by applying agent-built Pages API JSON. MUST load_skill catalog-page-helper before calling — that skill defines defaults, filters/operators, create vs update, sidebar placement, and the exact widget JSON to send. Do not invent page/widget shape here. Do NOT use for dashboards (upsert_dashboard_page), entity pages (update_entity_page / upsert_widget), or home. Before calling, call describe_user_details and follow pagePermissions.guidance.workflow. If pagePermissions.canCreatePages is false, do not call this tool. If pagePermissions.shouldAskVisibility is false, use pagePermissions.defaultVisibility. Pass a complete page-shaped payload (identifier, blueprint, title, icon, widgets with one table-entities-explorer that includes id, blueprint, displayMode "single", and dataset). On create, set icon to the blueprint icon from list_blueprints (not "Apps", not omitted). The tool validates and create/patches; it sets type/sidebar/section only. On update, get_page first, edit the explorer widget, and send the full payload; omit visibility only when leaving it unchanged. After success, link with the returned absolute url: [<title>](<url>).

upsert_dashboard_page

ChatGPT
Create or update a dashboard or home page. Do NOT use on entity pages (type "entity") — use update_entity_page or upsert_widget instead. Do NOT use on catalog pages (type "blueprint-entities") — use upsert_catalog_page instead. For ambiguous "page with a table" requests, resolve catalog vs dashboard first (catalog = full-page blueprint table; dashboard = layout that contains a table) — ask once if unclear; do not default to dashboard. Before calling this tool, call describe_user_details and follow pagePermissions.guidance.workflow. If pagePermissions.canCreatePages is false, do not call this tool. If pagePermissions.shouldAskVisibility is false, use pagePermissions.defaultVisibility. Only ask about private vs organization visibility when pagePermissions.shouldAskVisibility is true — never offer entity pages as a creation option. Do not call this tool if the user lacks permission for the requested visibility. Custom-widget widgets require org admin permissions and are rejected at call time for members. Decide create vs update from the conversation first. For updates you MUST pass the exact page identifier (private pages get an owner suffix on create — use the identifier returned by create/get_page/get_sidebar). If updating and the identifier is unknown, ask the user which page (or look it up via get_sidebar / get_page) — do not invent a base identifier or create a duplicate. After a successful create or update, always include a markdown link using the returned absolute url: [<title>](<url>). On create of a non-private page, call get_sidebar and set after to the last top-level (non-private) sidebar item so the page is appended at the end; omit after/parent for private pages. On create, if the user did not specify an icon, pass icon "Apps" (do not ask). Load dashboard-page-helper for full guidance. The dashboard-widget container is auto-generated; just provide widgets and layout. To create a private page, set visibility to "private"; private pages cannot be nested with parent or positioned with after, and the API may append an owner-specific suffix to the identifier. To add or update page filters without changing widgets, pass only identifier and pageFilters (call get_page first to see existing filters). pageFilters replaces the entire filter list; pass an empty array to clear all filters. Each widget needs an "id" (referenced in layout) and "type". Call load_widget_schema to get the schema for a widget type. Available widget types: - table-entities-explorer: Display entities in a table with filtering, sorting, and grouping - board: Kanban/board view of entities grouped into columns by one property or relation (aliases: kanban, kanban board, board view). Requires blueprint and exactly one groupBy field. - entity-details: Show details of a specific entity (for dashboard pages) - action-card-widget: Display action buttons in a card - workflow-card-widget: Display workflow self-service triggers in a card - action-runs-table-widget: Display action run history in a table - links-widget: Display a collection of links - ai-agent: Embed an AI agent chat interface - markdown: Render markdown content - iframe-widget: Embed an external URL in an iframe - entities-number-chart: Display a numeric metric (count, sum, average, etc.) - entities-pie-chart: Display entity distribution as a pie chart - bar-chart: Display entity distribution as a bar chart - multi-line-chart: Display trends over time as a multi-line chart - custom-widget: Display a custom view using a port plugin to see your data when native widgets are not enough

upsert_entity

ChatGPT
Create or update an entity (one catalog record). Updates if it exists, creates if it does not. A blueprint is the data model for a kind of record: it defines that record's properties and relations. blueprintIdentifier names which blueprint this entity belongs to. Call list_blueprints with that identifier first if you do not already have its schema. entity.identifier selects which entity to update or create. If omitted on create, the API generates one. Uses upsert with merge by default — only provided fields are updated, existing fields are preserved.

upsert_external_interface_app

ChatGPT
Create or update an external interface app (public/PKCE Auth0 client, no client secret) for your organization, so you can build a custom UI against Port's API. Omit appId to create a new external interface app — name and redirectUris are both required in that case. Pass appId to update an existing external interface app — at least one of name or redirectUris must be provided, and redirectUris replaces the entire existing set rather than merging with it. Each organization has a limited number of external interface app registrations. Registering or renaming to a name that's already taken, or redirectUris that are malformed, duplicated, or wildcards, will fail.

upsert_plugin

ChatGPT
Create or update a plugin. Updates if exists, creates if not. The plugin.identifier determines which plugin to update or create. HTML plugin workflow: create_plugin_html uploads to Port by default — you usually do not need this tool after create. Use upsert_plugin for HTML re-uploads from htmlPath, or when create_plugin_html was called with uploadToPort: false. For metadata-only updates (title, description, params), prefer update_plugin_metadata. Create: Requires identifier, title, and html or htmlPath. Optional description and params. Update HTML: Provide html or htmlPath. Title, description, and params are preserved unless explicitly set. Large bundles: Prefer htmlPath (path on the MCP server filesystem) over inline html. when html and htmlPath ways failed use port-plugins cli as default. Update metadata only: Use update_plugin_metadata, or provide at least one of title, description, or params here (no html or htmlPath).

upsert_scorecard

ChatGPT
Create or update a scorecard. Updates if exists, creates if not. The scorecard.identifier determines which scorecard to update or create. LEVELS: - Default levels: Basic, Bronze, Silver, Gold (lowest to highest) - "Basic" is the starting level - all entities begin here - Rules CANNOT be assigned to Basic level (will cause 409 error) - Assign rules only to Bronze, Silver, Gold levels RULES: - Each rule requires: identifier, level, query - query.combinator: "and" or "or" - query.conditions: array of property conditions CONDITION VALUES BY PROPERTY TYPE: - Boolean properties: Use value: true or value: false (NEVER use 1 or 0) - Number properties: Use numeric values (e.g., value: 42) - String properties: Use string values (e.g., value: "production")

upsert_sidebar_folder

ChatGPT
Create or update a folder in the sidebar. If the folder with the given identifier exists, it will be updated. Otherwise, a new folder will be created. Folders can be nested by specifying a parent folder identifier.

upsert_widget

ChatGPT
Create or update a single widget on a dashboard, home, or entity page. Preferred tool for updating one widget — use this instead of update_entity_page when changing a single widget's configuration. If the widget with the given ID exists, it will be updated. Otherwise, a new widget will be created. For entity pages (type "entity"), tabTitle is required — call get_page first to see available tabs. If the user's current context mentions a page identifier or blueprint, use it — do not ask the user which page. For dashboard/home pages, tabTitle is not needed. Custom widgets require org admin permissions and are rejected at call time for members. Available widget types: - table-entities-explorer: Display entities in a table with filtering, sorting, and grouping - board: Kanban/board view of entities grouped into columns by one property or relation (aliases: kanban, kanban board, board view). Requires blueprint and exactly one groupBy field. - entity-details: Show details of a specific entity (for dashboard pages) - action-card-widget: Display action buttons in a card - workflow-card-widget: Display workflow self-service triggers in a card - action-runs-table-widget: Display action run history in a table - links-widget: Display a collection of links - ai-agent: Embed an AI agent chat interface - markdown: Render markdown content - iframe-widget: Embed an external URL in an iframe - entities-number-chart: Display a numeric metric (count, sum, average, etc.) - entities-pie-chart: Display entity distribution as a pie chart - bar-chart: Display entity distribution as a bar chart - multi-line-chart: Display trends over time as a multi-line chart - custom-widget: Display a custom view using a port plugin to see your data when native widgets are not enough Call load_widget_schema to get the detailed schema for a specific widget type. Chart widget property fields use kebab-case prefixes (e.g. mirror-property#name, calculation-property#name).

upsert_workflow

ChatGPT
Create or update a workflow. Updates if exists, creates if not. The workflow.identifier determines which workflow to update or create. Build decision: Use this tool for any flow, automation, or multi-step process. > Use list_workflows to discover existing workflows before building new ones.

validate_page

ChatGPT
Validate page JSON for dashboard, home, entity, or blueprint-entities pages (Zod schema + guardrails). READ-ONLY — call when the user asks to show, list, or diagnose page validation issues, or when fixing/repairing/producing valid page JSON. Call instead of get_page for validation errors — get_page does not return them. MUST load_skill fix-pages-api-validation when fixing or providing valid page JSON. identifier = diagnose a stored page and return errors plus full PUT-shaped pageBody when invalid (use pageIdentifier from Current User View, or "{blueprint}Entity" when context has blueprint but no pageIdentifier). page = call after every edit and loop validate_page({ page }) until valid:true before delivering JSON — load fix-pages-api-validation for the full workflow. Responses include nextStep when actionable: present_errors, fix_and_revalidate, output_page_body — follow fix-pages-api-validation for each. Never infer extra errors, suggest deleting the page, or use page write tools.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

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/port-agent-skills-us"><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/port-agent-skills-us)