plug.directory
Add my server

Peaka

by ramamatarco.huggingface.ramamatar/peaka

  • Remote endpoint
  • 134 tools
  • peaka_delete__ai_agent_projectId_threads_threadId Delete ai-agent thread
  • peaka_delete__connections_projectId_connectionId Deletes the specified Connection. Any catalogs using this connection will lose access to their data source.
  • peaka_delete__data_projects_projectId_bitable_tableName Permanently deletes the specified [Peaka BI Table](https://docs.peaka.com/connecting-your-data/peaka-bi-table) and all its data from the project. This action is irreversible — all rows, columns, and schema definitions associated with the BI Table will be removed.
  • peaka_delete__data_projects_projectId_bitable_tableName_columns_columnName Permanently removes a column from the specified [Peaka BI Table](https://docs.peaka.com/connecting-your-data/peaka-bi-table). This action is irreversible — the column and all its stored data will be deleted from the BI Table.
  • peaka_delete__data_projects_projectId_cache_cacheId Permanently deletes a cache and all its associated data. This operation: - Cancels any running or scheduled sync workflows (both incremental and full refresh). - Drops the cached table from the internal BigTable store. - Removes all cache settings, execution history, and status records. This action is irreversible. To re-cache the table, a new cache must be created from scratch.
  • peaka_delete__data_projects_projectId_catalogs_catalogId Permanently removes the specified catalog from the project. This disconnects the underlying data source and makes all its schemas and tables unavailable for querying. This action is irreversible.
  • peaka_delete__data_projects_projectId_catalogs_catalogId_parametricTables Deletes a Parametric Table identified by its target schema and table name. The original source table is not affected.
  • peaka_delete__data_projects_projectId_exports_exportId Cancels a PENDING/RUNNING export (kills the running query and cleans up partial artifacts). A no-op on an already-finished job. Idempotent.
  • peaka_delete__data_projects_projectId_queries_folders_folderId Deletes a query folder by its ID. By default, only empty folders can be deleted. Set force=true to recursively delete the folder along with all its sub-folders and contained queries.
  • peaka_delete__data_projects_projectId_queries_queryId Permanently deletes a query by its ID.
  • peaka_delete__data_projects_projectId_semantic_catalogs_catalogId_table_tableId Deletes the specified Semantic Table from a Semantic Catalog.
  • peaka_delete__data_projects_projectId_table_tableName Permanently deletes the specified [Peaka Table](https://docs.peaka.com/connecting-your-data/peaka-table) and all its data from the project. This action is irreversible — all rows, columns, and schema definitions associated with the table will be removed.
  • peaka_delete__data_projects_projectId_table_tableName_columns_columnName Permanently removes a column from the specified [Peaka Table](https://docs.peaka.com/connecting-your-data/peaka-table). This action is irreversible — the column and all its stored data will be deleted from the table.
  • peaka_delete__metadata_projectId_categorical_catalogId_schemaName_tableName_columnName Delete categorical values from the column meta and remove the scheduled job
  • peaka_delete__metadata_projectId_golden_sqls_id Delete golden sql from the project.
  • peaka_delete__metadata_projectId_refresh_callback Unregister Metadata Refresh Job Callback
  • peaka_delete__metadata_projectId_relations_catalogId_schemaName_tableName_relationId Delete Relation From Metadata
  • peaka_delete__organizations_organizationId_workspaces_workspaceId Deletes a specified Workspace within an Organization. A Workspace is a collaborative environment that groups Projects to facilitate team collaboration and resource management. The hierarchical structure in Peaka is: <code>Organization (top-level) → Workspace → Project</code>
  • peaka_delete__organizations_organizationId_workspaces_workspaceId_projects_projectId Deletes the specified Project within a Workspace. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.
  • peaka_delete__projects_projectId <strong>Deprecated.</strong> Use the <code>Delete Project</code> endpoint under Organization instead. Deletes the specified Project. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.
  • peaka_delete__projects_projectId_apiKeys_apiKeyId Deletes the specified API Key. Once deleted, any requests authenticated with this key will be rejected.
  • peaka_get__ai_agent_projectId_threads List ai-agent threads
  • peaka_get__ai_agent_projectId_threads_threadId Get ai-agent thread
  • peaka_get__ai_agent_workflow_png Get png image of current ai workflow
  • peaka_get__connections_config List all connection configurations. This will return a list of all connection configurations available in the system.
  • peaka_get__connections_config_connectionType Returns the configuration schema for a specific connection type, including required credential fields and their types. Use this to understand what parameters are needed when creating a connection of this type.
  • peaka_get__connections_projectId Retrieves all connections for the specified Project. A Connection represents an authenticated link to an external data source (e.g., Stripe, Airtable, PostgreSQL).
  • peaka_get__connections_projectId_connectionId Returns details of a specified Connection.
  • peaka_get__connections_projectId_connectionId_detail Get connection detail by ID. Returns only non-sensitive information.
  • peaka_get__data_projects_projectId_bitable Lists all [Peaka BI Tables](https://docs.peaka.com/connecting-your-data/peaka-bi-table) in the project. Peaka BI Table is a robust data management solution optimized for handling large datasets of over one million records. It uses a column-oriented data storage approach, resulting in exceptionally fast filtering and grouping performance without requiring additional indexing. It is particularly well-suited for event data and bulk insertions, though it does not support JSON data types. See also: [Differences of Peaka Table and Peaka BI Table](https://docs.peaka.com/connecting-your-data/differences-of-peaka-table-and-peaka-bi-table)
  • peaka_get__data_projects_projectId_bitable_tableName_columns Lists all columns defined in the specified [Peaka BI Table](https://docs.peaka.com/connecting-your-data/peaka-bi-table). Returns column metadata including name, data type, display name, default value, and constraints such as nullability and uniqueness. Note that Peaka BI Table does not support JSON data types.
  • peaka_get__data_projects_projectId_cache_cacheId Retrieves the configuration of a specific cache, including the target catalog, schema, table, and the configured incremental and full refresh schedules. Use this endpoint to inspect a cache's current settings before updating them, or to confirm the schedule configuration of a cache after creation. To check the runtime status (last execution, progress, errors) of the cache, use the Get Cache Status endpoint instead.
  • peaka_get__data_projects_projectId_cache_cacheId_executionHistory Returns a paginated list of past sync executions for the specified cache, ordered from most recent to oldest. Each entry corresponds to one sync run (either incremental or full refresh) and includes its status, progress counters, error details (if failed), and lifecycle timestamps. The `executionMode` field on each entry indicates whether that run was an incremental sync or a full refresh. Use the `limit` and `offset` query parameters to page through history; defaults are `limit=10` and `offset=0`. Execution records have a retention window of 14 days after the cache or run is finalised, after which they are automatically removed.
  • peaka_get__data_projects_projectId_cache_cacheId_status Returns the current status of a specific cache, including execution details for both the last incremental sync and the last full refresh. The top-level `status` field is computed from the most recent execution across both sync types: - `NOT_INITIALIZED`: No sync has ever been executed for this cache. - `RUNNING`: At least one sync (incremental or full refresh) is currently in progress. - `COMPLETED`: The most recent sync completed successfully. - `FAILED`: The most recent sync failed. Check the `error` field in the relevant execution info for details. - `CANCELLED`: The most recent sync was cancelled via a cancel endpoint. Each execution info object (`lastIncrementalCacheExecution`, `lastFullRefreshCacheExecution`) contains: - `id`: Unique execution identifier. - `status`: Execution-specific status (RUNNING, COMPLETED, FAILED, CANCELLED). - `progress`: Real-time progress with record counts (cached, inserted, updated, deleted). - `error`: Error details if the execution failed. - `create
  • peaka_get__data_projects_projectId_cache_status Returns the status of all caches within a project. Each entry in the response array contains the same status information as the single cache status endpoint, including execution details for both sync types. This is useful for building a dashboard view that shows the health and progress of all cached tables in a project.
  • peaka_get__data_projects_projectId_catalog_catalogId_cache_status Returns the status of all caches within a specific catalog of a project. This filters the cache list to only those belonging to the given catalog, which is useful when managing caches per data source connection. Each entry in the response array contains the same status information as the single cache status endpoint.
  • peaka_get__data_projects_projectId_catalog_catalogId_schema_schemaName_cache_status Returns the status of all caches within a specific schema of a catalog. This is a narrower filter than the catalog-level status endpoint, useful when a single catalog contains many schemas and only a subset is of interest. Each entry in the response array contains the same status information as the single cache status endpoint.
  • peaka_get__data_projects_projectId_catalogs Returns all catalogs registered in the specified project. Each catalog represents a data source connected to Peaka, such as Airtable, Stripe, or an internal Peaka storage. Built-in catalog types like `internal` (Peaka Tables and BI Tables) and `query` (Peaka Queries) are always present.
  • peaka_get__data_projects_projectId_catalogs_catalogId Retrieves the details of a single catalog by its ID. Returns the catalog's name, display name, catalog type, and the associated connection ID.
  • peaka_get__data_projects_projectId_catalogs_catalogId_parametricTables Lists all Parametric Tables defined under the specified catalog. A Parametric Table is a pre-configured view of a REST-based table with fixed query parameter values (e.g., `_q_account`), allowing it to be queried like a regular table without passing those parameters each time.
  • peaka_get__data_projects_projectId_catalogs_catalogId_schemas Returns all schemas available under the specified catalog. Schemas are logical groupings of tables within a catalog. For external connectors, schemas typically correspond to databases or namespaces exposed by the data source.
  • peaka_get__data_projects_projectId_catalogs_catalogId_schemas_schemaName_tables Lists all tables available under the specified schema of a catalog. Each table entry includes its catalog and schema context along with caching metadata (`isCacheable`, `isDynamicTable`, `isCached`, `supportedCacheTypes`). `supportedCacheTypes` lists the cache types (`FULL_REFRESH`, `INCREMENTAL`) that can be used when creating a cache for the table; it is empty when the table is not cacheable, and absent when capability information could not be resolved. For the internal catalog, this includes [Peaka Tables](https://docs.peaka.com/connecting-your-data/peaka-table) and [Peaka BI Tables](https://docs.peaka.com/connecting-your-data/peaka-big-table).
  • peaka_get__data_projects_projectId_catalogs_catalogId_schemas_schemaName_tables_tableName_columns Lists all columns for a specific table within a catalog. Returns full column metadata including name, data type, display name, default value, and constraints (nullability, uniqueness). Some connectors expose additional virtual columns (prefixed with `_q_`) that can be used to pass query-time parameters to the data source.
  • peaka_get__data_projects_projectId_catalogs_catalogId_schemas_schemaName_tables_tableName_isCached Checks whether the specified table has an active cache in Peaka. When a table is cached, its data is stored locally in Peaka, enabling significantly faster query performance compared to live queries against the original data source. Returns `isCached: true` if a cache is currently active, or `false` otherwise. The response also carries `isCacheable` and `supportedCacheTypes` (`FULL_REFRESH`, `INCREMENTAL`), so a single call is enough to decide whether — and with which schedule types — a cache can be created for the table. `supportedCacheTypes` is empty when the table is not cacheable; both fields are absent when the information could not be resolved.
  • peaka_get__data_projects_projectId_catalogs_catalogId_schemas_schemaName_tables_tableName_statistics Returns statistical metadata for the specified table. Includes per-column `distinctFraction` values, which represent the estimated fraction of distinct values in a column relative to the total row count. These statistics are used internally by Peaka's query optimizer to improve query planning and execution performance.
  • peaka_get__data_projects_projectId_exports Returns the project's export jobs, newest first. Files are omitted from the list (call the single-export endpoint for download URLs); each item still carries `downloadable`.
  • peaka_get__data_projects_projectId_exports_exportId Returns the status of a single export job. For a SUCCEEDED job owned by the caller, `files` carries freshly-presigned download URLs; non-owners get the row with `downloadable=false`.
  • peaka_get__data_projects_projectId_materialized_queries_queryId_status Returns refresh status and schedule information for a single materialized query.
  • peaka_get__data_projects_projectId_materialized_queries_status Returns refresh status and schedule information for all materialized queries in the project.
  • peaka_get__data_projects_projectId_queries Returns all queries belonging to the given project. Each query includes its path and folderId if it is placed in a folder.
  • peaka_get__data_projects_projectId_queries_folders Returns all query folders belonging to the given project as a flat list.
  • peaka_get__data_projects_projectId_queries_folders_folderId Returns a single folder by its ID, including its direct child folders and the queries it contains.
  • peaka_get__data_projects_projectId_queries_folders_tree Returns the folder hierarchy as a tree structure. Optionally includes queries within each folder node. Use rootFolderId to get a subtree starting from a specific folder.
  • peaka_get__data_projects_projectId_queries_queryId Returns a single query by its ID. Includes path and folderId if the query is placed in a folder.
  • peaka_get__data_projects_projectId_table Lists all [Peaka Tables](https://docs.peaka.com/connecting-your-data/peaka-table) in the project. Peaka Table is an internal relational database within Peaka that allows you to organize and manage data efficiently. It supports structured data storage and enables you to add, delete, filter, and edit your data, including JSON data types. It is best suited for smaller datasets requiring frequent edits and broader data type support. See also: [Differences of Peaka Table and Peaka BI Table](https://docs.peaka.com/connecting-your-data/differences-of-peaka-table-and-peaka-bi-table)
  • peaka_get__data_projects_projectId_table_tableName_columns Lists all columns defined in the specified [Peaka Table](https://docs.peaka.com/connecting-your-data/peaka-table). Returns column metadata including name, data type, display name, default value, and constraints such as nullability and uniqueness.
  • peaka_get__data_projects_projectId_table_tableName_sample Returns a downloadable sample CSV file for the specified internal table in a project. This CSV sample contains a few rows of mock or representative data from the table's schema. It helps users understand the structure of the table and prepare matching CSV files for import. #### Response - Content-Type: `text/csv` - Disposition: Attachment (`sample.csv`) - The first row contains column headers. - The following rows contain example values for each column. #### Example Output ``` text,num19,numcol,decimalcol "sample text",1176,1044,77.3711303273 "sample text",9354,7923,96.6658831270 "sample text",7658,8750,30.3928941706 ``` This sample can be used as a template when preparing files to upload using the `/import` endpoint.
  • peaka_get__metadata_projectId Get Project Metadata
  • peaka_get__metadata_projectId_golden_sql_query Semantic query golden sqls for the project.
  • peaka_get__metadata_projectId_golden_sqls List of golden sqls for the project.
  • peaka_get__metadata_projectId_query Semantic query metadata for the project.
  • peaka_get__metadata_projectId_questions_generate Generate sample ai questions for the project
  • peaka_get__metadata_projectId_refresh_callback Get Metadata Refresh Job Callback
  • peaka_get__metadata_projectId_refresh_catalogId Get Metadata Refresh Job Status
  • peaka_get__metadata_projectId_relations_catalogId Get Project Catalog Metadata Relations
  • peaka_get__organizations Retrieves all the organizations accessible by the authenticated user. An Organization is the highest-level resource that can contain multiple Workspaces.
  • peaka_get__organizations_organizationId Returns the specified Organization. An Organization is the highest-level resource that can contain multiple Workspaces.
  • peaka_get__organizations_organizationId_workspaces Returns all workspaces under the specified Organization. A Workspace is a collaborative environment within an Organization that groups Projects together. It facilitates team collaboration, resource management, and organization of data operations. The hierarchical structure in Peaka is: <code>Organization (top-level) → Workspace → Project</code> Projects contain data catalogs and workflows that teams manage within a Workspace.
  • peaka_get__organizations_organizationId_workspaces_workspaceId Returns details of a specified Workspace, which is a collaborative environment within an Organization that groups Projects together. A Workspace facilitates team collaboration, resource management, and organization of data operations. The hierarchical structure in Peaka is: <code>Organization (top-level) → Workspace → Project</code> Projects contain data catalogs and workflows that teams manage within a Workspace.
  • peaka_get__organizations_organizationId_workspaces_workspaceId_projects Fetches all Projects within the given Workspace. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.
  • peaka_get__organizations_organizationId_workspaces_workspaceId_projects_projectId Returns details of a specified Project. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.
  • peaka_get__projects <strong>Deprecated.</strong> Use the <code>List Projects</code> endpoint under Organization instead. Retrieves all Projects accessible by the authenticated user. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.
  • peaka_get__projects_projectId <strong>Deprecated.</strong> Use the <code>Read Project</code> endpoint under Organization instead. Returns details of a specified Project. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.
  • peaka_get__projects_projectId_apiKeys Retrieves all API Keys associated with the specified Project.
  • peaka_get__supportedDrivers Returns connection strings for all supported drivers (JDBC, SQL Alchemy). These can be used to connect to Peaka's query engine from external tools.
  • peaka_get__supportedDrivers_jdbc Returns the JDBC connection string for connecting to Peaka's query engine from JDBC-compatible tools.
  • peaka_get__supportedDrivers_sql_alchemy Returns the SQL Alchemy connection string for connecting to Peaka's query engine. SQL Alchemy supports only one catalog at a time, so a <code>catalogName</code> must be provided.
  • peaka_get__ui_initSession <strong>Deprecated.</strong> Use <code>POST /ui/initSession</code> instead, which supports feature flags, session modes, and additional configuration options. Initializes an Embedded Peaka session and returns a session URL. The returned URL can be used to embed the Peaka UI in an iframe.
  • peaka_post__ai_agent_projectId_chat Chat with agent
  • peaka_post__ai_agent_projectId_chat_stream Chat with agent via stream
  • peaka_post__connections_projectId This endpoint allows you to create a new connection for a specified project. You need to provide the project ID and the connection details in the request body. The connection details include the name, type, and credentials required for the connection. Depending on the connection type, additional parameters may be required under credentials. You can view the list of supported connection types by calling the /connections/config endpoint. You can switch examples from the second dropdown of the sample request component. (cURL (first dropdown) - Stripe Connection Request (second dropdown)) **Note**: Typically, the connection creation process involves the following steps: 1. First, learn about the connection type and the required parameters by calling the /connections/config endpoint. 2. Create a connection request with the required parameters. 3. If the connection requires Oauth2 authorization, there may be additional steps to follow. See https://docs.peaka.com/how-to-guides/how-to-create-o
  • peaka_post__connections_projectId_oauth2 This callback/webhook is used while creating a new connection with Oauth2. See https://docs.peaka.com/how-to-guides/how-to-create-oauth2-based-connections-via-peaka for more information.
  • peaka_post__data_projects_projectId_bitable_tableName Creates a new [Peaka BI Table](https://docs.peaka.com/connecting-your-data/peaka-bi-table) with the given name in the specified project. Peaka BI Table uses a column-oriented storage approach optimized for large datasets of over one million records, offering fast filtering and grouping performance without additional indexing. It is particularly well-suited for event data and bulk insertions. Note that JSON data type is not supported. See also: [Differences of Peaka Table and Peaka BI Table](https://docs.peaka.com/connecting-your-data/differences-of-peaka-table-and-peaka-bi-table)
  • peaka_post__data_projects_projectId_bitable_tableName_columns Adds one or more columns to the specified [Peaka BI Table](https://docs.peaka.com/connecting-your-data/peaka-bi-table). Each column definition includes its name, data type, display name, optional default value, and constraints (nullability, uniqueness). Peaka BI Table supports VARCHAR, BIGINT, BOOLEAN, TIMESTAMP, TIME, DATE, UUID, and DECIMAL data types. Note that JSON data type is not supported in Peaka BI Table.
  • peaka_post__data_projects_projectId_cache Creates a new cache for a specific table in a catalog. Caching copies data from an external data source into the internal Peaka BigTable store for faster query performance. Not every table can be cached: check `isCacheable` and `supportedCacheTypes` in the List Tables response before creating a cache. `supportedCacheTypes` tells which of the modes below are available for the table (`FULL_REFRESH`, `INCREMENTAL`). The cache can be configured in three modes: - **One-time cache**: No schedules provided. Data is cached once during creation and never automatically refreshed. - **Scheduled incremental updates**: Provide `incrementalCacheSchedule` to periodically sync only the changes (inserts, updates, deletes) since the last sync. - **Scheduled full refresh + incremental**: Provide both `fullRefreshCacheSchedule` and `incrementalCacheSchedule`. Full refresh drops and rebuilds the entire cached table periodically, while incremental updates run more frequently between full refreshes. After
  • peaka_post__data_projects_projectId_cache_batch Creates multiple caches in a single request. Each item in the array follows the same schema as the single create cache endpoint. Caches are created independently; if one fails, the others may still succeed. The response contains a list of results, one per requested cache, each indicating success or failure. On success, the created cache object is included. On failure, the error message is provided. This is useful when enabling caching for multiple tables at once (e.g. during initial project setup).
  • peaka_post__data_projects_projectId_cache_cacheId_cancelFullRefreshUpdate Cancels a currently running full refresh (resync) workflow for the specified cache. This sends a cancellation signal to the underlying Temporal workflow. The cancellation is best-effort: if the workflow has already completed or is in its final stages, the cancel request may have no effect. Only workflows with a RUNNING status can be cancelled. After successful cancellation, the cache status transitions to CANCELLED. The previously cached data remains intact (the partial refresh data is discarded). A new full refresh or incremental sync can be triggered after cancellation. This endpoint only affects the full refresh workflow. To cancel an incremental sync, use the Cancel Incremental Update endpoint instead.
  • peaka_post__data_projects_projectId_cache_cacheId_cancelIncrementalUpdate Cancels a currently running incremental sync workflow for the specified cache. This sends a cancellation signal to the underlying Temporal workflow. The cancellation is best-effort: if the workflow has already completed or is in its final stages, the cancel request may have no effect. Only workflows with a RUNNING status can be cancelled. After successful cancellation, the cache status transitions to CANCELLED. Data that was already synced before the cancellation remains in the cache. A new incremental sync or full refresh can be triggered after cancellation. This endpoint only affects the incremental sync workflow. To cancel a full refresh, use the Cancel Full Refresh Update endpoint instead.
  • peaka_post__data_projects_projectId_cache_cacheId_fullRefreshUpdate Manually triggers a full refresh (resync) for the specified cache. This drops all existing cached data and rebuilds the cache from scratch by re-reading the entire source table. Full refresh is more expensive than incremental sync but ensures complete data consistency. It is useful when the source data has drifted or when schema changes have occurred. This is a one-time manual trigger that runs independently of any configured schedule. Use the Get Cache Status endpoint to monitor the progress of the triggered refresh. The `lastFullRefreshCacheExecution` field in the status response will reflect the new execution.
  • peaka_post__data_projects_projectId_cache_cacheId_incrementalUpdate Manually triggers an incremental (delta) sync for the specified cache. This syncs only the rows that have changed (inserted, updated, or deleted) since the last successful sync. Incremental sync is faster than a full refresh because it processes only the delta. This is a one-time manual trigger that runs independently of any configured schedule. If an incremental sync is already running, this call may start a new workflow that will be queued. Use the Get Cache Status endpoint to monitor the progress of the triggered sync. The `lastIncrementalCacheExecution` field in the status response will reflect the new execution.
  • peaka_post__data_projects_projectId_catalogs Creates a new catalog in the specified project. A catalog represents a connected data source — such as Airtable, Stripe, or Google Sheets — that exposes its schemas and tables for querying within Peaka. Requires a `name` and a `connectionId` referencing an existing connection. Some connectors accept additional `extraParameters` (e.g., Google Sheets requires specifying which sheets to include).
  • peaka_post__data_projects_projectId_catalogs_catalogId_parametricTables Creates a new Parametric Table under the specified catalog. A Parametric Table binds specific query parameter values to a source table from a REST catalog, producing a new named table (e.g., `xyz_customers`) that can be queried directly without supplying those parameters at query time. For example, if the source table `customers` requires a `_q_account` parameter, you can create a Parametric Table that fixes this value and exposes the result as a standalone table. Date and timestamp parameters also accept **relative-date macros**, re-evaluated on every query, so a table saved as "this week's sales" always returns the current week. Grammar: `@<anchor>[(+|-)<n><unit>]` - Anchors: `@today`, `@yesterday`, `@now` (current instant), `@sow` / `@eow` (week, Monday start), `@som` / `@eom` (month), `@soq` / `@eoq` (quarter), `@soy` / `@eoy` (year) - Units: `d` day, `w` week, `M` month, `q` quarter, `y` year, `h` hour, `m` minute (lowercase `m` is minute, uppercase `M` is month) - Offsets can be
  • peaka_post__data_projects_projectId_catalogs_catalogId_schemas_schemaName_tables_tableName_exports Submits an async export of a table as CSV or JSONL. Returns immediately with a job id; poll the status endpoint for the download URLs.
  • peaka_post__data_projects_projectId_catalogs_catalogId_share Shares a catalog from the current project with another Peaka project. The target project gains read access to the catalog's schemas and tables. Provide the `targetProjectId` of the project you want to share the catalog with.
  • peaka_post__data_projects_projectId_materialized_queries_queryId_cancel Cancels the in-progress refresh of a materialized query, if any.
  • peaka_post__data_projects_projectId_materialized_queries_queryId_refresh Triggers an immediate refresh of a materialized query. If the query has an existing schedule, the scheduled workflow is invoked; otherwise a one-time refresh is started.
  • peaka_post__data_projects_projectId_queries Creates a new query under the given project. Supports plain and materialized query types. Optionally accepts a path to place the query in a folder hierarchy. A MATERIALIZED query is materialized immediately on create and its result is queryable as `"peaka"."mtquery"."<name>"`; an optional `schedule` keeps it refreshed. To materialize an existing query, send `inputQueryRefId` with the source query's id instead of `inputQuery`: a snapshot of the source SQL is taken at create time and stored as the new query's own `inputQuery` (the source query is left untouched, and later changes to it do not propagate).
  • peaka_post__data_projects_projectId_queries_execute Executes a query and returns the result. Accepts a query builder object, a query ID, a query name, or a raw SQL statement. The **`format`** query parameter controls the shape of the `data` array in the response: | Value | Description | |-------|-------------| | `CELL_TYPED` *(default)* | Each cell is an object with `name`, `displayName`, `dataType`, `order`, and `value`. | | `SIMPLE` | Each row is a flat JSON object whose keys are the column names. | | `COMPACT` | Each row is a plain array of values ordered by column position. |
  • peaka_post__data_projects_projectId_queries_folders Creates a new query folder at the root level. The folder name is used to build the path (e.g. folderName "Reports" becomes path "/Reports"). Intermediate parent folders are created automatically if a nested path is provided.
  • peaka_post__data_projects_projectId_queries_folders_parentFolderId Creates a new query folder as a child of the specified parent folder. The gateway resolves the parent folder's path and creates the new folder at "{parentPath}/{folderName}".
  • peaka_post__data_projects_projectId_queries_queryId_exports Submits an async export of a saved query as CSV or JSONL. Returns immediately with a job id; poll the status endpoint for the download URLs.
  • peaka_post__data_projects_projectId_search Search for catalogs, schemas, and tables across the project. You can filter the search results by specifying a catalog or schema. You can also specify a limit and offset for pagination. See the request body for more details.
  • peaka_post__data_projects_projectId_semantic_catalogs Creates a new Semantic Catalog in the specified Project. A Semantic Catalog is a virtual catalog that groups Semantic Tables, which are backed by saved queries.
  • peaka_post__data_projects_projectId_semantic_catalogs_catalogId Creates a new Semantic Table within a Semantic Catalog. A Semantic Table maps a saved query to a table, making it queryable via SQL like any other table.
  • peaka_post__data_projects_projectId_semantic_catalogs_catalogId_share Shares a Semantic Catalog with another Project. The target Project gains read access to the catalog's schemas and tables.
  • peaka_post__data_projects_projectId_table_tableName Creates a new [Peaka Table](https://docs.peaka.com/connecting-your-data/peaka-table) with the given name in the specified project. Peaka Table is an internal relational database within Peaka that supports structured data storage with full CRUD operations. It accommodates a wide range of data types including JSON, and is best suited for smaller datasets that require frequent edits and precise changes. See also: [Differences of Peaka Table and Peaka BI Table](https://docs.peaka.com/connecting-your-data/differences-of-peaka-table-and-peaka-bi-table)
  • peaka_post__data_projects_projectId_table_tableName_columns Adds one or more columns to the specified [Peaka Table](https://docs.peaka.com/connecting-your-data/peaka-table). Each column definition includes its name, data type, display name, optional default value, and constraints (nullability, uniqueness). Peaka Table supports a wide range of data types including VARCHAR, BIGINT, BOOLEAN, TIMESTAMP, TIME, DATE, UUID, DECIMAL, and JSON.
  • peaka_post__data_projects_projectId_table_tableName_import Imports data from a CSV file into a specified internal table in a given project. This endpoint accepts a `multipart/form-data` request with two parts: - **file**: The CSV file to be imported. - **request**: A JSON string describing how the CSV columns map to the table's columns. CSV file format can be get from `/projects/{projectId}/table/{tableName}/sample`. #### Request JSON syntax The `request` part must contain: - `mappings`: A list of objects, each with: - `name`: The name of the target column in the internal table. - Either `csvColumnName` or `csvColumnIndex` to define the corresponding column in the CSV. - `containsHeader`: A boolean indicating whether the CSV includes a header row. #### Examples With column names: ``` { "mappings": [ { "name": "numcol", "csvColumnName": "numcol" }, { "name": "text", "csvColumnName": "text" }, { "name": "decimalcol", "csvColumnName": "decimalcol" } ], "containsHeader": true } ``` With column indexes: ``` { "mappings": [ { "name": "numcol", "csvC
  • peaka_post__metadata_projectId_golden_sqls Create golden sql for the project
  • peaka_post__metadata_projectId_refresh Refresh Project Metadata
  • peaka_post__metadata_projectId_refresh_callback Register Metadata Refresh Job Callback
  • peaka_post__metadata_projectId_relations_catalogId_schemaName_tableName_columnName Add Relation To Metadata
  • peaka_post__metadata_projectId_semantics_catalogId_schemaName_tableName Generate semantics for the table
  • peaka_post__organizations_organizationId_workspaces The endpoint allows you to create a new Workspace within an Organization. A Workspace is a collaborative environment within an Organization that groups Projects together. It facilitates team collaboration, resource management, and organization of data operations. The hierarchical structure in Peaka is: <code>Organization (top-level) → Workspace → Project</code> Projects contain data catalogs and workflows that teams manage within a Workspace.
  • peaka_post__organizations_organizationId_workspaces_workspaceId_projects Creates a new Project within the given Workspace. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.
  • peaka_post__projects <strong>Deprecated.</strong> Use the <code>Create Project</code> endpoint under Organization instead. Creates a new Project. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.
  • peaka_post__projects_projectId_apiKeys Creates a new API Key for the specified Project. The API Key is used to authenticate requests to the Peaka API on behalf of the Project. The full key value is only returned once at creation time. Store it securely, as it cannot be retrieved later.
  • peaka_post__sql_transpile_dialect Transpiles a SQL query from Peaka's SQL dialect (Trino) into the specified target dialect (e.g., mysql, postgres, bigquery). Useful when you need to export or reuse queries written in Peaka in other database systems.
  • peaka_post__ui_initSession Initializes an Embedded Peaka session and returns a session URL that can be used to embed the Peaka UI in an iframe. [Embedded Peaka](https://docs.peaka.com/embedded-peaka/introduction) allows you to integrate Peaka's data management capabilities — including connections, catalogs, caching, queries, and a full UI — directly into your application. The returned <code>sessionUrl</code> should be loaded inside an iframe. For security, direct iframe embedding requires enabling "Embedded UI" in Developer Settings and registering your domain over HTTPS. #### Configuration options - <code>theme</code> / <code>themeOverride</code>: Customize the look and feel of the embedded UI, including custom CSS theming. - <code>featureFlags</code>: Control visibility of UI sections (e.g., enable/disable queries, connectors). - <code>sessionMode</code>: Choose between <code>FULL_STUDIO</code> (complete Peaka experience) or <code>CONNECTOR_MODAL_ONLY</code> (streamlined connector setup). - <code>connectorType
  • peaka_put__ai_agent_projectId_threads_threadId Update ai-agent thread display name
  • peaka_put__connections_projectId_connectionId Updates the specified Connection. You can modify the name, credentials, or other parameters. The request body follows the same structure as the Create Connection endpoint.
  • peaka_put__data_projects_projectId_bitable_tableName_columns_columnName Updates the definition of an existing column in the specified [Peaka BI Table](https://docs.peaka.com/connecting-your-data/peaka-bi-table). Allows modifying the column's name, display name, data type, default value, and constraints such as nullability and uniqueness.
  • peaka_put__data_projects_projectId_cache_cacheId Updates the sync schedules of an existing cache. Use this to change how frequently the cache is refreshed. Only schedule fields are updated; the target table, catalog, and schema cannot be changed after creation. When a schedule is changed, any previously running scheduled workflow for that mode is replaced with the new schedule. Set a schedule's `type` to `NONE` to disable that particular sync mode. The schedule `expression` uses ISO-8601 duration format (e.g. `PT6H` = every 6 hours, `PT15M` = every 15 minutes, `P1D` = every day).
  • peaka_put__data_projects_projectId_queries_folders_folderId Moves queries into or out of a folder. Queries in queryIdsAdded are moved to the folder's path, queries in queryIdsRemoved are moved to root ("/").
  • peaka_put__data_projects_projectId_queries_queryId Updates the display name, SQL, or schedule of an existing query. Fields omitted from the request keep their current values. Sending `queryType: MATERIALIZED` converts a plain query into a materialized one. Sending `inputQueryRefId` re-resolves the referenced query's SQL and stores the fresh snapshot as this query's `inputQuery` — use it to re-sync a materialized query with its source. To move a query to a different folder use the Update Query Path endpoint.
  • peaka_put__data_projects_projectId_table_tableName_columns_columnName Updates the definition of an existing column in the specified [Peaka Table](https://docs.peaka.com/connecting-your-data/peaka-table). Allows modifying the column's name, display name, data type, default value, and constraints such as nullability and uniqueness.
  • peaka_put__metadata_projectId_catalogId Update Metadata ai usage per catalog level
  • peaka_put__metadata_projectId_catalogId_schemaName Update Metadata ai usage per schema level
  • peaka_put__metadata_projectId_catalogId_schemaName_tableName Update Metadata
  • peaka_put__metadata_projectId_categorical_catalogId_schemaName_tableName_columnName Generate categorical values from the column.
  • peaka_put__metadata_projectId_relations_catalogId_schemaName_tableName_relationId Update Relation From Metadata
  • peaka_put__organizations_organizationId_workspaces_workspaceId Updates the specified Workspace within an Organization. A Workspace is a collaborative environment within an Organization that groups Projects together, facilitating team collaboration and resource management. The hierarchical structure in Peaka is: <code>Organization (top-level) → Workspace → Project</code> Projects contain data catalogs and workflows that teams manage within a Workspace.
  • peaka_put__organizations_organizationId_workspaces_workspaceId_projects_projectId Updates the specified Project within a Workspace. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.
  • peaka_put__projects_projectId <strong>Deprecated.</strong> Use the <code>Update Project</code> endpoint under Organization instead. Updates the specified Project. A Project is a unit of work where queries, data tables, and semantic catalogs are managed. Projects live inside Workspaces.

As the server's own listing gives them. We never call a tool.