MCP App Store
by KeenEthics
Keboola icon

Keboola MCP Server for ChatGPT

By Keboola

Overview

Connect ChatGPT to your Keboola projects. Explore buckets and tables, ask questions about your data with read-only SQL, build Snowflake or BigQuery SQL transformations, run them in flows, and find out why a job failed. You sign in with your Keboola account. First you choose your Keboola region, then you log in to Keboola and approve access. ChatGPT can reach only the projects your Keboola account can reach, with the same role and permissions you have in Keboola. Before the plugin creates or changes anything, it asks you to confirm the project, and it asks again before it runs a job. The plugin cannot delete projects, buy or change subscriptions, or run write statements through SQL queries. Data changes go through Keboola transformations, which you can review in Keboola.

How to connect

  1. ChatGPT: Open the Keboola listing in the ChatGPT app directory and choose Connect. ChatGPT listing Keboola exposes 34 tools here.

Tools

add_config_row

ChatGPT
Creates a component configuration row in the specified configuration_id, using the specified name, component ID, configuration JSON, and description. BEFORE CALLING - REQUIRED STEPS: 1. Call get_components([component_id]) to retrieve the component's configuration_row_schema. 2. Read configuration_row_schema.required to find ALL mandatory top-level fields. 3. Call get_config_examples(component_id) to see real-world row parameter examples. 4. Populate parameters with every required field before calling this tool. Skipping these steps will cause a schema validation error. USAGE: - Use when you want to create a new row configuration for a specific component configuration. WHEN NOT TO USE: - keboola.orchestrator / keboola.flow → use create_flow / create_conditional_flow - keboola.data-apps → use modify_streamlit_data_app / deploy_data_app - keboola.snowflake-transformation / keboola.google-bigquery-transformation → use create_sql_transformation EXAMPLES: - user_input: Create a new configuration row for component X with these settings - set the component_id, configuration_id and configuration parameters accordingly - returns the created component configuration if successful.

create_conditional_flow

ChatGPT
Creates a new conditional flow configuration using keboola.flow. PRE-REQUISITES: - Always use get_flow_schema with flow_type="keboola.flow" and review get_flow_examples if unknown - Gather component configuration IDs for all tasks you include (for data apps, their data_app_id) RULES: - phases and tasks must follow the keboola.flow schema; each entry needs id and name - Exactly one entry phase (no incoming transitions); all phases must be reachable - Connect phases via next transitions; no cycles or dangling phases; empty next means flow end - Task/phase failures already stop the flow; add retries/conditions only if the user requests them - Always share the returned links with the user - Run a data app from a flow with a keboola.data-app-control task whose configData is {"parameters": {"appId": "<data_app_id>"}} (data_app_id from get_data_apps), with no configId; never use keboola.data-apps + configId. Each run restarts the app with a new build and a new token, or starts it if it is stopped; add "forceRestart": false to the parameters only if the user wants a running app left as it is WHEN TO USE: - Flows needing branching, conditions, retries, or notifications - Default choice when user simply says "create a flow," unless they explicitly want legacy orchestrator behavior

create_config

ChatGPT
Creates a root component configuration using the specified name, component ID, configuration JSON, and description. Not for SQL transformations (keboola.snowflake-transformation / keboola.google-bigquery-transformation), data apps (keboola.data-apps) or flows — use the dedicated tools (see WHEN NOT TO USE). This IS the tool for Python (keboola.python-transformation-v2), R (keboola.r-transformation-v2) and DuckDB (keboola.duckdb-transformation) transformations. BEFORE CALLING - REQUIRED STEPS: 1. Call get_components([component_id]) to retrieve the component's configuration_schema. 2. Read configuration_schema.required to find ALL mandatory top-level fields. 3. Call get_config_examples(component_id) to see real-world parameter examples. 4. Populate parameters with every required field before calling this tool. Skipping these steps will cause a schema validation error. USAGE: - Use when you want to create a new root configuration for a specific component. WHEN NOT TO USE: - keboola.orchestrator / keboola.flow → use create_flow / create_conditional_flow - keboola.data-apps → use modify_streamlit_data_app / deploy_data_app - keboola.snowflake-transformation / keboola.google-bigquery-transformation → use create_sql_transformation EXAMPLES: - user_input: Create a new configuration for component X with these settings - set the component_id and configuration parameters accordingly - returns the created component configuration if successful.

create_flow

ChatGPT
Creates a new legacy (non-conditional) flow using keboola.orchestrator. PRE-REQUISITES: - Always use get_flow_schema with flow_type="keboola.orchestrator" and review get_flow_examples if unknown - Collect component configuration IDs for every task you include (for data apps, their data_app_id) RULES: - phases and tasks must follow the orchestrator schema; each entry must include id and name - Phases run sequentially; tasks inside a phase run in parallel - Use dependsOn on phases to sequence them; reference other phase ids - Always share the returned links with the user - Run a data app from a flow with a keboola.data-app-control task whose configData is {"parameters": {"appId": "<data_app_id>"}} (data_app_id from get_data_apps), with no configId; never use keboola.data-apps + configId. Each run restarts the app with a new build and a new token, or starts it if it is stopped; add "forceRestart": false to the parameters only if the user wants a running app left as it is WHEN TO USE: - Simple/linear orchestrations without branching or conditions - ETL/ELT pipelines where phases just need ordering and parallel task groups

create_oauth_url

ChatGPT
Generates an OAuth authorization URL for a Keboola component configuration. When using this tool, be very concise in your response. Just guide the user to click the authorization link. Note that this tool should be called specifically for the OAuth-requiring components after their configuration is created e.g. keboola.ex-google-analytics-v4 and keboola.ex-gmail.

create_sql_transformation

