> ## Documentation Index
> Fetch the complete documentation index at: https://docs.engini.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Create toolset

> Creates a new toolset owned by the caller, with the given connections (and their
permitted tool slugs) and workflows. A connection entry may omit connectionId and
instead supply applicationSlug or at least one tool slug, letting the caller's
default connection for that application be resolved and stored at save time.



## OpenAPI

````yaml /developers/api-reference/openapi.json post /v1/toolsets
openapi: 3.0.0
info:
  title: Engini API
  version: v1
  description: The Engini public API.
servers:
  - url: https://api.engini.io
security:
  - Bearer: []
  - ApiKey: []
tags:
  - name: Auth
    description: Identify the caller a Developer API request is authenticated as.
  - name: On-prem agents
    description: >-
      Provision and manage agents that run Engini tasks inside a customer's
      network.
  - name: Applications
    description: >-
      Discover the applications (toolkits) available in Engini and their
      connection requirements.
  - name: Tools
    description: Browse and execute the tools exposed by Engini applications.
  - name: Toolsets
    description: Manage toolsets - named groupings of connections and tools.
  - name: McpServers
    description: >-
      Inspect and maintain MCP servers - the account-wide endpoints that expose
      Engini tools and workflows over the Model Context Protocol. Distinct from
      the MCPClient connection kind, which is Engini consuming a third-party MCP
      server.
  - name: Connections
    description: >-
      Manage connections to applications, including OAuth sign-in and
      default-connection selection.
  - name: Triggers
    description: >-
      Create triggers that fire when something changes in a connected app, and
      manage the destinations their events are delivered to.
paths:
  /v1/toolsets:
    post:
      tags:
        - Toolsets
      summary: Create toolset
      description: >-
        Creates a new toolset owned by the caller, with the given connections
        (and their

        permitted tool slugs) and workflows. A connection entry may omit
        connectionId and

        instead supply applicationSlug or at least one tool slug, letting the
        caller's

        default connection for that application be resolved and stored at save
        time.
      operationId: Toolsets_CreateToolset
      parameters: []
      requestBody:
        x-name: request
        description: The toolset creation payload.
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateToolsetRequest'
        required: true
        x-position: 1
      responses:
        '200':
          description: The newly created toolset.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ToolsetDTO'
        '400':
          description: Bad request - malformed body or invalid parameters.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: Unauthorized - missing or invalid bearer token or API key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: Forbidden - the caller lacks access to the resource.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: Not found - the resource does not exist.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          description: Too many requests - rate limit exceeded.
          headers:
            Retry-After:
              description: Number of seconds to wait before retrying.
              schema:
                type: integer
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Internal server error - an unexpected error occurred.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      security:
        - Bearer: []
        - ApiKey: []
      x-codeSamples:
        - lang: python
          label: Python
          source: |-
            from engini import Engini

            client = Engini()  # reads ENGINI_API_KEY

            toolset = client.toolsets.create(
                name="Support agent",
                connections=[
                    {"connectionId": 42, "toolSlugs": ["gmail_send_mail"]},
                    {"connectionId": 17, "applicationSlug": "monday"},
                ],
            )
        - lang: typescript
          label: TypeScript
          source: |-
            import { Engini } from "@engini/sdk";

            const client = new Engini(); // reads ENGINI_API_KEY

            const toolset = await client.toolsets.create({
              name: "Support agent",
              connections: [
                { connectionId: 42, toolSlugs: ["gmail_send_mail"] },
                { connectionId: 17, applicationSlug: "monday" },
              ],
            });
        - lang: bash
          label: CLI
          source: >-
            engini toolsets create --name support-agent --connection
            42:gmail_send_mail --application monday
