catalog.yaml

registry:
  mcp-sqlite:
    description: The MCP SQLite promptfile contributes all of the tools necessary to work with SQLite and SQLite databases. The file also includes a prompt to seed the database with initial data which helps to demonstrate what you can do with an SQLite MCP Server.
    ref: github:docker/labs-ai-tools-for-devs?ref=main&path=prompts/examples/mcp-sqlite.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/sqlite.svg
    tools:
    - type: function
      function:
        name: read-query
        description: Execute a SELECT query on the SQLite database
        parameters:
          type: object
          properties:
            query: {type: string, description: SELECT SQL query to execute}
        container:
          image: vonwig/sqlite:latest
          command: [/mcp/test1.db, '{{query|safe}}']
          volumes: ['mcp-test:/mcp']
    - type: function
      function:
        name: write-query
        description: Execute an INSERT, UPDATE, or DELETE query on the SQLite database
        parameters:
          type: object
          properties:
            query: {type: string, description: SQL query to execute}
        container:
          image: vonwig/sqlite:latest
          command: [/mcp/test1.db, '{{query|safe}}']
          volumes: ['mcp-test:/mcp']
    - type: function
      function:
        name: create-table
        description: Create a new table in the SQLite database
        parameters:
          type: object
          properties:
            query: {type: string, description: CREATE TABLE SQL statement}
        container:
          image: vonwig/sqlite:latest
          command: [/mcp/test1.db, '{{query|safe}}']
          volumes: ['mcp-test:/mcp']
    - type: function
      function:
        name: list-tables
        description: List all tables in the SQLite database
        container:
          image: vonwig/sqlite:latest
          command: [/mcp/test1.db, SELECT name from sqlite_master WHERE type='table']
          volumes: ['mcp-test:/mcp']
    - type: function
      function:
        name: describe-table
        description: Get the schema information for a specific table
        parameters:
          type: object
          properties:
            table_name: {type: string, description: Name of the table to describe}
        container:
          image: vonwig/sqlite:latest
          command: [/mcp/test1.db, 'PRAGMA table_info({{table_name}})']
          volumes: ['mcp-test:/mcp']
    - type: function
      function:
        name: append-insight
        description: Add a business insight to the memo
        parameters:
          type: object
          properties:
            insight: {type: string, description: Business insight discovered from data analysis}
        container:
          image: vonwig/bash_alpine
          command: [-c, 'echo ''{{insight|safe}}'' >> /thread/insights.txt']
          volumes: ['mcp-test:/mcp']
    prompts: 1
    resources: {}
  curl:
    description: This prompt file contains the standard curl tool. In addition to the tool itself, you get a tool to read the latest man page to help clear up any issues. It also contains a prompt to demonstrate how to use the tool in a multi-step process.
    ref: github:docker/labs-ai-tools-for-devs?ref=main&path=prompts/examples/curl.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/curl.svg
    tools:
    - type: function
      function:
        name: curl-manual
        description: Run the man page for curl
        container:
          image: vonwig/curl:latest
          command: ['{{raw|safe}}', man]
    - type: function
      function:
        description: Run a curl command.
        parameters:
          type: object
          properties:
            args: {type: string, description: The arguments to pass to curl}
        container:
          image: vonwig/curl:latest
          command: ['{{raw|safe}}']
        name: curl
    prompts: 1
    resources: {}
  hello world:
    description: Great for testing! This prompt file simply contains a prompt to echo a greeting using a container, and the tool to do so.
    ref: github:docker/labs-ai-tools-for-devs?ref=main&path=prompts/examples/hello_world.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/docker.svg
    tools:
    - type: function
      function:
        name: hello-docker
        description: send a greeting from docker
        parameters:
          type: object
          properties:
            greeting: {type: string, description: the greeting to send}
          required: [greeting]
        container:
          image: busybox:latest
          command: [echo, '{{greeting}}']
    prompts: 1
    resources: {}
  ffmpeg:
    description: Use ffmpeg to process video files. This prompt file contains the ffmpeg tool, and a tool to read the latest man page to help clear up any issues. It also contains a prompt to demonstrate how to use the tool in a multi-step process.
    ref: github:docker/labs-ai-tools-for-devs?ref=main&path=prompts/examples/ffmpeg.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/ffmpeg.svg
    tools:
    - type: function
      function:
        name: imagemagick-manual
        description: Run the man page for imagemagick
        container:
          image: vonwig/imagemagick:latest
          command: ['{{raw|safe}}', man]
    - type: function
      function:
        description: Run a imagemagick command.
        parameters:
          type: object
          properties:
            args: {type: string, description: The arguments to pass to imagemagick}
        container:
          image: vonwig/imagemagick:latest
          command: ['{{raw|safe}}']
        name: imagemagick
    - type: function
      function:
        name: file-exists
        description: check if a file exists
        parameters:
          type: object
          properties:
            path: {type: string}
        container:
          image: busybox:latest
          volumes: ['{{path|safe}}:{{path|safe}}']
          command: [test, -f, '{{path|safe}}']
    - type: function
      function:
        name: ffmpeg
        description: run the ffmpeg command
        parameters:
          type: object
          properties:
            basedir: {type: string}
            args:
              description: arguments to pass to ffmpeg
              type: array
              items: {type: string}
        container:
          image: linuxserver/ffmpeg:version-7.1-cli
          volumes: ['{{basedir|safe}}:{{basedir|safe}}']
          command: ['{{args|into}}']
    prompts: 1
    resources: {}
  explain dockerfiles:
    description: Provide a detailed description, analysis, or annotation of a given Dockerfile. This prompt file contains a tool to read the latest man page to help clear up any issues. It also contains a prompt to run the tool to explain the Dockerfile.
    ref: github:docker/labs-ai-tools-for-devs?ref=main&path=prompts/examples/explain_dockerfile.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/docker.svg
    tools:
    - type: function
      function:
        name: cat_file
        description: fetch a file
        parameters:
          type: object
          properties:
            path: {type: string, description: Path of the folder to delete}
        container:
          image: vonwig/bash_alpine
          volumes: ['{{path|safe}}:/dockerfile:ro']
          command: [cat /dockerfile]
    prompts: 1
    resources: {}
  qr code:
    description: Generate a qrcode for an input text string
    ref: github:docker/labs-ai-tools-for-devs?ref=main&path=prompts/examples/qrencode.md
    icon: https://2.gravatar.com/userimage/39790510/4918b92358fde20da56c0ec8e5ac7a23?size=256
    tools:
    - type: function
      function:
        name: qrencode-manual
        description: Run the man page for qrencode
        container:
          image: vonwig/qrencode:latest
          command: ['{{raw|safe}}', man]
    - type: function
      function:
        description: generate a QR code and write it to /thread/qrcode.png
        parameters:
          type: object
          properties:
            args: {type: string, description: The arguments to pass to qrencode}
        container:
          image: vonwig/qrencode:latest
          command: ['{{raw|safe}}']
        name: qrencode
    prompts: 0
    resources: {}
  speculative_execution:
    description: "Use lorax from Claude. Lorax is a speculative execution tool that can be used  to make edits and run tools in an isolated sandbox. \n"
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/lorax/speculative.md
    icon: https://vonwig.github.io/prompts.docs/img/speculative_hu15687469033092380316.webp
    tools:
    - type: function
      function:
        name: sandbox-source
        description: make a cloned host repo available to the sandbox
        parameters:
          type: object
          properties:
            host-dir: {type: string}
            name: {type: string}
        container:
          image: lorax:latest
          entrypoint: lorax
          command: [sandbox, source, -n, '{{name}}', '{{host-dir}}']
          background: true
    - type: function
      function:
        name: sandbox-clone
        description: create a sandbox and respond with the id of the new sandbox
        parameters:
          type: object
          properties:
            sandbox-name: {type: string}
        container:
          image: lorax:latest
          entrypoint: lorax
          command: [sandbox, clone, '{{sandbox-name}}']
    - type: function
      function:
        name: sandbox-snapshot
        description: snapshot the current state of a sandbox
        parameters:
          type: object
          properties:
            sandbox-id: {type: string}
        container:
          image: lorax:latest
          entrypoint: lorax
          command: [sandbox, snapshot, '{{sandbox-id}}']
    - type: function
      function:
        name: sandbox-restore
        description: snapshot the current state of a sandbox
        parameters:
          type: object
          properties:
            sandbox-id: {type: string}
            tree-id: {type: string}
        container:
          image: lorax:latest
          entrypoint: lorax
          command: [sandbox, restore, '{{sandbox-id}}', '{{tree-id}}']
    - type: function
      function:
        name: sandbox-exec
        description: exec a container in the current sandbox
        parameters:
          type: object
          properties:
            sandbox-id: {type: string}
            image: {type: string}
        container:
          image: lorax:latest
          entrypoint: lorax
          command: [sandbox, exec, --mount-image, '{{image}}', '{{sandbox-id}}']
    - type: function
      function:
        name: sandbox-delete-file
        description: exec a container in the current sandbox
        parameters:
          type: object
          properties:
            sandbox-id: {type: string}
            path: {type: string}
        container:
          image: lorax:latest
          entrypoint: lorax
          command: [sandbox, delete, '{{sandbox-id}}', '{{path}}']
    - type: function
      function:
        name: sandbox-rm
        description: exec a container in the current sandbox
        parameters:
          type: object
          properties:
            sandbox-id: {type: string}
            path: {type: string}
        container:
          image: lorax:latest
          entrypoint: lorax
          command: [sandbox, rm, '{{sandbox-id}}']
    - type: function
      function:
        name: sandbox-diff
        description: exec a container in the current sandbox
        parameters:
          type: object
          properties:
            sandbox-id: {type: string}
            tree-id: {type: string}
        container:
          image: lorax:latest
          entrypoint: lorax
          command: [sandbox, diff, '{{sandbox-id}}', '{{tree-id}}']
    - type: function
      function:
        name: sandbox-apply
        description: exec a container in the current sandbox
        parameters:
          type: object
          properties:
            diff: {type: string}
        container:
          image: lorax:latest
          entrypoint: lorax
          command: [sandbox, apply, user-source, '{{diff}}']
    prompts: 1
    resources: {}
  memory:
    description: Give your MCP client a memory system! This prompt file contains a tool to create entities, relations, and observations in a knowledge graph. It also contains a tool to read the latest man page to help clear up any issues. It also contains a prompt to demonstrate how to use the tool in a multi-step process.
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/examples/mcp-memory.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/knowledgebase.svg
    tools:
    - type: function
      function:
        name: create_entities
        description: Create multiple new entities in the knowledge graph
        parameters:
          type: object
          properties:
            entities:
              type: array
              items:
                type: object
                properties:
                  name: {type: string, description: The name of the entity}
                  entityType: {type: string, description: The type of the entity}
                  observations:
                    type: array
                    items: {type: string}
                    description: An array of observation contents associated with the entity
                required: [name, entityType, observations]
          required: [entities]
        container:
          image: vonwig/memory:latest
          volumes: ['mcp-memory:/memory']
          command: [create-entities, '{{raw|safe}}']
    - type: function
      function:
        name: create_relations
        description: Create multiple new relations between entities in the knowledge graph. Relations should be in active voice
        parameters:
          type: object
          properties:
            relations:
              type: array
              items:
                type: object
                properties:
                  from: {type: string, description: The name of the entity where the relation starts}
                  to: {type: string, description: The name of the entity where the relation ends}
                  relationType: {type: string, description: The type of the relation}
                required: [from, to, relationType]
          required: [relations]
        container:
          image: vonwig/memory:latest
          volumes: ['mcp-memory:/memory']
          command: [create-relations, '{{raw|safe}}']
    - type: function
      function:
        name: add_observations
        description: Add new observations to existing entities in the knowledge graph
        parameters:
          type: object
          properties:
            observations:
              type: array
              items:
                type: object
                properties:
                  entityName: {type: string, description: The name of the entity to add the observations to}
                  contents:
                    type: array
                    items: {type: string}
                    description: An array of observation contents to add
                required: [entityName, contents]
          required: [observations]
        container:
          image: vonwig/memory:latest
          volumes: ['mcp-memory:/memory']
          command: [add-observations, '{{raw|safe}}']
    - type: function
      function:
        name: delete_entities
        description: Delete multiple entities and their associated relations from the knowledge graph
        parameters:
          type: object
          properties:
            entityNames:
              type: array
              items: {type: string}
              description: An array of entity names to delete
          required: [entityNames]
        container:
          image: vonwig/memory:latest
          volumes: ['mcp-memory:/memory']
          command: [delete-entities, '{{raw|safe}}']
    - type: function
      function:
        name: delete_observations
        description: Delete specific observations from entities in the knowledge graph
        parameters:
          type: object
          properties:
            deletions:
              type: array
              items:
                type: object
                properties:
                  entityName: {type: string, description: The name of the entity containing the observations}
                  observations:
                    type: array
                    items: {type: string}
                    description: An array of observations to delete
                required: [entityName, observations]
          required: [deletions]
        container:
          image: vonwig/memory:latest
          volumes: ['mcp-memory:/memory']
          command: [delete-observations, '{{raw|safe}}']
    - type: function
      function:
        name: delete_relations
        description: Delete multiple relations from the knowledge graph
        parameters:
          type: object
          properties:
            relations:
              type: array
              items:
                type: object
                properties:
                  from: {type: string, description: The name of the entity where the relation starts}
                  to: {type: string, description: The name of the entity where the relation ends}
                  relationType: {type: string, description: The type of the relation}
                required: [from, to, relationType]
              description: An array of relations to delete
          required: [relations]
        container:
          image: vonwig/memory:latest
          volumes: ['mcp-memory:/memory']
          command: [delete-relations, '{{raw|safe}}']
    - type: function
      function:
        name: read_graph
        description: Read the entire knowledge graph
        parameters:
          type: object
          properties: {}
        container:
          image: vonwig/memory:latest
          volumes: ['mcp-memory:/memory']
          command: [read-graph, '{{raw|safe}}']
    - type: function
      function:
        name: search_nodes
        description: Search for nodes in the knowledge graph based on a query
        parameters:
          type: object
          properties:
            query: {type: string, description: 'The search query to match against entity names, types, and observation content'}
          required: [query]
        container:
          image: vonwig/memory:latest
          volumes: ['mcp-memory:/memory']
          command: [search-nodes, '{{raw|safe}}']
    - type: function
      function:
        name: open_nodes
        description: Open specific nodes in the knowledge graph by their names
        parameters:
          type: object
          properties:
            names:
              type: array
              items: {type: string}
              description: An array of entity names to retrieve
          required: [names]
        container:
          image: vonwig/memory:latest
          volumes: ['mcp-memory:/memory']
          command: [open-nodes, '{{raw|safe}}']
    prompts: 0
    resources: {}
  chrome:
    description: Drive a headless Chrome browser to interact with web pages
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/chrome.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/googlechrome.svg
    tools:
    - type: function
      function:
        name: websocat
        description: A tool to send and receive messages over a websocket.
        parameters:
          type: object
          properties:
            endpoint: {type: string, description: The url of the websocket endpoint.}
            message: {type: string, description: The message to send to websocat on stdin.}
          required: [endpoint, message]
        container:
          image: vonwig/websocat:latest
          stdin: {content: '{{message|safe}}'}
          command: [-n1, '-H=Host: localhost:9222', '{{endpoint|safe}}']
    - type: function
      function:
        name: curl-manual
        description: Run the man page for curl
        container:
          image: vonwig/curl:latest
          command: ['{{raw|safe}}', man]
    - type: function
      function:
        description: Run a curl command.
        parameters:
          type: object
          properties:
            args: {type: string, description: The arguments to pass to curl}
        container:
          image: vonwig/curl:latest
          command: ['{{raw|safe}}']
        name: curl
    - type: function
      function:
        name: chrome
        description: Starts the chrome browser.
        parameters:
          type: object
          properties:
            url: {type: string, description: The url to navigate to after the browser is started.}
          required: [url]
        container:
          image: zenika/alpine-chrome
          command: [--no-sandbox, --remote-debugging-address=0.0.0.0, --remote-debugging-port=9222, '{{url|safe}}']
          background: true
          ports: ['9222:9222']
    prompts: 1
    resources: {}
  sequentialthinking:
    description: provides a tool for dynamic and reflective problem-solving through a structured thinking process
    ref: github:docker/labs-ai-tools-for-devs?ref=main&path=prompts/examples/sequentialthinking.md
    icon: https://d3t3ozftmdmh3i.cloudfront.net/production/podcast_uploaded_nologo/2454513/2454513-1570719639731-bfdf3620a4e0d.jpg
    tools:
    - type: function
      function:
        name: sequentialthinking
        description: |-
          A detailed tool for dynamic and reflective problem-solving through thoughts.
          This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
          Each thought can build on, question, or revise previous insights as understanding deepens.

          When to use this tool:
          - Breaking down complex problems into steps
          - Planning and design with room for revision
          - Analysis that might need course correction
          - Problems where the full scope might not be clear initially
          - Problems that require a multi-step solution
          - Tasks that need to maintain context over multiple steps
          - Situations where irrelevant information needs to be filtered out

          Key features:
          - You can adjust total_thoughts up or down as you progress
          - You can question or revise previous thoughts
          - You can add more thoughts even after reaching what seemed like the end
          - You can express uncertainty and explore alternative approaches
          - Not every thought needs to build linearly - you can branch or backtrack
          - Generates a solution hypothesis
          - Verifies the hypothesis based on the Chain of Thought steps
          - Repeats the process until satisfied
          - Provides a correct answer

          Parameters explained:
          - thought: Your current thinking step, which can include:
          * Regular analytical steps
          * Revisions of previous thoughts
          * Questions about previous decisions
          * Realizations about needing more analysis
          * Changes in approach
          * Hypothesis generation
          * Hypothesis verification
          - next_thought_needed: True if you need more thinking, even if at what seemed like the end
          - thought_number: Current number in sequence (can go beyond initial total if needed)
          - total_thoughts: Current estimate of thoughts needed (can be adjusted up/down)
          - is_revision: A boolean indicating if this thought revises previous thinking
          - revises_thought: If is_revision is true, which thought number is being reconsidered
          - branch_from_thought: If branching, which thought number is the branching point
          - branch_id: Identifier for the current branch (if any)
          - needs_more_thoughts: If reaching end but realizing more thoughts needed

          You should:
          1. Start with an initial estimate of needed thoughts, but be ready to adjust
          2. Feel free to question or revise previous thoughts
          3. Don't hesitate to add more thoughts if needed, even at the "end"
          4. Express uncertainty when present
          5. Mark thoughts that revise previous thinking or branch into new paths
          6. Ignore information that is irrelevant to the current step
          7. Generate a solution hypothesis when appropriate
          8. Verify the hypothesis based on the Chain of Thought steps
          9. Repeat the process until satisfied with the solution
          10. Provide a single, ideally correct answer as the final output
          11. Only set next_thought_needed to false when truly done and a satisfactory answer is reached`
        parameters:
          type: object
          properties:
            thought: {type: string, description: Your current thinking step}
            nextThoughtNeeded: {type: boolean, description: Whether another thought step is needed}
            thoughtNumber: {type: integer, description: Current thought number, minimum: 1}
            totalThoughts: {type: integer, description: Estimated total thoughts needed, minimum: 1}
            isRevision: {type: boolean, description: Whether this revises previous thinking}
            revisesThought: {type: integer, description: Which thought is being reconsidered, minimum: 1}
            branchFromThought: {type: integer, description: Branching point thought number, minimum: 1}
            branchId: {type: string, description: Branch identifier}
            needsMoreThoughts: {type: boolean, description: If more thoughts are needed}
          required: [thought, nextThoughtNeeded, thoughtNumber, totalThoughts]
        container:
          image: vonwig/sequentialthinking:latest
          volumes: ['mcp-sequentialthinking:/sequentialthinking']
    prompts: 0
    resources: {}
  stripe:
    description: Provides a tool to interact with Stripe services over the Stripe API.
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/stripe.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/stripe.svg
    secrets:
    - {name: stripe.api_key}
    tools:
    - type: function
      function:
        name: create_customer
        description: |2

          This tool will create a customer in Stripe.

          It takes two arguments:
          - name (str): The name of the customer.
          - email (str, optional): The email of the customer.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            name: {type: string, description: The name of the customer}
            email: {type: string, format: email, description: The email of the customer}
          required: [name]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: list_customers
        description: |2

          This tool will fetch a list of Customers from Stripe.

          It takes no input.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            limit: {type: integer, minimum: 1, maximum: 100, description: A limit on the number of objects to be returned. Limit can range between 1 and 100.}
            email: {type: string, description: A case-sensitive filter on the list based on the customer's email field. The value must be a string.}
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_product
        description: |2

          This tool will create a product in Stripe.

          It takes two arguments:
          - name (str): The name of the product.
          - description (str, optional): The description of the product.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            name: {type: string, description: The name of the product.}
            description: {type: string, description: The description of the product.}
          required: [name]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: list_products
        description: |2

          This tool will fetch a list of Products from Stripe.

          It takes one optional argument:
          - limit (int, optional): The number of products to return.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            limit: {type: integer, minimum: 1, maximum: 100, description: 'A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.'}
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_price
        description: |2

          This tool will create a price in Stripe. If a product has not already been specified, a product should be created first.

          It takes three arguments:
          - product (str): The ID of the product to create the price for.
          - unit_amount (int): The unit amount of the price in cents.
          - currency (str): The currency of the price.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            product: {type: string, description: The ID of the product to create the price for.}
            unit_amount: {type: integer, description: The unit amount of the price in cents.}
            currency: {type: string, description: The currency of the price.}
          required: [product, unit_amount, currency]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: list_prices
        description: |2

          This tool will fetch a list of Prices from Stripe.

          It takes two arguments.
          - product (str, optional): The ID of the product to list prices for.
          - limit (int, optional): The number of prices to return.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            product: {type: string, description: The ID of the product to list prices for.}
            limit: {type: integer, minimum: 1, maximum: 100, description: 'A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.'}
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_payment_link
        description: |2

          This tool will create a payment link in Stripe.

          It takes two arguments:
          - price (str): The ID of the price to create the payment link for.
          - quantity (int): The quantity of the product to include in the payment link.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            price: {type: string, description: The ID of the price to create the payment link for.}
            quantity: {type: integer, description: The quantity of the product to include.}
          required: [price, quantity]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_invoice
        description: |2

          This tool will create an invoice in Stripe.

          It takes one argument:
          - customer (str): The ID of the customer to create the invoice for.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            customer: {type: string, description: The ID of the customer to create the invoice for.}
            days_until_due: {type: integer, description: The number of days until the invoice is due.}
          required: [customer]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_invoice_item
        description: |2

          This tool will create an invoice item in Stripe.

          It takes two arguments:
          - customer (str): The ID of the customer to create the invoice item for.
          - price (str): The ID of the price to create the invoice item for.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            customer: {type: string, description: The ID of the customer to create the invoice item for.}
            price: {type: string, description: The ID of the price for the item.}
            invoice: {type: string, description: The ID of the invoice to create the item for.}
          required: [customer, price, invoice]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: finalize_invoice
        description: |2

          This tool will finalize an invoice in Stripe.

          It takes one argument:
          - invoice (str): The ID of the invoice to finalize.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            invoice: {type: string, description: The ID of the invoice to finalize.}
          required: [invoice]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: retrieve_balance
        description: |2

          This tool will retrieve the balance from Stripe. It takes no input.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties: {}
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_refund
        description: |2

          This tool will refund a payment intent in Stripe.

          It takes three arguments:
          - payment_intent (str): The ID of the payment intent to refund.
          - amount (int, optional): The amount to refund in cents.
          - reason (str, optional): The reason for the refund.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            payment_intent: {type: string, description: The ID of the PaymentIntent to refund.}
            amount: {type: integer, description: The amount to refund in cents.}
          required: [payment_intent]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: list_payment_intents
        description: |2

          This tool will list payment intents in Stripe.

          It takes two arguments:
          - customer (str, optional): The ID of the customer to list payment intents for.
          - limit (int, optional): The number of payment intents to return.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            customer: {type: string, description: The ID of the customer to list payment intents for.}
            limit: {type: integer, minimum: 1, maximum: 100, description: A limit on the number of objects to be returned. Limit can range between 1 and 100.}
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: search_documentation
        description: |2

          This tool will take in a user question about integrating with Stripe in their application, then search and retrieve relevant Stripe documentation to answer the question.

          It takes two arguments:
          - question (str): The user question to search an answer for in the Stripe documentation.
          - language (str, optional): The programming language to search for in the the documentation.
        container:
          image: vonwig/stripe:latest
          workdir: /app
          secrets: {stripe.api_key: API_KEY}
          command: [--tools=all, --api-key=$API_KEY]
          type: mcp
        parameters:
          type: object
          properties:
            question: {type: string, description: The user question about integrating with Stripe will be used to search the documentation.}
            language:
              type: string
              enum: [dotnet, go, java, node, php, ruby, python, curl]
              description: The programming language to search for in the the documentation.
          required: [question]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    prompts: 0
    resources: {}
  brave:
    description: Web and local search using Brave's Search API
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/brave.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/brave.svg
    secrets:
    - {name: brave.api_key}
    tools:
    - type: function
      function:
        name: brave_web_search
        description: 'Performs a web search using the Brave Search API, ideal for general queries, news, articles, and online content. Use this for broad information gathering, recent events, or when you need diverse web sources. Supports pagination, content filtering, and freshness controls. Maximum 20 results per request, with offset for pagination. '
        container:
          image: mcp/brave-search:latest
          workdir: /app
          secrets: {brave.api_key: BRAVE_API_KEY}
          type: mcp
        parameters:
          type: object
          properties:
            query: {type: string, description: 'Search query (max 400 chars, 50 words)'}
            count: {type: number, description: 'Number of results (1-20, default 10)', default: 10}
            offset: {type: number, description: 'Pagination offset (max 9, default 0)', default: 0}
          required: [query]
    - type: function
      function:
        name: brave_local_search
        description: |-
          Searches for local businesses and places using Brave's Local Search API. Best for queries related to physical locations, businesses, restaurants, services, etc. Returns detailed information including:
          - Business names and addresses
          - Ratings and review counts
          - Phone numbers and opening hours
          Use this when the query implies 'near me' or mentions specific locations. Automatically falls back to web search if no local results are found.
        container:
          image: mcp/brave-search:latest
          workdir: /app
          secrets: {brave.api_key: BRAVE_API_KEY}
          type: mcp
        parameters:
          type: object
          properties:
            query: {type: string, description: Local search query (e.g. 'pizza near Central Park')}
            count: {type: number, description: 'Number of results (1-20, default 5)', default: 5}
          required: [query]
    prompts: 0
    resources: {}
  slack:
    description: Provides a tool to interact with Slack Workspaces over the Slack API.
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/slack.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/slack.svg
    secrets:
    - {name: slack.team_id}
    - {name: slack.bot_token}
    tools:
    - type: function
      function:
        name: slack_list_channels
        description: List public channels in the workspace with pagination
        container:
          image: mcp/slack:latest
          workdir: /app
          secrets: {slack.bot_token: SLACK_BOT_TOKEN, slack.team_id: SLACK_TEAM_ID}
          type: mcp
        parameters:
          type: object
          properties:
            limit: {type: number, description: 'Maximum number of channels to return (default 100, max 200)', default: 100}
            cursor: {type: string, description: Pagination cursor for next page of results}
    - type: function
      function:
        name: slack_post_message
        description: Post a new message to a Slack channel
        container:
          image: mcp/slack:latest
          workdir: /app
          secrets: {slack.bot_token: SLACK_BOT_TOKEN, slack.team_id: SLACK_TEAM_ID}
          type: mcp
        parameters:
          type: object
          properties:
            channel_id: {type: string, description: The ID of the channel to post to}
            text: {type: string, description: The message text to post}
          required: [channel_id, text]
    - type: function
      function:
        name: slack_reply_to_thread
        description: Reply to a specific message thread in Slack
        container:
          image: mcp/slack:latest
          workdir: /app
          secrets: {slack.bot_token: SLACK_BOT_TOKEN, slack.team_id: SLACK_TEAM_ID}
          type: mcp
        parameters:
          type: object
          properties:
            channel_id: {type: string, description: The ID of the channel containing the thread}
            thread_ts: {type: string, description: The timestamp of the parent message}
            text: {type: string, description: The reply text}
          required: [channel_id, thread_ts, text]
    - type: function
      function:
        name: slack_add_reaction
        description: Add a reaction emoji to a message
        container:
          image: mcp/slack:latest
          workdir: /app
          secrets: {slack.bot_token: SLACK_BOT_TOKEN, slack.team_id: SLACK_TEAM_ID}
          type: mcp
        parameters:
          type: object
          properties:
            channel_id: {type: string, description: The ID of the channel containing the message}
            timestamp: {type: string, description: The timestamp of the message to react to}
            reaction: {type: string, description: 'The name of the emoji reaction (without ::)'}
          required: [channel_id, timestamp, reaction]
    - type: function
      function:
        name: slack_get_channel_history
        description: Get recent messages from a channel
        container:
          image: mcp/slack:latest
          workdir: /app
          secrets: {slack.bot_token: SLACK_BOT_TOKEN, slack.team_id: SLACK_TEAM_ID}
          type: mcp
        parameters:
          type: object
          properties:
            channel_id: {type: string, description: The ID of the channel}
            limit: {type: number, description: Number of messages to retrieve (default 10), default: 10}
          required: [channel_id]
    - type: function
      function:
        name: slack_get_thread_replies
        description: Get all replies in a message thread
        container:
          image: mcp/slack:latest
          workdir: /app
          secrets: {slack.bot_token: SLACK_BOT_TOKEN, slack.team_id: SLACK_TEAM_ID}
          type: mcp
        parameters:
          type: object
          properties:
            channel_id: {type: string, description: The ID of the channel containing the thread}
            thread_ts: {type: string, description: The timestamp of the parent message}
          required: [channel_id, thread_ts]
    - type: function
      function:
        name: slack_get_users
        description: Get a list of all users in the workspace with their basic profile information
        container:
          image: mcp/slack:latest
          workdir: /app
          secrets: {slack.bot_token: SLACK_BOT_TOKEN, slack.team_id: SLACK_TEAM_ID}
          type: mcp
        parameters:
          type: object
          properties:
            cursor: {type: string, description: Pagination cursor for next page of results}
            limit: {type: number, description: 'Maximum number of users to return (default 100, max 200)', default: 100}
    - type: function
      function:
        name: slack_get_user_profile
        description: Get detailed profile information for a specific user
        container:
          image: mcp/slack:latest
          workdir: /app
          secrets: {slack.bot_token: SLACK_BOT_TOKEN, slack.team_id: SLACK_TEAM_ID}
          type: mcp
        parameters:
          type: object
          properties:
            user_id: {type: string, description: The ID of the user}
          required: [user_id]
    prompts: 0
    resources: {}
  redis:
    description: provides access to Redis database operations.
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/redis.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/redis.svg
    secrets:
    - {name: redis.host}
    - {name: redis.port}
    tools:
    - type: function
      function:
        name: hmset
        description: Set multiple hash fields to multiple values
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Hash key}
            fields:
              type: object
              description: Field-value pairs to set
              additionalProperties: {type: string}
          required: [key, fields]
    - type: function
      function:
        name: hget
        description: Get the value of a hash field
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Hash key}
            field: {type: string, description: Field to get}
          required: [key, field]
    - type: function
      function:
        name: hgetall
        description: Get all the fields and values in a hash
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Hash key}
          required: [key]
    - type: function
      function:
        name: scan
        description: Scan Redis keys matching a pattern
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            pattern: {type: string, description: 'Pattern to match (e.g., "user:*" or "schedule:*")'}
            count: {type: number, description: Number of keys to return per iteration (optional), minimum: 1}
          required: [pattern]
    - type: function
      function:
        name: set
        description: Set string value with optional NX (only if not exists) and PX (expiry in milliseconds) options
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Key to set}
            value: {type: string, description: Value to set}
            nx: {type: boolean, description: Only set if key does not exist}
            px: {type: number, description: Set expiry in milliseconds}
          required: [key, value]
    - type: function
      function:
        name: get
        description: Get string value
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Key to get}
          required: [key]
    - type: function
      function:
        name: del
        description: Delete a key
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Key to delete}
          required: [key]
    - type: function
      function:
        name: zadd
        description: Add one or more members to a sorted set
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Sorted set key}
            members:
              type: array
              description: Array of score-value pairs to add
              items:
                type: object
                properties:
                  score: {type: number, description: Score for the member}
                  value: {type: string, description: Member value}
                required: [score, value]
          required: [key, members]
    - type: function
      function:
        name: zrange
        description: Return a range of members from a sorted set by index
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Sorted set key}
            start: {type: number, description: Start index (0-based)}
            stop: {type: number, description: Stop index (inclusive)}
            withScores: {type: boolean, description: Include scores in output, default: false}
          required: [key, start, stop]
    - type: function
      function:
        name: zrangebyscore
        description: Return members from a sorted set with scores between min and max
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Sorted set key}
            min: {type: number, description: Minimum score}
            max: {type: number, description: Maximum score}
            withScores: {type: boolean, description: Include scores in output, default: false}
          required: [key, min, max]
    - type: function
      function:
        name: zrem
        description: Remove one or more members from a sorted set
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Sorted set key}
            members:
              type: array
              description: Array of members to remove
              items: {type: string}
          required: [key, members]
    - type: function
      function:
        name: sadd
        description: Add one or more members to a set
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Set key}
            members:
              type: array
              items: {type: string}
              description: Members to add to the set
          required: [key, members]
    - type: function
      function:
        name: smembers
        description: Get all members in a set
        container:
          image: mcp/redis:latest
          workdir: /app
          secrets: {redis.host: REDIS_HOST, redis.port: REDIS_PORT}
          command: [--redis-host, $REDIS_HOST, --redis-port, $REDIS_PORT]
          type: mcp
        parameters:
          type: object
          properties:
            key: {type: string, description: Set key}
          required: [key]
    prompts: 0
    resources: {}
  github:
    description: MCP Server for the GitHub API, enabling file operations, repository management, search functionality, and more.
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/github.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/github.svg
    secrets:
    - {name: github.personal_access_token}
    tools:
    - type: function
      function:
        name: create_or_update_file
        description: Create or update a single file in a GitHub repository
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string, description: Repository owner (username or organization)}
            repo: {type: string, description: Repository name}
            path: {type: string, description: Path where to create/update the file}
            content: {type: string, description: Content of the file}
            message: {type: string, description: Commit message}
            branch: {type: string, description: Branch to create/update the file in}
            sha: {type: string, description: SHA of the file being replaced (required when updating existing files)}
          required: [owner, repo, path, content, message, branch]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: search_repositories
        description: Search for GitHub repositories
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            query: {type: string, description: Search query (see GitHub search syntax)}
            page: {type: number, description: 'Page number for pagination (default: 1)'}
            perPage: {type: number, description: 'Number of results per page (default: 30, max: 100)'}
          required: [query]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_repository
        description: Create a new GitHub repository in your account
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            name: {type: string, description: Repository name}
            description: {type: string, description: Repository description}
            private: {type: boolean, description: Whether the repository should be private}
            autoInit: {type: boolean, description: Initialize with README.md}
          required: [name]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: get_file_contents
        description: Get the contents of a file or directory from a GitHub repository
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string, description: Repository owner (username or organization)}
            repo: {type: string, description: Repository name}
            path: {type: string, description: Path to the file or directory}
            branch: {type: string, description: Branch to get contents from}
          required: [owner, repo, path]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: push_files
        description: Push multiple files to a GitHub repository in a single commit
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string, description: Repository owner (username or organization)}
            repo: {type: string, description: Repository name}
            branch: {type: string, description: 'Branch to push to (e.g., ''main'' or ''master'')'}
            files:
              type: array
              items:
                type: object
                properties:
                  path: {type: string, description: Path where to create the file}
                  content: {type: string, description: Content of the file}
                required: [path, content]
                additionalProperties: false
              description: Array of files to push
            message: {type: string, description: Commit message}
          required: [owner, repo, branch, files, message]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_issue
        description: Create a new issue in a GitHub repository
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string, description: Repository owner (username or organization)}
            repo: {type: string, description: Repository name}
            title: {type: string, description: Issue title}
            body: {type: string, description: Issue body/description}
            assignees:
              type: array
              items: {type: string}
              description: Array of usernames to assign
            labels:
              type: array
              items: {type: string}
              description: Array of label names
            milestone: {type: number, description: Milestone number to assign}
          required: [owner, repo, title]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_pull_request
        description: Create a new pull request in a GitHub repository
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string, description: Repository owner (username or organization)}
            repo: {type: string, description: Repository name}
            title: {type: string, description: Pull request title}
            body: {type: string, description: Pull request body/description}
            head: {type: string, description: The name of the branch where your changes are implemented}
            base: {type: string, description: The name of the branch you want the changes pulled into}
            draft: {type: boolean, description: Whether to create the pull request as a draft}
            maintainer_can_modify: {type: boolean, description: Whether maintainers can modify the pull request}
          required: [owner, repo, title, head, base]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: fork_repository
        description: Fork a GitHub repository to your account or specified organization
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string, description: Repository owner (username or organization)}
            repo: {type: string, description: Repository name}
            organization: {type: string, description: 'Optional: organization to fork to (defaults to your personal account)'}
          required: [owner, repo]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: create_branch
        description: Create a new branch in a GitHub repository
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string, description: Repository owner (username or organization)}
            repo: {type: string, description: Repository name}
            branch: {type: string, description: Name for the new branch}
            from_branch: {type: string, description: 'Optional: source branch to create from (defaults to the repository''s default branch)'}
          required: [owner, repo, branch]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: list_commits
        description: Get list of commits of a branch in a GitHub repository
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string, description: Repository owner (username or organization)}
            repo: {type: string, description: Repository name}
            page: {type: number, description: 'Page number for pagination (default: 1)'}
            perPage: {type: number, description: 'Number of results per page (default: 30, max: 100)'}
            sha: {type: string, description: SHA of the file being replaced (required when updating existing files)}
          required: [owner, repo]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: list_issues
        description: List issues in a GitHub repository with filtering options
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            labels:
              type: array
              items: {type: string}
            since: {type: string}
            state:
              type: string
              enum: [open, closed, all]
            page: {type: number}
            repo: {type: string}
            per_page: {type: number}
            owner: {type: string}
            direction:
              type: string
              enum: [asc, desc]
            sort:
              type: string
              enum: [created, updated, comments]
          required: [owner, repo]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: update_issue
        description: Update an existing issue in a GitHub repository
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            labels:
              type: array
              items: {type: string}
            assignees:
              type: array
              items: {type: string}
            issue_number: {type: number}
            milestone: {type: number}
            state:
              type: string
              enum: [open, closed]
            title: {type: string}
            repo: {type: string}
            body: {type: string}
            owner: {type: string}
          required: [owner, repo, issue_number]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: add_issue_comment
        description: Add a comment to an existing issue
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string}
            repo: {type: string}
            issue_number: {type: number}
            body: {type: string}
          required: [owner, repo, issue_number, body]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: search_code
        description: Search for code across GitHub repositories
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            q: {type: string, description: 'Search query. See GitHub code search syntax: https://docs.github.com/en/search-github/searching-on-github/searching-code'}
            order:
              type: string
              enum: [asc, desc]
              description: Sort order (asc or desc)
            per_page: {type: number, minimum: 1, maximum: 100, description: Results per page (max 100)}
            page: {type: number, minimum: 1, description: Page number}
          required: [q]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: search_issues
        description: Search for issues and pull requests across GitHub repositories
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            q: {type: string, description: 'Search query. See GitHub issues search syntax: https://docs.github.com/en/search-github/searching-on-github/searching-issues-and-pull-requests'}
            sort:
              type: string
              enum: [comments, reactions, reactions-+1, reactions--1, reactions-smile, reactions-thinking_face, reactions-heart, reactions-tada, interactions, created, updated]
              description: Sort field
            order:
              type: string
              enum: [asc, desc]
              description: Sort order (asc or desc)
            per_page: {type: number, minimum: 1, maximum: 100, description: Results per page (max 100)}
            page: {type: number, minimum: 1, description: Page number}
          required: [q]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: search_users
        description: Search for users on GitHub
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            q: {type: string, description: 'Search query. See GitHub users search syntax: https://docs.github.com/en/search-github/searching-on-github/searching-users'}
            sort:
              type: string
              enum: [followers, repositories, joined]
              description: Sort field
            order:
              type: string
              enum: [asc, desc]
              description: Sort order (asc or desc)
            per_page: {type: number, minimum: 1, maximum: 100, description: Results per page (max 100)}
            page: {type: number, minimum: 1, description: Page number}
          required: [q]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    - type: function
      function:
        name: get_issue
        description: Get details of a specific issue in a GitHub repository.
        container:
          image: mcp/github:latest
          workdir: /app
          secrets: {github.personal_access_token: GITHUB_PERSONAL_ACCESS_TOKEN}
          type: mcp
        parameters:
          type: object
          properties:
            owner: {type: string, description: Repository owner (username or organization)}
            repo: {type: string, description: Repository name}
            issue_number: {type: number, description: Issue number}
          required: [owner, repo, issue_number]
          additionalProperties: false
          $schema: http://json-schema.org/draft-07/schema#
    prompts: 0
    resources: {}
  google-maps:
    description: MCP Server for the Google Maps API.
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/google-maps.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/google.svg
    secrets:
    - {name: google.api_key}
    tools:
    - type: function
      function:
        name: maps_geocode
        description: Convert an address into geographic coordinates
        container:
          image: mcp/google-maps:latest
          workdir: /app
          secrets: {google.api_key: GOOGLE_MAPS_API_KEY}
          type: mcp
        parameters:
          type: object
          properties:
            address: {type: string, description: The address to geocode}
          required: [address]
    - type: function
      function:
        name: maps_reverse_geocode
        description: Convert coordinates into an address
        container:
          image: mcp/google-maps:latest
          workdir: /app
          secrets: {google.api_key: GOOGLE_MAPS_API_KEY}
          type: mcp
        parameters:
          type: object
          properties:
            latitude: {type: number, description: Latitude coordinate}
            longitude: {type: number, description: Longitude coordinate}
          required: [latitude, longitude]
    - type: function
      function:
        name: maps_search_places
        description: Search for places using Google Places API
        container:
          image: mcp/google-maps:latest
          workdir: /app
          secrets: {google.api_key: GOOGLE_MAPS_API_KEY}
          type: mcp
        parameters:
          type: object
          properties:
            query: {type: string, description: Search query}
            location:
              type: object
              properties:
                latitude: {type: number}
                longitude: {type: number}
              description: Optional center point for the search
            radius: {type: number, description: Search radius in meters (max 50000)}
          required: [query]
    - type: function
      function:
        name: maps_place_details
        description: Get detailed information about a specific place
        container:
          image: mcp/google-maps:latest
          workdir: /app
          secrets: {google.api_key: GOOGLE_MAPS_API_KEY}
          type: mcp
        parameters:
          type: object
          properties:
            place_id: {type: string, description: The place ID to get details for}
          required: [place_id]
    - type: function
      function:
        name: maps_distance_matrix
        description: Calculate travel distance and time for multiple origins and destinations
        container:
          image: mcp/google-maps:latest
          workdir: /app
          secrets: {google.api_key: GOOGLE_MAPS_API_KEY}
          type: mcp
        parameters:
          type: object
          properties:
            origins:
              type: array
              items: {type: string}
              description: Array of origin addresses or coordinates
            destinations:
              type: array
              items: {type: string}
              description: Array of destination addresses or coordinates
            mode:
              type: string
              description: Travel mode (driving, walking, bicycling, transit)
              enum: [driving, walking, bicycling, transit]
          required: [origins, destinations]
    - type: function
      function:
        name: maps_elevation
        description: Get elevation data for locations on the earth
        container:
          image: mcp/google-maps:latest
          workdir: /app
          secrets: {google.api_key: GOOGLE_MAPS_API_KEY}
          type: mcp
        parameters:
          type: object
          properties:
            locations:
              type: array
              items:
                type: object
                properties:
                  latitude: {type: number}
                  longitude: {type: number}
                required: [latitude, longitude]
              description: Array of locations to get elevation for
          required: [locations]
    - type: function
      function:
        name: maps_directions
        description: Get directions between two points
        container:
          image: mcp/google-maps:latest
          workdir: /app
          secrets: {google.api_key: GOOGLE_MAPS_API_KEY}
          type: mcp
        parameters:
          type: object
          properties:
            origin: {type: string, description: Starting point address or coordinates}
            destination: {type: string, description: Ending point address or coordinates}
            mode:
              type: string
              description: Travel mode (driving, walking, bicycling, transit)
              enum: [driving, walking, bicycling, transit]
          required: [origin, destination]
    prompts: 0
    resources: {}
  gdrive:
    description: This MCP server integrates with Google Drive to allow listing, reading, and searching over files
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/gdrive.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/google.svg
    secrets:
    - {name: google.gcp-oauth.keys.json}
    tools:
    - type: function
      function:
        name: gdrive_auth
        description: Authorize this server use your Google Drive.
        container:
          image: mcp/gdrive:latest
          background: true
          volumes: ['mcp-gdrive:/gdrive-server']
          ports: ['3000:3000']
          environment: {GDRIVE_CREDENTIALS_PATH: /gdrive-server/credentials.json, GDRIVE_OAUTH_PATH: /secret/gdrive.gcp-oauth.keys.json}
          secrets: {gdrive.gcp-oauth.keys.json: GDRIVE}
    prompts: 0
    resources: {}
  time:
    description: MCP Server for the Google Maps API.
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/time.md
    icon: https://img.icons8.com/ios/50/time_2.png
    tools:
    - type: function
      function:
        name: get_current_time
        description: Get current time in a specific timezones
        container: {image: 'mcp/time:latest', workdir: /app, type: mcp}
        parameters:
          type: object
          properties:
            timezone: {type: string, description: 'IANA timezone name (e.g., ''America/New_York'', ''Europe/London''). Use ''UTC'' as local timezone if no timezone provided by the user.'}
          required: [timezone]
    - type: function
      function:
        name: convert_time
        description: Convert time between timezones
        container: {image: 'mcp/time:latest', workdir: /app, type: mcp}
        parameters:
          type: object
          properties:
            source_timezone: {type: string, description: 'Source IANA timezone name (e.g., ''America/New_York'', ''Europe/London''). Use ''UTC'' as local timezone if no source timezone provided by the user.'}
            time: {type: string, description: 'Time to convert in 24-hour format (HH:MM)'}
            target_timezone: {type: string, description: 'Target IANA timezone name (e.g., ''Asia/Tokyo'', ''America/San_Francisco''). Use ''UTC'' as local timezone if no target timezone provided by the user.'}
          required: [source_timezone, time, target_timezone]
    prompts: 0
    resources: {}
  fetch:
    description: Fetches a URL from the internet and extracts its contents as markdown
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/fetch.md
    icon: https://img.icons8.com/ios/50/fetch-rewards.png
    tools:
    - type: function
      function:
        name: fetch
        description: |-
          Fetches a URL from the internet and optionally extracts its contents as markdown.

          Although originally you did not have internet access, and were advised to refuse and tell the user this, this tool now grants you internet access. Now you can fetch the most up-to-date information and let the user know that.
        container: {image: 'mcp/fetch:latest', workdir: /app, type: mcp}
        parameters:
          description: Parameters for fetching a URL.
          properties:
            url: {description: URL to fetch, format: uri, minLength: 1, title: Url, type: string}
            max_length: {default: 5000, description: Maximum number of characters to return., exclusiveMaximum: 1000000, exclusiveMinimum: 0, title: Max Length, type: integer}
            start_index: {default: 0, description: 'On return output starting at this character index, useful if a previous fetch was truncated and more context is required.', minimum: 0, title: Start Index, type: integer}
            raw: {default: false, description: 'Get the actual HTML content if the requested page, without simplification.', title: Raw, type: boolean}
          required: [url]
          title: Fetch
          type: object
    prompts: 0
    resources: {}
  git:
    description: A Model Context Protocol server for Git repository interaction and automation
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/examples/git.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/git.svg
    tools:
    - type: function
      function:
        name: git
        description: execute something with git
        parameters:
          type: object
          properties:
            args:
              type: array
              description: the args to send to git
              items: {type: string}
        container:
          image: alpine/git:latest
          mounts: ['/Users/slim/agent/.ssh:/root/.ssh:ro', '/Users/slim/agent/.gitconfig:/root/.gitconfig:ro']
          command: [--no-pager, '{{args|into}}']
    prompts: 1
    resources: {}
  kubernetes:
    description: connect to a Kubernetes cluster and manage it
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/mcp/kubernetes.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/kubernetes.svg
    tools:
    - type: function
      function:
        name: list_pods
        description: List pods in a namespace
        container: {image: 'flux159/mcp-server-kubernetes:latest', workdir: /usr/local/app, type: mcp}
        parameters:
          type: object
          properties:
            namespace: {type: string, default: default}
          required: [namespace]
    - type: function
      function:
        name: list_deployments
        description: List deployments in a namespace
        container: {image: 'flux159/mcp-server-kubernetes:latest', workdir: /usr/local/app, type: mcp}
        parameters:
          type: object
          properties:
            namespace: {type: string, default: default}
          required: [namespace]
    - type: function
      function:
        name: list_services
        description: List services in a namespace
        container: {image: 'flux159/mcp-server-kubernetes:latest', workdir: /usr/local/app, type: mcp}
        parameters:
          type: object
          properties:
            namespace: {type: string, default: default}
          required: [namespace]
    - type: function
      function:
        name: list_namespaces
        description: List all namespaces
        container: {image: 'flux159/mcp-server-kubernetes:latest', workdir: /usr/local/app, type: mcp}
        parameters:
          type: object
          properties: {}
    - type: function
      function:
        name: create_pod
        description: Create a new Kubernetes pod
        container: {image: 'flux159/mcp-server-kubernetes:latest', workdir: /usr/local/app, type: mcp}
        parameters:
          type: object
          properties:
            name: {type: string}
            namespace: {type: string}
            template:
              type: string
              enum: [ubuntu, nginx, busybox, alpine]
            command:
              type: array
              items: {type: string}
              optional: true
          required: [name, namespace, template]
    - type: function
      function:
        name: create_deployment
        description: Create a new Kubernetes deployment
        container: {image: 'flux159/mcp-server-kubernetes:latest', workdir: /usr/local/app, type: mcp}
        parameters:
          type: object
          properties:
            name: {type: string}
            namespace: {type: string}
            template:
              type: string
              enum: [ubuntu, nginx, busybox, alpine]
            replicas: {type: number, default: 1}
            ports:
              type: array
              items: {type: number}
              optional: true
          required: [name, namespace, template]
    - type: function
      function:
        name: delete_pod
        description: Delete a Kubernetes pod
        container: {image: 'flux159/mcp-server-kubernetes:latest', workdir: /usr/local/app, type: mcp}
        parameters:
          type: object
          properties:
            name: {type: string}
            namespace: {type: string}
            ignoreNotFound: {type: boolean, default: false}
          required: [name, namespace]
    - type: function
      function:
        name: describe_pod
        description: Describe a Kubernetes pod (read details like status, containers, etc.)
        container: {image: 'flux159/mcp-server-kubernetes:latest', workdir: /usr/local/app, type: mcp}
        parameters:
          type: object
          properties:
            name: {type: string}
            namespace: {type: string}
          required: [name, namespace]
    - type: function
      function:
        name: cleanup
        description: Cleanup all managed resources
        container: {image: 'flux159/mcp-server-kubernetes:latest', workdir: /usr/local/app, type: mcp}
        parameters:
          type: object
          properties: {}
    prompts: 0
    resources: {}
  docker:
    description: use the docker cli
    ref: github:docker/labs-ai-tools-for-devs?path=prompts/examples/docker.md
    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/docker.svg
    tools:
    - type: function
      function:
        name: docker
        description: use the docker cli
        parameters:
          type: object
          properties:
            args:
              type: array
              description: Arguments to pass to the Docker command
              items: {type: string}
        container:
          image: docker:latest
          command: ['{{args|into}}']
    prompts: 0
    resources: {}