NVIDIA Capabilities

Before deploying a new AI model version, checks GitHub Actions test status, verifies Datadog SLO compliance, and requires a passing ServiceNow change request.

naftiko: "0.5"
info:
  label: "AI Model Deployment Release Gate"
  description: "Before deploying a new AI model version, checks GitHub Actions test status, verifies Datadog SLO compliance, and requires a passing ServiceNow change request."
  tags:
    - devops
    - ai
    - github
    - datadog
    - servicenow
    - release-management
capability:
  exposes:
    - type: mcp
      namespace: ai-release-ops
      port: 8080
      tools:
        - name: validate-model-release
          description: "Given a GitHub repository, commit SHA, and ServiceNow change number, validate that CI tests pass, SLO compliance is met in Datadog, and the change request is approved before releasing an AI model. Use as a pre-deployment gate."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository containing the AI model code."
            - name: commit_sha
              in: body
              type: string
              description: "The commit SHA to validate for release."
            - name: change_number
              in: body
              type: string
              description: "The ServiceNow change request number for this deployment."
            - name: datadog_monitor_id
              in: body
              type: string
              description: "The Datadog SLO monitor ID to check for compliance."
          steps:
            - name: check-ci-status
              type: call
              call: "github.get-commit-status"
              with:
                owner: "nvidia"
                repo: "{{repository}}"
                ref: "{{commit_sha}}"
            - name: check-slo
              type: call
              call: "datadog.get-monitor"
              with:
                monitor_id: "{{datadog_monitor_id}}"
            - name: get-change-approval
              type: call
              call: "servicenow.get-change-request"
              with:
                number: "{{change_number}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: commit-statuses
          path: "/repos/{{owner}}/{{repo}}/commits/{{ref}}/status"
          inputParameters:
            - name: owner
              in: path
            - name: repo
              in: path
            - name: ref
              in: path
          operations:
            - name: get-commit-status
              method: GET
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-requests
          path: "/table/change_request"
          inputParameters:
            - name: number
              in: query
          operations:
            - name: get-change-request
              method: GET

Submits a change request in ServiceNow for a planned infrastructure change, waits for approval state, and unblocks or blocks the deployment pipeline.

naftiko: "0.5"
info:
  label: "Change Management Approval Gate"
  description: "Submits a change request in ServiceNow for a planned infrastructure change, waits for approval state, and unblocks or blocks the deployment pipeline."
  tags:
    - itsm
    - change-management
    - servicenow
    - devops
capability:
  exposes:
    - type: mcp
      namespace: change-management
      port: 8080
      tools:
        - name: submit-change-request
          description: "Given a change description, risk level, and planned start/end dates, create a ServiceNow change request and return its number and approval state. Use as a deployment gate before releasing to production."
          inputParameters:
            - name: short_description
              in: body
              type: string
              description: "Brief description of the planned infrastructure change."
            - name: risk_level
              in: body
              type: string
              description: "Risk level of the change: 'low', 'medium', or 'high'."
            - name: planned_start
              in: body
              type: string
              description: "Planned start date/time in ISO 8601 format."
            - name: planned_end
              in: body
              type: string
              description: "Planned end date/time in ISO 8601 format."
          call: "servicenow.create-change-request"
          with:
            short_description: "{{short_description}}"
            risk: "{{risk_level}}"
            start_date: "{{planned_start}}"
            end_date: "{{planned_end}}"
          outputParameters:
            - name: change_number
              type: string
              mapping: "$.result.number"
            - name: state
              type: string
              mapping: "$.result.state"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-requests
          path: "/table/change_request"
          operations:
            - name: create-change-request
              method: POST

On a GitHub Actions pipeline failure on a protected branch, creates a Jira bug, posts a Datadog event marker, and alerts the engineering Slack channel.

naftiko: "0.5"
info:
  label: "CI/CD Pipeline Failure Response"
  description: "On a GitHub Actions pipeline failure on a protected branch, creates a Jira bug, posts a Datadog event marker, and alerts the engineering Slack channel."
  tags:
    - devops
    - ci-cd
    - github
    - jira
    - datadog
    - slack
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: devops-ops
      port: 8080
      tools:
        - name: handle-pipeline-failure
          description: "Given a GitHub Actions pipeline failure event, create a Jira bug in the ENG project, post a Datadog event marker, and alert the #engineering-alerts Slack channel with full context."
          inputParameters:
            - name: pipeline_id
              in: body
              type: string
              description: "The GitHub Actions workflow run ID."
            - name: repository
              in: body
              type: string
              description: "The GitHub repository full name (e.g., 'nvidia/cuda-toolkit')."
            - name: branch
              in: body
              type: string
              description: "The branch name that triggered the failure."
            - name: failed_job
              in: body
              type: string
              description: "Name of the failed workflow job."
            - name: commit_sha
              in: body
              type: string
              description: "The commit SHA that triggered the run."
            - name: log_url
              in: body
              type: string
              description: "URL to the full pipeline failure log."
          steps:
            - name: create-jira-bug
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Bug"
                summary: "[CI Failure] {{repository}} / {{branch}} — {{failed_job}}"
                description: "Pipeline: {{pipeline_id}}\nBranch: {{branch}}\nCommit: {{commit_sha}}\nLog: {{log_url}}"
            - name: post-datadog-event
              type: call
              call: "datadog.create-event"
              with:
                title: "CI Failure: {{repository}} {{branch}}"
                text: "Job {{failed_job}} failed. Commit: {{commit_sha}}"
                alert_type: "error"
                source_type_name: "github"
            - name: notify-slack
              type: call
              call: "slack.post-message"
              with:
                channel: "engineering-alerts"
                text: "Pipeline Failure: {{repository}} | Branch: {{branch}} | Job: {{failed_job}} | Jira: {{create-jira-bug.key}} | Log: {{log_url}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Publishes a generated technical document or release note to a Confluence space and notifies the relevant Microsoft Teams channel.

naftiko: "0.5"
info:
  label: "Confluence Documentation Publisher"
  description: "Publishes a generated technical document or release note to a Confluence space and notifies the relevant Microsoft Teams channel."
  tags:
    - communication
    - confluence
    - microsoft-teams
    - documentation
capability:
  exposes:
    - type: mcp
      namespace: docs-publishing
      port: 8080
      tools:
        - name: publish-doc-to-confluence
          description: "Given a Confluence space key, parent page ID, title, and content, create a new Confluence page and notify the designated Teams channel. Use for publishing release notes, architecture docs, or runbooks."
          inputParameters:
            - name: space_key
              in: body
              type: string
              description: "The Confluence space key (e.g., 'CUDA')."
            - name: parent_page_id
              in: body
              type: string
              description: "The Confluence page ID of the parent under which to publish."
            - name: title
              in: body
              type: string
              description: "The title of the new Confluence page."
            - name: content
              in: body
              type: string
              description: "The page body content in Confluence storage format or markdown."
            - name: teams_channel_id
              in: body
              type: string
              description: "The Microsoft Teams channel ID to notify after publishing."
          steps:
            - name: create-confluence-page
              type: call
              call: "confluence.create-page"
              with:
                space_key: "{{space_key}}"
                parent_page_id: "{{parent_page_id}}"
                title: "{{title}}"
                content: "{{content}}"
            - name: notify-teams
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "{{teams_channel_id}}"
                text: "New doc published: {{title}} — {{create-confluence-page.webui_url}}"
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://nvidia.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: team_id
              in: path
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

When a Datadog monitor alert fires, automatically creates a ServiceNow incident with alert details and assigns it to the on-call team.

naftiko: "0.5"
info:
  label: "Datadog Alert to ServiceNow Incident Bridge"
  description: "When a Datadog monitor alert fires, automatically creates a ServiceNow incident with alert details and assigns it to the on-call team."
  tags:
    - observability
    - datadog
    - servicenow
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: alert-bridge
      port: 8080
      tools:
        - name: bridge-alert-to-incident
          description: "Given a Datadog monitor alert payload (monitor ID, state, message), create a corresponding ServiceNow incident and return the incident number. Use to automatically convert monitoring alerts into tracked incidents."
          inputParameters:
            - name: monitor_id
              in: body
              type: string
              description: "The Datadog monitor ID that fired."
            - name: monitor_name
              in: body
              type: string
              description: "Human-readable name of the Datadog monitor."
            - name: alert_message
              in: body
              type: string
              description: "The alert message body from Datadog."
            - name: environment
              in: body
              type: string
              description: "Affected environment (e.g., 'prod', 'staging')."
          steps:
            - name: get-monitor-details
              type: call
              call: "datadog.get-monitor"
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-servicenow-incident
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Alert: {{monitor_name}} in {{environment}}"
                description: "{{alert_message}}\nDatadog Monitor ID: {{monitor_id}}"
                urgency: "1"
                category: "monitoring"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST

When Datadog detects high CUDA compilation latency, creates a Jira P1 and notifies the CUDA team in Slack.

naftiko: "0.5"
info:
  label: "Datadog CUDA Compilation Latency Alert"
  description: "When Datadog detects high CUDA compilation latency, creates a Jira P1 and notifies the CUDA team in Slack."
  tags:
    - engineering
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: cuda-perf
      port: 8080
      tools:
        - name: handle-compilation-alert
          description: "Given a Datadog monitor ID for CUDA compilation latency, create a Jira P1 and notify the CUDA team."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
          steps:
            - name: get-monitor
              type: call
              call: dd-cuda.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-p1
              type: call
              call: jira-cuda.create-issue
              with:
                project_key: "CUDA"
                issuetype: "Incident"
                summary: "P1: CUDA compilation latency — {{get-monitor.name}}"
                priority: "Highest"
            - name: notify-cuda
              type: call
              call: slack-cuda.post-message
              with:
                channel: "cuda-engineering"
                text: "COMPILATION ALERT: {{get-monitor.name}} | Jira: {{create-p1.key}}"
  consumes:
    - type: http
      namespace: dd-cuda
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: jira-cuda
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-cuda
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates a weekly SLO compliance digest for DGX clusters from Datadog and posts it to the infrastructure Slack channel.

naftiko: "0.5"
info:
  label: "Datadog DGX Cluster SLO Weekly Digest"
  description: "Generates a weekly SLO compliance digest for DGX clusters from Datadog and posts it to the infrastructure Slack channel."
  tags:
    - infrastructure
    - datadog
    - slack
    - slo
capability:
  exposes:
    - type: mcp
      namespace: dgx-slo
      port: 8080
      tools:
        - name: handle-dgx-slo-digest
          description: "Given a Datadog SLO ID, generate a weekly DGX cluster SLO digest and post to Slack."
          inputParameters:
            - name: slo_id
              in: body
              type: string
              description: "Datadog SLO ID for DGX cluster."
          steps:
            - name: get-slo
              type: call
              call: dd-dgx.get-slo-history
              with:
                slo_id: "{{slo_id}}"
            - name: post-digest
              type: call
              call: slack-infra.post-message
              with:
                channel: "infrastructure"
                text: "DGX SLO Weekly: Target: {{get-slo.target}}% | Actual: {{get-slo.overall_status}} | Budget: {{get-slo.error_budget_remaining}}%"
  consumes:
    - type: http
      namespace: dd-dgx
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: slo
          path: "/slo/{{slo_id}}/history"
          inputParameters:
            - name: slo_id
              in: path
          operations:
            - name: get-slo-history
              method: GET
    - type: http
      namespace: slack-infra
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Datadog for current GPU cluster utilization metrics across data center hosts.

naftiko: "0.5"
info:
  label: "Datadog GPU Cluster Utilization Check"
  description: "Queries Datadog for current GPU cluster utilization metrics across data center hosts."
  tags:
    - infrastructure
    - datadog
    - gpu
capability:
  exposes:
    - type: mcp
      namespace: gpu-infra
      port: 8080
      tools:
        - name: get-gpu-utilization
          description: "Given a cluster name, return GPU utilization metrics from Datadog. Use for capacity planning and workload scheduling."
          inputParameters:
            - name: cluster_name
              in: body
              type: string
              description: "GPU cluster name to query."
          call: "dd-gpu.get-metrics"
          with:
            query: "avg:gpu.utilization{cluster:{{cluster_name}}}"
          outputParameters:
            - name: series
              type: array
              mapping: "$.series"
  consumes:
    - type: http
      namespace: dd-gpu
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: metrics
          path: "/query"
          inputParameters:
            - name: query
              in: query
          operations:
            - name: get-metrics
              method: GET

When Datadog detects GPU driver crashes, creates a Jira bug and notifies the driver team in Slack.

naftiko: "0.5"
info:
  label: "Datadog GPU Driver Crash Handler"
  description: "When Datadog detects GPU driver crashes, creates a Jira bug and notifies the driver team in Slack."
  tags:
    - drivers
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: driver-crash
      port: 8080
      tools:
        - name: handle-driver-crash
          description: "Given a Datadog monitor ID for driver crashes, create a Jira bug and notify the driver team."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
            - name: driver_version
              in: body
              type: string
              description: "GPU driver version."
          steps:
            - name: get-monitor
              type: call
              call: dd-driver.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-bug
              type: call
              call: jira-driver.create-issue
              with:
                project_key: "DRV"
                issuetype: "Bug"
                summary: "Driver crash: v{{driver_version}} — {{get-monitor.name}}"
                priority: "Critical"
            - name: notify-driver
              type: call
              call: slack-driver.post-message
              with:
                channel: "driver-engineering"
                text: "DRIVER CRASH: v{{driver_version}} | {{get-monitor.name}} | Jira: {{create-bug.key}}"
  consumes:
    - type: http
      namespace: dd-driver
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: jira-driver
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-driver
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects GPU power draw anomalies, creates a ServiceNow incident and notifies the facilities team in Slack.

naftiko: "0.5"
info:
  label: "Datadog GPU Power Draw Anomaly Handler"
  description: "When Datadog detects GPU power draw anomalies, creates a ServiceNow incident and notifies the facilities team in Slack."
  tags:
    - facilities
    - datadog
    - servicenow
    - slack
capability:
  exposes:
    - type: mcp
      namespace: power-ops
      port: 8080
      tools:
        - name: handle-power-anomaly
          description: "Given a Datadog monitor ID for power anomalies, create a ServiceNow incident and notify facilities."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
            - name: rack_id
              in: body
              type: string
              description: "Rack identifier."
          steps:
            - name: get-monitor
              type: call
              call: dd-power.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-incident
              type: call
              call: snow-power.create-incident
              with:
                short_description: "Power anomaly: Rack {{rack_id}} — {{get-monitor.name}}"
                urgency: "2"
            - name: notify-facilities
              type: call
              call: slack-power.post-message
              with:
                channel: "facilities-ops"
                text: "POWER ANOMALY: Rack {{rack_id}} | {{get-monitor.name}} | SNOW: {{create-incident.number}}"
  consumes:
    - type: http
      namespace: dd-power
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: snow-power
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: bearer
        token: "$secrets.servicenow_token"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack-power
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects GPU thermal threshold breaches, creates a ServiceNow incident and notifies the data center ops Slack channel.

naftiko: "0.5"
info:
  label: "Datadog GPU Thermal Alert to ServiceNow"
  description: "When Datadog detects GPU thermal threshold breaches, creates a ServiceNow incident and notifies the data center ops Slack channel."
  tags:
    - infrastructure
    - datadog
    - servicenow
    - slack
capability:
  exposes:
    - type: mcp
      namespace: thermal-ops
      port: 8080
      tools:
        - name: handle-thermal-alert
          description: "Given a Datadog monitor ID for GPU thermal alerts, create a ServiceNow incident and notify data center ops in Slack."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID for the thermal alert."
            - name: host_name
              in: body
              type: string
              description: "Host experiencing thermal issues."
          steps:
            - name: get-monitor
              type: call
              call: dd-thermal.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-incident
              type: call
              call: snow-thermal.create-incident
              with:
                short_description: "GPU thermal alert: {{host_name}} — {{get-monitor.name}}"
                urgency: "1"
                category: "Hardware"
            - name: notify-ops
              type: call
              call: slack-dc.post-message
              with:
                channel: "datacenter-ops"
                text: "THERMAL ALERT: {{host_name}} | {{get-monitor.name}} | SNOW: {{create-incident.number}}"
  consumes:
    - type: http
      namespace: dd-thermal
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: snow-thermal
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: bearer
        token: "$secrets.servicenow_token"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack-dc
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects H100 GPU memory errors, creates a ServiceNow incident and notifies the hardware team in Slack.

naftiko: "0.5"
info:
  label: "Datadog H100 Memory Error Handler"
  description: "When Datadog detects H100 GPU memory errors, creates a ServiceNow incident and notifies the hardware team in Slack."
  tags:
    - hardware
    - datadog
    - servicenow
    - slack