ChatGPT
Creates an SQL transformation using the specified name, SQL query following the current SQL dialect, a detailed description, and a list of created table names. CONSIDERATIONS: - By default, SQL transformation must create at least one table to produce a result; omit only if the user explicitly indicates that no table creation is needed. - Each SQL code block must include descriptive name that reflects its purpose and group one or more executable semantically related SQL statements. - Each SQL query statement within a code block must be executable and follow the current SQL dialect. - Use delimited identifiers for the current SQL dialect for all identifiers and FQN references. - When referring to the input tables within the SQL query, use fully qualified table names, which can be retrieved using appropriate tools. - When creating a new table within the SQL query (e.g. CREATE TABLE ...): use only the table name with delimited identifiers, without the fully qualified path; add the plain table name without delimiters to the created_table_names list. - Unless otherwise specified by user, transformation name and description are generated based on the SQL query and user intent. - If there are 20 or more SQL transformations in the project, consider organizing them with a folder: existing folder names are surfaced in the response's change_summary — use one of them or create a new one. USAGE: - Use when you want to create a new SQL transformation. - This is THE tool for creating keboola.snowflake-transformation and keboola.google-bigquery-transformation components (do NOT use create_config for these); the transformation ID is derived automatically from the workspace SQL dialect. - Snowflake/BigQuery only. For Python, R, or DuckDB transformations, use create_config with the appropriate component_id instead — this tool cannot create them. EXAMPLES: - user_input: Can you create a new transformation out of this sql query? - set the sql_code_blocks to the query, and set other parameters accordingly. - returns the created SQL transformation configuration if successful. - user_input: Generate me an SQL transformation which [USER INTENT] - set the sql_code_blocks to the query based on the [USER INTENT], and set other parameters accordingly. - returns the created SQL transformation configuration if successful.

create_stream

ChatGPT
Creates a Data Stream: a source with an endpoint receiving events and the sinks storing them in tables. - source_type="http": one sink into table_id with the given columns. Send events as HTTP POST requests (any body, JSON recommended) to the returned endpoint_url. - source_type="otlp": three sinks storing logs, metrics and traces into the tables "in.c-otlp-<source_id>.logs|metrics|traces". Configure the OpenTelemetry SDK/Collector OTLP/HTTP exporter: OTEL_EXPORTER_OTLP_ENDPOINT=<otlp_base_url> and OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <otlp_secret>". Rows appear in the tables in batches, typically within a few minutes. The returned endpoint embeds a secret: give it only to the user. If Data Streams are not enabled in the project, the tool fails with the project feature key and a link to the Data Streams page where the user can request the feature. Tell the user how to request it.

deploy_data_app