components:
  schemas:
    CreateToolsetRequest:
      type: object
      description: Request body for creating a toolset.
      additionalProperties: false
      required:
        - name
        - connections
      properties:
        name:
          type: string
          description: Display name for the new toolset.
        connections:
          type: array
          description: Connections to include in the toolset and their permitted tools.
          items:
            $ref: '#/components/schemas/ToolsetConnectionRequest'
        workflows:
          type: array
          description: Workflow token GUIDs to include in the toolset.
          nullable: true
          items:
            type: string
    ToolsetDTO:
      type: object
      description: >-
        Public-shape DTO for a toolset (per-account-user, named scope bundling
        specific

        connections + an allowed tool set).
      additionalProperties: false
      required:
        - toolsetId
        - name
        - connections
        - workflows
        - createdDate
      properties:
        toolsetId:
          type: string
          description: Unique identifier of the toolset (the MCPServer token GUID).
        name:
          type: string
          description: Display name of the toolset.
        connections:
          type: array
          description: Connections included in this toolset and their permitted tools.
          items:
            $ref: '#/components/schemas/ToolsetConnectionDTO'
        workflows:
          type: array
          description: Workflow token GUIDs included in this toolset.
          items:
            type: string
        createdDate:
          type: string
          description: When the toolset was created.
          format: date-time
        updatedDate:
          type: string
          description: When the toolset was last updated; null if never updated.
          format: date-time
          nullable: true
        createdByAccountUserId:
          type: integer
          description: Account-user ID that created the toolset.
          format: int32
          nullable: true
        updatedByAccountUserId:
          type: integer
          description: >-
            Account-user ID that last updated the toolset; null/0 until first
            updated.
          format: int32
          nullable: true
    ErrorResponse:
      type: object
      description: >-
        Unified machine-readable error envelope returned by every non-200
        Developer API response.
      additionalProperties: false
      required:
        - errorCode
        - message
        - requestId
        - timestamp
      properties:
        errorCode:
          type: string
          description: Machine-readable error code identifying the failure.
        message:
          type: string
          description: Human-readable error message.
        requestId:
          type: string
          description: Identifier of the request, for support/correlation.
        timestamp:
          type: string
          description: Timestamp when the error occurred (ISO 8601).
        details:
          type: array
          description: Per-field validation details, when applicable.
          nullable: true
          items:
            $ref: '#/components/schemas/ErrorDetail'
    ToolsetConnectionRequest:
      type: object
      description: A connection entry in a create/update toolset request.
      additionalProperties: false
      properties:
        connectionId:
          type: integer
          description: >-
            Optional connection identifier (Connector ID). Omit it to let the
            backend pick the

            caller's default connection for the application of the listed tools
            (resolved and

            stored as a concrete id at save time); when omitted, ToolSlugs must
            list

            at least one tool so the application can be determined.
          format: int32
          nullable: true
        applicationSlug:
          type: string
          description: >-
            Optional application slug. When ConnectionId is omitted, supply this
            to

            scope the entry to a whole application (all its tools) using the
            caller's default

            connection for that app — resolved and stored as a concrete
            connectionId at save time.

            An alternative to listing tool slugs; if both are supplied,
            applicationSlug is

            authoritative for the application.
          nullable: true
        toolSlugs:
          type: array
          description: >-
            Tool slugs to permit for this connection; omit/empty to permit all
            tools of the app. When ConnectionId is omitted, supply either
            applicationSlug or at least one tool slug.
          nullable: true
          items:
            type: string
    ToolsetConnectionDTO:
      type: object
      description: A connection within a toolset, scoped to a set of permitted tools.
      additionalProperties: false
      required:
        - connectionId
        - applicationSlug
        - toolSlugs
      properties:
        connectionId:
          type: integer
          description: Identifier of the connection (Connector ID).
          format: int32
        applicationSlug:
          type: string
          description: Slug of the connection's application.
        applicationName:
          type: string
          description: Display name of the connection's application.
          nullable: true
        toolSlugs:
          type: array
          description: >-
            Tool slugs permitted for this connection; empty means all tools of
            the app are permitted.
          items:
            type: string
    ErrorDetail:
      type: object
      description: A single field-level error detail within an ErrorResponse.
      additionalProperties: false
      required:
        - field
        - issue
      properties:
        field:
          type: string
          description: Name of the field the issue relates to.
        issue:
          type: string
          description: Description of the issue with the field.
  securitySchemes:
    Bearer:
      type: http
      description: Enter your JWT token
      scheme: bearer
      bearerFormat: JWT
    ApiKey:
      type: apiKey
      description: >-
        Opaque Developer API key (prefix `eng_`). Authenticates as the key's
        owner and resolves the account automatically.
      name: x-api-key
      in: header

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.