capability:
  exposes:
    - type: mcp
      namespace: h100-ops
      port: 8080
      tools:
        - name: handle-memory-error
          description: "Given a Datadog monitor ID for H100 memory errors, create a ServiceNow incident and notify the hardware team in Slack."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
            - name: host_name
              in: body
              type: string
              description: "Host with memory errors."
          steps:
            - name: get-monitor
              type: call
              call: dd-h100.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-incident
              type: call
              call: snow-hw.create-incident
              with:
                short_description: "H100 memory error: {{host_name}} — {{get-monitor.name}}"
                urgency: "2"
            - name: notify-hw
              type: call
              call: slack-hw.post-message
              with:
                channel: "hardware-engineering"
                text: "H100 MEMORY ERROR: {{host_name}} | {{get-monitor.name}} | SNOW: {{create-incident.number}}"
  consumes:
    - type: http
      namespace: dd-h100
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: snow-hw
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: bearer
        token: "$secrets.servicenow_token"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack-hw
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks inference service latency metrics from Datadog for NVIDIA AI platform services.

naftiko: "0.5"
info:
  label: "Datadog Inference Service Latency Check"
  description: "Checks inference service latency metrics from Datadog for NVIDIA AI platform services."
  tags:
    - ai
    - datadog
    - inference
capability:
  exposes:
    - type: mcp
      namespace: inference-ops
      port: 8080
      tools:
        - name: get-inference-latency
          description: "Given a service name, return current inference latency metrics from Datadog. Use for SLA compliance monitoring."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "Inference service name in Datadog."
          call: "dd-inference.get-metrics"
          with:
            query: "avg:inference.latency{service:{{service_name}}}"
          outputParameters:
            - name: series
              type: array
              mapping: "$.series"
  consumes:
    - type: http
      namespace: dd-inference
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: metrics
          path: "/query"
          inputParameters:
            - name: query
              in: query
          operations:
            - name: get-metrics
              method: GET

Queries Datadog for the current health status of a specified host or service, returning monitor states and alert counts.

naftiko: "0.5"
info:
  label: "Datadog Infrastructure Health Check"
  description: "Queries Datadog for the current health status of a specified host or service, returning monitor states and alert counts."
  tags:
    - observability
    - datadog
    - monitoring
capability:
  exposes:
    - type: mcp
      namespace: observability
      port: 8080
      tools:
        - name: get-service-health
          description: "Given a Datadog service name, return the current monitor states and active alert count. Use to check GPU cluster or application health before a deployment."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "The Datadog service name to query (e.g., 'cuda-inference-service')."
          call: "datadog.get-monitors"
          with:
            name: "{{service_name}}"
          outputParameters:
            - name: monitors
              type: array
              mapping: "$.monitors"
            - name: alert_count
              type: number
              mapping: "$.total_count"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          inputParameters:
            - name: name
              in: query
          operations:
            - name: get-monitors
              method: GET

When Datadog detects GPU Kubernetes cluster autoscaling events, logs to Snowflake and notifies the platform team in Slack.

naftiko: "0.5"
info:
  label: "Datadog Kubernetes Cluster Autoscale Alert"
  description: "When Datadog detects GPU Kubernetes cluster autoscaling events, logs to Snowflake and notifies the platform team in Slack."
  tags:
    - platform
    - datadog
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: k8s-ops
      port: 8080
      tools:
        - name: handle-autoscale-alert
          description: "Given a Datadog monitor ID for K8s autoscale events, log to Snowflake and notify in Slack."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
            - name: cluster_name
              in: body
              type: string
              description: "Kubernetes cluster name."
          steps:
            - name: get-monitor
              type: call
              call: dd-k8s.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: log-event
              type: call
              call: snowflake-k8s.run-query
              with:
                cluster: "{{cluster_name}}"
                event: "autoscale"
            - name: notify-platform
              type: call
              call: slack-k8s.post-message
              with:
                channel: "platform-ops"
                text: "K8S AUTOSCALE: {{cluster_name}} | {{get-monitor.name}} | Logged to Snowflake"
  consumes:
    - type: http
      namespace: dd-k8s
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: snowflake-k8s
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-k8s
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects GPU networking switch failures, creates a ServiceNow incident and notifies the network ops Slack channel.

naftiko: "0.5"
info:
  label: "Datadog Networking Switch Failure Handler"
  description: "When Datadog detects GPU networking switch failures, creates a ServiceNow incident and notifies the network ops Slack channel."
  tags:
    - networking
    - datadog
    - servicenow
    - slack
capability:
  exposes:
    - type: mcp
      namespace: network-ops
      port: 8080
      tools:
        - name: handle-switch-failure
          description: "Given a Datadog monitor ID for a switch failure, create a ServiceNow incident and notify network ops."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
            - name: switch_id
              in: body
              type: string
              description: "Switch identifier."
          steps:
            - name: get-monitor
              type: call
              call: dd-net.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-incident
              type: call
              call: snow-net.create-incident
              with:
                short_description: "Switch failure: {{switch_id}} — {{get-monitor.name}}"
                urgency: "1"
            - name: notify-net
              type: call
              call: slack-net.post-message
              with:
                channel: "network-ops"
                text: "SWITCH FAILURE: {{switch_id}} | {{get-monitor.name}} | SNOW: {{create-incident.number}}"
  consumes:
    - type: http
      namespace: dd-net
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: snow-net
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: bearer
        token: "$secrets.servicenow_token"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack-net
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Datadog for NVLink interconnect bandwidth utilization across GPU clusters.

naftiko: "0.5"
info:
  label: "Datadog NVLink Bandwidth Monitor"
  description: "Queries Datadog for NVLink interconnect bandwidth utilization across GPU clusters."
  tags:
    - infrastructure
    - datadog
    - nvlink
capability:
  exposes:
    - type: mcp
      namespace: nvlink-ops
      port: 8080
      tools:
        - name: get-nvlink-bandwidth
          description: "Given a cluster name, return NVLink bandwidth utilization from Datadog. Use for interconnect performance monitoring."
          inputParameters:
            - name: cluster_name
              in: body
              type: string
              description: "GPU cluster name."
          call: "dd-nvlink.get-metrics"
          with:
            query: "avg:nvlink.bandwidth{cluster:{{cluster_name}}}"
          outputParameters:
            - name: series
              type: array
              mapping: "$.series"
  consumes:
    - type: http
      namespace: dd-nvlink
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: metrics
          path: "/query"
          inputParameters:
            - name: query
              in: query
          operations:
            - name: get-metrics
              method: GET

Queries Datadog for all SLO compliance breaches in the past 7 days and publishes a weekly reliability report to a Confluence page and the engineering Slack channel.

naftiko: "0.5"
info:
  label: "Datadog SLO Breach Weekly Report"
  description: "Queries Datadog for all SLO compliance breaches in the past 7 days and publishes a weekly reliability report to a Confluence page and the engineering Slack channel."
  tags:
    - observability
    - datadog
    - confluence
    - slack
    - slo
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: reliability-reporting
      port: 8080
      tools:
        - name: publish-slo-weekly-report
          description: "Fetch all SLO compliance data from Datadog for the past 7 days, publish a reliability report to Confluence, and post a summary to Slack. Use for weekly engineering reliability reviews."
          inputParameters:
            - name: confluence_space_key
              in: body
              type: string
              description: "Confluence space key for the reliability report."
            - name: confluence_parent_id
              in: body
              type: string
              description: "Confluence parent page ID for the weekly report."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel to post the SLO summary to."
          steps:
            - name: get-slo-data
              type: call
              call: "datadog.list-slos"
              with:
                query: "service:nvidia-production"
            - name: publish-report
              type: call
              call: "confluence.create-page"
              with:
                space_key: "{{confluence_space_key}}"
                parent_page_id: "{{confluence_parent_id}}"
                title: "Weekly SLO Reliability Report"
                content: "SLO compliance data from Datadog for the past 7 days across NVIDIA production services."
            - name: notify-engineering
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Weekly SLO Report published: {{publish-report.webui_url}}"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: slos
          path: "/slo"
          inputParameters:
            - name: query
              in: query
          operations:
            - name: list-slos
              method: GET
    - type: http
      namespace: confluence
      baseUri: "https://nvidia.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new hire is created in Workday, opens a ServiceNow onboarding ticket, provisions a GitHub org membership, and sends a Microsoft Teams welcome message.

naftiko: "0.5"
info:
  label: "Employee Onboarding Orchestrator"
  description: "When a new hire is created in Workday, opens a ServiceNow onboarding ticket, provisions a GitHub org membership, and sends a Microsoft Teams welcome message."
  tags:
    - hr
    - onboarding
    - workday
    - servicenow
    - github
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: hr-onboarding
      port: 8080
      tools:
        - name: trigger-onboarding
          description: "Given a Workday employee ID and start date, orchestrate the full onboarding sequence across ServiceNow, GitHub, and Microsoft Teams. Use when a new engineer or business hire joins NVIDIA."
          inputParameters:
            - name: workday_employee_id
              in: body
              type: string
              description: "The Workday worker ID for the new hire."
            - name: start_date
              in: body
              type: string
              description: "The employee's start date in ISO 8601 format (YYYY-MM-DD)."
            - name: github_team_slug
              in: body
              type: string
              description: "The GitHub team slug the new hire should be added to (e.g., 'cuda-engineering')."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{workday_employee_id}}"
            - name: open-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                category: "hr_onboarding"
                short_description: "New hire onboarding: {{get-employee.full_name}}"
                assigned_group: "IT_Onboarding"
            - name: add-github-member
              type: call
              call: "github.add-team-member"
              with:
                org: "nvidia"
                team_slug: "{{github_team_slug}}"
                username: "{{get-employee.github_username}}"
            - name: send-welcome
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{get-employee.work_email}}"
                text: "Welcome to NVIDIA, {{get-employee.first_name}}! Your IT onboarding ticket is {{open-ticket.number}}."
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/nvidia/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: team-members
          path: "/orgs/{{org}}/teams/{{team_slug}}/memberships/{{username}}"
          inputParameters:
            - name: org
              in: path
            - name: team_slug
              in: path
            - name: username
              in: path
          operations:
            - name: add-team-member
              method: PUT
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: chat-messages
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST

When an employee departure is recorded in Workday, revokes GitHub org access, suspends the Okta account, and creates a ServiceNow offboarding task.

naftiko: "0.5"
info:
  label: "Engineer Offboarding Workflow"
  description: "When an employee departure is recorded in Workday, revokes GitHub org access, suspends the Okta account, and creates a ServiceNow offboarding task."
  tags:
    - hr
    - offboarding
    - workday
    - github
    - okta
    - servicenow
capability:
  exposes:
    - type: mcp
      namespace: hr-offboarding
      port: 8080
      tools:
        - name: trigger-offboarding
          description: "Given a Workday employee ID, orchestrate the full offboarding sequence: revoke GitHub org membership, suspend Okta user, and open a ServiceNow offboarding task. Use when an employee separates from NVIDIA."
          inputParameters:
            - name: workday_employee_id
              in: body
              type: string
              description: "The Workday worker ID of the departing employee."
            - name: last_day
              in: body
              type: string
              description: "The employee's last working day in ISO 8601 format (YYYY-MM-DD)."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{workday_employee_id}}"
            - name: revoke-github
              type: call
              call: "github.remove-org-member"
              with:
                org: "nvidia"
                username: "{{get-employee.github_username}}"
            - name: suspend-okta-user
              type: call
              call: "okta.suspend-user"
              with:
                user_id: "{{get-employee.okta_user_id}}"
            - name: create-offboarding-task
              type: call
              call: "servicenow.create-task"
              with:
                short_description: "Offboarding: {{get-employee.full_name}} — last day {{last_day}}"
                category: "hr_offboarding"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/nvidia/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-members
          path: "/orgs/{{org}}/members/{{username}}"
          inputParameters:
            - name: org
              in: path
            - name: username
              in: path
          operations:
            - name: remove-org-member
              method: DELETE
    - type: http
      namespace: okta
      baseUri: "https://nvidia.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users/{{user_id}}/lifecycle/suspend"
          inputParameters:
            - name: user_id
              in: path
          operations:
            - name: suspend-user
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: tasks
          path: "/table/sc_task"
          operations:
            - name: create-task
              method: POST

Monitors CUDA compatibility test matrix results in GitHub CI and notifies the CUDA team in Slack on failures.

naftiko: "0.5"
info:
  label: "GitHub CUDA Compat Test Matrix"
  description: "Monitors CUDA compatibility test matrix results in GitHub CI and notifies the CUDA team in Slack on failures."
  tags:
    - testing
    - github
    - slack
    - cuda
capability:
  exposes:
    - type: mcp
      namespace: cuda-compat
      port: 8080
      tools:
        - name: handle-compat-test
          description: "Given a GitHub run ID, check compatibility test matrix results and notify on failures."
          inputParameters:
            - name: run_id
              in: body
              type: integer
              description: "GitHub Actions run ID."
          steps:
            - name: get-run
              type: call
              call: github-compat.get-run
              with:
                run_id: "{{run_id}}"
            - name: notify-team
              type: call
              call: slack-compat.post-message
              with:
                channel: "cuda-testing"
                text: "CUDA Compat Test: Run {{run_id}} | {{get-run.name}} | Status: {{get-run.conclusion}} | URL: {{get-run.html_url}}"
  consumes:
    - type: http
      namespace: github-compat
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: runs
          path: "/repos/NVIDIA/cuda-compat/actions/runs/{{run_id}}"
          inputParameters:
            - name: run_id
              in: path
          operations:
            - name: get-run
              method: GET
    - type: http
      namespace: slack-compat
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Processes GitHub security advisories for CUDA repositories, creates Jira security tickets, and notifies the security team in Slack.

naftiko: "0.5"
info:
  label: "GitHub CUDA Security Advisory Handler"
  description: "Processes GitHub security advisories for CUDA repositories, creates Jira security tickets, and notifies the security team in Slack."
  tags:
    - security
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: cuda-security
      port: 8080
      tools:
        - name: handle-cuda-advisory
          description: "Given a GitHub advisory ID, create a Jira security ticket and notify the security team in Slack."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "GitHub repository name."
            - name: alert_number
              in: body
              type: integer
              description: "Security alert number."
          steps:
            - name: get-alert
              type: call
              call: github-sec.get-alert
              with:
                repo_name: "{{repo_name}}"
                alert_number: "{{alert_number}}"
            - name: create-ticket
              type: call
              call: jira-sec.create-issue
              with:
                project_key: "SEC"
                issuetype: "Bug"
                summary: "Security: {{get-alert.rule.description}} in {{repo_name}}"
                priority: "Critical"
            - name: notify-security
              type: call
              call: slack-sec.post-message
              with:
                channel: "security-alerts"
                text: "CUDA SECURITY: {{repo_name}} | {{get-alert.rule.description}} | Severity: {{get-alert.rule.severity}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: github-sec
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: alerts
          path: "/repos/NVIDIA/{{repo_name}}/code-scanning/alerts/{{alert_number}}"
          inputParameters:
            - name: repo_name
              in: path
            - name: alert_number
              in: path
          operations:
            - name: get-alert
              method: GET
    - type: http
      namespace: jira-sec
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-sec
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the review status of a pull request in the CUDA toolkit repository.

naftiko: "0.5"
info:
  label: "GitHub CUDA Toolkit PR Status"
  description: "Retrieves the review status of a pull request in the CUDA toolkit repository."
  tags:
    - engineering
    - github
    - cuda
capability:
  exposes:
    - type: mcp
      namespace: cuda-dev
      port: 8080
      tools:
        - name: get-cuda-pr
          description: "Given a PR number, return the CUDA toolkit PR review status. Use for merge readiness checks."
          inputParameters:
            - name: pr_number
              in: body
              type: integer
              description: "Pull request number."
          call: "github-cuda.get-pr"
          with:
            pr_number: "{{pr_number}}"
          outputParameters:
            - name: pr
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-cuda
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pulls
          path: "/repos/NVIDIA/cuda-toolkit/pulls/{{pr_number}}"
          inputParameters:
            - name: pr_number
              in: path
          operations:
            - name: get-pr
              method: GET

Generates DeepStream SDK release notes from GitHub PRs and posts them to the product team Slack channel.

naftiko: "0.5"
info:
  label: "GitHub DeepStream SDK Release Notes"
  description: "Generates DeepStream SDK release notes from GitHub PRs and posts them to the product team Slack channel."
  tags:
    - product
    - github
    - slack
    - deepstream