ChatGPT
Deploys/redeploys a data app or stops a running data app in the Keboola environment asynchronously, given the action and the configuration ID. MCP never runs git on your behalf. All git work — clone, branch, commit, push, merge, branch-delete — is yours. This tool only triggers deploys against existing git state. Mode (python-js apps) - mode='dev' deploys the target as a dev version of the data app — the runtime uses a development setup.sh (hot reload) and the data-app proxy enables an auto-auth path so an iframe preview can render without a manual login. Only meaningful on draft configs (python-js apps with isDraft=true). - For prod redeploys (including after merging a draft's branch into main), use no mode — the prod app picks up the current main. - The branch a draft deploys from is pinned in parameters.dataApp.git.branch at create time; there is no deploy-time override. Configuration publishing - Every deploy publishes the latest saved configuration version (for both python-js and Streamlit apps), so configuration-only changes -- secrets, Storage access, git branch, size -- go live together with the code. For python-js apps the code itself is always re-pulled from git. - deployment_info.version is the configuration version the app is actually running; deployment_info.latest_config_version is the latest saved one. If deployment_info.has_unpublished_changes is true, the configuration was changed after the deploy was triggered -- deploy again to publish it. Streamlit apps Streamlit apps have no managed git repo, so mode has no effect on the deployed app. mode=None is the expected call shape. General considerations - Redeploying a data app takes some time; the app reports state="starting" until the new deployment serves production. - state is notDeployed (never deployed), starting, running, suspended (asleep, wakes on the next visit) or disabled (failed to start; only a deploy brings it back). - After deployment, the deployment info includes the app URL and the latest logs to help diagnose in-app errors. - To start or restart an app on a schedule or after other jobs, add it to a flow as a keboola.data-app-control task (see the flow tools) instead of calling this tool.

docs_query

ChatGPT
Answers a question using the Keboola documentation as a source.

find_component_id

ChatGPT
Returns list of component IDs that match the given query. WHEN TO USE: - Use when you want to find the component for a specific purpose. USAGE EXAMPLES: - user_input: "I am looking for a salesforce extractor component" → Returns a list of component IDs that match the query, ordered by relevance/best match.

get_accessible_projects

ChatGPT
Lists the Keboola projects the current login can access across the stack, each with its SQL dialect and organization. Only call this when a data tool call has actually failed asking you to confirm a project scope -- the session may already be pre-scoped (e.g. the user chose specific projects at login time), in which case data tools already work and this call would just be extra, unnecessary API traffic. When a scope genuinely is needed: present the projects, ask whether the user wants to work across all of them or a subset, then call set_project_scope with their choice. This tool compacts several API calls (token introspection plus a per-project token verify for the SQL dialect and organization) into one result, so the assistant does not need a separate get_project_info call per project. Pass with_llm_instruction=true on the first call to also receive the base working instructions grouped by dialect.

get_buckets

ChatGPT
Lists buckets or retrieves full details of specific buckets, including descriptions, lineage references (created/updated by), and links. WHEN NOT TO USE: - Do NOT call with bucket_ids=[] just to find a bucket by name. Use search with item_types=["bucket"] instead. - Only use bucket_ids=[] when you need a complete inventory of all buckets in the project. EXAMPLES: - bucket_ids=[] → summaries of all buckets in the project - bucket_ids=["id1", ...] → full details of the buckets with the specified IDs

get_components

ChatGPT
Retrieves detailed information about one or more components by their IDs. RETURNS FOR EACH COMPONENT: - Component metadata (name, type, description) - Documentation and usage instructions - Configuration JSON schema (required for creating/updating configurations) - Links to component dashboard in Keboola UI Components that cannot be retrieved are listed in not_found (missing) or errors (server-side, retryable); the call fails only if none of them can be retrieved. WHEN TO USE: - Before creating a new configuration: fetch the component to get its configuration schema - Before updating a configuration: fetch the component to understand valid configuration options - When user asks about component capabilities or documentation PREREQUISITES: - You must know the component_id(s). If unknown, first use find_component_id or docs tool to discover them. EXAMPLES: - User: "Create a generic extractor configuration" → First call find_component_id to get the component_id, then call this tool to get the schema - User: "What options does the Snowflake writer support?" → Call this tool with the Snowflake writer component_id to retrieve its documentation and schema

get_config_examples

ChatGPT
Retrieves sample configuration examples for a specific component. USAGE: - Use before calling create_config or add_config_row to understand the expected parameters structure. - Use when you want to see example configurations for a specific component. EXAMPLES: - user_input: Show me example configurations for component X - set the component_id parameter accordingly - returns a markdown formatted string with configuration examples

get_configs

ChatGPT
Retrieves component configurations in the project with optional filtering. Can list summaries of multiple configurations (grouped by component) or retrieve full details for specific configurations. Returns a list of components, each containing: - Component metadata (ID, name, type, description) - Configurations for that component (summaries by default, full details if requested) - Links to the Keboola UI PARAMETER BEHAVIOR: - If configs is provided (non-empty): Returns FULL details ONLY for those configs. Configs that cannot be retrieved are listed in not_found (missing) or errors (server-side, retryable); the call fails only if none of them can be retrieved. - Else if component_ids is provided (non-empty): Lists config summaries for those components. - Else: Lists configs based on component_types (all types if empty). WHEN TO USE: - For listing: Use component_types/component_ids. - For details: Use configs (can handle multiple). WHEN NOT TO USE: - Do NOT list all configs just to find a configuration by name. Use search with item_types=["configuration", "transformation"] instead. - Only use broad listing (empty component_types and component_ids) when you need a complete inventory of all configurations in the project. EXAMPLES: - List all configs (summaries): component_types=[], component_ids=[] - List extractors (summaries): component_types=["extractor"] - Get details for specific configs: configs=[{"component_id": "keboola.ex-db-mysql", "configuration_id": "12345"}]

get_data_apps

ChatGPT
Lists summaries of data apps in the project given the limit and offset or gets details of a data apps by providing their configuration IDs. WHEN NOT TO USE: - Do NOT list all data apps just to find one by name. Use search with item_types=["data-app"] instead. - Only list all data apps when you need a complete inventory. Considerations: - If configuration_ids are provided, the tool will return details of the data apps by their configuration IDs. - If no configuration_ids are provided, the tool will list all data apps in the project given the limit and offset. - Data App detail contains configuration, metadata, source code, links, and deployment info along with the latest data app logs to investigate in-app errors. The logs may be updated after opening the data app URL. - deployment_info.last_run carries the outcome of the most recent deployment attempt. For an app that fails to start, check its failure_reason/failure_message FIRST — they cover setup-phase failures (e.g. invalid secrets, git clone errors, failing setup scripts) that happen before the container starts and therefore never appear in the regular logs. - repo_url (managed git repo URL for python-js apps) is ONLY populated on the detail path (when configuration_ids is provided). The inventory list always returns repo_url=None, even for python-js apps with a managed repo — to retrieve the URL, call this tool again with the target configuration_ids. - When called with configuration_ids=[<prod-cfg>] for a python-js prod app, the response includes a drafts: [...] array of every draft (configs with isDraft=true and parentConfigurationId == <prod-cfg>) currently in the project. Drafts in trash are not included. Use this to discover existing drafts when continuing a previously abandoned iteration. The array is empty for drafts themselves and for Streamlit apps.

get_flow_examples

ChatGPT
Retrieves examples of valid flow configurations. PRE-REQUISITES: - Unknown examples for the target flow type: keboola.flow (conditional) or keboola.orchestrator (legacy) to help build the specific flow configuration by mirroring the structure/fields. RULES: - Conditional-flow examples require conditional flows to be enabled; otherwise use legacy orchestrator examples - Present the examples or cite unavailability to the user

get_flow_schema

ChatGPT
Returns the JSON schema for the given flow type (markdown). PRE-REQUISITES: - Unknown schema for the target flow type: keboola.flow (conditional) or keboola.orchestrator (legacy) RULES: - Projects without conditional flows enabled cannot request keboola.flow schema - Use the returned schema to shape phases and tasks for create_flow / create_conditional_flow / update_flow

get_flows

ChatGPT
Lists flows or retrieves full details for specific flows. WHEN NOT TO USE: - Do NOT call with flow_ids=[] just to find a flow by name. Use search with item_types=["flow"] instead. - Only use flow_ids=[] when you need a complete list of all flows in the project. OPTIONS: - flow_ids=[] → summaries of all flows in the project - flow_ids=["id1", ...] → full details (including phases/tasks) for those flows; flows that cannot be retrieved are listed in not_found (missing) or errors (server-side, retryable), and the call fails only if none of them can be retrieved; a flow whose schedules cannot be read is still returned, with schedules unset and schedules_error saying why (so it is not the same as a flow with no schedules)

get_jobs

ChatGPT
Retrieves job execution information from the Keboola project. CONTEXT: Jobs in Keboola are execution records of components (extractors, transformations, writers, flows). Each job represents a single run with its status, timing, configuration, and results. TWO MODES OF OPERATION (controlled by job_ids parameter): MODE 1: GET DETAILS FOR SPECIFIC JOBS (job_ids is non-empty) - Provide one or more job IDs: job_ids=["12345", "67890"] - Returns: FULL details for each job including status, config_data, results, timing, and metadata - Jobs that cannot be retrieved are listed in not_found (missing) or errors (server-side, retryable); the call fails only if none of them can be retrieved - Ignores: All filtering/sorting parameters (status, component_id, config_id, limit, offset, sort_by, sort_order) - Use when: You know specific job IDs and need complete information about them MODE 2: LIST/SEARCH JOBS (job_ids is empty) - Leave job_ids empty: job_ids=[] - Returns: SUMMARY list of jobs (id, status, component_id, config_id, timing only - no config_data or results) - Supports: Filtering by status/component_id/config_id, pagination with limit/offset, sorting - Use when: You need to find jobs, see recent executions, or monitor job history DECISION GUIDE: - Start with MODE 2 (list) to find jobs → then use MODE 1 (details) if you need full information - If you already know job IDs → use MODE 1 directly - For monitoring/browsing → use MODE 2 with filters NOTE: Jobs cannot be found by name using the search tool. However, always use the filtering parameters (status, component_id, config_id) to narrow results rather than listing all jobs with no filters. If you need to find jobs for a specific configuration but only know its name, first use search to find the configuration ID, then filter jobs by that config_id. COMMON WORKFLOWS: 1. Find failed jobs: job_ids=[], status="error" → identify problematic job IDs → get details with MODE 1 2. Check recent runs: job_ids=[], component_id="...", limit=10 → see latest executions 3. Monitor specific job: job_ids=["123"] → poll for status and results 4. Troubleshoot config: job_ids=[], component_id="...", config_id="...", status="error" → find which runs failed EXAMPLES: MODE 1 - Get full details: - job_ids=["12345"] → detailed info for job 12345 - job_ids=["12345", "67890"] → detailed info for multiple jobs MODE 2 - List/search jobs: - job_ids=[] → list latest 100 jobs (default) - job_ids=[], status="error" → list only failed jobs - job_ids=[], status="processing" → list currently running jobs - job_ids=[], component_id="keboola.ex-aws-s3" → list jobs for S3 extractor - job_ids=[], component_id="keboola.ex-aws-s3", config_id="12345" → list jobs for specific configuration - job_ids=[], limit=50, offset=100 → pagination (skip first 100, get next 50) - job_ids=[], sort_by="endTime", sort_order="asc" → oldest completed first - job_ids=[], sort_by="durationSeconds", sort_order="desc" → longest running first LOG RETRIEVAL (only in MODE 1): - Set include_logs=True to fetch execution logs from the Storage API events - Logs are fetched using the job's runId and returned in chronological order - Use log_tail_lines to control how many recent log events to return (default 50, max 500) - Use log_event_types to filter by event type: ["error"] for just errors, ["error", "warn"] for errors and warnings - If a job has no runId (e.g., not yet started), logs will be None - If the log events cannot be read, the job is still returned: logs will be None and logs_error says why EXAMPLES WITH LOGS: - job_ids=["12345"], include_logs=True → job details + last 50 log events - job_ids=["12345"], include_logs=True, log_event_types=["error"] → job details + only error events - job_ids=["12345"], include_logs=True, log_tail_lines=200 → job details + last 200 log events

get_project_info

ChatGPT
Retrieves structured information about the current project, including essential context and base instructions for working with it (e.g., transformations, components, workflows, and dependencies). Always call this tool at least once at the start of a conversation to establish the project context before using other tools. Reports on exactly one project; pass project_id to pick which when the session is scoped to 2+ projects.

get_semantic_context

ChatGPT
Loads semantic objects grouped by semantic object type. CONSIDERATIONS: - If a selection has empty ids, the tool returns all objects of that type in compact form. - If a selection has non-empty ids, the tool returns only those specific objects with full attributes. - semantic_model_ids optionally narrows the lookup to specific semantic models. - An object returned here carries scope ("project", "organization", or "targeted"), project_id (the project it was created in -- present regardless of scope), source_project_id (which project an "organization"-scope object came from, if known), and target_project_ids (the sibling projects granted read access, for "targeted" scope). This is reported only for an object that appears in the current project's listing or that was loaded by id -- an "organization"-scope object owned by another project is not surfaced by the listing path today, only via a direct id lookup. scope describes visibility of the metastore object itself, not whether its underlying Keboola Storage table is actually reachable from every project that can see it -- a "targeted"/"organization" object's data may still need its bucket separately shared and linked (get_shared_buckets/link_shared_bucket) before a query against it will work outside the owning project. Pass resolve_data_location=True to check this directly instead of inferring it from scope alone. - An object's scope_elevation_requested_at being set means a project has asked an organization admin to promote it from "project" to "organization" scope, and the request is still pending. Treat this as a forward-looking signal: once approved, the object (a semantic-model's promotion also carries its datasets' underlying tables along) becomes visible org-wide, which may require separately sharing the physical data too -- promotion alone does not do that automatically. WHEN TO USE: - When you already know IDs of the semantic objects you want to load and want to inspect them in detail. - When you want to list all semantic objects of certain types or specific semantic models. - When you want to list semantic models. WHEN NOT TO USE: - When you need to discover semantic objects. EXAMPLES: - List all semantic models: semantic_objects=[{"object_type": "semantic-model"}] - List semantic datasets and metrics for specific semantic models: semantic_objects=[{"object_type": "semantic-dataset"}, {"object_type": "semantic-metric"}], semantic_model_ids=["model-uuid-1", "model-uuid-2"] - Get detailed context for specific semantic objects by their id: semantic_objects=[{"object_type": "semantic-dataset", "ids": ["dataset-uuid-1"]}, {"object_type": "semantic-metric", "ids": ["metric-uuid-1", "metric-uuid-2"]}] - List all constraints for specific semantic models: semantic_objects=[{"object_type": "semantic-constraint"}], semantic_model_ids=["model-uuid-1"]

get_semantic_schema

ChatGPT
Returns JSON schemas for the requested semantic object types. WHEN TO USE: - When you want to know the JSON schema of a semantic object type, e.g. before searching something specific.

get_shared_buckets

ChatGPT
Lists buckets shared with this project by other Keboola projects that are not necessarily linked into this project yet (the Data Catalog "Shared with me" view). Use this to answer "what data is shared with this project?" or "what could I link?" — get_buckets only returns buckets already in this project (including already-linked ones). Results are paginated (limit/offset) because the number of shared buckets can be large for projects in big organizations — always check total_count and the message to see whether more results exist, and page through with offset rather than assuming a single call returns everything. Use link_shared_bucket to link a shared bucket returned here into this project.

get_streams

ChatGPT
Retrieves the Data Streams in the project: sources receiving events and the sinks writing them to tables. Data Streams receive events over HTTP (webhooks, apps) or OTLP (OpenTelemetry logs/metrics/traces) and store them in Storage tables in near real time, without any component configuration. Each stream includes its endpoint_url (with the secret embedded) and, for OTLP, otlp_base_url plus otlp_secret. Give these only to the user who asked; they authenticate writes into the project. Sessions with read-only access get them hidden (secret_redacted=true). If Data Streams are not enabled in the project, the tool fails with the project feature key and a link to the Data Streams page where the user can request the feature. Tell the user how to request it. EXAMPLES: - source_ids=[] -> all Data Streams with their sinks and endpoints - source_ids=["github-webhooks"] -> only that stream

get_tables

ChatGPT
Lists tables in buckets or retrieves full details of specific tables, including fully qualified database name, column definitions, lineage references (created/updated by) and links. WHEN NOT TO USE: - Do NOT list tables across buckets just to find a table by name. Use search with item_types=["table"] instead — it also matches column names and descriptions. - Only use bucket_ids listing when you need all tables in specific known buckets. RETURNS: - With bucket_ids: Summaries of tables (ID, name, description, primary key). - With table_ids: Full details including columns, data types, and fully qualified database names. - With table_ids and include_usage: Full details plus components / transformations that use the tables in their input / output mappings. Use only when explicitly needed or evident from context; usage calculation might be demanding in big projects. COLUMN DATA TYPES: - database_native_type: The actual type in the storage backend (Snowflake, BigQuery, etc.) with precision, scale, and other implementation details - keboola_base_type: Standardized type indicating the semantic data type. May not always be available. When present, it reveals the actual type of data stored in the column - for example, a column with database_native_type VARCHAR might have keboola_base_type INTEGER, indicating it stores integer values despite being stored as text in the backend. QUERYABILITY RULE: - A table is directly queryable via query_data tool only if fullyQualifiedName is present and non-null in the response. - If fullyQualifiedName is absent or null (e.g. for linked/alias tables from other projects), the table cannot be queried via SQL from this workspace. - Do not attempt to construct or guess the FQN — it will not work. In that case, inform the user of the limitation immediately. EXAMPLES: - bucket_ids=["id1", ...] → summary info of the tables in the buckets with the specified IDs - table_ids=["id1", ...] → detailed info of the tables specified by their IDs - bucket_ids=[] and table_ids=[] → empty list; you have to specify at least one filter

modify_flow

ChatGPT
Updates an existing flow configuration (either legacy keboola.orchestrator or conditional keboola.flow) or manages schedules for this flow. PRE-REQUISITES: - Always use get_flow_schema (and get_flow_examples) for that flow type you want to update to follow the required structure and see the examples if unknown - Only pass phases/tasks when you want to replace them; omit to keep the existing ones unchanged RULES (ALL FLOWS): - flow_type must match the stored component id of the flow; do not switch flow types during update - phases and tasks must follow the schema for the selected flow type; include at least id and name - Tasks must reference existing component configurations (data app tasks an existing data_app_id); keep dependencies consistent - Run a data app from a flow with a keboola.data-app-control task whose configData is {"parameters": {"appId": "<data_app_id>"}} (data_app_id from get_data_apps), with no configId; never use keboola.data-apps + configId. Each run restarts the app with a new build and a new token, or starts it if it is stopped; add "forceRestart": false to the parameters only if the user wants a running app left as it is - Always provide a clear change_description and surface any links returned in the response to the user - A flow can have multiple schedules for automation runs. Add/update/remove schedules only if requested. - When updating a flow or a schedule, specify only the fields you want to update, others will be kept unchanged. CONDITIONAL FLOWS (keboola.flow): - Maintain a single entry phase and ensure every phase is reachable; connect phases via next transitions - No cycles or dangling phases; failed tasks already stop the flow, so only add retries/conditions if requested LEGACY FLOWS (keboola.orchestrator): - Phases run sequentially; tasks inside a phase run in parallel; dependsOn references other phase ids - Use continueOnFailure or best-effort patterns only when the user explicitly asks for them WHEN TO USE: - Renaming a flow, updating descriptions, adding/removing phases or tasks, updating schedules, adjusting dependencies, or enabling/disabling flow execution

modify_streamlit_data_app

ChatGPT
Creates or updates a Streamlit data app. Use this tool to create new data apps and to update existing Streamlit apps. Other data apps cannot be changed here; tell the user so. Considerations: - The source_code parameter must be a complete and runnable Streamlit app. It must include a placeholder {QUERY_DATA_FUNCTION} where a query_data function will be injected. This function queries the workspace to get data, it accepts a string of SQL query following current sql dialect and returns a pandas DataFrame with the results from the workspace. - The placeholder is substituted only by this tool when it saves the configuration; it is not a platform feature. A configuration written any other way (e.g. Storage API, CLI) must define query_data itself, otherwise the literal placeholder breaks the app. - Write SQL queries so they are compatible with the current workspace backend, you can ensure this by using the query_data tool to inspect the data in the workspace before using it in the data app. - If you're updating an existing data app, provide the configuration_id parameter and the change_description parameter. To keep existing data app values during an update, leave them as empty strings, lists, or None appropriately based on the parameter type. - After creating or updating a data app with this tool, ALWAYS call deploy_data_app(action="deploy", configuration_id=...) to start a new app or restart an existing app so changes take effect. Without this step, a newly created app will not start, and an existing app will keep running the previous deployment without the latest changes. - New apps use the HTTP basic authentication by default for security unless explicitly specified otherwise; when updating, set authentication_type to default to keep the existing authentication type configuration (including OIDC setups) unless explicitly specified otherwise. - authentication_type='oidc' (with the oidc argument) switches an existing app to OIDC. It is rejected on create. The tool never takes a client secret: the user enters it in the Keboola UI. Set up OIDC in this order: 1. Create the app with 'basic-auth'. The output has oidc_callback_url. 2. The user registers oidc_callback_url at the identity provider and gives you the client_id. 3. Update the app with authentication_type='oidc' and oidc (client_id, issuer_url, and optionally logout_url, allowed_roles). 4. The user enters the client secret in the app's Authentication section in the Keboola UI. If the client can open URLs, it is asked to open that page. 5. Only if you use allowed_roles: update with 'oidc' once more after the secret is saved. 6. Call deploy_data_app last. If the output has oidc_setup_required=true, tell the user to follow change_summary. In oidc, null keeps the stored logout_url / allowed_roles; '' or [] removes them. The slug stays fixed on OIDC apps. SQL & DATA TYPE RULES: - Use delimited identifiers for the current SQL dialect for all column names and aliases in SQL. Match the exact identifier case used in SQL when referencing columns in Python code. - query_data RETURNS ALL COLUMNS AS STRINGS regardless of SQL CAST. Always convert types in Python after loading: df["col"] = pd.to_numeric(df["col"], errors="coerce").fillna(0) and df["date"] = pd.to_datetime(df["date"], errors="coerce").

query_data

ChatGPT
Executes an SQL SELECT query to get the data from the underlying database. Only one read-only statement is accepted: SELECT or WITH ... SELECT, and on Snowflake also SHOW, DESCRIBE or EXPLAIN (BigQuery has none of these; query INFORMATION_SCHEMA instead). Anything else, including multiple statements, is rejected before it reaches the database. BEFORE QUERYING: Always verify the table has a non-null fullyQualifiedName from get_tables tool. If it does not, the table is not SQL-accessible from this workspace — do not attempt the query and inform user. CRITICAL SQL REQUIREMENTS: ALWAYS check the SQL dialect before constructing queries. Do not include any comments in the SQL code Use delimited identifiers and FQN format for the current SQL dialect. TABLE AND COLUMN REFERENCES: Always use fully qualified table names in the exact FQN format provided by table information tools Follow the identifier structure exactly as shown by table info tools for the current SQL dialect For every column reference, call get_tables first and copy that column's `quotedName` value VERBATIM. Do not guess the name, re-case it, or hand-quote it yourself — use the exact `quotedName` from get_tables. Snowflake case trap: unquoted identifiers fold to UPPERCASE while quoted identifiers are case-sensitive, so hand-quoting a guessed lowercase name (e.g. "date") fails with invalid identifier even though the column physically exists as DATE. The quotedName from get_tables already carries the correct case and dialect quoting, so copying it avoids this. CTE (WITH CLAUSE) RULES: ALL column references in main query MUST match exact case used in the CTE If you alias a column in a CTE, reference it under the aliased name in the subsequent queries Define all column aliases explicitly in CTEs Use delimited identifiers in both CTE definition and references to preserve case FUNCTION COMPATIBILITY: Check data types before using date functions (DATE_TRUNC, EXTRACT require proper date/timestamp types) Cast VARCHAR columns to appropriate types before using in date/numeric functions ERROR PREVENTION: Keboola Storage stores empty cells as empty strings ('') rather than NULL — even for columns reported as VARCHAR/STRING with nullable=false — so casting a text column straight to numeric/date/timestamp throws (`Numeric value '' is not recognized` on Snowflake, `Bad double value` on BigQuery). When casting, use the dialect-safe cast: on Snowflake TRY_CAST(x AS ...) (or TRY_TO_DATE/TRY_TO_NUMBER), which returns NULL instead of erroring; on BigQuery SAFE_CAST(x AS ...) — BigQuery has NO TRY_CAST. Alternatively wrap the column with NULLIF(col, '') before CAST. This is defensive against empty strings, not a guarantee for genuinely non-numeric or non-date values. For numeric casts always specify precision and scale so fractional values survive: on Snowflake use `TRY_CAST(x AS NUMBER(38,9))` or `TRY_TO_NUMBER(x, 38, 9)` (never bare `NUMBER`/`DECIMAL`/`NUMERIC`, which mean `NUMBER(38,0)` and silently round `'3.75'` to 4); on BigQuery use `NUMERIC`/`BIGNUMERIC` (never bare `INT64`, which truncates). Use `FLOAT`/`DOUBLE`/`FLOAT64` only for ratios/averages. Check for division by zero using NULLIF(denominator, 0) * Always use the LIMIT clause in your SELECT statements when fetching data. There are hard limits imposed by this tool on the maximum number of rows that can be fetched and the maximum number of characters. The tool will truncate the data if those limits are exceeded. Pick the LIMIT to match the actual need: - Use a small LIMIT (<=100) for inspection, sampling, or checking distinct values. - Compute aggregates (COUNT, GROUP BY, SUM, AVG, etc.) in SQL rather than pulling raw rows to aggregate them yourself — a large LIMIT does not make row-level aggregation in context correct or efficient. - Only use a large LIMIT when the user explicitly asked for row-level data. - A truncated result is a contiguous prefix of the query's output, not a random sample: any aggregate computed over truncated data is wrong, not just incomplete. DATA V…

run_job

ChatGPT
Starts a new job for a given component or transformation.

search_semantic_context

ChatGPT
Searches semantic models and semantic objects using regex patterns matched against their names, descriptions and stringified JSON attributes. Returns compact matches grouped by semantic model. Each match includes the semantic object type, the paths where the patterns matched, and compact object view. CONSIDERATIONS: - The search is case-insensitive by default. Use case_sensitive=True when exact casing matters. - The search is performed against semantic object names and data attributes which are stringified JSON objects following their corresponding JSON schema. - The search can be scoped to specific semantic models or semantic object types but prefer broader search without scoping unless required by the context. - Matches carry the same scope/project_id/source_project_id/target_project_ids fields as get_semantic_context -- see that tool's CONSIDERATIONS for what they mean and imply. WHEN TO USE: - When you need to discover which semantic objects are relevant to a user request. - When you know business terms, column names, metric fragments, or rule names, but not exact object UUIDs. - When you need to find semantic objects by keyword or values used in their attributes. WHEN NOT TO USE: - When you know the exact IDs. EXAMPLES: - Find semantic objects by business concepts for revenue or sales: patterns=["revenue", "sales"] - Find semantic objects using a Keboola table ID: patterns=["out.c-sales-main.fact_orders"] - Find semantic dataset for a certain table: patterns=["in.c-sales-main.fact_orders"], semantic_types=["semantic-dataset"] - Find semantic datasets that mention a column name: patterns=["column_name"], semantic_types=["semantic-dataset"] - Search semantic objects e.g. semantic metrics, relationships, and constraints using a certain semantic dataset: patterns=["table-id-of-the-dataset"], semantic_types=["semantic-metric", "semantic-relationship", "semantic-constraint"] - Search semantic constraints using e.g. certain semantic metrics and certain semantic datasets: patterns=["metric-name-1", "metric-name-2", "table-id-from-the-dataset"], semantic_types=["semantic-metric", "semantic-relationship"] - Search something within specific semantic models only: patterns=["something"], semantic_model_ids=["<semantic-model-uuid-1>", "<semantic-model-uuid-2>"]

set_project_scope

ChatGPT
Scopes the current session to a set of Keboola projects. Mints a scoped access token (narrowed to project_ids, optionally read-only) that is used for the rest of the conversation. Read-only tools then run against every scoped project in a single call; write/modify/delete tools take a project_id argument naming which scoped project to target (required once 2+ projects are scoped). Call this when the user states which projects to work on; it can be called again any time to re-scope. On most transports the server does not remember this scope between calls: pass the returned scope_token as the scope_token argument on every subsequent tool call in this conversation to keep it in effect. Not needed for a local server or an OAuth-authenticated session, both of which persist the confirmed scope server-side instead -- scope_token is null there.

update_config

ChatGPT
Updates an existing root component configuration by modifying its parameters, storage mappings, name or description. Not for SQL transformations (keboola.snowflake-transformation / keboola.google-bigquery-transformation), data apps (keboola.data-apps) or flows — use the dedicated tools (see WHEN NOT TO USE). This IS the tool for updating Python (keboola.python-transformation-v2), R (keboola.r-transformation-v2) and DuckDB (keboola.duckdb-transformation) transformations. This tool allows PARTIAL parameter updates - you only need to provide the fields you want to change. All other fields will remain unchanged. Use this tool when modifying existing configurations; for configuration rows, use update_config_row instead. WHEN TO USE: - Modifying configuration parameters (credentials, settings, API keys, etc.) - Updating storage mappings (input/output tables or files) - Changing configuration name or description - Any combination of the above WHEN NOT TO USE: - keboola.orchestrator / keboola.flow → use update_flow - keboola.data-apps → use modify_streamlit_data_app / deploy_data_app - keboola.snowflake-transformation / keboola.google-bigquery-transformation → use update_sql_transformation PREREQUISITES: - Configuration must already exist (use create_config for new configurations) - You must know both component_id and configuration_id - For parameter updates: Review the component's root_configuration_schema using get_components. - For storage updates: Ensure mappings are valid for the component type IMPORTANT CONSIDERATIONS: - Parameter updates are PARTIAL - only specify fields you want to change - parameter_updates supports granular operations: set keys, replace strings, remove keys, or append to lists - Parameters must conform to the component's root_configuration_schema - Validate schemas before calling: use get_components to retrieve root_configuration_schema - For row-based components, this updates the ROOT only (use update_config_row for individual rows) WORKFLOW: 1. Retrieve current configuration using get_configs (to understand current state) 2. Identify specific parameters/storage mappings to modify 3. Prepare parameter_updates list with targeted operations 4. Call update_config with only the fields to change

update_config_row

ChatGPT
Updates an existing component configuration row by modifying its parameters, storage mappings, name, or description. This tool allows PARTIAL parameter updates - you only need to provide the fields you want to change. All other fields will remain unchanged. Configuration rows are individual items within a configuration, often representing separate data sources, tables, or endpoints that share the same component type and parent configuration settings. WHEN TO USE: - Modifying row-specific parameters (table sources, filters, credentials, etc.) - Updating storage mappings for a specific row (input/output tables or files) - Changing row name or description - Any combination of the above WHEN NOT TO USE: - keboola.orchestrator / keboola.flow → use update_flow - keboola.data-apps → use modify_streamlit_data_app / deploy_data_app - keboola.snowflake-transformation / keboola.google-bigquery-transformation → use update_sql_transformation PREREQUISITES: - The configuration row must already exist (use add_config_row for new rows) - You must know component_id, configuration_id, and configuration_row_id - For parameter updates: Review the component's row_configuration_schema using get_components - For storage updates: Ensure mappings are valid for row-level storage IMPORTANT CONSIDERATIONS: - Parameter updates are PARTIAL - only specify fields you want to change - parameter_updates supports granular operations: set individual keys, replace strings, or remove keys - Parameters must conform to the component's row_configuration_schema (not root schema) - Validate schemas before calling: use get_components to retrieve row_configuration_schema - Each row operates independently - changes to one row don't affect others - Row-level storage is separate from root-level storage configuration WORKFLOW: 1. Retrieve current configuration using get_configs to see existing rows 2. Identify the specific row to modify by its configuration_row_id 3. Prepare parameter_updates list with targeted operations for this row 4. Call update_config_row with only the fields to change

update_descriptions

ChatGPT
Updates the description for a Keboola storage item. This tool supports three item types, inferred from the provided item_id: - bucket: item_id = "in.c-bucket" - table: item_id = "in.c-bucket.table" - column: item_id = "in.c-bucket.table.column" Usage examples (payload uses a list of DescriptionUpdate objects): - Update a bucket: updates=[DescriptionUpdate(item_id="in.c-my-bucket", description="New bucket description")] - Update a table: updates=[DescriptionUpdate(item_id="in.c-my-bucket.my-table", description="New table description")] - Update a column: updates=[DescriptionUpdate(item_id="in.c-my-bucket.my-table.my_column", description="New column description")]

update_flow

ChatGPT
Updates an existing flow configuration (either legacy keboola.orchestrator or conditional keboola.flow). PRE-REQUISITES: - Always use get_flow_schema (and get_flow_examples) for that flow type you want to update to follow the required structure and see the examples if unknown - Only pass phases/tasks when you want to replace them; omit to keep the existing ones unchanged RULES (ALL FLOWS): - flow_type must match the stored component id of the flow; do not switch flow types during update - phases and tasks must follow the schema for the selected flow type; include at least id and name - Tasks must reference existing component configurations (data app tasks an existing data_app_id); keep dependencies consistent - Run a data app from a flow with a keboola.data-app-control task whose configData is {"parameters": {"appId": "<data_app_id>"}} (data_app_id from get_data_apps), with no configId; never use keboola.data-apps + configId. Each run restarts the app with a new build and a new token, or starts it if it is stopped; add "forceRestart": false to the parameters only if the user wants a running app left as it is - Always provide a clear change_description and surface any links returned in the response to the user CONDITIONAL FLOWS (keboola.flow): - Maintain a single entry phase and ensure every phase is reachable; connect phases via next transitions - No cycles or dangling phases; failed tasks already stop the flow, so only add retries/conditions if requested LEGACY FLOWS (keboola.orchestrator): - Phases run sequentially; tasks inside a phase run in parallel; dependsOn references other phase ids - Use continueOnFailure or best-effort patterns only when the user explicitly asks for them WHEN TO USE: - Renaming a flow, updating descriptions, adding/removing phases or tasks, adjusting dependencies, or enabling/disabling flow execution

update_project_description

ChatGPT
Updates the description of the current Keboola project.

update_sql_transformation

ChatGPT
Updates an existing SQL transformation configuration by modifying its SQL code, storage mappings, name or description. This tool allows PARTIAL parameter updates for transformation SQL blocks and code - you only need to provide the operations you want to perform. All other fields will remain unchanged. Use this for modifying SQL transformations created with create_sql_transformation. WHEN TO USE: - SQL transformations only (Snowflake/BigQuery); use update_config for Python/R/DuckDB transformations - Modifying SQL queries in transformation (add/edit/remove SQL statements) - Updating transformation block or code block names - Changing input/output table mappings for the transformation - Updating the transformation name or description - Any combination of the above PREREQUISITES: - Transformation must already exist (use create_sql_transformation for new transformations) - You must know the configuration_id of the transformation - SQL dialect is determined automatically from the workspace - CRITICAL: Use get_configs first to see the current transformation structure and get block_id/code_id values TRANSFORMATION STRUCTURE: A transformation has this hierarchy: transformation └─ blocks[] - List of transformation blocks (each has a unique block_id) └─ block.name - Descriptive name for the block └─ block.codes[] - List of code blocks within the block (each has a unique code_id) └─ code.name - Descriptive name for the code block └─ code.script - SQL script (string with SQL statements) Example structure from get_configs: { "blocks": [ { "id": "b0", ← block_id needed for operations (format: b{index}) "name": "Data Preparation", "codes": [ { "id": "b0.c0", ← code_id needed for operations (format: b{block_index}.c{code_index}) "name": "Load customers", "script": "SELECT FROM customers WHERE status = 'active';" } ] } ] } PARAMETER UPDATE OPERATIONS: All operations use block_id and code_id to identify elements (get these from get_configs first). ID Format: - block_id: "b0", "b1", "b2", etc. (format: b{index}) - code_id: "b0.c0", "b0.c1", "b1.c0", etc. (format: b{block_index}.c{code_index}) 1. BLOCK OPERATIONS: - add_block: Create a new block in the transformation {"op": "add_block", "block": {"name": "New Block", "codes": []}, "position": "end"} - remove_block: Delete an entire block {"op": "remove_block", "block_id": "b0"} - rename_block: Change a block's name {"op": "rename_block", "block_id": "b2", "block_name": "Updated Name"} 2. CODE BLOCK OPERATIONS: - add_code: Create a new code block within an existing block {"op": "add_code", "block_id": "b1", "code": {"name": "New Code", "script": "SELECT 1;"}, "position": "end"} - remove_code: Delete a code block {"op": "remove_code", "block_id": "b0", "code_id": "b0.c0"} - rename_code: Change a code block's name {"op": "rename_code", "block_id": "b1", "code_id": "b1.c2", "code_name": "Updated Name"} 3. SQL SCRIPT OPERATIONS: - set_code: Replace the entire SQL script (overwrites existing) {"op": "set_code", "block_id": "b0", "code_id": "b0.c0", "script": "SELECT FROM new_table;"} - add_script: Append or prepend SQL to existing script (preserves existing) {"op": "add_script", "block_id": "b2", "code_id": "b2.c1", "script": "WHERE date > '2024-01-01'", "position": "end"} - str_replace: Find and replace text in SQL scripts {"op": "str_replace", "search_for": "old_table", "replace_with": "new_table", "block_id": "b0",' "code_id": "b0.c0"} - Omit code_id to replace in all codes of a block - Omit both block_id and code_id to replace everywhere IMPORTANT CONSIDERATIONS: - Parameter updates are PARTIAL - only the operations you specify are applied - All other parts of the transformation remain unchanged - Each SQL script must be executable and follow the current SQL dialect: - Use delimited identifiers for the current SQL dialect. - Never mix delimiter styles within a single query. - Storage configuration is COMPLETE REPLACEMENT - include ALL mappings you want to keep - Leave updated_description empty to preserve the original description - SCHEMA CHANGES: Destructive schema changes (removing colu…

validate_semantic_query

ChatGPT
Performs best-effort semantic validation of an SQL query against one or more semantic models and compares it with the expected semantic objects provided. RETURNS: - validation_auto_detected: semantic validation built from objects heuristically detected in the SQL - validation_detected_from_expected: semantic validation built only from explicitly provided expected object IDs - expected semantic objects that were matched or missing in the auto-detected result - unexpected auto-detected objects outside the expected semantic scope LIMITATIONS: - Detection is heuristic and based on string matching over SQL and semantic metadata. - The tool does not parse SQL semantically and does not execute the query. - Auto-detected objects, missing objects, and relationship matches may therefore be imperfect. - Use the result as a best-effort semantic check, not as a formal proof that the query is correct. CONSIDERATIONS: - Prefer calling this tool before executing any SQL that touches semantic objects. - This tool confirms the SQL dialect, surfaces semantic constraint violations, and provides post-execution checks. - Only proceed to query_data once this tool returns valid=True and violations is empty. If violations are found, fix the query first or consider the limitations of this tool. - Besides constraint findings, violations flags SQL that contradicts the model itself: a join between two datasets on keys their relationship does not define (join_key_mismatch, error), and an aggregate that matches no defined metric (undefined_metric, warning). - Entries under semantic_models carry scope/project_id/source_project_id/ target_project_ids -- see get_semantic_context's CONSIDERATIONS for what they mean. A "targeted"/"organization"-scope model does not guarantee the query is actually runnable from every project that can see it; this tool validates against the semantic layer, not against whether the underlying Storage tables are reachable here. Pass resolve_data_location=True to check that directly for every used dataset instead of inferring it from scope alone. WHEN TO USE: - Before generating or approving a query that should follow a semantic model. - When you want to validate a SQL query against the semantic objects before executing it using "query_data" tool or creating a new SQL transformation out of it, especially when investigating data quality issues. - When you want to verify that a query uses the intended semantic objects. - When you need to surface semantic business-rule violations or follow-up checks. EXAMPLES: - Validate a SQL query against one semantic model: sql_query="SELECT SUM(\"REVENUE\") FROM ...", semantic_model_ids=["semantic-model-uuid"], expected_semantic_objects=[{"object_type": "semantic-dataset"}] - Validate a cross-model query against two semantic models: sql_query="SELECT * FROM ...", semantic_model_ids=["model-uuid-1", "model-uuid-2"], expected_semantic_objects=[{"object_type": "semantic-dataset", "ids": ["dataset-uuid-1"]}] - Validate a query and compare it against expected objects: sql_query="SELECT SUM(\"REVENUE\") FROM ...", semantic_model_ids=["semantic-model-uuid"], expected_semantic_objects=[{"object_type": "semantic-metric", "ids": ["metric-uuid-1"]}]

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/keboola"><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/keboola)