capability:
  exposes:
    - type: mcp
      namespace: deepstream-release
      port: 8080
      tools:
        - name: handle-release-notes
          description: "Given a release tag, compile release notes and post to Slack."
          inputParameters:
            - name: release_tag
              in: body
              type: string
              description: "GitHub release tag."
          steps:
            - name: get-release
              type: call
              call: github-ds.get-release
              with:
                tag: "{{release_tag}}"
            - name: post-notes
              type: call
              call: slack-ds.post-message
              with:
                channel: "deepstream-releases"
                text: "DeepStream Release: {{release_tag}} | {{get-release.name}} | {{get-release.html_url}}"
  consumes:
    - type: http
      namespace: github-ds
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/NVIDIA/DeepStream/releases/tags/{{tag}}"
          inputParameters:
            - name: tag
              in: path
          operations:
            - name: get-release
              method: GET
    - type: http
      namespace: slack-ds
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches open Dependabot security alerts for a GitHub repository and creates Jira tickets for critical and high severity vulnerabilities.

naftiko: "0.5"
info:
  label: "GitHub Dependabot Alert Triage"
  description: "Fetches open Dependabot security alerts for a GitHub repository and creates Jira tickets for critical and high severity vulnerabilities."
  tags:
    - security
    - devops
    - github
    - jira
    - vulnerability-management
capability:
  exposes:
    - type: mcp
      namespace: vuln-triage
      port: 8080
      tools:
        - name: triage-dependabot-alerts
          description: "Fetch open Dependabot alerts for a GitHub repository at critical or high severity and create Jira security tickets for each. Use during weekly vulnerability review cycles or after a new CVE disclosure."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "GitHub repository name within the NVIDIA org (e.g., 'triton-inference-server')."
            - name: severity
              in: body
              type: string
              description: "Minimum severity to triage: 'critical' or 'high'."
            - name: jira_project_key
              in: body
              type: string
              description: "The Jira project key for security tickets (e.g., 'SECURITY')."
          steps:
            - name: get-dependabot-alerts
              type: call
              call: "github.list-dependabot-alerts"
              with:
                owner: "nvidia"
                repo: "{{repository}}"
                severity: "{{severity}}"
                state: "open"
            - name: create-security-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "{{jira_project_key}}"
                issuetype: "Bug"
                summary: "Dependabot {{severity}} vulnerabilities in {{repository}}"
                description: "Open Dependabot alerts at {{severity}} severity in {{repository}}. Immediate remediation required."
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: dependabot-alerts
          path: "/repos/{{owner}}/{{repo}}/dependabot/alerts"
          inputParameters:
            - name: owner
              in: path
            - name: repo
              in: path
            - name: severity
              in: query
            - name: state
              in: query
          operations:
            - name: list-dependabot-alerts
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

When NCCL performance regression is detected in GitHub CI, creates a Jira issue and notifies the communications team in Slack.

naftiko: "0.5"
info:
  label: "GitHub NCCL Performance Regression Handler"
  description: "When NCCL performance regression is detected in GitHub CI, creates a Jira issue and notifies the communications team in Slack."
  tags:
    - performance
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: nccl-perf
      port: 8080
      tools:
        - name: handle-nccl-regression
          description: "Given a GitHub run ID showing NCCL regression, create a Jira issue and notify in Slack."
          inputParameters:
            - name: run_id
              in: body
              type: integer
              description: "GitHub Actions run ID."
          steps:
            - name: get-run
              type: call
              call: github-nccl.get-run
              with:
                run_id: "{{run_id}}"
            - name: create-issue
              type: call
              call: jira-nccl.create-issue
              with:
                project_key: "NCCL"
                issuetype: "Bug"
                summary: "Performance regression: {{get-run.name}}"
            - name: notify-team
              type: call
              call: slack-nccl.post-message
              with:
                channel: "nccl-engineering"
                text: "NCCL REGRESSION: {{get-run.name}} | Run: {{run_id}} | Jira: {{create-issue.key}}"
  consumes:
    - type: http
      namespace: github-nccl
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: runs
          path: "/repos/NVIDIA/nccl/actions/runs/{{run_id}}"
          inputParameters:
            - name: run_id
              in: path
          operations:
            - name: get-run
              method: GET
    - type: http
      namespace: jira-nccl
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-nccl
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks CI status for a branch in the NeMo framework repository.

naftiko: "0.5"
info:
  label: "GitHub NeMo Framework Branch Status"
  description: "Checks CI status for a branch in the NeMo framework repository."
  tags:
    - engineering
    - github
    - nemo
capability:
  exposes:
    - type: mcp
      namespace: nemo-dev
      port: 8080
      tools:
        - name: get-nemo-branch
          description: "Given a branch name, return CI status for the NeMo framework repository. Use before merging changes."
          inputParameters:
            - name: branch_name
              in: body
              type: string
              description: "Branch name to check."
          call: "github-nemo.get-branch"
          with:
            branch_name: "{{branch_name}}"
          outputParameters:
            - name: branch
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-nemo
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: branches
          path: "/repos/NVIDIA/NeMo/branches/{{branch_name}}"
          inputParameters:
            - name: branch_name
              in: path
          operations:
            - name: get-branch
              method: GET

Orchestrates Omniverse platform releases by validating test results, creating a GitHub release, and notifying in Slack.

naftiko: "0.5"
info:
  label: "GitHub Omniverse Release Pipeline"
  description: "Orchestrates Omniverse platform releases by validating test results, creating a GitHub release, and notifying in Slack."
  tags:
    - platform
    - github
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: omniverse-release
      port: 8080
      tools:
        - name: handle-omniverse-release
          description: "Given a release version, validate tests and create a GitHub release."
          inputParameters:
            - name: version
              in: body
              type: string
              description: "Omniverse release version."
          steps:
            - name: validate-tests
              type: call
              call: snowflake-ov.run-query
              with:
                version: "{{version}}"
            - name: create-release
              type: call
              call: github-ov.create-release
              with:
                tag_name: "{{version}}"
                name: "Omniverse {{version}}"
            - name: notify-team
              type: call
              call: slack-ov.post-message
              with:
                channel: "omniverse-releases"
                text: "Omniverse Release: {{version}} | Tests: {{validate-tests.pass_rate}}% | URL: {{create-release.html_url}}"
  consumes:
    - type: http
      namespace: snowflake-ov
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: github-ov
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/NVIDIA/Omniverse/releases"
          operations:
            - name: create-release
              method: POST
    - type: http
      namespace: slack-ov
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches all repositories in the NVIDIA GitHub organization, identifies those with no activity in 180 days, and publishes an audit report to Confluence.

naftiko: "0.5"
info:
  label: "GitHub Org Repository Audit"
  description: "Fetches all repositories in the NVIDIA GitHub organization, identifies those with no activity in 180 days, and publishes an audit report to Confluence."
  tags:
    - devops
    - github
    - confluence
    - audit
    - governance
capability:
  exposes:
    - type: mcp
      namespace: repo-governance
      port: 8080
      tools:
        - name: audit-stale-repositories
          description: "List all NVIDIA GitHub org repositories, identify those with no pushes in 180 days, and publish a stale repo audit to Confluence. Use for annual repo governance reviews or cleanup campaigns."
          inputParameters:
            - name: confluence_space_key
              in: body
              type: string
              description: "Confluence space key to publish the audit report to."
            - name: confluence_parent_id
              in: body
              type: string
              description: "Confluence parent page ID for the audit report."
          steps:
            - name: list-org-repos
              type: call
              call: "github.list-org-repos"
              with:
                org: "nvidia"
                sort: "pushed"
                direction: "asc"
            - name: publish-audit
              type: call
              call: "confluence.create-page"
              with:
                space_key: "{{confluence_space_key}}"
                parent_page_id: "{{confluence_parent_id}}"
                title: "Stale Repository Audit"
                content: "GitHub organization repository audit. Repositories sorted by last push date for review and archival."
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-repos
          path: "/orgs/{{org}}/repos"
          inputParameters:
            - name: org
              in: path
            - name: sort
              in: query
            - name: direction
              in: query
          operations:
            - name: list-org-repos
              method: GET
    - type: http
      namespace: confluence
      baseUri: "https://nvidia.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST

Fetches open pull requests with no review activity in over 24 hours from GitHub and posts a reminder to the relevant Slack channel.

naftiko: "0.5"
info:
  label: "GitHub Pull Request Review Reminder"
  description: "Fetches open pull requests with no review activity in over 24 hours from GitHub and posts a reminder to the relevant Slack channel."
  tags:
    - devops
    - github
    - slack
    - code-review
capability:
  exposes:
    - type: mcp
      namespace: devops-review
      port: 8080
      tools:
        - name: remind-stale-prs
          description: "Given a GitHub repository and Slack channel, fetch open pull requests with no review activity and post reminders. Use to unblock engineering review queues."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "GitHub repository full name (e.g., 'nvidia/tensorrt')."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel to post reminders to (e.g., '#tensorrt-team')."
            - name: stale_hours
              in: body
              type: integer
              description: "Number of hours without review activity before a PR is considered stale."
          steps:
            - name: list-open-prs
              type: call
              call: "github.list-pull-requests"
              with:
                owner: "nvidia"
                repo: "{{repository}}"
                state: "open"
            - name: post-reminder
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Stale PRs detected in {{repository}} — please review open pull requests awaiting feedback."
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pull-requests
          path: "/repos/{{owner}}/{{repo}}/pulls"
          inputParameters:
            - name: owner
              in: path
            - name: repo
              in: path
            - name: state
              in: query
          operations:
            - name: list-pull-requests
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When CI fails in a RAPIDS repository, creates a Jira bug and notifies the data science team in Slack.

naftiko: "0.5"
info:
  label: "GitHub RAPIDS CI Failure Handler"
  description: "When CI fails in a RAPIDS repository, creates a Jira bug and notifies the data science team in Slack."
  tags:
    - data-science
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: rapids-ci
      port: 8080
      tools:
        - name: handle-rapids-ci-failure
          description: "Given a GitHub run ID for a failed RAPIDS CI, create a Jira bug and notify in Slack."
          inputParameters:
            - name: run_id
              in: body
              type: integer
              description: "GitHub Actions run ID."
            - name: repo_name
              in: body
              type: string
              description: "RAPIDS repository name."
          steps:
            - name: get-run
              type: call
              call: github-rapids.get-run
              with:
                run_id: "{{run_id}}"
                repo_name: "{{repo_name}}"
            - name: create-bug
              type: call
              call: jira-rapids.create-issue
              with:
                project_key: "RAPIDS"
                issuetype: "Bug"
                summary: "CI failure: {{repo_name}} — {{get-run.name}}"
            - name: notify-ds
              type: call
              call: slack-rapids.post-message
              with:
                channel: "rapids-engineering"
                text: "CI FAILURE: {{repo_name}} | {{get-run.name}} | Jira: {{create-bug.key}}"
  consumes:
    - type: http
      namespace: github-rapids
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: runs
          path: "/repos/rapidsai/{{repo_name}}/actions/runs/{{run_id}}"
          inputParameters:
            - name: repo_name
              in: path
            - name: run_id
              in: path
          operations:
            - name: get-run
              method: GET
    - type: http
      namespace: jira-rapids
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-rapids
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

On a new GitHub release tag, fetches the merged pull requests since the last release and generates structured release notes, posting them to Confluence.

naftiko: "0.5"
info:
  label: "GitHub Release Notes Generator"
  description: "On a new GitHub release tag, fetches the merged pull requests since the last release and generates structured release notes, posting them to Confluence."
  tags:
    - devops
    - github
    - confluence
    - release-management
capability:
  exposes:
    - type: mcp
      namespace: release-ops
      port: 8080
      tools:
        - name: generate-release-notes
          description: "Given a GitHub repository and tag name, fetch merged pull requests since the previous tag and publish structured release notes to Confluence. Use as part of the software release process."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository name within the NVIDIA org."
            - name: tag_name
              in: body
              type: string
              description: "The new release tag (e.g., 'v12.0.0')."
            - name: confluence_space_key
              in: body
              type: string
              description: "Confluence space key where release notes will be published."
            - name: confluence_parent_id
              in: body
              type: string
              description: "Confluence parent page ID for the release notes."
          steps:
            - name: get-merged-prs
              type: call
              call: "github.list-pull-requests"
              with:
                owner: "nvidia"
                repo: "{{repository}}"
                state: "closed"
            - name: publish-release-notes
              type: call
              call: "confluence.create-page"
              with:
                space_key: "{{confluence_space_key}}"
                parent_page_id: "{{confluence_parent_id}}"
                title: "Release Notes — {{tag_name}}"
                content: "Release notes for {{tag_name}} generated from merged pull requests in {{repository}}."
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pull-requests
          path: "/repos/{{owner}}/{{repo}}/pulls"
          inputParameters:
            - name: owner
              in: path
            - name: repo
              in: path
            - name: state
              in: query
          operations:
            - name: list-pull-requests
              method: GET
    - type: http
      namespace: confluence
      baseUri: "https://nvidia.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST

Triggers a security code scan on a GitHub repository, waits for results, and opens a Jira ticket for any critical vulnerabilities found.

naftiko: "0.5"
info:
  label: "GitHub Repository Security Scan"
  description: "Triggers a security code scan on a GitHub repository, waits for results, and opens a Jira ticket for any critical vulnerabilities found."
  tags:
    - devops
    - security
    - github
    - jira
capability:
  exposes:
    - type: mcp
      namespace: security-ops
      port: 8080
      tools:
        - name: run-security-scan
          description: "Given a GitHub repository name, trigger a code scanning analysis and create Jira tickets for any critical severity findings. Use during release gating or on-demand security audits."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository name within the NVIDIA org (e.g., 'cuda-toolkit')."
            - name: ref
              in: body
              type: string
              description: "The git ref (branch or SHA) to scan."
          steps:
            - name: get-code-scanning-alerts
              type: call
              call: "github.list-code-scanning-alerts"
              with:
                owner: "nvidia"
                repo: "{{repository}}"
                ref: "{{ref}}"
                severity: "critical"
            - name: create-jira-vuln-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SECURITY"
                issuetype: "Bug"
                summary: "Critical Vulnerability: {{repository}} @ {{ref}}"
                description: "Critical security findings detected in {{repository}} on {{ref}}. Review GitHub code scanning results immediately."
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: code-scanning-alerts
          path: "/repos/{{owner}}/{{repo}}/code-scanning/alerts"
          inputParameters:
            - name: owner
              in: path
            - name: repo
              in: path
            - name: ref
              in: query
            - name: severity
              in: query
          operations:
            - name: list-code-scanning-alerts
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

Runs TensorRT-LLM benchmark validation from GitHub CI, logs results to Snowflake, and posts to the inference team Slack channel.

naftiko: "0.5"
info:
  label: "GitHub TensorRT-LLM Benchmark Pipeline"
  description: "Runs TensorRT-LLM benchmark validation from GitHub CI, logs results to Snowflake, and posts to the inference team Slack channel."
  tags:
    - ai
    - github
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: trt-llm-bench
      port: 8080
      tools:
        - name: handle-benchmark
          description: "Given a GitHub run ID, check benchmark results and post to Slack."
          inputParameters:
            - name: run_id
              in: body
              type: integer
              description: "GitHub Actions run ID."
            - name: model_name
              in: body
              type: string
              description: "LLM model name."
          steps:
            - name: get-run
              type: call
              call: github-trtllm.get-run
              with:
                run_id: "{{run_id}}"
            - name: log-results
              type: call
              call: snowflake-trt.run-query
              with:
                model: "{{model_name}}"
                run_id: "{{run_id}}"
            - name: notify-team
              type: call
              call: slack-trt.post-message
              with:
                channel: "tensorrt-llm"
                text: "TRT-LLM Benchmark: {{model_name}} | Run: {{run_id}} | Status: {{get-run.conclusion}} | Logged to Snowflake"
  consumes:
    - type: http
      namespace: github-trtllm
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: runs
          path: "/repos/NVIDIA/TensorRT-LLM/actions/runs/{{run_id}}"
          inputParameters:
            - name: run_id
              in: path
          operations:
            - name: get-run
              method: GET
    - type: http
      namespace: snowflake-trt
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-trt
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the latest TensorRT release information from the GitHub repository.

naftiko: "0.5"
info:
  label: "GitHub TensorRT Release Lookup"
  description: "Retrieves the latest TensorRT release information from the GitHub repository."
  tags:
    - engineering
    - github
    - tensorrt
capability:
  exposes:
    - type: mcp
      namespace: tensorrt-ops
      port: 8080
      tools:
        - name: get-latest-release
          description: "Return the latest TensorRT release tag and details from GitHub. Use for deployment version validation."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "GitHub repository name (e.g. TensorRT)."
          call: "github-trt.get-release"
          with:
            repo_name: "{{repo_name}}"
          outputParameters:
            - name: release
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-trt
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/NVIDIA/{{repo_name}}/releases/latest"
          inputParameters:
            - name: repo_name
              in: path
          operations:
            - name: get-release
              method: GET

Validates Triton Inference Server deployment by checking GitHub release status and Datadog health, then notifies the inference team in Slack.

naftiko: "0.5"
info:
  label: "GitHub Triton Inference Deployment Gate"
  description: "Validates Triton Inference Server deployment by checking GitHub release status and Datadog health, then notifies the inference team in Slack."
  tags:
    - ai
    - github
    - datadog
    - slack
capability:
  exposes:
    - type: mcp
      namespace: triton-deploy
      port: 8080
      tools:
        - name: handle-triton-deployment
          description: "Given a release tag, validate deployment readiness and notify the inference team in Slack."
          inputParameters:
            - name: release_tag
              in: body
              type: string
              description: "GitHub release tag for Triton."
          steps:
            - name: get-release
              type: call
              call: github-triton.get-release
              with:
                tag: "{{release_tag}}"
            - name: check-health
              type: call
              call: dd-triton.get-monitors
              with:
                tags: "triton-inference"
            - name: notify-team
              type: call
              call: slack-triton.post-message
              with:
                channel: "inference-deployments"
                text: "Triton Deploy: {{release_tag}} | Release: {{get-release.name}} | Monitors: {{check-health.total_count}} | Alerts: {{check-health.alert_count}}"
  consumes:
    - type: http
      namespace: github-triton
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/NVIDIA/triton-inference-server/releases/tags/{{tag}}"
          inputParameters:
            - name: tag
              in: path
          operations:
            - name: get-release
              method: GET
    - type: http
      namespace: dd-triton
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          inputParameters:
            - name: tags
              in: query
          operations:
            - name: get-monitors
              method: GET
    - type: http
      namespace: slack-triton
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors Datadog cost metrics for GPU cluster spend anomalies, opens a Jira ticket for investigation, and notifies the FinOps Slack channel.

naftiko: "0.5"
info:
  label: "GPU Infrastructure Cost Anomaly Responder"
  description: "Monitors Datadog cost metrics for GPU cluster spend anomalies, opens a Jira ticket for investigation, and notifies the FinOps Slack channel."
  tags:
    - cloud
    - finops
    - datadog
    - jira
    - slack
    - cost-management
capability:
  exposes:
    - type: mcp
      namespace: cloud-ops
      port: 8080
      tools:
        - name: handle-cost-anomaly
          description: "Given a cost anomaly alert from Datadog (metric name, threshold exceeded, percentage over), open a Jira investigation ticket and notify the #finops Slack channel. Use when GPU or cloud spend spikes unexpectedly."
          inputParameters:
            - name: metric_name
              in: body
              type: string
              description: "The Datadog metric that triggered the anomaly (e.g., 'aws.ec2.gpu.utilization')."
            - name: current_value
              in: body
              type: number
              description: "The current metric value that exceeded the threshold."
            - name: threshold
              in: body
              type: number
              description: "The configured anomaly threshold value."
            - name: environment
              in: body
              type: string
              description: "The environment affected (e.g., 'prod', 'staging')."
          steps:
            - name: create-jira-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "FINOPS"
                issuetype: "Task"
                summary: "Cost Anomaly: {{metric_name}} exceeded {{threshold}} in {{environment}}"
                description: "Metric: {{metric_name}}\nCurrent Value: {{current_value}}\nThreshold: {{threshold}}\nEnvironment: {{environment}}"
            - name: notify-finops
              type: call
              call: "slack.post-message"
              with:
                channel: "finops-alerts"
                text: "Cost Anomaly Detected: {{metric_name}} = {{current_value}} (threshold: {{threshold}}) in {{environment}}. Jira: {{create-jira-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns current headcount grouped by department and cost center from Workday, used for workforce planning and finance reporting.

naftiko: "0.5"
info:
  label: "Headcount Snapshot by Department"
  description: "Returns current headcount grouped by department and cost center from Workday, used for workforce planning and finance reporting."
  tags:
    - hr
    - workforce-planning
    - workday
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: hr-reporting
      port: 8080
      tools:
        - name: get-headcount-snapshot
          description: "Returns a list of active employees grouped by department and cost center from Workday. Use for headcount planning, finance reporting, or org chart analysis."
          call: "workday.list-workers"
          outputParameters:
            - name: employees
              type: array
              mapping: "$.data"
            - name: total_count
              type: number
              mapping: "$.total"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers-export
          path: "/nvidia/workers"
          operations:
            - name: list-workers
              method: GET

Tracks AI ethics review requests in Jira and notifies the responsible AI team in Slack.

naftiko: "0.5"
info:
  label: "Jira AI Ethics Review Workflow"
  description: "Tracks AI ethics review requests in Jira and notifies the responsible AI team in Slack."
  tags:
    - ethics
    - jira
    - slack
    - ai
capability:
  exposes:
    - type: mcp
      namespace: ethics-ops
      port: 8080
      tools:
        - name: handle-ethics-review
          description: "Given a Jira project key, track ethics review items and notify the responsible AI team."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key for ethics reviews."
          steps:
            - name: search-reviews
              type: call
              call: jira-ethics.search-issues
              with:
                jql: "project = {{project_key}} AND status = 'Pending Review'"
            - name: post-status
              type: call
              call: slack-ethics.post-message
              with:
                channel: "responsible-ai"
                text: "Ethics Review Queue: {{search-reviews.total}} pending reviews | Please prioritize in Jira."
  consumes:
    - type: http
      namespace: jira-ethics
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack-ethics
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current sprint status for the NVIDIA AI Platform Jira board.

naftiko: "0.5"
info:
  label: "Jira AI Platform Sprint Status"
  description: "Retrieves the current sprint status for the NVIDIA AI Platform Jira board."
  tags:
    - project-management
    - jira
    - ai-platform
capability:
  exposes:
    - type: mcp
      namespace: ai-platform-pm
      port: 8080
      tools:
        - name: get-sprint-status
          description: "Given a Jira board ID, return the current sprint status for the AI platform team. Use for standup meetings."
          inputParameters:
            - name: board_id
              in: body
              type: integer
              description: "Jira board ID."
          call: "jira-aiplatform.get-sprints"
          with:
            board_id: "{{board_id}}"
          outputParameters:
            - name: sprints
              type: array
              mapping: "$.values"
  consumes:
    - type: http
      namespace: jira-aiplatform
      baseUri: "https://nvidia.atlassian.net/rest/agile/1.0"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: sprints
          path: "/board/{{board_id}}/sprint"
          inputParameters:
            - name: board_id
              in: path
          operations:
            - name: get-sprints
              method: GET

When a Jira bug is escalated to P1, creates a dedicated Slack incident channel, pins the Jira link, and invites the on-call response team.

naftiko: "0.5"
info:
  label: "Jira Bug to Slack Incident Command"
  description: "When a Jira bug is escalated to P1, creates a dedicated Slack incident channel, pins the Jira link, and invites the on-call response team."
  tags:
    - itsm
    - devops
    - jira
    - slack
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: incident-command
      port: 8080
      tools:
        - name: create-incident-channel
          description: "Given a Jira P1 bug key and on-call user IDs, create a Slack incident channel named after the bug key, post the Jira link, and invite the responders. Use immediately upon P1 escalation."
          inputParameters:
            - name: jira_bug_key
              in: body
              type: string
              description: "The Jira P1 bug key (e.g., 'ENG-9871')."
            - name: jira_bug_url
              in: body
              type: string
              description: "Direct URL to the Jira bug for pinning in the incident channel."
            - name: oncall_slack_user_ids
              in: body
              type: string
              description: "Comma-separated Slack user IDs to invite to the incident channel."
          steps:
            - name: create-slack-channel
              type: call
              call: "slack.create-channel"
              with:
                name: "inc-{{jira_bug_key}}"
            - name: post-jira-link
              type: call
              call: "slack-msg.post-message"
              with:
                channel: "{{create-slack-channel.channel_id}}"
                text: "Incident channel for {{jira_bug_key}}: {{jira_bug_url}} — On-call responders please join."
  consumes:
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: conversations
          path: "/conversations.create"
          operations:
            - name: create-channel
              method: POST
    - type: http
      namespace: slack-msg
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Tracks compliance audit items in Jira, checks status, and posts updates to the compliance Slack channel.

naftiko: "0.5"
info:
  label: "Jira Compliance Audit Tracker"
  description: "Tracks compliance audit items in Jira, checks status, and posts updates to the compliance Slack channel."
  tags:
    - compliance
    - jira
    - slack
    - audit
capability:
  exposes:
    - type: mcp
      namespace: compliance-ops
      port: 8080
      tools:
        - name: handle-audit-tracking
          description: "Given a Jira project key for compliance, track audit items and post to Slack."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key."
          steps:
            - name: search-items
              type: call
              call: jira-comp.search-issues
              with:
                jql: "project = {{project_key}} AND status != Done"
            - name: post-status
              type: call
              call: slack-comp.post-message
              with:
                channel: "compliance"
                text: "Audit Status: {{project_key}} | Open items: {{search-items.total}} | Please review in Jira."
  consumes:
    - type: http
      namespace: jira-comp
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack-comp
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Identifies cross-team dependencies in Jira and posts a dependency status report to the program management Slack channel.

naftiko: "0.5"
info:
  label: "Jira Cross-Team Dependency Report"
  description: "Identifies cross-team dependencies in Jira and posts a dependency status report to the program management Slack channel."
  tags:
    - project-management
    - jira
    - slack
    - dependencies
capability:
  exposes:
    - type: mcp
      namespace: dep-ops
      port: 8080
      tools:
        - name: handle-dependency-report
          description: "Given a project key, identify blocked items and post a report to Slack."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key."
          steps:
            - name: search-blocked
              type: call
              call: jira-deps.search-issues
              with:
                jql: "project = {{project_key}} AND status = Blocked"
            - name: post-report
              type: call
              call: slack-pm.post-message
              with:
                channel: "program-management"
                text: "Dependency Report: {{project_key}} | Blocked items: {{search-blocked.total}} | Review in Jira."
  consumes:
    - type: http
      namespace: jira-deps
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack-pm
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Escalates customer support issues from Salesforce to Jira engineering tickets and notifies the support team in Slack.

naftiko: "0.5"
info:
  label: "Jira Customer Support Escalation"
  description: "Escalates customer support issues from Salesforce to Jira engineering tickets and notifies the support team in Slack."
  tags:
    - support
    - jira
    - salesforce
    - slack
capability:
  exposes:
    - type: mcp
      namespace: support-escalation
      port: 8080
      tools:
        - name: handle-support-escalation
          description: "Given a Salesforce case ID, create a Jira engineering ticket and notify the support team."
          inputParameters:
            - name: case_id
              in: body
              type: string
              description: "Salesforce case ID."
          steps:
            - name: get-case
              type: call
              call: sf-support.get-case
              with:
                case_id: "{{case_id}}"
            - name: create-ticket
              type: call
              call: jira-support.create-issue
              with:
                project_key: "ENG"
                issuetype: "Bug"
                summary: "Customer escalation: {{get-case.Subject}}"
                description: "From SF case {{case_id}}: {{get-case.Description}}"
            - name: notify-support
              type: call
              call: slack-support.post-message
              with:
                channel: "support-escalations"
                text: "ESCALATION: {{get-case.Subject}} | Case: {{case_id}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: sf-support
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: cases
          path: "/sobjects/Case/{{case_id}}"
          inputParameters:
            - name: case_id
              in: path
          operations:
            - name: get-case
              method: GET
    - type: http
      namespace: jira-support
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-support
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns the current count of open bugs in the DGX systems Jira project.

naftiko: "0.5"
info:
  label: "Jira DGX Bug Count"
  description: "Returns the current count of open bugs in the DGX systems Jira project."
  tags:
    - engineering
    - jira
    - dgx
capability:
  exposes:
    - type: mcp
      namespace: dgx-eng
      port: 8080
      tools:
        - name: get-dgx-bug-count
          description: "Given a priority, return the count of open DGX bugs in Jira. Use for quality tracking and sprint planning."
          inputParameters:
            - name: priority
              in: body
              type: string
              description: "Bug priority filter (e.g. High, Critical)."
          call: "jira-dgx.search-issues"
          with:
            jql: "project = DGX AND type = Bug AND status != Done AND priority = {{priority}}"
          outputParameters:
            - name: total
              type: number
              mapping: "$.total"
  consumes:
    - type: http
      namespace: jira-dgx
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET

Validates GPU driver release readiness by checking Jira ticket statuses and Datadog test monitors, then posts a go/no-go to Slack.

naftiko: "0.5"
info:
  label: "Jira Driver Release Readiness Check"
  description: "Validates GPU driver release readiness by checking Jira ticket statuses and Datadog test monitors, then posts a go/no-go to Slack."
  tags:
    - engineering
    - jira
    - datadog
    - slack
capability:
  exposes:
    - type: mcp
      namespace: driver-release
      port: 8080
      tools:
        - name: handle-driver-readiness
          description: "Given a Jira fix version and Datadog service tag, validate driver release readiness and post to Slack."
          inputParameters:
            - name: fix_version
              in: body
              type: string
              description: "Jira fix version for the driver release."
            - name: service_tag
              in: body
              type: string
              description: "Datadog service tag for test monitors."
          steps:
            - name: check-tickets
              type: call
              call: jira-driver.search-issues
              with:
                jql: "fixVersion = {{fix_version}} AND status != Done"
            - name: check-monitors
              type: call
              call: dd-driver.get-monitors
              with:
                tags: "{{service_tag}}"
            - name: post-readiness
              type: call
              call: slack-driver.post-message
              with:
                channel: "driver-releases"
                text: "Driver Release Readiness: {{fix_version}} | Open tickets: {{check-tickets.total}} | Monitor alerts: {{check-monitors.alert_count}}"
  consumes:
    - type: http
      namespace: jira-driver
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: dd-driver
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          inputParameters:
            - name: tags
              in: query
          operations:
            - name: get-monitors
              method: GET
    - type: http
      namespace: slack-driver
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a hardware defect is reported in Jira, creates a ServiceNow change request and notifies the hardware team in Slack.

naftiko: "0.5"
info:
  label: "Jira Hardware Defect to ServiceNow"
  description: "When a hardware defect is reported in Jira, creates a ServiceNow change request and notifies the hardware team in Slack."
  tags:
    - hardware
    - jira
    - servicenow
    - slack
capability:
  exposes:
    - type: mcp
      namespace: hw-defect
      port: 8080
      tools:
        - name: handle-hw-defect
          description: "Given a Jira issue key for a hardware defect, create a ServiceNow change request and notify hardware engineering."
          inputParameters:
            - name: issue_key
              in: body
              type: string
              description: "Jira issue key."
          steps:
            - name: get-issue
              type: call
              call: jira-hw.get-issue
              with:
                issue_key: "{{issue_key}}"
            - name: create-change
              type: call
              call: snow-hw.create-change
              with:
                short_description: "HW defect: {{get-issue.fields.summary}}"
                description: "From Jira {{issue_key}}: {{get-issue.fields.description}}"
            - name: notify-hw
              type: call
              call: slack-hw.post-message
              with:
                channel: "hardware-engineering"
                text: "HW DEFECT: {{issue_key}} | {{get-issue.fields.summary}} | SNOW: {{create-change.number}}"
  consumes:
    - type: http
      namespace: jira-hw
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue/{{issue_key}}"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: get-issue
              method: GET
    - type: http
      namespace: snow-hw
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: bearer
        token: "$secrets.servicenow_token"
      resources:
        - name: changes
          path: "/table/change_request"
          operations:
            - name: create-change
              method: POST
    - type: http
      namespace: slack-hw
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Compiles NeMo framework sprint metrics from Jira and posts a retrospective summary to the AI frameworks Slack channel.

naftiko: "0.5"
info:
  label: "Jira NeMo Sprint Retrospective"
  description: "Compiles NeMo framework sprint metrics from Jira and posts a retrospective summary to the AI frameworks Slack channel."
  tags:
    - engineering
    - jira
    - slack
    - agile
capability:
  exposes:
    - type: mcp
      namespace: nemo-agile
      port: 8080
      tools:
        - name: handle-nemo-retro
          description: "Given a sprint ID, compile NeMo sprint metrics and post a retrospective to Slack."
          inputParameters:
            - name: sprint_id
              in: body
              type: integer
              description: "Jira sprint ID."
          steps:
            - name: get-sprint
              type: call
              call: jira-nemo.get-sprint
              with:
                sprint_id: "{{sprint_id}}"
            - name: get-issues
              type: call
              call: jira-nemo.get-sprint-issues
              with:
                sprint_id: "{{sprint_id}}"
            - name: post-retro
              type: call
              call: slack-nemo.post-message
              with:
                channel: "ai-frameworks"
                text: "NeMo Sprint Retro: {{get-sprint.name}} | Completed: {{get-issues.total}} | Goal: {{get-sprint.goal}}"
  consumes:
    - type: http
      namespace: jira-nemo
      baseUri: "https://nvidia.atlassian.net/rest/agile/1.0"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: sprints
          path: "/sprint/{{sprint_id}}"
          inputParameters:
            - name: sprint_id
              in: path
          operations:
            - name: get-sprint
              method: GET
        - name: sprint-issues
          path: "/sprint/{{sprint_id}}/issue"
          inputParameters:
            - name: sprint_id
              in: path
          operations:
            - name: get-sprint-issues
              method: GET
    - type: http
      namespace: slack-nemo
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Compiles quarterly GPU product roadmap progress from Jira epics and posts a summary to the executive Slack channel.

naftiko: "0.5"
info:
  label: "Jira Quarterly Roadmap Summary"
  description: "Compiles quarterly GPU product roadmap progress from Jira epics and posts a summary to the executive Slack channel."
  tags:
    - project-management
    - jira
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: roadmap-ops
      port: 8080
      tools:
        - name: handle-roadmap-summary
          description: "Given a project key and quarter, compile roadmap progress and post to the executive Slack channel."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key."
            - name: quarter
              in: body
              type: string
              description: "Quarter (e.g. Q1-2026)."
          steps:
            - name: search-epics
              type: call
              call: jira-roadmap.search-issues
              with:
                jql: "project = {{project_key}} AND type = Epic AND updated >= startOfQuarter()"
            - name: post-summary
              type: call
              call: slack-exec.post-message
              with:
                channel: "executive-updates"
                text: "Quarterly Roadmap ({{quarter}}): {{project_key}} | Epics: {{search-epics.total}} | Review in Jira."
  consumes:
    - type: http
      namespace: jira-roadmap
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack-exec
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches the active sprint for a Jira project board, computes completion percentage, and posts the digest to a Microsoft Teams channel.

naftiko: "0.5"
info:
  label: "Jira Sprint Progress Digest"
  description: "Fetches the active sprint for a Jira project board, computes completion percentage, and posts the digest to a Microsoft Teams channel."
  tags:
    - devops
    - jira
    - microsoft-teams
    - reporting
    - agile
capability:
  exposes:
    - type: mcp
      namespace: devops-reporting
      port: 8080
      tools:
        - name: digest-sprint-progress
          description: "Given a Jira board ID, fetch the active sprint's issues, compute completion stats, and post the summary to a Microsoft Teams channel. Use for daily stand-up digests or weekly engineering reviews."
          inputParameters:
            - name: jira_board_id
              in: body
              type: integer
              description: "The Jira agile board ID (numeric) to query for the active sprint."
            - name: teams_channel_id
              in: body
              type: string
              description: "The Microsoft Teams channel ID to post the digest to."
          steps:
            - name: get-active-sprint
              type: call
              call: "jira.get-board-sprints"
              with:
                board_id: "{{jira_board_id}}"
                state: "active"
            - name: get-sprint-issues
              type: call
              call: "jira-issues.search-issues"
              with:
                jql: "sprint = {{get-active-sprint.sprint_id}} ORDER BY status"
            - name: post-digest
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "{{teams_channel_id}}"
                text: "Sprint Progress: Board {{jira_board_id}} — Sprint {{get-active-sprint.sprint_name}} | Total issues: {{get-sprint-issues.total}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: board-sprints
          path: "/board/{{board_id}}/sprint"
          inputParameters:
            - name: board_id
              in: path
            - name: state
              in: query
          operations:
            - name: get-board-sprints
              method: GET
    - type: http
      namespace: jira-issues
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues-search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: team_id
              in: path
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Publishes an employer brand or product announcement post to the NVIDIA LinkedIn company page, then posts the published URL to the communications Slack channel.

naftiko: "0.5"
info:
  label: "LinkedIn Employer Brand Post Scheduler"
  description: "Publishes an employer brand or product announcement post to the NVIDIA LinkedIn company page, then posts the published URL to the communications Slack channel."
  tags:
    - marketing
    - social
    - linkedin
    - slack
capability:
  exposes:
    - type: mcp
      namespace: social-marketing
      port: 8080
      tools:
        - name: publish-linkedin-post
          description: "Given post content and optional media, publish a post to the NVIDIA LinkedIn company page and notify the #communications Slack channel with the post URL. Use for employer branding or product announcements."
          inputParameters:
            - name: post_text
              in: body
              type: string
              description: "The text content of the LinkedIn post."
            - name: visibility
              in: body
              type: string
              description: "Post visibility: 'PUBLIC' or 'CONNECTIONS'."
          steps:
            - name: create-linkedin-post
              type: call
              call: "linkedin.create-share"
              with:
                text: "{{post_text}}"
                visibility: "{{visibility}}"
            - name: notify-comms
              type: call
              call: "slack.post-message"
              with:
                channel: "communications"
                text: "LinkedIn post published: {{create-linkedin-post.activity_id}}"
  consumes:
    - type: http
      namespace: linkedin
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_access_token"
      resources:
        - name: shares
          path: "/ugcPosts"
          operations:
            - name: create-share
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Sends a broadcast message to all NVIDIA Microsoft Teams channels in a specified team, used for company-wide announcements and all-hands meeting reminders.

naftiko: "0.5"
info:
  label: "Microsoft Teams All-Hands Broadcast"
  description: "Sends a broadcast message to all NVIDIA Microsoft Teams channels in a specified team, used for company-wide announcements and all-hands meeting reminders."
  tags:
    - communication
    - microsoft-teams
    - announcements
capability:
  exposes:
    - type: mcp
      namespace: communications-ops
      port: 8080
      tools:
        - name: broadcast-all-hands-notice
          description: "Given a Teams team ID and message content, post an all-hands announcement to the general channel. Use for company-wide announcements, meeting invites, or policy updates."
          inputParameters:
            - name: team_id
              in: body
              type: string
              description: "The Microsoft Teams team ID to broadcast to."
            - name: channel_id
              in: body
              type: string
              description: "The Teams channel ID (typically the General channel)."
            - name: message
              in: body
              type: string
              description: "The announcement message content."
          call: "msteams.post-channel-message"
          with:
            team_id: "{{team_id}}"
            channel_id: "{{channel_id}}"
            text: "{{message}}"
  consumes:
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: team_id
              in: path
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Creates a Microsoft Teams meeting for a Salesforce opportunity deal review, inviting all listed opportunity stakeholders.

naftiko: "0.5"
info:
  label: "Microsoft Teams Meeting Scheduler for Deal Review"
  description: "Creates a Microsoft Teams meeting for a Salesforce opportunity deal review, inviting all listed opportunity stakeholders."
  tags:
    - sales
    - communication
    - salesforce
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: sales-coordination
      port: 8080
      tools:
        - name: schedule-deal-review
          description: "Given a Salesforce opportunity ID and meeting datetime, fetch opportunity contacts and create a Microsoft Teams meeting invite for all stakeholders. Use when scheduling a deal review or QBR for an active opportunity."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity ID for the deal review."
            - name: meeting_start
              in: body
              type: string
              description: "Meeting start time in ISO 8601 format."
            - name: meeting_end
              in: body
              type: string
              description: "Meeting end time in ISO 8601 format."
          steps:
            - name: get-opportunity
              type: call
              call: "salesforce.get-opportunity"
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: create-teams-meeting
              type: call
              call: "msteams.create-online-meeting"
              with:
                subject: "Deal Review: {{get-opportunity.Name}}"
                start_datetime: "{{meeting_start}}"
                end_datetime: "{{meeting_end}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: online-meetings
          path: "/me/onlineMeetings"
          operations:
            - name: create-online-meeting
              method: POST

When a Salesforce opportunity moves to the Proposal stage, creates a scoping Jira epic and assigns it to the solutions engineering team.

naftiko: "0.5"
info:
  label: "New Jira Epic from Salesforce Opportunity"
  description: "When a Salesforce opportunity moves to the Proposal stage, creates a scoping Jira epic and assigns it to the solutions engineering team."
  tags:
    - sales
    - devops
    - salesforce
    - jira
capability:
  exposes:
    - type: mcp
      namespace: presales-ops
      port: 8080
      tools:
        - name: create-scoping-epic
          description: "Given a Salesforce opportunity ID, create a scoping Jira epic for the solutions engineering team. Use when an opportunity reaches Proposal stage and technical scoping work needs to begin."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity ID at Proposal stage."
            - name: jira_project_key
              in: body
              type: string
              description: "The Jira project key for the solutions engineering team."
          steps:
            - name: get-opportunity
              type: call
              call: "salesforce.get-opportunity"
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: create-scoping-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "{{jira_project_key}}"
                issuetype: "Epic"
                summary: "Scoping: {{get-opportunity.Name}}"
                description: "Technical scoping for opportunity {{opportunity_id}}. Account: {{get-opportunity.AccountName}}. Value: {{get-opportunity.Amount}}."
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

When a Jira access request ticket is approved, provisions the user into the correct Okta groups and closes the ticket.

naftiko: "0.5"
info:
  label: "Okta Group Provisioning from Jira Role Request"
  description: "When a Jira access request ticket is approved, provisions the user into the correct Okta groups and closes the ticket."
  tags:
    - identity
    - security
    - okta
    - jira
    - access-management
capability:
  exposes:
    - type: mcp
      namespace: access-provisioning
      port: 8080
      tools:
        - name: provision-okta-group-access
          description: "Given a Jira access request ticket number and Okta group ID, add the user to the Okta group and close the Jira ticket. Use when an IT access request has been approved and needs to be fulfilled."
          inputParameters:
            - name: jira_ticket_key
              in: body
              type: string
              description: "The Jira ticket key for the approved access request (e.g., 'ACCESS-4521')."
            - name: okta_user_id
              in: body
              type: string
              description: "The Okta user ID of the requester."
            - name: okta_group_id
              in: body
              type: string
              description: "The Okta group ID to add the user to."
          steps:
            - name: add-to-okta-group
              type: call
              call: "okta.add-user-to-group"
              with:
                group_id: "{{okta_group_id}}"
                user_id: "{{okta_user_id}}"
            - name: close-jira-ticket
              type: call
              call: "jira.transition-issue"
              with:
                issue_key: "{{jira_ticket_key}}"
                transition_id: "Done"
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://nvidia.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: group-users
          path: "/groups/{{group_id}}/users/{{user_id}}"
          inputParameters:
            - name: group_id
              in: path
            - name: user_id
              in: path
          operations:
            - name: add-user-to-group
              method: PUT
    - type: http
      namespace: jira
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issue-transitions
          path: "/issue/{{issue_key}}/transitions"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: transition-issue
              method: POST

Pulls a list of Okta users with inactive status or no login in 90 days and posts the report to a Slack channel for the identity governance team.

naftiko: "0.5"
info:
  label: "Okta User Access Review"
  description: "Pulls a list of Okta users with inactive status or no login in 90 days and posts the report to a Slack channel for the identity governance team."
  tags:
    - identity
    - security
    - okta
    - slack
    - access-review
capability:
  exposes:
    - type: mcp
      namespace: identity-ops
      port: 8080
      tools:
        - name: run-access-review
          description: "List Okta users who are inactive or have not logged in for 90+ days and post the count and details to the #identity-governance Slack channel. Use for quarterly access reviews or compliance audits."
          inputParameters:
            - name: days_inactive
              in: body
              type: integer
              description: "Number of days without login to consider a user inactive (default 90)."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel for the access review report (e.g., '#identity-governance')."
          steps:
            - name: list-inactive-users
              type: call
              call: "okta.list-users"
              with:
                filter: "status eq \"ACTIVE\" and lastLogin lt \"90 days ago\""
            - name: post-report
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Access Review: {{list-inactive-users.count}} Okta users have not logged in for {{days_inactive}}+ days. Review and action required."
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://nvidia.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users"
          inputParameters:
            - name: filter
              in: query
          operations:
            - name: list-users
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches open requisitions and candidate pipeline stages from Workday Recruiting, giving talent teams a real-time view of hiring progress by role.

naftiko: "0.5"
info:
  label: "Recruiting Pipeline Status"
  description: "Fetches open requisitions and candidate pipeline stages from Workday Recruiting, giving talent teams a real-time view of hiring progress by role."
  tags:
    - hr
    - recruiting
    - workday
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: recruiting
      port: 8080
      tools:
        - name: get-recruiting-pipeline
          description: "Given a job requisition ID, return the full candidate pipeline with stage counts from Workday Recruiting. Use for hiring manager updates or talent dashboards."
          inputParameters:
            - name: job_req_id
              in: body
              type: string
              description: "The Workday job requisition ID (e.g., JR-12345)."
          call: "workday-recruiting.get-requisition-pipeline"
          with:
            req_id: "{{job_req_id}}"
          outputParameters:
            - name: requisition_title
              type: string
              mapping: "$.jobRequisitionData.jobRequisitionTitle"
            - name: candidate_count
              type: number
              mapping: "$.jobRequisitionData.candidateCount"
  consumes:
    - type: http
      namespace: workday-recruiting
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/recruiting/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: requisitions
          path: "/jobRequisitions/{{req_id}}"
          inputParameters:
            - name: req_id
              in: path
          operations:
            - name: get-requisition-pipeline
              method: GET

Orchestrates academic GPU partnership onboarding in Salesforce and notifies the academic programs team in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Academic Partnership Onboarding"
  description: "Orchestrates academic GPU partnership onboarding in Salesforce and notifies the academic programs team in Slack."
  tags:
    - partnerships
    - salesforce
    - slack
    - academic
capability:
  exposes:
    - type: mcp
      namespace: academic-ops
      port: 8080
      tools:
        - name: handle-academic-onboarding
          description: "Given institution details, create a Salesforce partner account and notify the academic team."
          inputParameters:
            - name: institution_name
              in: body
              type: string
              description: "Academic institution name."
            - name: program_type
              in: body
              type: string
              description: "Program type (e.g. research, teaching)."
          steps:
            - name: create-account
              type: call
              call: sf-academic.create-account
              with:
                name: "{{institution_name}}"
                type: "Academic — {{program_type}}"
            - name: notify-team
              type: call
              call: slack-academic.post-message
              with:
                channel: "academic-programs"
                text: "NEW ACADEMIC PARTNER: {{institution_name}} | Program: {{program_type}} | SF: {{create-account.id}}"
  consumes:
    - type: http
      namespace: sf-academic
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account"
          operations:
            - name: create-account
              method: POST
    - type: http
      namespace: slack-academic
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches a Salesforce enterprise account's open cases, opportunity pipeline, and last activity date, then posts a health summary to the account team's Slack channel.

naftiko: "0.5"
info:
  label: "Salesforce Account Health Digest"
  description: "Fetches a Salesforce enterprise account's open cases, opportunity pipeline, and last activity date, then posts a health summary to the account team's Slack channel."
  tags:
    - sales
    - crm
    - salesforce
    - slack
    - account-management
capability:
  exposes:
    - type: mcp
      namespace: account-ops
      port: 8080
      tools:
        - name: digest-account-health
          description: "Given a Salesforce account ID and Slack channel, fetch open support cases, pipeline opportunities, and last activity date, then post a structured health digest. Use for weekly account reviews or pre-meeting prep."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "The Salesforce account ID (18-character SFDC ID)."
            - name: slack_channel
              in: body
              type: string
              description: "The Slack channel to post the account health digest to."
          steps:
            - name: get-account
              type: call
              call: "salesforce.get-account"
              with:
                account_id: "{{account_id}}"
            - name: get-open-cases
              type: call
              call: "salesforce-cases.query-cases"
              with:
                account_id: "{{account_id}}"
                status: "Open"
            - name: post-digest
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Account Health: {{get-account.Name}} | Open Cases: {{get-open-cases.totalSize}} | Last Activity: {{get-account.LastActivityDate}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: get-account
              method: GET
    - type: http
      namespace: salesforce-cases
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: cases-query
          path: "/query"
          inputParameters:
            - name: q
              in: query
          operations:
            - name: query-cases
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Compiles DGX Cloud customer health scores from Salesforce and posts a digest to the customer success Slack channel.

naftiko: "0.5"
info:
  label: "Salesforce Cloud Customer Health Digest"
  description: "Compiles DGX Cloud customer health scores from Salesforce and posts a digest to the customer success Slack channel."
  tags:
    - customer-success
    - salesforce
    - slack
    - cloud
capability:
  exposes:
    - type: mcp
      namespace: cs-ops
      port: 8080
      tools:
        - name: handle-customer-health
          description: "Given a customer segment, compile health scores and post to customer success."
          inputParameters:
            - name: segment
              in: body
              type: string
              description: "Customer segment (e.g. enterprise, startup)."
          steps:
            - name: query-health
              type: call
              call: sf-cs.query-accounts
              with:
                segment: "{{segment}}"
            - name: post-digest
              type: call
              call: slack-cs.post-message
              with:
                channel: "customer-success"
                text: "Customer Health ({{segment}}): Accounts: {{query-health.totalSize}} | At-risk: {{query-health.at_risk}} | Healthy: {{query-health.healthy}}"
  consumes:
    - type: http
      namespace: sf-cs
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/query"
          inputParameters:
            - name: segment
              in: query
          operations:
            - name: query-accounts
              method: GET
    - type: http
      namespace: slack-cs
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Orchestrates DGX Cloud trial onboarding by creating Salesforce records, provisioning access, and notifying the cloud team in Slack.

naftiko: "0.5"
info:
  label: "Salesforce DGX Cloud Trial Onboarding"
  description: "Orchestrates DGX Cloud trial onboarding by creating Salesforce records, provisioning access, and notifying the cloud team in Slack."
  tags:
    - cloud
    - salesforce
    - slack
    - onboarding
capability:
  exposes:
    - type: mcp
      namespace: dgx-cloud-ops
      port: 8080
      tools:
        - name: handle-dgx-trial
          description: "Given customer details, create a Salesforce trial record and notify the DGX Cloud team in Slack."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "Salesforce account ID."
            - name: trial_tier
              in: body
              type: string
              description: "DGX Cloud trial tier."
          steps:
            - name: get-account
              type: call
              call: sf-dgx.get-account
              with:
                account_id: "{{account_id}}"
            - name: notify-cloud
              type: call
              call: slack-dgx.post-message
              with:
                channel: "dgx-cloud-ops"
                text: "DGX CLOUD TRIAL: {{get-account.Name}} | Tier: {{trial_tier}} | Account: {{account_id}} | Please provision trial environment."
  consumes:
    - type: http
      namespace: sf-dgx
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: get-account
              method: GET
    - type: http
      namespace: slack-dgx
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an enterprise deal closes in Salesforce, creates a Jira delivery project and notifies the delivery team in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Enterprise Deal to Jira Delivery"
  description: "When an enterprise deal closes in Salesforce, creates a Jira delivery project and notifies the delivery team in Slack."
  tags:
    - delivery
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: deal-delivery
      port: 8080
      tools:
        - name: handle-deal-delivery
          description: "Given a closed opportunity ID, create a Jira delivery project and notify the team."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "Salesforce opportunity ID."
          steps:
            - name: get-opp
              type: call
              call: sf-deals.get-opportunity
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: create-project
              type: call
              call: jira-del.create-issue
              with:
                project_key: "DEL"
                issuetype: "Epic"
                summary: "Delivery: {{get-opp.Name}} — {{get-opp.Account.Name}}"
            - name: notify-delivery
              type: call
              call: slack-del.post-message
              with:
                channel: "delivery-ops"
                text: "NEW DELIVERY: {{get-opp.Name}} | Account: {{get-opp.Account.Name}} | ${{get-opp.Amount}} | Jira: {{create-project.key}}"
  consumes:
    - type: http
      namespace: sf-deals
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
    - type: http
      namespace: jira-del
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-del
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Looks up enterprise GPU order details in Salesforce for data center procurement tracking.

naftiko: "0.5"
info:
  label: "Salesforce Enterprise GPU Order Lookup"
  description: "Looks up enterprise GPU order details in Salesforce for data center procurement tracking."
  tags:
    - sales
    - salesforce
    - gpu
capability:
  exposes:
    - type: mcp
      namespace: gpu-sales
      port: 8080
      tools:
        - name: get-gpu-order
          description: "Given a Salesforce opportunity ID, return enterprise GPU order details. Use for order fulfillment tracking."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "Salesforce opportunity record ID."
          call: "sf-gpu.get-opportunity"
          with:
            opportunity_id: "{{opportunity_id}}"
          outputParameters:
            - name: opportunity
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: sf-gpu
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET

When a high-value GPU deal is created in Salesforce, creates a Jira delivery planning epic and alerts sales leadership in Slack.

naftiko: "0.5"
info:
  label: "Salesforce High-Value GPU Deal Alert"
  description: "When a high-value GPU deal is created in Salesforce, creates a Jira delivery planning epic and alerts sales leadership in Slack."
  tags:
    - sales
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: deal-ops
      port: 8080
      tools:
        - name: handle-high-value-deal
          description: "Given a Salesforce opportunity ID, create a Jira epic and notify sales leadership in Slack."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "Salesforce opportunity record ID."
          steps:
            - name: get-opp
              type: call
              call: sf-deals.get-opportunity
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: create-epic
              type: call
              call: jira-deals.create-issue
              with:
                project_key: "GPU"
                issuetype: "Epic"
                summary: "GPU delivery: {{get-opp.Name}} — ${{get-opp.Amount}}"
            - name: notify-leadership
              type: call
              call: slack-deals.post-message
              with:
                channel: "sales-leadership"
                text: "HIGH-VALUE DEAL: {{get-opp.Name}} | ${{get-opp.Amount}} | Account: {{get-opp.Account.Name}} | Jira: {{create-epic.key}}"
  consumes:
    - type: http
      namespace: sf-deals
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
    - type: http
      namespace: jira-deals
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-deals
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new lead is created in Salesforce from a developer-focused campaign, enriches the record with the lead's public GitHub profile data.

naftiko: "0.5"
info:
  label: "Salesforce Lead Enrichment from GitHub Activity"
  description: "When a new lead is created in Salesforce from a developer-focused campaign, enriches the record with the lead's public GitHub profile data."
  tags:
    - sales
    - crm
    - salesforce
    - github
    - lead-enrichment
capability:
  exposes:
    - type: mcp
      namespace: lead-enrichment
      port: 8080
      tools:
        - name: enrich-developer-lead
          description: "Given a Salesforce lead ID and a GitHub username, fetch the GitHub profile and update the Salesforce lead record with developer context. Use for developer-sourced inbound leads."
          inputParameters:
            - name: lead_id
              in: body
              type: string
              description: "The Salesforce lead ID to enrich."
            - name: github_username
              in: body
              type: string
              description: "The GitHub username of the lead."
          steps:
            - name: get-github-profile
              type: call
              call: "github.get-user"
              with:
                username: "{{github_username}}"
            - name: update-salesforce-lead
              type: call
              call: "salesforce.update-lead"
              with:
                lead_id: "{{lead_id}}"
                github_company: "{{get-github-profile.company}}"
                github_followers: "{{get-github-profile.followers}}"
                github_public_repos: "{{get-github-profile.public_repos}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: users
          path: "/users/{{username}}"
          inputParameters:
            - name: username
              in: path
          operations:
            - name: get-user
              method: GET
    - type: http
      namespace: salesforce
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: leads
          path: "/sobjects/Lead/{{lead_id}}"
          inputParameters:
            - name: lead_id
              in: path
          operations:
            - name: update-lead
              method: PATCH

Looks up NeMo framework customer license details in Salesforce.

naftiko: "0.5"
info:
  label: "Salesforce NeMo Customer License Lookup"
  description: "Looks up NeMo framework customer license details in Salesforce."
  tags:
    - crm
    - salesforce
    - nemo
capability:
  exposes:
    - type: mcp
      namespace: nemo-licensing
      port: 8080
      tools:
        - name: get-license
          description: "Given a Salesforce account ID, return NeMo framework license details. Use for customer support and renewal tracking."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "Salesforce account record ID."
          call: "sf-nemo.get-account"
          with:
            account_id: "{{account_id}}"
          outputParameters:
            - name: account
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: sf-nemo
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: get-account
              method: GET

When a Salesforce opportunity reaches the Closed Won stage, creates a corresponding Jira epic for the delivery team and notifies the account Slack channel.

naftiko: "0.5"
info:
  label: "Salesforce Opportunity Sync to Jira"
  description: "When a Salesforce opportunity reaches the Closed Won stage, creates a corresponding Jira epic for the delivery team and notifies the account Slack channel."
  tags:
    - sales
    - crm
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: sales-ops
      port: 8080
      tools:
        - name: sync-closed-won-opportunity
          description: "Given a Salesforce opportunity ID, fetch opportunity details and create a Jira epic for the implementation team. Notify the relevant Slack channel. Use when a deal closes to kick off delivery workflows."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity ID (18-character SFDC ID)."
            - name: jira_project_key
              in: body
              type: string
              description: "The Jira project key for the delivery team (e.g., 'DGX')."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel to notify on deal close (e.g., '#enterprise-sales')."
          steps:
            - name: get-opportunity
              type: call
              call: "salesforce.get-opportunity"
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: create-jira-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "{{jira_project_key}}"
                issuetype: "Epic"
                summary: "Delivery: {{get-opportunity.Name}}"
                description: "Customer: {{get-opportunity.AccountName}}\nValue: {{get-opportunity.Amount}}\nClose Date: {{get-opportunity.CloseDate}}\nSFDC ID: {{opportunity_id}}"
            - name: notify-slack
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Closed Won: {{get-opportunity.Name}} ({{get-opportunity.Amount}}) — Jira Epic: {{create-jira-epic.key}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Tracks NVIDIA partner certifications in Salesforce, creates renewal tasks in Jira, and notifies the partnerships team in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Partner Certification Tracker"
  description: "Tracks NVIDIA partner certifications in Salesforce, creates renewal tasks in Jira, and notifies the partnerships team in Slack."
  tags:
    - partnerships
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: partner-cert
      port: 8080
      tools:
        - name: handle-certification-tracking
          description: "Given a partner account ID, check certification status and create renewal tasks if needed."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "Salesforce partner account ID."
          steps:
            - name: get-account
              type: call
              call: sf-cert.get-account
              with:
                account_id: "{{account_id}}"
            - name: create-renewal
              type: call
              call: jira-cert.create-issue
              with:
                project_key: "PART"
                issuetype: "Task"
                summary: "Cert renewal: {{get-account.Name}}"
            - name: notify-partners
              type: call
              call: slack-partners.post-message
              with:
                channel: "partnerships"
                text: "CERT TRACKING: {{get-account.Name}} | Account: {{account_id}} | Renewal: {{create-renewal.key}}"
  consumes:
    - type: http
      namespace: sf-cert
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: get-account
              method: GET
    - type: http
      namespace: jira-cert
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-partners
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates quarterly revenue forecast from Salesforce, enriches with Snowflake analytics, and posts to the finance Slack channel.

naftiko: "0.5"
info:
  label: "Salesforce Revenue Forecast to Snowflake"
  description: "Generates quarterly revenue forecast from Salesforce, enriches with Snowflake analytics, and posts to the finance Slack channel."
  tags:
    - finance
    - salesforce
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: revenue-ops
      port: 8080
      tools:
        - name: handle-revenue-forecast
          description: "Given a quarter, compile revenue forecast and post to finance."
          inputParameters:
            - name: quarter
              in: body
              type: string
              description: "Quarter (e.g. Q1-2026)."
          steps:
            - name: query-pipeline
              type: call
              call: sf-revenue.query-opportunities
              with:
                quarter: "{{quarter}}"
            - name: enrich-data
              type: call
              call: snowflake-rev.run-query
              with:
                quarter: "{{quarter}}"
            - name: post-forecast
              type: call
              call: slack-fin.post-message
              with:
                channel: "finance-leadership"
                text: "Revenue Forecast ({{quarter}}): Pipeline: ${{query-pipeline.totalAmount}} | Weighted: ${{enrich-data.weighted}} | Win rate: {{enrich-data.win_rate}}%"
  consumes:
    - type: http
      namespace: sf-revenue
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: query
          path: "/query"
          inputParameters:
            - name: quarter
              in: query
          operations:
            - name: query-opportunities
              method: GET
    - type: http
      namespace: snowflake-rev
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-fin
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries ServiceNow for data center capacity data, enriches with Snowflake analytics, and posts to the infrastructure Slack channel.

naftiko: "0.5"
info:
  label: "ServiceNow Data Center Capacity Planner"
  description: "Queries ServiceNow for data center capacity data, enriches with Snowflake analytics, and posts to the infrastructure Slack channel."
  tags:
    - infrastructure
    - servicenow
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: capacity-ops
      port: 8080
      tools:
        - name: handle-capacity-planning
          description: "Given a data center ID, compile capacity data and post a planning report."
          inputParameters:
            - name: datacenter_id
              in: body
              type: string
              description: "Data center identifier."
          steps:
            - name: get-capacity
              type: call
              call: snow-cap.get-cmdb
              with:
                datacenter_id: "{{datacenter_id}}"
            - name: enrich-data
              type: call
              call: snowflake-cap.run-query
              with:
                datacenter_id: "{{datacenter_id}}"
            - name: post-report
              type: call
              call: slack-cap.post-message
              with:
                channel: "infrastructure-planning"
                text: "Capacity Report: DC {{datacenter_id}} | Racks: {{get-capacity.total_racks}} | Utilization: {{enrich-data.utilization}}% | Available: {{enrich-data.available_slots}}"
  consumes:
    - type: http
      namespace: snow-cap
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: bearer
        token: "$secrets.servicenow_token"
      resources:
        - name: cmdb
          path: "/table/cmdb_ci_datacenter"
          inputParameters:
            - name: datacenter_id
              in: query
          operations:
            - name: get-cmdb
              method: GET
    - type: http
      namespace: snowflake-cap
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-cap
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves open data center incidents from ServiceNow for GPU infrastructure operations.

naftiko: "0.5"
info:
  label: "ServiceNow Data Center Incident Lookup"
  description: "Retrieves open data center incidents from ServiceNow for GPU infrastructure operations."
  tags:
    - operations
    - servicenow
    - datacenter
capability:
  exposes:
    - type: mcp
      namespace: dc-ops
      port: 8080
      tools:
        - name: get-dc-incidents
          description: "Given a data center location, return open incidents from ServiceNow. Use for operations dashboards."
          inputParameters:
            - name: location
              in: body
              type: string
              description: "Data center location identifier."
          call: "snow-dc.get-incidents"
          with:
            location: "{{location}}"
          outputParameters:
            - name: incidents
              type: array
              mapping: "$.result"
  consumes:
    - type: http
      namespace: snow-dc
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: bearer
        token: "$secrets.servicenow_token"
      resources:
        - name: incidents
          path: "/table/incident"
          inputParameters:
            - name: location
              in: query
          operations:
            - name: get-incidents
              method: GET

Checks the RMA status for a GPU unit in ServiceNow.

naftiko: "0.5"
info:
  label: "ServiceNow GPU RMA Status"
  description: "Checks the RMA status for a GPU unit in ServiceNow."
  tags:
    - support
    - servicenow
    - rma
capability:
  exposes:
    - type: mcp
      namespace: rma-ops
      port: 8080
      tools:
        - name: get-rma-status
          description: "Given a ServiceNow case number, return the GPU RMA status. Use for customer support tracking."
          inputParameters:
            - name: case_number
              in: body
              type: string
              description: "ServiceNow case number."
          call: "snow-rma.get-case"
          with:
            number: "{{case_number}}"
          outputParameters:
            - name: case_record
              type: object
              mapping: "$.result"
  consumes:
    - type: http
      namespace: snow-rma
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: bearer
        token: "$secrets.servicenow_token"
      resources:
        - name: cases
          path: "/table/sn_customerservice_case"
          inputParameters:
            - name: number
              in: query
          operations:
            - name: get-case
              method: GET

When a ServiceNow P1 incident is unacknowledged for 15 minutes, escalates it to the on-call engineering manager via Microsoft Teams and updates the incident record.

naftiko: "0.5"
info:
  label: "ServiceNow Incident Escalation"
  description: "When a ServiceNow P1 incident is unacknowledged for 15 minutes, escalates it to the on-call engineering manager via Microsoft Teams and updates the incident record."
  tags:
    - itsm
    - servicenow
    - microsoft-teams
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: itsm-ops
      port: 8080
      tools:
        - name: escalate-p1-incident
          description: "Given a ServiceNow incident number, escalate it to the on-call engineering manager via Microsoft Teams and update the incident priority and assignment. Use when a P1 incident has breached the acknowledgment SLA."
          inputParameters:
            - name: incident_number
              in: body
              type: string
              description: "The ServiceNow incident number (e.g., 'INC0012345')."
            - name: escalation_manager_upn
              in: body
              type: string
              description: "The UPN (email) of the on-call engineering manager to notify."
          steps:
            - name: get-incident
              type: call
              call: "servicenow.get-incident"
              with:
                number: "{{incident_number}}"
            - name: update-incident
              type: call
              call: "servicenow-update.update-incident"
              with:
                sys_id: "{{get-incident.sys_id}}"
                escalation: "1"
                assigned_to: "{{escalation_manager_upn}}"
            - name: notify-manager
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{escalation_manager_upn}}"
                text: "ESCALATED P1 Incident: {{incident_number}} — {{get-incident.short_description}}. Immediate action required."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          inputParameters:
            - name: number
              in: query
          operations:
            - name: get-incident
              method: GET
    - type: http
      namespace: servicenow-update
      baseUri: "https://nvidia.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incident-record
          path: "/table/incident/{{sys_id}}"
          inputParameters:
            - name: sys_id
              in: path
          operations:
            - name: update-incident
              method: PATCH
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: mail
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST

When a Jira project is closed, archives the corresponding Slack channel and posts a closure notice to the project's Microsoft Teams channel.

naftiko: "0.5"
info:
  label: "Slack Channel Archival for Closed Projects"
  description: "When a Jira project is closed, archives the corresponding Slack channel and posts a closure notice to the project's Microsoft Teams channel."
  tags:
    - communication
    - slack
    - jira
    - microsoft-teams
    - project-management
capability:
  exposes:
    - type: mcp
      namespace: project-closeout
      port: 8080
      tools:
        - name: archive-project-channel
          description: "Given a Jira project key, Slack channel ID, and Teams channel ID, mark the Jira project as closed, archive the Slack channel, and post a closure notice to Teams. Use when a software project or product line is wound down."
          inputParameters:
            - name: jira_project_key
              in: body
              type: string
              description: "The Jira project key being closed (e.g., 'VOLTA')."
            - name: slack_channel_id
              in: body
              type: string
              description: "The Slack channel ID to archive."
            - name: teams_channel_id
              in: body
              type: string
              description: "The Microsoft Teams channel ID to notify of closure."
          steps:
            - name: archive-slack-channel
              type: call
              call: "slack.archive-channel"
              with:
                channel: "{{slack_channel_id}}"
            - name: notify-teams
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "{{teams_channel_id}}"
                text: "Project {{jira_project_key}} has been closed. The associated Slack channel has been archived."
  consumes:
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: channel-archive
          path: "/conversations.archive"
          operations:
            - name: archive-channel
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: team_id
              in: path
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Generates AI training infrastructure cost analytics from Snowflake and posts the report to the finance Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake AI Training Cost Report"
  description: "Generates AI training infrastructure cost analytics from Snowflake and posts the report to the finance Slack channel."
  tags:
    - finance
    - snowflake
    - slack
    - ai-training
capability:
  exposes:
    - type: mcp
      namespace: training-finance
      port: 8080
      tools:
        - name: handle-training-cost-report
          description: "Given a time period, generate AI training cost analytics from Snowflake and post to the finance Slack channel."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period (e.g. 2026-Q1)."
          steps:
            - name: query-costs
              type: call
              call: snowflake-costs.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-finance.post-message
              with:
                channel: "finance-ops"
                text: "AI Training Cost Report ({{period}}): Total: ${{query-costs.total_cost}} | GPU hours: {{query-costs.gpu_hours}} | Cost/hour: ${{query-costs.cost_per_hour}}"
  consumes:
    - type: http
      namespace: snowflake-costs
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-finance
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for Blackwell GPU chip yield analytics, creates Jira tasks for low-yield batches, and posts to the manufacturing Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Blackwell Yield Analysis"
  description: "Queries Snowflake for Blackwell GPU chip yield analytics, creates Jira tasks for low-yield batches, and posts to the manufacturing Slack channel."
  tags:
    - manufacturing
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: blackwell-mfg
      port: 8080
      tools:
        - name: handle-yield-analysis
          description: "Given a batch ID, query yield data from Snowflake and create Jira tasks for review."
          inputParameters:
            - name: batch_id
              in: body
              type: string
              description: "Manufacturing batch ID."
          steps:
            - name: query-yield
              type: call
              call: snowflake-yield.run-query
              with:
                batch_id: "{{batch_id}}"
            - name: create-task
              type: call
              call: jira-mfg.create-issue
              with:
                project_key: "MFG"
                issuetype: "Task"
                summary: "Yield review: Batch {{batch_id}} — {{query-yield.yield_rate}}%"
            - name: notify-mfg
              type: call
              call: slack-mfg.post-message
              with:
                channel: "gpu-manufacturing"
                text: "YIELD ANALYSIS: Batch {{batch_id}} | Rate: {{query-yield.yield_rate}}% | Units: {{query-yield.total_units}} | Jira: {{create-task.key}}"
  consumes:
    - type: http
      namespace: snowflake-yield
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-mfg
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-mfg
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for CUDA toolkit benchmark results across GPU architectures.

naftiko: "0.5"
info:
  label: "Snowflake CUDA Benchmark Query"
  description: "Queries Snowflake for CUDA toolkit benchmark results across GPU architectures."
  tags:
    - analytics
    - snowflake
    - cuda
capability:
  exposes:
    - type: mcp
      namespace: cuda-analytics
      port: 8080
      tools:
        - name: get-benchmark-results
          description: "Given a GPU architecture and CUDA version, return benchmark results from Snowflake. Use for performance regression tracking."
          inputParameters:
            - name: gpu_architecture
              in: body
              type: string
              description: "GPU architecture name (e.g. Hopper, Blackwell)."
            - name: cuda_version
              in: body
              type: string
              description: "CUDA toolkit version."
          call: "snowflake-cuda.run-query"
          with:
            architecture: "{{gpu_architecture}}"
            cuda: "{{cuda_version}}"
          outputParameters:
            - name: benchmarks
              type: array
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-cuda
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Queries Snowflake for customer churn risk indicators, creates Salesforce tasks, and notifies customer success in Slack.

naftiko: "0.5"
info:
  label: "Snowflake Customer Churn Risk Alert"
  description: "Queries Snowflake for customer churn risk indicators, creates Salesforce tasks, and notifies customer success in Slack."
  tags:
    - customer-success
    - snowflake
    - salesforce
    - slack
capability:
  exposes:
    - type: mcp
      namespace: churn-ops
      port: 8080
      tools:
        - name: handle-churn-risk
          description: "Given a risk threshold, identify at-risk customers and create follow-up tasks."
          inputParameters:
            - name: risk_threshold
              in: body
              type: number
              description: "Churn risk score threshold."
          steps:
            - name: query-risk
              type: call
              call: snowflake-churn.run-query
              with:
                threshold: "{{risk_threshold}}"
            - name: create-task
              type: call
              call: sf-churn.create-task
              with:
                subject: "Churn risk customers above {{risk_threshold}} threshold"
            - name: notify-cs
              type: call
              call: slack-churn.post-message
              with:
                channel: "customer-success"
                text: "CHURN RISK ALERT: {{query-risk.at_risk_count}} customers above {{risk_threshold}} threshold | SF Task: {{create-task.id}}"
  consumes:
    - type: http
      namespace: snowflake-churn
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: sf-churn
      baseUri: "https://nvidia.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: tasks
          path: "/sobjects/Task"
          operations:
            - name: create-task
              method: POST
    - type: http
      namespace: slack-churn
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake query history for long-running or failed jobs and posts a daily data pipeline health digest to a Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Data Pipeline Health Monitor"
  description: "Queries Snowflake query history for long-running or failed jobs and posts a daily data pipeline health digest to a Slack channel."
  tags:
    - data
    - analytics
    - snowflake
    - slack
    - monitoring
capability:
  exposes:
    - type: mcp
      namespace: data-ops
      port: 8080
      tools:
        - name: digest-pipeline-health
          description: "Query Snowflake for failed or long-running queries in the past 24 hours and post a health summary to the specified Slack channel. Use for daily data engineering stand-ups or automated pipeline monitoring."
          inputParameters:
            - name: warehouse_name
              in: body
              type: string
              description: "The Snowflake virtual warehouse to monitor (e.g., 'DATA_ENGINEERING_WH')."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel for the health digest (e.g., '#data-ops')."
          steps:
            - name: query-failed-jobs
              type: call
              call: "snowflake.query-history"
              with:
                warehouse_name: "{{warehouse_name}}"
                error_code: "NOT_NULL"
            - name: post-digest
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Data Pipeline Health Digest: Snowflake warehouse {{warehouse_name}} — check query history for failures and long-running jobs in the last 24 hours."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: query-history
          path: "/statements"
          inputParameters:
            - name: warehouse_name
              in: query
            - name: error_code
              in: query
          operations:
            - name: query-history
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Runs a data quality SQL assertion against a Snowflake table and posts pass/fail results to Slack, blocking downstream pipeline runs on failure.

naftiko: "0.5"
info:
  label: "Snowflake Data Quality Gate"
  description: "Runs a data quality SQL assertion against a Snowflake table and posts pass/fail results to Slack, blocking downstream pipeline runs on failure."
  tags:
    - data
    - analytics
    - snowflake
    - slack
    - data-quality
capability:
  exposes:
    - type: mcp
      namespace: data-quality
      port: 8080
      tools:
        - name: run-data-quality-check
          description: "Execute a data quality SQL statement against a Snowflake table and post the result to Slack. Returns pass/fail status. Use as a gate before loading data into downstream BI or ML pipelines."
          inputParameters:
            - name: database
              in: body
              type: string
              description: "Snowflake database name (e.g., 'PROD_DW')."
            - name: schema
              in: body
              type: string
              description: "Snowflake schema name (e.g., 'PUBLIC')."
            - name: table_name
              in: body
              type: string
              description: "Table to run quality checks against."
            - name: sql_statement
              in: body
              type: string
              description: "The SQL assertion query to execute. Should return 0 rows on pass."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel to post results to."
          steps:
            - name: execute-quality-check
              type: call
              call: "snowflake.execute-statement"
              with:
                database: "{{database}}"
                schema: "{{schema}}"
                statement: "{{sql_statement}}"
            - name: post-result
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Data Quality Check on {{database}}.{{schema}}.{{table_name}}: {{execute-quality-check.statementStatusUrl}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for data center power consumption analytics and posts the report to the sustainability Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Data Center Power Consumption Report"
  description: "Queries Snowflake for data center power consumption analytics and posts the report to the sustainability Slack channel."
  tags:
    - sustainability
    - snowflake
    - slack
    - datacenter
capability:
  exposes:
    - type: mcp
      namespace: power-analytics
      port: 8080
      tools:
        - name: handle-power-report
          description: "Given a data center ID, query power consumption from Snowflake and post to the sustainability Slack channel."
          inputParameters:
            - name: datacenter_id
              in: body
              type: string
              description: "Data center identifier."
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-power
              type: call
              call: snowflake-power.run-query
              with:
                datacenter_id: "{{datacenter_id}}"
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-green.post-message
              with:
                channel: "sustainability"
                text: "Power Report: DC {{datacenter_id}} ({{period}}) | Total: {{query-power.total_kwh}} kWh | PUE: {{query-power.pue}} | GPU load: {{query-power.avg_gpu_load}}%"
  consumes:
    - type: http
      namespace: snowflake-power
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-green
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries developer program growth metrics from Snowflake and posts to the developer relations Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Developer Program Growth Report"
  description: "Queries developer program growth metrics from Snowflake and posts to the developer relations Slack channel."
  tags:
    - devrel
    - snowflake
    - slack
    - analytics
capability:
  exposes:
    - type: mcp
      namespace: devrel-analytics
      port: 8080
      tools:
        - name: handle-devrel-report
          description: "Given a period, query developer program growth and post to Slack."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-growth
              type: call
              call: snowflake-devrel.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-devrel.post-message
              with:
                channel: "developer-relations"
                text: "DevRel Growth ({{period}}): New developers: {{query-growth.new_devs}} | Active: {{query-growth.active_devs}} | SDK downloads: {{query-growth.sdk_downloads}}"
  consumes:
    - type: http
      namespace: snowflake-devrel
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-devrel
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for GPU driver download statistics by version and platform.

naftiko: "0.5"
info:
  label: "Snowflake Driver Download Analytics"
  description: "Queries Snowflake for GPU driver download statistics by version and platform."
  tags:
    - analytics
    - snowflake
    - drivers
capability:
  exposes:
    - type: mcp
      namespace: driver-analytics
      port: 8080
      tools:
        - name: get-download-stats
          description: "Given a driver version, return download statistics from Snowflake. Use for release adoption tracking."
          inputParameters:
            - name: driver_version
              in: body
              type: string
              description: "GPU driver version number."
          call: "snowflake-drivers.run-query"
          with:
            driver_version: "{{driver_version}}"
          outputParameters:
            - name: stats
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-drivers
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Generates DGX Cloud usage billing reports from Snowflake and posts to the finance Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake GPU Cloud Usage Billing Report"
  description: "Generates DGX Cloud usage billing reports from Snowflake and posts to the finance Slack channel."
  tags:
    - finance
    - snowflake
    - slack
    - cloud
capability:
  exposes:
    - type: mcp
      namespace: billing-ops
      port: 8080
      tools:
        - name: handle-billing-report
          description: "Given a billing period, generate cloud usage billing report and post to finance."
          inputParameters:
            - name: billing_period
              in: body
              type: string
              description: "Billing period (e.g. 2026-03)."
          steps:
            - name: query-usage
              type: call
              call: snowflake-billing.run-query
              with:
                period: "{{billing_period}}"
            - name: post-report
              type: call
              call: slack-billing.post-message
              with:
                channel: "finance-ops"
                text: "DGX Cloud Billing ({{billing_period}}): Total: ${{query-usage.total_revenue}} | Customers: {{query-usage.active_customers}} | GPU-hours: {{query-usage.total_gpu_hours}}"
  consumes:
    - type: http
      namespace: snowflake-billing
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-billing
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries GPU defect rate data from Snowflake and creates Jira quality tasks for batches exceeding thresholds.

naftiko: "0.5"
info:
  label: "Snowflake GPU Defect Rate Analysis"
  description: "Queries GPU defect rate data from Snowflake and creates Jira quality tasks for batches exceeding thresholds."
  tags:
    - quality
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: quality-ops
      port: 8080
      tools:
        - name: handle-defect-analysis
          description: "Given a product line, query defect rates and create quality tasks."
          inputParameters:
            - name: product_line
              in: body
              type: string
              description: "GPU product line."
          steps:
            - name: query-defects
              type: call
              call: snowflake-qa.run-query
              with:
                product_line: "{{product_line}}"
            - name: create-task
              type: call
              call: jira-qa.create-issue
              with:
                project_key: "QA"
                issuetype: "Task"
                summary: "Defect rate review: {{product_line}} — {{query-defects.defect_rate}}%"
            - name: notify-qa
              type: call
              call: slack-qa.post-message
              with:
                channel: "quality-engineering"
                text: "DEFECT ANALYSIS: {{product_line}} | Rate: {{query-defects.defect_rate}}% | Units: {{query-defects.total_tested}} | Jira: {{create-task.key}}"
  consumes:
    - type: http
      namespace: snowflake-qa
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-qa
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-qa
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for GPU sales pipeline analytics by product line and region.

naftiko: "0.5"
info:
  label: "Snowflake GPU Sales Pipeline Query"
  description: "Queries Snowflake for GPU sales pipeline analytics by product line and region."
  tags:
    - analytics
    - snowflake
    - sales
capability:
  exposes:
    - type: mcp
      namespace: sales-analytics
      port: 8080
      tools:
        - name: get-pipeline-analytics
          description: "Given a product line and region, return GPU sales pipeline data from Snowflake. Use for revenue forecasting."
          inputParameters:
            - name: product_line
              in: body
              type: string
              description: "GPU product line (e.g. H100, A100, Blackwell)."
            - name: region
              in: body
              type: string
              description: "Sales region."
          call: "snowflake-sales.run-query"
          with:
            product_line: "{{product_line}}"
            region: "{{region}}"
          outputParameters:
            - name: pipeline
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-sales
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Queries Snowflake for NVIDIA Inference API usage analytics and posts the report to the product Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Inference API Usage Report"
  description: "Queries Snowflake for NVIDIA Inference API usage analytics and posts the report to the product Slack channel."
  tags:
    - product
    - snowflake
    - slack
    - inference
capability:
  exposes:
    - type: mcp
      namespace: inference-analytics
      port: 8080
      tools:
        - name: handle-usage-report
          description: "Given a period, query inference API usage and post to Slack."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-usage
              type: call
              call: snowflake-api.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-api.post-message
              with:
                channel: "product-analytics"
                text: "Inference API Usage ({{period}}): Requests: {{query-usage.total_requests}} | Unique users: {{query-usage.unique_users}} | Avg latency: {{query-usage.avg_latency}}ms"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake account usage data to generate a credit consumption report by warehouse and publishes it to the FinOps Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Usage Cost Report"
  description: "Queries Snowflake account usage data to generate a credit consumption report by warehouse and publishes it to the FinOps Slack channel."
  tags:
    - finops
    - data
    - snowflake
    - slack
    - cost-management
capability:
  exposes:
    - type: mcp
      namespace: snowflake-finops
      port: 8080
      tools:
        - name: report-snowflake-costs
          description: "Query Snowflake account usage for credit consumption by warehouse over a given date range and post the report to the FinOps Slack channel. Use for weekly or monthly cloud cost reviews."
          inputParameters:
            - name: start_date
              in: body
              type: string
              description: "Report start date in ISO 8601 format (YYYY-MM-DD)."
            - name: end_date
              in: body
              type: string
              description: "Report end date in ISO 8601 format (YYYY-MM-DD)."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel for the cost report (e.g., '#finops')."
          steps:
            - name: query-usage
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT WAREHOUSE_NAME, SUM(CREDITS_USED) as TOTAL_CREDITS FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY WHERE START_TIME BETWEEN '{{start_date}}' AND '{{end_date}}' GROUP BY WAREHOUSE_NAME ORDER BY TOTAL_CREDITS DESC"
            - name: post-report
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Snowflake Cost Report ({{start_date}} to {{end_date}}): Query complete. Review warehouse credit consumption in the Snowflake console."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://nvidia.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Initiates annual performance reviews in Workday, creates Jira tracking tasks, and notifies HR in Slack.

naftiko: "0.5"
info:
  label: "Workday Annual Performance Review Launcher"
  description: "Initiates annual performance reviews in Workday, creates Jira tracking tasks, and notifies HR in Slack."
  tags:
    - hr
    - workday
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: perf-review
      port: 8080
      tools:
        - name: handle-review-launch
          description: "Given a review cycle name, create Jira tracking and notify HR in Slack."
          inputParameters:
            - name: cycle_name
              in: body
              type: string
              description: "Performance review cycle name."
            - name: target_date
              in: body
              type: string
              description: "Target completion date."
          steps:
            - name: create-tracking
              type: call
              call: jira-hr.create-issue
              with:
                project_key: "HR"
                issuetype: "Epic"
                summary: "Performance Review: {{cycle_name}} — Due {{target_date}}"
            - name: notify-hr
              type: call
              call: slack-hr.post-message
              with:
                channel: "hr-business-partners"
                text: "REVIEW CYCLE: {{cycle_name}} | Due: {{target_date}} | Tracking: {{create-tracking.key}}"
  consumes:
    - type: http
      namespace: jira-hr
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-hr
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates a compensation band report by department from Workday and publishes it to a secure Confluence page for the compensation team.

naftiko: "0.5"
info:
  label: "Workday Compensation Band Report"
  description: "Generates a compensation band report by department from Workday and publishes it to a secure Confluence page for the compensation team."
  tags:
    - hr
    - compensation
    - workday
    - confluence
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: compensation-reporting
      port: 8080
      tools:
        - name: publish-compensation-report
          description: "Fetch compensation band data by department from Workday and publish a structured report to a Confluence page. Use for annual compensation reviews or pay equity analysis."
          inputParameters:
            - name: department_id
              in: body
              type: string
              description: "The Workday department ID to generate the compensation report for."
            - name: confluence_space_key
              in: body
              type: string
              description: "The Confluence space key where the report will be published."
            - name: confluence_parent_id
              in: body
              type: string
              description: "The Confluence parent page ID for the report."
          steps:
            - name: get-compensation-data
              type: call
              call: "workday.get-compensation-by-department"
              with:
                department_id: "{{department_id}}"
            - name: publish-to-confluence
              type: call
              call: "confluence.create-page"
              with:
                space_key: "{{confluence_space_key}}"
                parent_page_id: "{{confluence_parent_id}}"
                title: "Compensation Report — Department {{department_id}}"
                content: "Compensation band data exported from Workday for department {{department_id}}."
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: compensation
          path: "/nvidia/workers"
          inputParameters:
            - name: department_id
              in: query
          operations:
            - name: get-compensation-by-department
              method: GET
    - type: http
      namespace: confluence
      baseUri: "https://nvidia.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST

Checks the compensation review cycle status for a department in Workday.

naftiko: "0.5"
info:
  label: "Workday Compensation Review Status"
  description: "Checks the compensation review cycle status for a department in Workday."
  tags:
    - hr
    - workday
    - compensation
capability:
  exposes:
    - type: mcp
      namespace: comp-ops
      port: 8080
      tools:
        - name: get-review-status
          description: "Given a department name, return the compensation review cycle status from Workday. Use for HR planning."
          inputParameters:
            - name: department
              in: body
              type: string
              description: "Department name."
          call: "workday-comp.get-review"
          with:
            department: "{{department}}"
          outputParameters:
            - name: review
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: workday-comp
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/nvidia"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: reviews
          path: "/compensationReviews"
          inputParameters:
            - name: department
              in: query
          operations:
            - name: get-review
              method: GET

Orchestrates contractor offboarding from Workday by revoking access and notifying IT in Slack.

naftiko: "0.5"
info:
  label: "Workday Contractor Offboarding"
  description: "Orchestrates contractor offboarding from Workday by revoking access and notifying IT in Slack."
  tags:
    - hr
    - workday
    - slack
    - offboarding
capability:
  exposes:
    - type: mcp
      namespace: contractor-offboard
      port: 8080
      tools:
        - name: handle-contractor-offboard
          description: "Given a Workday worker ID for a departing contractor, notify IT for access revocation."
          inputParameters:
            - name: worker_id
              in: body
              type: string
              description: "Workday contingent worker ID."
          steps:
            - name: get-worker
              type: call
              call: workday-offboard.get-worker
              with:
                worker_id: "{{worker_id}}"
            - name: notify-it
              type: call
              call: slack-offboard.post-message
              with:
                channel: "it-security"
                text: "CONTRACTOR EXIT: {{get-worker.fullName}} ({{worker_id}}) | Revoke all access immediately."
  consumes:
    - type: http
      namespace: workday-offboard
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/nvidia"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: slack-offboard
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls diversity metrics from Workday and posts a quarterly report to the HR leadership Slack channel.

naftiko: "0.5"
info:
  label: "Workday Diversity Metrics Report"
  description: "Pulls diversity metrics from Workday and posts a quarterly report to the HR leadership Slack channel."
  tags:
    - hr
    - workday
    - slack
    - dei
capability:
  exposes:
    - type: mcp
      namespace: dei-ops
      port: 8080
      tools:
        - name: handle-dei-report
          description: "Given a quarter, pull diversity metrics from Workday and post to HR leadership in Slack."
          inputParameters:
            - name: quarter
              in: body
              type: string
              description: "Quarter identifier."
          steps:
            - name: get-metrics
              type: call
              call: workday-dei.get-report
              with:
                quarter: "{{quarter}}"
            - name: post-report
              type: call
              call: slack-dei.post-message
              with:
                channel: "hr-leadership"
                text: "DEI Report ({{quarter}}): Headcount: {{get-metrics.total}} | Gender: {{get-metrics.gender_ratio}} | Ethnic: {{get-metrics.ethnic_ratio}}"
  consumes:
    - type: http
      namespace: workday-dei
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/nvidia"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: reports
          path: "/diversityMetrics"
          inputParameters:
            - name: quarter
              in: query
          operations:
            - name: get-report
              method: GET
    - type: http
      namespace: slack-dei
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves current headcount for GPU engineering teams from Workday.

naftiko: "0.5"
info:
  label: "Workday GPU Engineering Headcount"
  description: "Retrieves current headcount for GPU engineering teams from Workday."
  tags:
    - hr
    - workday
    - engineering
capability:
  exposes:
    - type: mcp
      namespace: hr-analytics
      port: 8080
      tools:
        - name: get-eng-headcount
          description: "Given a department name, return current engineering headcount from Workday. Use for workforce planning."
          inputParameters:
            - name: department
              in: body
              type: string
              description: "Department name to query."
          call: "workday-eng.get-headcount"
          with:
            department: "{{department}}"
          outputParameters:
            - name: headcount
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: workday-eng
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/nvidia"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: headcount
          path: "/headcountReport"
          inputParameters:
            - name: department
              in: query
          operations:
            - name: get-headcount
              method: GET

Tracks intern program metrics from Workday and posts updates to the talent Slack channel.

naftiko: "0.5"
info:
  label: "Workday Intern Program Tracker"
  description: "Tracks intern program metrics from Workday and posts updates to the talent Slack channel."
  tags:
    - hr
    - workday
    - slack
    - internship
capability:
  exposes:
    - type: mcp
      namespace: intern-ops
      port: 8080
      tools:
        - name: handle-intern-tracking
          description: "Given a program year, track intern metrics and post updates."
          inputParameters:
            - name: program_year
              in: body
              type: string
              description: "Internship program year."
          steps:
            - name: get-metrics
              type: call
              call: workday-intern.get-report
              with:
                year: "{{program_year}}"
            - name: post-update
              type: call
              call: slack-talent.post-message
              with:
                channel: "talent-programs"
                text: "Intern Program ({{program_year}}): Active: {{get-metrics.active_interns}} | Offers extended: {{get-metrics.offers}} | Conversion: {{get-metrics.conversion_rate}}%"
  consumes:
    - type: http
      namespace: workday-intern
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/nvidia"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: reports
          path: "/internProgram"
          inputParameters:
            - name: year
              in: query
          operations:
            - name: get-report
              method: GET
    - type: http
      namespace: slack-talent
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a leave request is submitted in Workday, notifies the manager in Slack for approval.

naftiko: "0.5"
info:
  label: "Workday Leave Approval Notification"
  description: "When a leave request is submitted in Workday, notifies the manager in Slack for approval."
  tags:
    - hr
    - workday
    - slack
    - leave-management
capability:
  exposes:
    - type: mcp
      namespace: leave-ops
      port: 8080
      tools:
        - name: handle-leave-request
          description: "Given a Workday employee ID and leave dates, notify the manager in Slack."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "Workday employee ID."
            - name: leave_dates
              in: body
              type: string
              description: "Requested leave dates."
          steps:
            - name: get-worker
              type: call
              call: workday-leave.get-worker
              with:
                employee_id: "{{employee_id}}"
            - name: notify-manager
              type: call
              call: slack-leave.post-message
              with:
                channel: "manager-approvals"
                text: "LEAVE REQUEST: {{get-worker.fullName}} | Dates: {{leave_dates}} | Please review in Workday."
  consumes:
    - type: http
      namespace: workday-leave
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/nvidia"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{employee_id}}"
          inputParameters:
            - name: employee_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: slack-leave
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new hire starts in Workday, provisions GPU cluster access and notifies the hiring manager in Slack.

naftiko: "0.5"
info:
  label: "Workday New Hire GPU Access Provisioning"
  description: "When a new hire starts in Workday, provisions GPU cluster access and notifies the hiring manager in Slack."
  tags:
    - hr
    - workday
    - slack
    - onboarding
capability:
  exposes:
    - type: mcp
      namespace: gpu-access
      port: 8080
      tools:
        - name: handle-gpu-access
          description: "Given a Workday employee ID, retrieve their role and notify IT for GPU cluster access provisioning in Slack."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "Workday employee ID."
            - name: cluster_name
              in: body
              type: string
              description: "GPU cluster to provision access to."
          steps:
            - name: get-worker
              type: call
              call: workday-access.get-worker
              with:
                employee_id: "{{employee_id}}"
            - name: notify-it
              type: call
              call: slack-it.post-message
              with:
                channel: "it-provisioning"
                text: "GPU ACCESS: {{get-worker.fullName}} ({{employee_id}}) | Role: {{get-worker.jobTitle}} | Cluster: {{cluster_name}} | Please provision access."
  consumes:
    - type: http
      namespace: workday-access
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/nvidia"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{employee_id}}"
          inputParameters:
            - name: employee_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: slack-it
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns the count of open engineering job requisitions in Workday.

naftiko: "0.5"
info:
  label: "Workday Open Engineering Requisitions"
  description: "Returns the count of open engineering job requisitions in Workday."
  tags:
    - hr
    - workday
    - recruiting
capability:
  exposes:
    - type: mcp
      namespace: talent-ops
      port: 8080
      tools:
        - name: get-open-reqs
          description: "Given a team name, return open engineering requisitions from Workday. Use for hiring pipeline tracking."
          inputParameters:
            - name: team
              in: body
              type: string
              description: "Engineering team name."
          call: "workday-recruit.get-requisitions"
          with:
            team: "{{team}}"
          outputParameters:
            - name: requisitions
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: workday-recruit
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/nvidia"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: requisitions
          path: "/jobRequisitions"
          inputParameters:
            - name: team
              in: query
          operations:
            - name: get-requisitions
              method: GET

Fetches all employees due for a performance review from Workday and creates individual Jira tasks for their managers, then notifies via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Workday Performance Review Cycle Kickoff"
  description: "Fetches all employees due for a performance review from Workday and creates individual Jira tasks for their managers, then notifies via Microsoft Teams."
  tags:
    - hr
    - performance-management
    - workday
    - jira
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: perf-review-ops
      port: 8080
      tools:
        - name: kickoff-performance-reviews
          description: "Fetch employees due for performance review from Workday, create a Jira task for each manager, and notify HR via Microsoft Teams. Use to kick off quarterly or annual review cycles."
          inputParameters:
            - name: review_cycle_name
              in: body
              type: string
              description: "Name of the review cycle (e.g., 'Q1 2026 Performance Review')."
            - name: jira_project_key
              in: body
              type: string
              description: "Jira project key for performance review tasks (e.g., 'HR')."
            - name: hr_teams_channel_id
              in: body
              type: string
              description: "Microsoft Teams channel ID to notify HR of kickoff."
          steps:
            - name: get-review-eligible
              type: call
              call: "workday.list-workers"
              with:
                review_cycle: "{{review_cycle_name}}"
            - name: create-review-tasks
              type: call
              call: "jira.create-issue"
              with:
                project_key: "{{jira_project_key}}"
                issuetype: "Task"
                summary: "Performance Review Cycle: {{review_cycle_name}}"
                description: "Managers: please complete performance reviews for all direct reports in Workday by the deadline."
            - name: notify-hr-teams
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "{{hr_teams_channel_id}}"
                text: "Performance review cycle '{{review_cycle_name}}' has been kicked off. Manager tasks created in Jira: {{create-review-tasks.key}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/nvidia/workers"
          inputParameters:
            - name: review_cycle
              in: query
          operations:
            - name: list-workers
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://nvidia.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: team_id
              in: path
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

When an employee's role changes in Workday, updates their Okta group memberships to reflect the new role's access requirements.

naftiko: "0.5"
info:
  label: "Workday Role Change Propagation"
  description: "When an employee's role changes in Workday, updates their Okta group memberships to reflect the new role's access requirements."
  tags:
    - hr
    - identity
    - workday
    - okta
    - access-management
capability:
  exposes:
    - type: mcp
      namespace: role-sync
      port: 8080
      tools:
        - name: sync-role-change
          description: "Given a Workday employee ID, old role group ID, and new role Okta group ID, remove the user from the old group and add them to the new one. Use when an employee is promoted or transfers teams."
          inputParameters:
            - name: workday_employee_id
              in: body
              type: string
              description: "The Workday worker ID of the employee whose role changed."
            - name: old_okta_group_id
              in: body
              type: string
              description: "The Okta group ID corresponding to the previous role."
            - name: new_okta_group_id
              in: body
              type: string
              description: "The Okta group ID corresponding to the new role."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{workday_employee_id}}"
            - name: remove-old-group
              type: call
              call: "okta-remove.remove-user-from-group"
              with:
                group_id: "{{old_okta_group_id}}"
                user_id: "{{get-employee.okta_user_id}}"
            - name: add-new-group
              type: call
              call: "okta-add.add-user-to-group"
              with:
                group_id: "{{new_okta_group_id}}"
                user_id: "{{get-employee.okta_user_id}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/nvidia/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta-remove
      baseUri: "https://nvidia.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: group-users
          path: "/groups/{{group_id}}/users/{{user_id}}"
          inputParameters:
            - name: group_id
              in: path
            - name: user_id
              in: path
          operations:
            - name: remove-user-from-group
              method: DELETE
    - type: http
      namespace: okta-add
      baseUri: "https://nvidia.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: group-users
          path: "/groups/{{group_id}}/users/{{user_id}}"
          inputParameters:
            - name: group_id
              in: path
            - name: user_id
              in: path
          operations:
            - name: add-user-to-group
              method: PUT