Netflix Capabilities

Submits user-generated content or subtitle text to Anthropic Claude for moderation analysis, logs the result in Snowflake, and flags problematic content for human review in Jira.

naftiko: "0.5"
info:
  label: "Anthropic Content Moderation Assistant"
  description: "Submits user-generated content or subtitle text to Anthropic Claude for moderation analysis, logs the result in Snowflake, and flags problematic content for human review in Jira."
  tags:
    - ai
    - content-moderation
    - anthropic
    - snowflake
    - jira
capability:
  exposes:
    - type: mcp
      namespace: ai-moderation
      port: 8080
      tools:
        - name: moderate-content
          description: "Given a piece of user-generated content or subtitle text and a content ID, submit it to Anthropic Claude for safety analysis, log the result in Snowflake, and open a Jira review task if flagged. Use for automated content safety screening."
          inputParameters:
            - name: content_id
              in: body
              type: string
              description: "Unique identifier for the content being moderated."
            - name: content_text
              in: body
              type: string
              description: "The text to be moderated."
            - name: content_type
              in: body
              type: string
              description: "Type of content: user_review, subtitle, or comment."
          steps:
            - name: analyze-content
              type: call
              call: "anthropic.create-message"
              with:
                model: "claude-3-5-sonnet-20241022"
                content: "Analyze the following {{content_type}} for policy violations. Return JSON with fields: safe (boolean), reason (string). Content: {{content_text}}"
            - name: log-result
              type: call
              call: "snowflake-mod.execute-statement"
              with:
                statement: "INSERT INTO content_moderation_log VALUES ('{{content_id}}', '{{analyze-content.safe}}', '{{analyze-content.reason}}', CURRENT_TIMESTAMP())"
            - name: open-review-task
              type: call
              call: "jira-mod.create-issue"
              with:
                project_key: "TRUST"
                issuetype: "Task"
                summary: "Content review required: {{content_id}}"
                description: "AI moderation flag reason: {{analyze-content.reason}}"
  consumes:
    - type: http
      namespace: anthropic
      baseUri: "https://api.anthropic.com/v1"
      authentication:
        type: apikey
        key: "x-api-key"
        value: "$secrets.anthropic_api_key"
        placement: header
      resources:
        - name: messages
          path: "/messages"
          operations:
            - name: create-message
              method: POST
    - type: http
      namespace: snowflake-mod
      baseUri: "https://netflix.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: jira-mod
      baseUri: "https://netflix.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 AWS Cost Explorer detects unusual spend on a service, creates a Jira FinOps review ticket and posts an alert to the cloud cost Slack channel with estimated overage details.

naftiko: "0.5"
info:
  label: "AWS Cloud Cost Anomaly Responder"
  description: "When AWS Cost Explorer detects unusual spend on a service, creates a Jira FinOps review ticket and posts an alert to the cloud cost Slack channel with estimated overage details."
  tags:
    - cloud
    - finops
    - aws
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: cloud-finops
      port: 8080
      tools:
        - name: handle-cost-anomaly
          description: "Given an AWS service name, anomaly ID, and estimated excess cost, create a Jira cost-review task and notify the FinOps Slack channel. Invoke when AWS Cost Anomaly Detection fires an alert."
          inputParameters:
            - name: anomaly_id
              in: body
              type: string
              description: "The AWS Cost Explorer anomaly detection ID."
            - name: service_name
              in: body
              type: string
              description: "The AWS service experiencing the cost anomaly."
            - name: excess_cost_usd
              in: body
              type: number
              description: "The estimated excess spend in USD."
          steps:
            - name: create-review-ticket
              type: call
              call: "jira-finops.create-issue"
              with:
                project_key: "FINOPS"
                issuetype: "Task"
                summary: "AWS cost anomaly: {{service_name}} — ${{excess_cost_usd}} excess"
                description: "Anomaly ID: {{anomaly_id}}"
            - name: alert-finops
              type: call
              call: "slack-finops.post-message"
              with:
                channel: "cloud-cost-alerts"
                text: "Cost Anomaly: {{service_name}} | Excess: ${{excess_cost_usd}} | Jira: {{create-review-ticket.key}}"
  consumes:
    - type: http
      namespace: jira-finops
      baseUri: "https://netflix.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-finops
      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 GitHub Actions workflow failure on a protected branch, opens a Jira bug, creates a New Relic deployment marker, and alerts the responsible team in Slack.

naftiko: "0.5"
info:
  label: "CI/CD Pipeline Failure Handler"
  description: "On a GitHub Actions workflow failure on a protected branch, opens a Jira bug, creates a New Relic deployment marker, and alerts the responsible team in Slack."
  tags:
    - devops
    - ci-cd
    - github
    - jira
    - new-relic
    - slack
capability:
  exposes:
    - type: mcp
      namespace: devops-ci
      port: 8080
      tools:
        - name: handle-pipeline-failure
          description: "Given a GitHub Actions run ID, repository, branch, failing job name, and commit SHA, open a Jira bug, create a New Relic deployment event, and post an alert to the team's Slack channel. Invoke on any protected-branch pipeline failure."
          inputParameters:
            - name: run_id
              in: body
              type: string
              description: "The GitHub Actions workflow run ID."
            - name: repository
              in: body
              type: string
              description: "The GitHub repository in owner/repo format."
            - name: branch
              in: body
              type: string
              description: "The branch on which the failure occurred."
            - name: job_name
              in: body
              type: string
              description: "The name of the failed job."
            - name: commit_sha
              in: body
              type: string
              description: "The commit SHA that triggered the run."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel ID or name to notify."
          steps:
            - name: create-bug
              type: call
              call: "jira-ci.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Bug"
                summary: "[CI Failure] {{repository}} / {{branch}} — {{job_name}}"
                description: "Run: {{run_id}}\nCommit: {{commit_sha}}"
            - name: create-nr-event
              type: call
              call: "newrelic.create-deployment-marker"
              with:
                entity_name: "{{repository}}"
                version: "{{commit_sha}}"
                description: "Pipeline failure on {{branch}}: {{job_name}}"
            - name: alert-team
              type: call
              call: "slack-ci.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Pipeline Failure: {{repository}} | Branch: {{branch}} | Job: {{job_name}} | Jira: {{create-bug.key}}"
  consumes:
    - type: http
      namespace: jira-ci
      baseUri: "https://netflix.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: newrelic
      baseUri: "https://api.newrelic.com/v2"
      authentication:
        type: apikey
        key: "X-Api-Key"
        value: "$secrets.newrelic_api_key"
        placement: header
      resources:
        - name: deployments
          path: "/deployments.json"
          operations:
            - name: create-deployment-marker
              method: POST
    - type: http
      namespace: slack-ci
      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

Creates or updates an incident runbook page in Confluence from a structured template and posts the link to the relevant Slack on-call channel.

naftiko: "0.5"
info:
  label: "Confluence Runbook Publisher"
  description: "Creates or updates an incident runbook page in Confluence from a structured template and posts the link to the relevant Slack on-call channel."
  tags:
    - itsm
    - documentation
    - confluence
    - slack
    - runbooks
capability:
  exposes:
    - type: mcp
      namespace: runbook-ops
      port: 8080
      tools:
        - name: publish-runbook
          description: "Given a service name, runbook content, and Confluence space key, create or update the runbook page and post the page link to the on-call Slack channel. Use when a new service is deployed or when runbooks need updating."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "The name of the service the runbook covers."
            - name: space_key
              in: body
              type: string
              description: "The Confluence space key where the runbook will be published."
            - name: runbook_content
              in: body
              type: string
              description: "The runbook body content in Confluence wiki markup or HTML."
          steps:
            - name: create-page
              type: call
              call: "confluence.create-page"
              with:
                space_key: "{{space_key}}"
                title: "Runbook: {{service_name}}"
                body: "{{runbook_content}}"
            - name: notify-oncall
              type: call
              call: "slack-runbook.post-message"
              with:
                channel: "on-call"
                text: "Runbook published for {{service_name}}: {{create-page.page_url}}"
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://netflix.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: slack-runbook
      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 video encoding pipeline health from Datadog monitors.

naftiko: "0.5"
info:
  label: "Datadog Encoding Pipeline Health Check"
  description: "Checks video encoding pipeline health from Datadog monitors."
  tags:
    - encoding
    - datadog
    - video
capability:
  exposes:
    - type: mcp
      namespace: encoding-ops
      port: 8080
      tools:
        - name: get-encoding-health
          description: "Given a service name, return encoding pipeline health."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "Encoding service name."
          call: "dd-encode.get-monitors"
          with:
            name: "{{service_name}}"
          outputParameters:
            - name: monitors
              type: array
              mapping: "$.monitors"
  consumes:
    - type: http
      namespace: dd-encode
      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

Checks video playback error rates from Datadog.

naftiko: "0.5"
info:
  label: "Datadog Playback Error Rate Check"
  description: "Checks video playback error rates from Datadog."
  tags:
    - streaming
    - datadog
    - playback
capability:
  exposes:
    - type: mcp
      namespace: playback-ops
      port: 8080
      tools:
        - name: get-playback-errors
          description: "Given a device type, return playback error rates."
          inputParameters:
            - name: device_type
              in: body
              type: string
              description: "Device type (e.g. smart_tv, mobile)."
          call: "dd-playback.get-metrics"
          with:
            query: "avg:playback.error_rate{device:{{device_type}}}"
          outputParameters:
            - name: series
              type: array
              mapping: "$.series"
  consumes:
    - type: http
      namespace: dd-playback
      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 streaming CDN latency metrics by region.

naftiko: "0.5"
info:
  label: "Datadog Streaming CDN Latency Check"
  description: "Queries Datadog for streaming CDN latency metrics by region."
  tags:
    - streaming
    - datadog
    - cdn
capability:
  exposes:
    - type: mcp
      namespace: cdn-ops
      port: 8080
      tools:
        - name: get-cdn-latency
          description: "Given a region, return streaming CDN latency metrics from Datadog."
          inputParameters:
            - name: region
              in: body
              type: string
              description: "Geographic region."
          call: "dd-cdn.get-metrics"
          with:
            query: "avg:cdn.latency{region:{{region}}}"
          outputParameters:
            - name: series
              type: array
              mapping: "$.series"
  consumes:
    - type: http
      namespace: dd-cdn
      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 an employee termination is recorded in Workday, deactivates their Okta account, removes GitHub organization membership, archives their Confluence profile, and notifies their manager in Slack.

naftiko: "0.5"
info:
  label: "Employee Offboarding Deprovisioner"
  description: "When an employee termination is recorded in Workday, deactivates their Okta account, removes GitHub organization membership, archives their Confluence profile, and notifies their manager in Slack."
  tags:
    - hr
    - offboarding
    - workday
    - okta
    - github
    - slack
capability:
  exposes:
    - type: mcp
      namespace: hr-offboarding
      port: 8080
      tools:
        - name: trigger-offboarding
          description: "Given a Workday employee ID, deactivate Okta account, remove from GitHub org, and notify the manager in Slack. Invoke on confirmed termination in Workday."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday worker ID of the departing employee."
          steps:
            - name: get-employee
              type: call
              call: "workday-off.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: deactivate-okta
              type: call
              call: "okta-off.deactivate-user"
              with:
                login: "{{get-employee.work_email}}"
            - name: remove-github
              type: call
              call: "github-off.remove-org-member"
              with:
                org: "netflix"
                username: "{{get-employee.github_username}}"
            - name: notify-manager
              type: call
              call: "slack-off.post-message"
              with:
                channel: "{{get-employee.manager_slack_id}}"
                text: "Offboarding complete for {{get-employee.full_name}}. Okta and GitHub access have been revoked."
  consumes:
    - type: http
      namespace: workday-off
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/netflix/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta-off
      baseUri: "https://netflix.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: user-lifecycle
          path: "/users/{{login}}/lifecycle/deactivate"
          inputParameters:
            - name: login
              in: path
          operations:
            - name: deactivate-user
              method: POST
    - type: http
      namespace: github-off
      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: slack-off
      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 Chaos Monkey release from GitHub.

naftiko: "0.5"
info:
  label: "GitHub Chaos Monkey Release Lookup"
  description: "Retrieves the latest Chaos Monkey release from GitHub."
  tags:
    - reliability
    - github
    - chaos-engineering
capability:
  exposes:
    - type: mcp
      namespace: chaos-ops
      port: 8080
      tools:
        - name: get-chaos-release
          description: "Return the latest Chaos Monkey release."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "Repository name."
          call: "github-chaos.get-release"
          with:
            repo_name: "{{repo_name}}"
          outputParameters:
            - name: release
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-chaos
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/Netflix/{{repo_name}}/releases/latest"
          inputParameters:
            - name: repo_name
              in: path
          operations:
            - name: get-release
              method: GET

Checks CI status for a branch in the Conductor workflow repository.

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

When Dependabot raises a critical or high vulnerability alert in a GitHub repository, opens a Jira security ticket and notifies the responsible team in Slack.

naftiko: "0.5"
info:
  label: "GitHub Dependabot Alert Triage"
  description: "When Dependabot raises a critical or high vulnerability alert in a GitHub repository, opens a Jira security ticket and notifies the responsible team in Slack."
  tags:
    - security
    - devops
    - github
    - jira
    - slack
    - dependency-management
capability:
  exposes:
    - type: mcp
      namespace: security-vuln
      port: 8080
      tools:
        - name: triage-dependabot-alert
          description: "Given a GitHub repository, Dependabot alert number, and severity, open a Jira security ticket and notify the repository owners in Slack. Use for automated vulnerability triage on critical and high severity Dependabot alerts."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository in owner/repo format."
            - name: alert_number
              in: body
              type: integer
              description: "The Dependabot security alert number."
            - name: severity
              in: body
              type: string
              description: "Alert severity: critical, high, medium, or low."
            - name: package_name
              in: body
              type: string
              description: "The vulnerable package name."
          steps:
            - name: get-alert
              type: call
              call: "github-vuln.get-dependabot-alert"
              with:
                repo: "{{repository}}"
                alert_number: "{{alert_number}}"
            - name: create-ticket
              type: call
              call: "jira-vuln.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Bug"
                summary: "[{{severity}}] Dependabot: {{package_name}} in {{repository}}"
                priority: "High"
            - name: notify-owners
              type: call
              call: "slack-vuln.post-message"
              with:
                channel: "security-alerts"
                text: "Dependabot alert ({{severity}}): {{package_name}} in {{repository}}. Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: github-vuln
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: dependabot-alerts
          path: "/repos/{{repo}}/dependabot/alerts/{{alert_number}}"
          inputParameters:
            - name: repo
              in: path
            - name: alert_number
              in: path
          operations:
            - name: get-dependabot-alert
              method: GET
    - type: http
      namespace: jira-vuln
      baseUri: "https://netflix.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-vuln
      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 successful GitHub Actions deployment to production, creates a New Relic deployment marker, transitions the linked Jira issue to Done, and posts a release note to the engineering Slack channel.

naftiko: "0.5"
info:
  label: "GitHub Deployment to Production Tracker"
  description: "On a successful GitHub Actions deployment to production, creates a New Relic deployment marker, transitions the linked Jira issue to Done, and posts a release note to the engineering Slack channel."
  tags:
    - devops
    - deployment
    - github
    - new-relic
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: devops-deploy
      port: 8080
      tools:
        - name: record-production-deployment
          description: "Given a repository, commit SHA, environment, and Jira issue key, record a New Relic deployment marker, close the Jira issue, and post a release note to Slack. Use after every successful production deployment."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository in owner/repo format."
            - name: commit_sha
              in: body
              type: string
              description: "The deployed commit SHA."
            - name: environment
              in: body
              type: string
              description: "The deployment environment (e.g., production, canary)."
            - name: jira_issue_key
              in: body
              type: string
              description: "Jira issue key to mark as Done (e.g., ENG-4321)."
          steps:
            - name: create-nr-marker
              type: call
              call: "newrelic-deploy.create-deployment-marker"
              with:
                entity_name: "{{repository}}"
                version: "{{commit_sha}}"
                description: "Deployed to {{environment}}"
            - name: close-jira
              type: call
              call: "jira-deploy.transition-issue"
              with:
                issue_key: "{{jira_issue_key}}"
                transition_id: "31"
            - name: post-release
              type: call
              call: "slack-deploy.post-message"
              with:
                channel: "releases"
                text: "Deployed {{repository}} ({{commit_sha}}) to {{environment}}. Jira: {{jira_issue_key}} closed."
  consumes:
    - type: http
      namespace: newrelic-deploy
      baseUri: "https://api.newrelic.com/v2"
      authentication:
        type: apikey
        key: "X-Api-Key"
        value: "$secrets.newrelic_api_key"
        placement: header
      resources:
        - name: deployments
          path: "/deployments.json"
          operations:
            - name: create-deployment-marker
              method: POST
    - type: http
      namespace: jira-deploy
      baseUri: "https://netflix.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
    - type: http
      namespace: slack-deploy
      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

Lists all public or unarchived repositories in the Netflix GitHub organization and flags any that are missing required topics, descriptions, or CODEOWNERS files.

naftiko: "0.5"
info:
  label: "GitHub Org Repo Audit"
  description: "Lists all public or unarchived repositories in the Netflix GitHub organization and flags any that are missing required topics, descriptions, or CODEOWNERS files."
  tags:
    - devops
    - github
    - compliance
    - audit
capability:
  exposes:
    - type: mcp
      namespace: github-audit
      port: 8080
      tools:
        - name: audit-org-repos
          description: "Given a GitHub organization name, list all repositories and identify those missing required metadata (description, topics, CODEOWNERS). Returns a list of non-compliant repos for remediation. Use for quarterly repository governance audits."
          inputParameters:
            - name: org
              in: body
              type: string
              description: "The GitHub organization name to audit."
          call: "github-org.list-repos"
          with:
            org: "{{org}}"
          outputParameters:
            - name: repos
              type: array
              mapping: "$.items[*]"
  consumes:
    - type: http
      namespace: github-org
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: repos
          path: "/orgs/{{org}}/repos"
          inputParameters:
            - name: org
              in: path
          operations:
            - name: list-repos
              method: GET

When a GitHub pull request is opened against a main branch, triggers a security scan, posts findings as a PR comment, and opens a Jira security ticket for any critical findings.

naftiko: "0.5"
info:
  label: "GitHub Pull Request Security Scan Orchestrator"
  description: "When a GitHub pull request is opened against a main branch, triggers a security scan, posts findings as a PR comment, and opens a Jira security ticket for any critical findings."
  tags:
    - devops
    - security
    - github
    - jira
    - code-review
capability:
  exposes:
    - type: mcp
      namespace: devops-security
      port: 8080
      tools:
        - name: scan-pull-request
          description: "Given a GitHub repository, PR number, and branch, trigger a security scan via the GitHub Security API, post findings to the PR as a review comment, and open a Jira issue for critical vulnerabilities. Invoke on every PR opened against main or release branches."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository in owner/repo format."
            - name: pr_number
              in: body
              type: integer
              description: "The pull request number."
            - name: commit_sha
              in: body
              type: string
              description: "The head commit SHA of the pull request."
          steps:
            - name: get-pr
              type: call
              call: "github-pr.get-pull-request"
              with:
                repo: "{{repository}}"
                pr_number: "{{pr_number}}"
            - name: get-scan-alerts
              type: call
              call: "github-sec.list-code-scanning-alerts"
              with:
                repo: "{{repository}}"
                ref: "{{commit_sha}}"
            - name: post-review-comment
              type: call
              call: "github-review.create-review-comment"
              with:
                repo: "{{repository}}"
                pr_number: "{{pr_number}}"
                body: "Security scan complete. Alerts: {{get-scan-alerts.count}}. Critical: {{get-scan-alerts.critical_count}}"
            - name: open-security-ticket
              type: call
              call: "jira-sec.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Bug"
                summary: "Security findings in {{repository}} PR#{{pr_number}}"
                priority: "High"
  consumes:
    - type: http
      namespace: github-pr
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pull-requests
          path: "/repos/{{repo}}/pulls/{{pr_number}}"
          inputParameters:
            - name: repo
              in: path
            - name: pr_number
              in: path
          operations:
            - name: get-pull-request
              method: GET
    - type: http
      namespace: github-sec
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: code-scanning-alerts
          path: "/repos/{{repo}}/code-scanning/alerts"
          inputParameters:
            - name: repo
              in: path
            - name: ref
              in: query
          operations:
            - name: list-code-scanning-alerts
              method: GET
    - type: http
      namespace: github-review
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: review-comments
          path: "/repos/{{repo}}/pulls/{{pr_number}}/reviews"
          inputParameters:
            - name: repo
              in: path
            - name: pr_number
              in: path
          operations:
            - name: create-review-comment
              method: POST
    - type: http
      namespace: jira-sec
      baseUri: "https://netflix.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

Audits GitHub repositories in the Netflix organization for missing branch protection rules and security policies, then opens Jira remediation tasks for non-compliant repos.

naftiko: "0.5"
info:
  label: "GitHub Repository Security Policy Enforcer"
  description: "Audits GitHub repositories in the Netflix organization for missing branch protection rules and security policies, then opens Jira remediation tasks for non-compliant repos."
  tags:
    - security
    - github
    - compliance
    - jira
capability:
  exposes:
    - type: mcp
      namespace: security-enforcement
      port: 8080
      tools:
        - name: audit-repo-security-policy
          description: "Given a GitHub organization and repository name, check for required branch protection and secret scanning policies. Open a Jira security remediation task for any gaps found. Use for monthly security compliance audits."
          inputParameters:
            - name: org
              in: body
              type: string
              description: "The GitHub organization name."
            - name: repo_name
              in: body
              type: string
              description: "The repository name to audit."
          steps:
            - name: get-branch-protection
              type: call
              call: "github-policy.get-branch-protection"
              with:
                org: "{{org}}"
                repo: "{{repo_name}}"
                branch: "main"
            - name: open-remediation-task
              type: call
              call: "jira-policy.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Task"
                summary: "Security policy gap: {{org}}/{{repo_name}}"
                description: "Branch protection status: {{get-branch-protection.enabled}}"
  consumes:
    - type: http
      namespace: github-policy
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: branch-protection
          path: "/repos/{{org}}/{{repo}}/branches/{{branch}}/protection"
          inputParameters:
            - name: org
              in: path
            - name: repo
              in: path
            - name: branch
              in: path
          operations:
            - name: get-branch-protection
              method: GET
    - type: http
      namespace: jira-policy
      baseUri: "https://netflix.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

Retrieves PR review status in the streaming platform repository.

naftiko: "0.5"
info:
  label: "GitHub Streaming Platform PR Status"
  description: "Retrieves PR review status in the streaming platform repository."
  tags:
    - engineering
    - github
    - streaming
capability:
  exposes:
    - type: mcp
      namespace: stream-dev
      port: 8080
      tools:
        - name: get-stream-pr
          description: "Given a PR number, return review status."
          inputParameters:
            - name: pr_number
              in: body
              type: integer
              description: "PR number."
          call: "github-stream.get-pr"
          with:
            pr_number: "{{pr_number}}"
          outputParameters:
            - name: pr
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-stream
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pulls
          path: "/repos/Netflix/streaming-platform/pulls/{{pr_number}}"
          inputParameters:
            - name: pr_number
              in: path
          operations:
            - name: get-pr
              method: GET

Retrieves the latest Zuul gateway release from GitHub.

naftiko: "0.5"
info:
  label: "GitHub Zuul Gateway Release Lookup"
  description: "Retrieves the latest Zuul gateway release from GitHub."
  tags:
    - engineering
    - github
    - zuul
capability:
  exposes:
    - type: mcp
      namespace: zuul-ops
      port: 8080
      tools:
        - name: get-zuul-release
          description: "Return the latest Zuul release from GitHub."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "Repository name."
          call: "github-zuul.get-release"
          with:
            repo_name: "{{repo_name}}"
          outputParameters:
            - name: release
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-zuul
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/Netflix/{{repo_name}}/releases/latest"
          inputParameters:
            - name: repo_name
              in: path
          operations:
            - name: get-release
              method: GET

Retrieves sprint status for the content engineering Jira board.

naftiko: "0.5"
info:
  label: "Jira Content Engineering Sprint Status"
  description: "Retrieves sprint status for the content engineering Jira board."
  tags:
    - engineering
    - jira
    - content
capability:
  exposes:
    - type: mcp
      namespace: content-eng
      port: 8080
      tools:
        - name: get-sprint-status
          description: "Given a board ID, return sprint status."
          inputParameters:
            - name: board_id
              in: body
              type: integer
              description: "Jira board ID."
          call: "jira-content.get-sprints"
          with:
            board_id: "{{board_id}}"
          outputParameters:
            - name: sprints
              type: array
              mapping: "$.values"
  consumes:
    - type: http
      namespace: jira-content
      baseUri: "https://netflix.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

Returns status and details of a content engineering Jira ticket.

naftiko: "0.5"
info:
  label: "Jira Content Engineering Ticket Lookup"
  description: "Returns status and details of a content engineering Jira ticket."
  tags:
    - devops
    - jira
    - content-engineering
capability:
  exposes:
    - type: mcp
      namespace: jira_content_enginee
      port: 8080
      tools:
        - name: query-data
          description: "Returns status and details of a content engineering Jira ticket."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

After a P1 incident is resolved in Jira, automatically creates a Confluence post-mortem page from a template and links it back to the original Jira incident.

naftiko: "0.5"
info:
  label: "Jira Incident Post-Mortem Creator"
  description: "After a P1 incident is resolved in Jira, automatically creates a Confluence post-mortem page from a template and links it back to the original Jira incident."
  tags:
    - itsm
    - incident-management
    - jira
    - confluence
    - post-mortem
capability:
  exposes:
    - type: mcp
      namespace: postmortem-ops
      port: 8080
      tools:
        - name: create-post-mortem
          description: "Given a resolved Jira incident key, create a Confluence post-mortem page pre-filled with incident timeline, impact, and resolution details, then link the page back to the Jira issue. Use after every P1 or P2 incident is resolved."
          inputParameters:
            - name: incident_key
              in: body
              type: string
              description: "The Jira incident issue key (e.g., OPS-1234)."
          steps:
            - name: get-incident
              type: call
              call: "jira-pm.get-issue"
              with:
                issue_key: "{{incident_key}}"
            - name: create-pm-page
              type: call
              call: "confluence-pm.create-page"
              with:
                space_key: "POSTMORTEMS"
                title: "Post-Mortem: {{get-incident.summary}} ({{incident_key}})"
                body: "Incident: {{incident_key}}\nSummary: {{get-incident.summary}}\nResolved: {{get-incident.resolution_date}}"
            - name: link-to-jira
              type: call
              call: "jira-pm-link.add-remote-link"
              with:
                issue_key: "{{incident_key}}"
                url: "{{create-pm-page.page_url}}"
                title: "Post-Mortem Document"
  consumes:
    - type: http
      namespace: jira-pm
      baseUri: "https://netflix.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: confluence-pm
      baseUri: "https://netflix.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: jira-pm-link
      baseUri: "https://netflix.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: remote-links
          path: "/issue/{{issue_key}}/remotelink"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: add-remote-link
              method: POST

Returns open bug count in the recommendation engine Jira project.

naftiko: "0.5"
info:
  label: "Jira Recommendation Engine Bug Count"
  description: "Returns open bug count in the recommendation engine Jira project."
  tags:
    - ai
    - jira
    - recommendations
capability:
  exposes:
    - type: mcp
      namespace: rec-eng
      port: 8080
      tools:
        - name: get-rec-bugs
          description: "Given a priority, return recommendation engine bug count."
          inputParameters:
            - name: priority
              in: body
              type: string
              description: "Priority filter."
          call: "jira-rec.search-issues"
          with:
            jql: "project = REC AND type = Bug AND status != Done AND priority = {{priority}}"
          outputParameters:
            - name: total
              type: number
              mapping: "$.total"
  consumes:
    - type: http
      namespace: jira-rec
      baseUri: "https://netflix.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

Fetches completed sprint data from Jira for an engineering team and posts a velocity trend report to the team's Slack channel to support sprint planning.

naftiko: "0.5"
info:
  label: "Jira Sprint Velocity Report"
  description: "Fetches completed sprint data from Jira for an engineering team and posts a velocity trend report to the team's Slack channel to support sprint planning."
  tags:
    - devops
    - agile
    - jira
    - reporting
    - slack
capability:
  exposes:
    - type: mcp
      namespace: agile-reporting
      port: 8080
      tools:
        - name: publish-sprint-velocity
          description: "Given a Jira board ID and number of past sprints, fetch completed sprint velocity data and post a trend summary to Slack. Use before sprint planning or quarterly engineering reviews."
          inputParameters:
            - name: board_id
              in: body
              type: string
              description: "The Jira agile board ID."
            - name: sprint_count
              in: body
              type: integer
              description: "Number of past sprints to include in the velocity trend."
          steps:
            - name: get-sprints
              type: call
              call: "jira-velocity.get-closed-sprints"
              with:
                board_id: "{{board_id}}"
                max_results: "{{sprint_count}}"
            - name: post-velocity
              type: call
              call: "slack-velocity.post-message"
              with:
                channel: "engineering-planning"
                text: "Sprint Velocity Report (last {{sprint_count}} sprints) for board {{board_id}}: {{get-sprints.avg_velocity}} pts avg."
  consumes:
    - type: http
      namespace: jira-velocity
      baseUri: "https://netflix.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: closed-sprints
          path: "/board/{{board_id}}/sprint"
          inputParameters:
            - name: board_id
              in: path
            - name: max_results
              in: query
          operations:
            - name: get-closed-sprints
              method: GET
    - type: http
      namespace: slack-velocity
      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 studio production tracking status from Jira.

naftiko: "0.5"
info:
  label: "Jira Studio Production Tracker"
  description: "Retrieves studio production tracking status from Jira."
  tags:
    - content
    - jira
    - production
capability:
  exposes:
    - type: mcp
      namespace: studio-ops
      port: 8080
      tools:
        - name: get-production-status
          description: "Given a project key, return studio production status."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key."
          call: "jira-studio.search-issues"
          with:
            jql: "project = {{project_key}} AND type = Story"
          outputParameters:
            - name: issues
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: jira-studio
      baseUri: "https://netflix.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

Pulls competitive talent movement and hiring trend data from LinkedIn to generate a quarterly talent intelligence report, posted to the recruiting leadership Slack channel.

naftiko: "0.5"
info:
  label: "LinkedIn Talent Intelligence Digest"
  description: "Pulls competitive talent movement and hiring trend data from LinkedIn to generate a quarterly talent intelligence report, posted to the recruiting leadership Slack channel."
  tags:
    - hr
    - recruiting
    - linkedin
    - talent-intelligence
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: talent-intelligence
      port: 8080
      tools:
        - name: digest-talent-trends
          description: "Given a LinkedIn organization URN and date range, fetch talent flow and competitor hiring signals and post a quarterly intelligence summary to the recruiting leadership Slack channel. Use for strategic workforce planning."
          inputParameters:
            - name: org_urn
              in: body
              type: string
              description: "The Netflix LinkedIn organization URN."
            - name: date_from
              in: body
              type: string
              description: "Start date for the talent trend analysis in YYYY-MM-DD format."
            - name: date_to
              in: body
              type: string
              description: "End date for the analysis in YYYY-MM-DD format."
          steps:
            - name: get-follower-stats
              type: call
              call: "linkedin-talent.get-follower-statistics"
              with:
                org_urn: "{{org_urn}}"
            - name: post-digest
              type: call
              call: "slack-talent.post-message"
              with:
                channel: "recruiting-leadership"
                text: "Talent Intelligence Digest ({{date_from}}–{{date_to}}): Followers={{get-follower-stats.total_count}}, Growth={{get-follower-stats.growth_rate}}"
  consumes:
    - type: http
      namespace: linkedin-talent
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_token"
      resources:
        - name: follower-statistics
          path: "/organizationalEntityFollowerStatistics"
          inputParameters:
            - name: org_urn
              in: query
          operations:
            - name: get-follower-statistics
              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 an A/B test reaches significance, queries results from Snowflake, creates a Jira deployment ticket, and notifies the product team.

naftiko: "0.5"
info:
  label: "Netflix A/B Test Graduation Workflow"
  description: "When an A/B test reaches significance, queries results from Snowflake, creates a Jira deployment ticket, and notifies the product team."
  tags:
    - analytics
    - snowflake
    - jira
    - slack
    - experimentation
capability:
  exposes:
    - type: mcp
      namespace: netflix_ab_test_grad
      port: 8080
      tools:
        - name: handle-event
          description: "When an A/B test reaches significance, queries results from Snowflake, creates a Jira deployment ticket, and notifies the product team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[analytics] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "analytics-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks accessibility compliance from Snowflake for subtitles and audio descriptions, creates Jira tasks, and alerts the accessibility team.

naftiko: "0.5"
info:
  label: "Netflix Accessibility Compliance Checker"
  description: "Checks accessibility compliance from Snowflake for subtitles and audio descriptions, creates Jira tasks, and alerts the accessibility team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - accessibility
capability:
  exposes:
    - type: mcp
      namespace: netflix_accessibilit
      port: 8080
      tools:
        - name: handle-event
          description: "Checks accessibility compliance from Snowflake for subtitles and audio descriptions, creates Jira tasks, and alerts the accessibility team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors ad tier revenue metrics from Snowflake, creates Jira tasks for underperforming segments, and notifies the ads team.

naftiko: "0.5"
info:
  label: "Netflix Ad Tier Revenue Monitor"
  description: "Monitors ad tier revenue metrics from Snowflake, creates Jira tasks for underperforming segments, and notifies the ads team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - advertising
capability:
  exposes:
    - type: mcp
      namespace: netflix_ad_tier_reve
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors ad tier revenue metrics from Snowflake, creates Jira tasks for underperforming segments, and notifies the ads team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Validates audio quality for new content from Snowflake checks, creates Jira tasks for failures, and notifies the audio team.

naftiko: "0.5"
info:
  label: "Netflix Audio Quality Validation Workflow"
  description: "Validates audio quality for new content from Snowflake checks, creates Jira tasks for failures, and notifies the audio team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - audio
capability:
  exposes:
    - type: mcp
      namespace: netflix_audio_qualit
      port: 8080
      tools:
        - name: handle-event
          description: "Validates audio quality for new content from Snowflake checks, creates Jira tasks for failures, and notifies the audio team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When content is updated, triggers CDN cache purge, verifies propagation via New Relic, and notifies the content delivery team.

naftiko: "0.5"
info:
  label: "Netflix CDN Cache Purge Workflow"
  description: "When content is updated, triggers CDN cache purge, verifies propagation via New Relic, and notifies the content delivery team."
  tags:
    - streaming
    - new-relic
    - jira
    - slack
    - cdn
capability:
  exposes:
    - type: mcp
      namespace: netflix_cdn_cache_pu
      port: 8080
      tools:
        - name: handle-event
          description: "When content is updated, triggers CDN cache purge, verifies propagation via New Relic, and notifies the content delivery team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a chaos experiment completes, queries results from New Relic, creates Jira findings, and notifies the resilience team.

naftiko: "0.5"
info:
  label: "Netflix Chaos Engineering Experiment Tracker"
  description: "When a chaos experiment completes, queries results from New Relic, creates Jira findings, and notifies the resilience team."
  tags:
    - devops
    - new-relic
    - jira
    - slack
    - chaos-engineering
capability:
  exposes:
    - type: mcp
      namespace: netflix_chaos_engine
      port: 8080
      tools:
        - name: handle-event
          description: "When a chaos experiment completes, queries results from New Relic, creates Jira findings, and notifies the resilience team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[devops] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "devops-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Analyzes content cost-per-view from Snowflake, creates Jira tasks for underperforming titles, and posts insights to Slack.

naftiko: "0.5"
info:
  label: "Netflix Content Cost Per View Analysis"
  description: "Analyzes content cost-per-view from Snowflake, creates Jira tasks for underperforming titles, and posts insights to Slack."
  tags:
    - finance
    - snowflake
    - jira
    - slack
    - content-analytics
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_cost
      port: 8080
      tools:
        - name: handle-event
          description: "Analyzes content cost-per-view from Snowflake, creates Jira tasks for underperforming titles, and posts insights to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[finance] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "finance-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Analyzes CDN performance from Snowflake, creates Jira optimization tasks for slow regions, and posts findings to Slack.

naftiko: "0.5"
info:
  label: "Netflix Content Delivery Optimization"
  description: "Analyzes CDN performance from Snowflake, creates Jira optimization tasks for slow regions, and posts findings to Slack."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - cdn
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_deli
      port: 8080
      tools:
        - name: handle-event
          description: "Analyzes CDN performance from Snowflake, creates Jira optimization tasks for slow regions, and posts findings to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Before a title launch, verifies encoding completion, CDN propagation, and metadata quality from Snowflake, creates Jira tasks for gaps, and notifies the launch team.

naftiko: "0.5"
info:
  label: "Netflix Content Launch Readiness Check"
  description: "Before a title launch, verifies encoding completion, CDN propagation, and metadata quality from Snowflake, creates Jira tasks for gaps, and notifies the launch team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - content-launch
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_laun
      port: 8080
      tools:
        - name: handle-event
          description: "Before a title launch, verifies encoding completion, CDN propagation, and metadata quality from Snowflake, creates Jira tasks for gaps, and notifies the launch team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When content licenses approach expiry, queries viewership from Snowflake, creates Jira renewal tasks, and notifies content acquisition.

naftiko: "0.5"
info:
  label: "Netflix Content Licensing Expiry Handler"
  description: "When content licenses approach expiry, queries viewership from Snowflake, creates Jira renewal tasks, and notifies content acquisition."
  tags:
    - content
    - snowflake
    - jira
    - slack
    - content-licensing
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_lice
      port: 8080
      tools:
        - name: handle-event
          description: "When content licenses approach expiry, queries viewership from Snowflake, creates Jira renewal tasks, and notifies content acquisition."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[content] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "content-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries localization quality scores from Snowflake, creates Jira tasks for low-quality translations, and alerts the localization team.

naftiko: "0.5"
info:
  label: "Netflix Content Localization Quality Check"
  description: "Queries localization quality scores from Snowflake, creates Jira tasks for low-quality translations, and alerts the localization team."
  tags:
    - content
    - snowflake
    - jira
    - slack
    - localization
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_loca
      port: 8080
      tools:
        - name: handle-event
          description: "Queries localization quality scores from Snowflake, creates Jira tasks for low-quality translations, and alerts the localization team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[content] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "content-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Audits content metadata quality from Snowflake, creates Jira tasks for incomplete entries, and notifies the metadata team.

naftiko: "0.5"
info:
  label: "Netflix Content Metadata Quality Audit"
  description: "Audits content metadata quality from Snowflake, creates Jira tasks for incomplete entries, and notifies the metadata team."
  tags:
    - content
    - snowflake
    - jira
    - slack
    - metadata
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_meta
      port: 8080
      tools:
        - name: handle-event
          description: "Audits content metadata quality from Snowflake, creates Jira tasks for incomplete entries, and notifies the metadata team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[content] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "content-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When AI content moderation flags an issue, creates a Jira review task, queries similar flags from Snowflake, and alerts the trust team.

naftiko: "0.5"
info:
  label: "Netflix Content Moderation Escalation"
  description: "When AI content moderation flags an issue, creates a Jira review task, queries similar flags from Snowflake, and alerts the trust team."
  tags:
    - content
    - snowflake
    - jira
    - slack
    - moderation
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_mode
      port: 8080
      tools:
        - name: handle-event
          description: "When AI content moderation flags an issue, creates a Jira review task, queries similar flags from Snowflake, and alerts the trust team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[content] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "content-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors content processing pipeline throughput from Snowflake, creates Jira tickets for bottlenecks, and alerts the pipeline team.

naftiko: "0.5"
info:
  label: "Netflix Content Pipeline Throughput Monitor"
  description: "Monitors content processing pipeline throughput from Snowflake, creates Jira tickets for bottlenecks, and alerts the pipeline team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - content-pipeline
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_pipe
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors content processing pipeline throughput from Snowflake, creates Jira tickets for bottlenecks, and alerts the pipeline team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates premiere week analytics from Snowflake for new titles, creates Jira insight tasks, and posts highlights to Slack.

naftiko: "0.5"
info:
  label: "Netflix Content Premiere Analytics Digest"
  description: "Generates premiere week analytics from Snowflake for new titles, creates Jira insight tasks, and posts highlights to Slack."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - content-analytics
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_prem
      port: 8080
      tools:
        - name: handle-event
          description: "Generates premiere week analytics from Snowflake for new titles, creates Jira insight tasks, and posts highlights to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When content ratings show anomalous patterns, queries Snowflake for details, creates a Jira investigation, and alerts the trust team.

naftiko: "0.5"
info:
  label: "Netflix Content Ratings Anomaly Detector"
  description: "When content ratings show anomalous patterns, queries Snowflake for details, creates a Jira investigation, and alerts the trust team."
  tags:
    - content
    - snowflake
    - jira
    - slack
    - trust-safety
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_rati
      port: 8080
      tools:
        - name: handle-event
          description: "When content ratings show anomalous patterns, queries Snowflake for details, creates a Jira investigation, and alerts the trust team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[content] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "content-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Triggers recommendation model refresh, queries performance from Snowflake, creates Jira tasks for degraded models, and posts to Slack.

naftiko: "0.5"
info:
  label: "Netflix Content Recommendation Refresh"
  description: "Triggers recommendation model refresh, queries performance from Snowflake, creates Jira tasks for degraded models, and posts to Slack."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - recommendations
capability:
  exposes:
    - type: mcp
      namespace: netflix_content_reco
      port: 8080
      tools:
        - name: handle-event
          description: "Triggers recommendation model refresh, queries performance from Snowflake, creates Jira tasks for degraded models, and posts to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates data platform health digest from Snowflake and New Relic, creates Jira tasks for issues, and posts to Slack.

naftiko: "0.5"
info:
  label: "Netflix Data Platform Health Digest"
  description: "Generates data platform health digest from Snowflake and New Relic, creates Jira tasks for issues, and posts to Slack."
  tags:
    - data-engineering
    - snowflake
    - new-relic
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: netflix_data_platfor
      port: 8080
      tools:
        - name: handle-event
          description: "Generates data platform health digest from Snowflake and New Relic, creates Jira tasks for issues, and posts to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[data-engineering] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "data-engineering-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When device compatibility drops, queries Snowflake for affected devices, creates Jira bugs, and alerts the device team.

naftiko: "0.5"
info:
  label: "Netflix Device Compatibility Regression"
  description: "When device compatibility drops, queries Snowflake for affected devices, creates Jira bugs, and alerts the device team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - devices
capability:
  exposes:
    - type: mcp
      namespace: netflix_device_compa
      port: 8080
      tools:
        - name: handle-event
          description: "When device compatibility drops, queries Snowflake for affected devices, creates Jira bugs, and alerts the device team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When encoding pipeline failures occur, queries Snowflake for affected titles, creates Jira tickets, and alerts the encoding team.

naftiko: "0.5"
info:
  label: "Netflix Encoding Pipeline Failure Handler"
  description: "When encoding pipeline failures occur, queries Snowflake for affected titles, creates Jira tickets, and alerts the encoding team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - encoding
capability:
  exposes:
    - type: mcp
      namespace: netflix_encoding_pip
      port: 8080
      tools:
        - name: handle-event
          description: "When encoding pipeline failures occur, queries Snowflake for affected titles, creates Jira tickets, and alerts the encoding team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors Netflix Games performance metrics from Snowflake, creates Jira tickets for issues, and notifies the gaming team.

naftiko: "0.5"
info:
  label: "Netflix Gaming Performance Monitor"
  description: "Monitors Netflix Games performance metrics from Snowflake, creates Jira tickets for issues, and notifies the gaming team."
  tags:
    - gaming
    - snowflake
    - jira
    - slack
    - performance
capability:
  exposes:
    - type: mcp
      namespace: netflix_gaming_perfo
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors Netflix Games performance metrics from Snowflake, creates Jira tickets for issues, and notifies the gaming team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[gaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "gaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Coordinates global content launches by verifying localization, CDN readiness, and marketing assets, reporting status to Slack.

naftiko: "0.5"
info:
  label: "Netflix Global Launch Coordination"
  description: "Coordinates global content launches by verifying localization, CDN readiness, and marketing assets, reporting status to Slack."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - global-launch
capability:
  exposes:
    - type: mcp
      namespace: netflix_global_launc
      port: 8080
      tools:
        - name: handle-event
          description: "Coordinates global content launches by verifying localization, CDN readiness, and marketing assets, reporting status to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Analyzes infrastructure costs from Snowflake, creates Jira optimization tasks for high-cost services, and posts to Slack.

naftiko: "0.5"
info:
  label: "Netflix Infrastructure Cost Optimization"
  description: "Analyzes infrastructure costs from Snowflake, creates Jira optimization tasks for high-cost services, and posts to Slack."
  tags:
    - finops
    - snowflake
    - jira
    - slack
    - infrastructure
capability:
  exposes:
    - type: mcp
      namespace: netflix_infrastructu
      port: 8080
      tools:
        - name: handle-event
          description: "Analyzes infrastructure costs from Snowflake, creates Jira optimization tasks for high-cost services, and posts to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[finops] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "finops-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries interactive content engagement metrics from Snowflake, creates Jira product insights, and posts to Slack.

naftiko: "0.5"
info:
  label: "Netflix Interactive Content Performance"
  description: "Queries interactive content engagement metrics from Snowflake, creates Jira product insights, and posts to Slack."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - interactive
capability:
  exposes:
    - type: mcp
      namespace: netflix_interactive_
      port: 8080
      tools:
        - name: handle-event
          description: "Queries interactive content engagement metrics from Snowflake, creates Jira product insights, and posts to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

During live events, monitors stream health from New Relic, creates PagerDuty alerts for issues, and posts status to Slack.

naftiko: "0.5"
info:
  label: "Netflix Live Event Monitoring Workflow"
  description: "During live events, monitors stream health from New Relic, creates PagerDuty alerts for issues, and posts status to Slack."
  tags:
    - streaming
    - new-relic
    - pagerduty
    - slack
    - live-events
capability:
  exposes:
    - type: mcp
      namespace: netflix_live_event_m
      port: 8080
      tools:
        - name: handle-event
          description: "During live events, monitors stream health from New Relic, creates PagerDuty alerts for issues, and posts status to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a microservice is deployed, verifies health via New Relic, logs in ServiceNow, and notifies the platform team.

naftiko: "0.5"
info:
  label: "Netflix Microservice Deployment Tracker"
  description: "When a microservice is deployed, verifies health via New Relic, logs in ServiceNow, and notifies the platform team."
  tags:
    - devops
    - new-relic
    - servicenow
    - slack
    - deployments
capability:
  exposes:
    - type: mcp
      namespace: netflix_microservice
      port: 8080
      tools:
        - name: handle-event
          description: "When a microservice is deployed, verifies health via New Relic, logs in ServiceNow, and notifies the platform team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[devops] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "devops-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors ML training pipeline health from Snowflake, creates Jira tickets for failed jobs, and alerts the ML platform team.

naftiko: "0.5"
info:
  label: "Netflix ML Model Training Pipeline Monitor"
  description: "Monitors ML training pipeline health from Snowflake, creates Jira tickets for failed jobs, and alerts the ML platform team."
  tags:
    - ml
    - snowflake
    - jira
    - slack
    - ml-ops
capability:
  exposes:
    - type: mcp
      namespace: netflix_ml_model_tra
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors ML training pipeline health from Snowflake, creates Jira tickets for failed jobs, and alerts the ML platform team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[ml] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "ml-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors Open Connect appliance health from Snowflake, creates Jira tickets for degraded appliances, and alerts the ISP team.

naftiko: "0.5"
info:
  label: "Netflix Open Connect Appliance Health"
  description: "Monitors Open Connect appliance health from Snowflake, creates Jira tickets for degraded appliances, and alerts the ISP team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - open-connect
capability:
  exposes:
    - type: mcp
      namespace: netflix_open_connect
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors Open Connect appliance health from Snowflake, creates Jira tickets for degraded appliances, and alerts the ISP team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Tracks device certification status from Snowflake, creates Jira tasks for expiring certs, and notifies the partnerships team.

naftiko: "0.5"
info:
  label: "Netflix Partner Device Certification"
  description: "Tracks device certification status from Snowflake, creates Jira tasks for expiring certs, and notifies the partnerships team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - partnerships
capability:
  exposes:
    - type: mcp
      namespace: netflix_partner_devi
      port: 8080
      tools:
        - name: handle-event
          description: "Tracks device certification status from Snowflake, creates Jira tasks for expiring certs, and notifies the partnerships team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When playback errors spike, queries New Relic for affected regions, creates a PagerDuty incident, and notifies the streaming team.

naftiko: "0.5"
info:
  label: "Netflix Playback Error Spike Handler"
  description: "When playback errors spike, queries New Relic for affected regions, creates a PagerDuty incident, and notifies the streaming team."
  tags:
    - streaming
    - new-relic
    - pagerduty
    - slack
    - playback
capability:
  exposes:
    - type: mcp
      namespace: netflix_playback_err
      port: 8080
      tools:
        - name: handle-event
          description: "When playback errors spike, queries New Relic for affected regions, creates a PagerDuty incident, and notifies the streaming team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When recommendation accuracy drops, queries Snowflake for model metrics, creates a Jira investigation, and alerts the ML team.

naftiko: "0.5"
info:
  label: "Netflix Recommendation Model Drift Alert"
  description: "When recommendation accuracy drops, queries Snowflake for model metrics, creates a Jira investigation, and alerts the ML team."
  tags:
    - streaming
    - snowflake
    - jira
    - slack
    - recommendations
capability:
  exposes:
    - type: mcp
      namespace: netflix_recommendati
      port: 8080
      tools:
        - name: handle-event
          description: "When recommendation accuracy drops, queries Snowflake for model metrics, creates a Jira investigation, and alerts the ML team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates regional content performance digests from Snowflake, creates Jira strategy tasks, and posts to Slack.

naftiko: "0.5"
info:
  label: "Netflix Regional Content Strategy Digest"
  description: "Generates regional content performance digests from Snowflake, creates Jira strategy tasks, and posts to Slack."
  tags:
    - content
    - snowflake
    - jira
    - slack
    - strategy
capability:
  exposes:
    - type: mcp
      namespace: netflix_regional_con
      port: 8080
      tools:
        - name: handle-event
          description: "Generates regional content performance digests from Snowflake, creates Jira strategy tasks, and posts to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[content] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "content-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a security vulnerability is found, creates a Jira security ticket, queries affected services from New Relic, and pages security.

naftiko: "0.5"
info:
  label: "Netflix Security Vulnerability Response"
  description: "When a security vulnerability is found, creates a Jira security ticket, queries affected services from New Relic, and pages security."
  tags:
    - security
    - new-relic
    - jira
    - slack
    - pagerduty
capability:
  exposes:
    - type: mcp
      namespace: netflix_security_vul
      port: 8080
      tools:
        - name: handle-event
          description: "When a security vulnerability is found, creates a Jira security ticket, queries affected services from New Relic, and pages security."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[security] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "security-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a studio production exceeds budget threshold, queries Snowflake for spending details, creates a Jira task, and alerts finance.

naftiko: "0.5"
info:
  label: "Netflix Studio Production Budget Alert"
  description: "When a studio production exceeds budget threshold, queries Snowflake for spending details, creates a Jira task, and alerts finance."
  tags:
    - finance
    - snowflake
    - jira
    - slack
    - studio
capability:
  exposes:
    - type: mcp
      namespace: netflix_studio_produ
      port: 8080
      tools:
        - name: handle-event
          description: "When a studio production exceeds budget threshold, queries Snowflake for spending details, creates a Jira task, and alerts finance."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[finance] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "finance-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When churn rates exceed thresholds, queries Snowflake for cohort analysis, creates Jira growth tasks, and notifies the retention team.

naftiko: "0.5"
info:
  label: "Netflix Subscriber Churn Alert"
  description: "When churn rates exceed thresholds, queries Snowflake for cohort analysis, creates Jira growth tasks, and notifies the retention team."
  tags:
    - analytics
    - snowflake
    - jira
    - slack
    - retention
capability:
  exposes:
    - type: mcp
      namespace: netflix_subscriber_c
      port: 8080
      tools:
        - name: handle-event
          description: "When churn rates exceed thresholds, queries Snowflake for cohort analysis, creates Jira growth tasks, and notifies the retention team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[analytics] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "analytics-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates subscriber growth forecasts from Snowflake, creates Jira planning tasks, and posts projections to Slack.

naftiko: "0.5"
info:
  label: "Netflix Subscriber Growth Forecast"
  description: "Generates subscriber growth forecasts from Snowflake, creates Jira planning tasks, and posts projections to Slack."
  tags:
    - analytics
    - snowflake
    - jira
    - slack
    - growth
capability:
  exposes:
    - type: mcp
      namespace: netflix_subscriber_g
      port: 8080
      tools:
        - name: handle-event
          description: "Generates subscriber growth forecasts from Snowflake, creates Jira planning tasks, and posts projections to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[analytics] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "analytics-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries talent engagement metrics from Snowflake, updates Salesforce talent records, and posts highlights to Slack.

naftiko: "0.5"
info:
  label: "Netflix Talent Engagement Tracker"
  description: "Queries talent engagement metrics from Snowflake, updates Salesforce talent records, and posts highlights to Slack."
  tags:
    - content
    - snowflake
    - salesforce
    - slack
    - talent
capability:
  exposes:
    - type: mcp
      namespace: netflix_talent_engag
      port: 8080
      tools:
        - name: handle-event
          description: "Queries talent engagement metrics from Snowflake, updates Salesforce talent records, and posts highlights to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[content] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "content-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When video quality metrics degrade, queries New Relic for ISP patterns, creates a Jira ticket, and alerts the QoE team.

naftiko: "0.5"
info:
  label: "Netflix Video Quality Degradation Handler"
  description: "When video quality metrics degrade, queries New Relic for ISP patterns, creates a Jira ticket, and alerts the QoE team."
  tags:
    - streaming
    - new-relic
    - jira
    - slack
    - video-quality
capability:
  exposes:
    - type: mcp
      namespace: netflix_video_qualit
      port: 8080
      tools:
        - name: handle-event
          description: "When video quality metrics degrade, queries New Relic for ISP patterns, creates a Jira ticket, and alerts the QoE team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[streaming] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "streaming-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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-api
      baseUri: "https://netflix.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-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns CDN performance metrics including cache hit rates and latency from New Relic.

naftiko: "0.5"
info:
  label: "New Relic CDN Performance Check"
  description: "Returns CDN performance metrics including cache hit rates and latency from New Relic."
  tags:
    - streaming
    - new-relic
    - cdn
capability:
  exposes:
    - type: mcp
      namespace: new_relic_cdn_perfor
      port: 8080
      tools:
        - name: query-data
          description: "Returns CDN performance metrics including cache hit rates and latency from New Relic."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Returns health status and error rates for a Netflix microservice from New Relic.

naftiko: "0.5"
info:
  label: "New Relic Microservice Health Check"
  description: "Returns health status and error rates for a Netflix microservice from New Relic."
  tags:
    - observability
    - new-relic
    - microservices
capability:
  exposes:
    - type: mcp
      namespace: new_relic_microservi
      port: 8080
      tools:
        - name: query-data
          description: "Returns health status and error rates for a Netflix microservice from New Relic."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

When New Relic detects a service anomaly or SLO breach, opens a high-priority Jira incident, pages the on-call engineer via PagerDuty, and posts a war-room link to Slack.

naftiko: "0.5"
info:
  label: "New Relic Service Anomaly Response"
  description: "When New Relic detects a service anomaly or SLO breach, opens a high-priority Jira incident, pages the on-call engineer via PagerDuty, and posts a war-room link to Slack."
  tags:
    - observability
    - incident-response
    - new-relic
    - jira
    - pagerduty
    - slack
capability:
  exposes:
    - type: mcp
      namespace: observability-ops
      port: 8080
      tools:
        - name: handle-service-anomaly
          description: "Given a New Relic alert ID and affected service name, create a Jira P1 incident, trigger PagerDuty on-call escalation, and post a war-room Slack message. Invoke for any SLO breach or critical service anomaly."
          inputParameters:
            - name: alert_id
              in: body
              type: string
              description: "The New Relic alert incident ID."
            - name: service_name
              in: body
              type: string
              description: "The name of the affected Netflix service."
            - name: alert_message
              in: body
              type: string
              description: "Human-readable description of the anomaly."
          steps:
            - name: create-incident
              type: call
              call: "jira-incident.create-issue"
              with:
                project_key: "OPS"
                issuetype: "Incident"
                summary: "[P1] Service anomaly: {{service_name}}"
                description: "New Relic alert: {{alert_id}}\n{{alert_message}}"
                priority: "Highest"
            - name: page-oncall
              type: call
              call: "pagerduty.trigger-incident"
              with:
                title: "{{service_name}} anomaly: {{alert_message}}"
                severity: "critical"
                incident_key: "nr-{{alert_id}}"
            - name: post-warroom
              type: call
              call: "slack-incident.post-message"
              with:
                channel: "incidents"
                text: "P1 Incident: {{service_name}} | {{alert_message}} | Jira: {{create-incident.key}} | PD: {{page-oncall.incident_url}}"
  consumes:
    - type: http
      namespace: jira-incident
      baseUri: "https://netflix.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: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: trigger-incident
              method: POST
    - type: http
      namespace: slack-incident
      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 current SLO compliance metrics from New Relic and posts a weekly service health report to the engineering leadership Slack channel.

naftiko: "0.5"
info:
  label: "New Relic SLO Weekly Report"
  description: "Fetches current SLO compliance metrics from New Relic and posts a weekly service health report to the engineering leadership Slack channel."
  tags:
    - observability
    - slo
    - new-relic
    - reporting
    - slack
capability:
  exposes:
    - type: mcp
      namespace: slo-reporting
      port: 8080
      tools:
        - name: publish-slo-report
          description: "Query New Relic for all SLO statuses and post a weekly compliance report to the engineering leadership Slack channel. Use for weekly engineering reviews and board-level reliability briefings."
          steps:
            - name: get-slo-status
              type: call
              call: "newrelic-slo.list-service-levels"
            - name: post-report
              type: call
              call: "slack-slo.post-message"
              with:
                channel: "engineering-leadership"
                text: "Weekly SLO Report: {{get-slo-status.count}} service levels monitored. Compliant: {{get-slo-status.compliant_count}}."
  consumes:
    - type: http
      namespace: newrelic-slo
      baseUri: "https://api.newrelic.com/v2"
      authentication:
        type: apikey
        key: "X-Api-Key"
        value: "$secrets.newrelic_api_key"
        placement: header
      resources:
        - name: service-levels
          path: "/service_levels.json"
          operations:
            - name: list-service-levels
              method: GET
    - type: http
      namespace: slack-slo
      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 streaming service SLO status from New Relic.

naftiko: "0.5"
info:
  label: "New Relic Streaming Service SLO Check"
  description: "Checks streaming service SLO status from New Relic."
  tags:
    - reliability
    - new-relic
    - slo
capability:
  exposes:
    - type: mcp
      namespace: slo-ops
      port: 8080
      tools:
        - name: get-streaming-slo
          description: "Given an SLI name, return SLO status from New Relic."
          inputParameters:
            - name: sli_name
              in: body
              type: string
              description: "SLI name."
          call: "nr-slo.get-sli"
          with:
            name: "{{sli_name}}"
          outputParameters:
            - name: slo
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: nr-slo
      baseUri: "https://api.newrelic.com/v2"
      authentication:
        type: apikey
        key: "Api-Key"
        value: "$secrets.newrelic_api_key"
        placement: header
      resources:
        - name: slis
          path: "/sli"
          inputParameters:
            - name: name
              in: query
          operations:
            - name: get-sli
              method: GET

Pulls all active Okta users assigned to a specified application group and cross-references with Workday active workers to flag stale or orphaned access.

naftiko: "0.5"
info:
  label: "Okta Access Review — Application Group Audit"
  description: "Pulls all active Okta users assigned to a specified application group and cross-references with Workday active workers to flag stale or orphaned access."
  tags:
    - identity
    - security
    - okta
    - workday
    - access-review
capability:
  exposes:
    - type: mcp
      namespace: identity-review
      port: 8080
      tools:
        - name: run-access-review
          description: "Given an Okta group ID, list all group members and compare against active Workday workers to identify orphaned accounts. Use for quarterly access reviews and SOX compliance audits."
          inputParameters:
            - name: group_id
              in: body
              type: string
              description: "The Okta group ID to audit."
            - name: app_name
              in: body
              type: string
              description: "Human-readable application name for audit logging."
          steps:
            - name: get-group-members
              type: call
              call: "okta-audit.get-group-members"
              with:
                group_id: "{{group_id}}"
            - name: get-active-workers
              type: call
              call: "workday-audit.list-workers"
  consumes:
    - type: http
      namespace: okta-audit
      baseUri: "https://netflix.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: group-members
          path: "/groups/{{group_id}}/users"
          inputParameters:
            - name: group_id
              in: path
          operations:
            - name: get-group-members
              method: GET
    - type: http
      namespace: workday-audit
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: active-workers
          path: "/netflix/workers"
          operations:
            - name: list-workers
              method: GET

Identifies Okta users without MFA enrolled in a target group and sends each user a Slack reminder message with enrollment instructions, plus creates a compliance Jira ticket.

naftiko: "0.5"
info:
  label: "Okta MFA Compliance Enforcer"
  description: "Identifies Okta users without MFA enrolled in a target group and sends each user a Slack reminder message with enrollment instructions, plus creates a compliance Jira ticket."
  tags:
    - identity
    - security
    - okta
    - jira
    - slack
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: mfa-compliance
      port: 8080
      tools:
        - name: enforce-mfa-enrollment
          description: "Given an Okta group ID, identify users without MFA enrolled, send each user a Slack reminder, and create a Jira compliance remediation ticket. Use for monthly MFA enforcement cycles."
          inputParameters:
            - name: group_id
              in: body
              type: string
              description: "The Okta group ID to check for MFA enrollment."
          steps:
            - name: get-non-mfa-users
              type: call
              call: "okta-compliance.list-users-without-mfa"
              with:
                group_id: "{{group_id}}"
            - name: send-reminder
              type: call
              call: "slack-mfa.post-message"
              with:
                channel: "security-reminders"
                text: "MFA enforcement: {{get-non-mfa-users.count}} users in group {{group_id}} still need to enroll in MFA. Reminder messages sent."
            - name: create-compliance-ticket
              type: call
              call: "jira-compliance.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Task"
                summary: "MFA non-compliance: {{get-non-mfa-users.count}} users in group {{group_id}}"
  consumes:
    - type: http
      namespace: okta-compliance
      baseUri: "https://netflix.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users-without-mfa
          path: "/groups/{{group_id}}/users"
          inputParameters:
            - name: group_id
              in: path
          operations:
            - name: list-users-without-mfa
              method: GET
    - type: http
      namespace: slack-mfa
      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
    - type: http
      namespace: jira-compliance
      baseUri: "https://netflix.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

Looks up content licensing deal details in Salesforce.

naftiko: "0.5"
info:
  label: "Salesforce Content Licensing Deal Lookup"
  description: "Looks up content licensing deal details in Salesforce."
  tags:
    - content
    - salesforce
    - licensing
capability:
  exposes:
    - type: mcp
      namespace: licensing-ops
      port: 8080
      tools:
        - name: get-licensing-deal
          description: "Given an opportunity ID, return licensing deal details."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "Salesforce opportunity ID."
          call: "sf-licensing.get-opportunity"
          with:
            opportunity_id: "{{opportunity_id}}"
          outputParameters:
            - name: opportunity
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: sf-licensing
      baseUri: "https://netflix.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

Queries Snowflake for A/B test results including conversion rates and statistical significance.

naftiko: "0.5"
info:
  label: "Snowflake A/B Test Results Query"
  description: "Queries Snowflake for A/B test results including conversion rates and statistical significance."
  tags:
    - analytics
    - snowflake
    - experimentation
capability:
  exposes:
    - type: mcp
      namespace: snowflake_ab_test_re
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for A/B test results including conversion rates and statistical significance."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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 ad-supported tier metrics including ad fill rates and viewer engagement.

naftiko: "0.5"
info:
  label: "Snowflake Ad Tier Performance Query"
  description: "Queries Snowflake for ad-supported tier metrics including ad fill rates and viewer engagement."
  tags:
    - streaming
    - snowflake
    - advertising
capability:
  exposes:
    - type: mcp
      namespace: snowflake_ad_tier_pe
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for ad-supported tier metrics including ad fill rates and viewer engagement."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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 adaptive bitrate streaming quality metrics by region.

naftiko: "0.5"
info:
  label: "Snowflake Adaptive Bitrate Metrics"
  description: "Queries Snowflake for adaptive bitrate streaming quality metrics by region."
  tags:
    - streaming
    - snowflake
    - video-quality
capability:
  exposes:
    - type: mcp
      namespace: snowflake_adaptive_b
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for adaptive bitrate streaming quality metrics by region."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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 the content acquisition pipeline funnel metrics.

naftiko: "0.5"
info:
  label: "Snowflake Content Acquisition Funnel"
  description: "Queries Snowflake for the content acquisition pipeline funnel metrics."
  tags:
    - content
    - snowflake
    - acquisition
capability:
  exposes:
    - type: mcp
      namespace: snowflake_content_ac
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for the content acquisition pipeline funnel metrics."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Queries content engagement funnel metrics from Snowflake.

naftiko: "0.5"
info:
  label: "Snowflake Content Engagement Funnel"
  description: "Queries content engagement funnel metrics from Snowflake."
  tags:
    - analytics
    - snowflake
    - engagement
capability:
  exposes:
    - type: mcp
      namespace: engagement-analytics
      port: 8080
      tools:
        - name: get-engagement-funnel
          description: "Given a title ID, return engagement funnel metrics."
          inputParameters:
            - name: title_id
              in: body
              type: string
              description: "Netflix title ID."
          call: "snowflake-engage.run-query"
          with:
            title_id: "{{title_id}}"
          outputParameters:
            - name: funnel
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-engage
      baseUri: "https://netflix.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 content licensing costs by region and content category.

naftiko: "0.5"
info:
  label: "Snowflake Content Licensing Cost Query"
  description: "Queries Snowflake for content licensing costs by region and content category."
  tags:
    - finance
    - snowflake
    - content-licensing
capability:
  exposes:
    - type: mcp
      namespace: snowflake_content_li
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for content licensing costs by region and content category."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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 content localization progress by language and title.

naftiko: "0.5"
info:
  label: "Snowflake Content Localization Status"
  description: "Queries Snowflake for content localization progress by language and title."
  tags:
    - streaming
    - snowflake
    - localization
capability:
  exposes:
    - type: mcp
      namespace: snowflake_content_lo
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for content localization progress by language and title."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Queries recommendation algorithm quality metrics from Snowflake.

naftiko: "0.5"
info:
  label: "Snowflake Content Recommendation Quality"
  description: "Queries recommendation algorithm quality metrics from Snowflake."
  tags:
    - ai
    - snowflake
    - recommendations
capability:
  exposes:
    - type: mcp
      namespace: rec-analytics
      port: 8080
      tools:
        - name: get-rec-quality
          description: "Given a model version, return recommendation quality metrics."
          inputParameters:
            - name: model_version
              in: body
              type: string
              description: "Model version."
          call: "snowflake-rec.run-query"
          with:
            model: "{{model_version}}"
          outputParameters:
            - name: quality
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-rec
      baseUri: "https://netflix.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 content viewership analytics by title and region.

naftiko: "0.5"
info:
  label: "Snowflake Content Viewership Query"
  description: "Queries Snowflake for content viewership analytics by title and region."
  tags:
    - analytics
    - snowflake
    - content
capability:
  exposes:
    - type: mcp
      namespace: content-analytics
      port: 8080
      tools:
        - name: get-viewership
          description: "Given a title ID and region, return viewership data from Snowflake."
          inputParameters:
            - name: title_id
              in: body
              type: string
              description: "Netflix title ID."
            - name: region
              in: body
              type: string
              description: "Region."
          call: "snowflake-content.run-query"
          with:
            title_id: "{{title_id}}"
            region: "{{region}}"
          outputParameters:
            - name: viewership
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-content
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Runs a data quality assertion query against a Snowflake table and opens a Jira data quality incident if row counts or null rates exceed thresholds, notifying the data engineering team in Slack.

naftiko: "0.5"
info:
  label: "Snowflake Data Quality Gate"
  description: "Runs a data quality assertion query against a Snowflake table and opens a Jira data quality incident if row counts or null rates exceed thresholds, notifying the data engineering team in Slack."
  tags:
    - data
    - data-quality
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: data-quality
      port: 8080
      tools:
        - name: run-data-quality-check
          description: "Given a Snowflake table name and quality thresholds, execute a quality assertion query and open a Jira incident if thresholds are breached. Post results to the data engineering Slack channel. Use for automated pipeline quality gates."
          inputParameters:
            - name: table_name
              in: body
              type: string
              description: "The fully qualified Snowflake table name (database.schema.table)."
            - name: null_rate_threshold
              in: body
              type: number
              description: "Maximum acceptable null rate (0.0 to 1.0) for key columns."
            - name: min_row_count
              in: body
              type: integer
              description: "Minimum expected row count for the table."
          steps:
            - name: run-quality-query
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT COUNT(*) as row_count FROM {{table_name}}"
            - name: open-incident
              type: call
              call: "jira-dq.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "Data quality failure: {{table_name}}"
                description: "Row count: {{run-quality-query.row_count}}. Threshold: {{min_row_count}}"
            - name: notify-data-team
              type: call
              call: "slack-dq.post-message"
              with:
                channel: "data-quality-alerts"
                text: "DQ Check: {{table_name}} | Rows: {{run-quality-query.row_count}} | Jira: {{open-incident.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://netflix.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: jira-dq
      baseUri: "https://netflix.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-dq
      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 playback compatibility rates by device type and OS version.

naftiko: "0.5"
info:
  label: "Snowflake Device Compatibility Query"
  description: "Queries Snowflake for playback compatibility rates by device type and OS version."
  tags:
    - streaming
    - snowflake
    - devices
capability:
  exposes:
    - type: mcp
      namespace: snowflake_device_com
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for playback compatibility rates by device type and OS version."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Returns the status and metrics for a content encoding job from Snowflake.

naftiko: "0.5"
info:
  label: "Snowflake Encoding Job Status"
  description: "Returns the status and metrics for a content encoding job from Snowflake."
  tags:
    - streaming
    - snowflake
    - encoding
capability:
  exposes:
    - type: mcp
      namespace: snowflake_encoding_j
      port: 8080
      tools:
        - name: query-data
          description: "Returns the status and metrics for a content encoding job from Snowflake."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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 parental controls adoption and configuration rates.

naftiko: "0.5"
info:
  label: "Snowflake Parental Controls Usage Query"
  description: "Queries Snowflake for parental controls adoption and configuration rates."
  tags:
    - streaming
    - snowflake
    - safety
capability:
  exposes:
    - type: mcp
      namespace: snowflake_parental_c
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for parental controls adoption and configuration rates."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Polls Snowflake task history for failed or stalled tasks over a configurable lookback window and publishes a pipeline health summary to the data platform Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Pipeline Run Monitor"
  description: "Polls Snowflake task history for failed or stalled tasks over a configurable lookback window and publishes a pipeline health summary to the data platform Slack channel."
  tags:
    - data
    - pipeline-monitoring
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: data-pipeline-ops
      port: 8080
      tools:
        - name: monitor-pipeline-runs
          description: "Query Snowflake task execution history for failures within a lookback window and post a health summary to the data platform Slack channel. Use for scheduled pipeline health monitoring or on-demand triage."
          inputParameters:
            - name: lookback_hours
              in: body
              type: integer
              description: "Number of hours to look back for failed Snowflake tasks."
          steps:
            - name: query-task-history
              type: call
              call: "snowflake-monitor.execute-statement"
              with:
                statement: "SELECT * FROM TABLE(INFORMATION_SCHEMA.TASK_HISTORY()) WHERE state='FAILED' AND scheduled_time > DATEADD(hour, -{{lookback_hours}}, CURRENT_TIMESTAMP())"
            - name: post-health-summary
              type: call
              call: "slack-pipeline.post-message"
              with:
                channel: "data-platform-ops"
                text: "Pipeline Monitor (last {{lookback_hours}}h): {{query-task-history.row_count}} failed tasks detected."
  consumes:
    - type: http
      namespace: snowflake-monitor
      baseUri: "https://netflix.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-pipeline
      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 recommendation engine accuracy metrics by algorithm variant.

naftiko: "0.5"
info:
  label: "Snowflake Recommendation Accuracy Query"
  description: "Queries Snowflake for recommendation engine accuracy metrics by algorithm variant."
  tags:
    - streaming
    - snowflake
    - recommendations
capability:
  exposes:
    - type: mcp
      namespace: snowflake_recommenda
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for recommendation engine accuracy metrics by algorithm variant."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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 studio production budget utilization by project.

naftiko: "0.5"
info:
  label: "Snowflake Studio Production Budget Query"
  description: "Queries Snowflake for studio production budget utilization by project."
  tags:
    - finance
    - snowflake
    - studio
capability:
  exposes:
    - type: mcp
      namespace: snowflake_studio_pro
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for studio production budget utilization by project."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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 subscriber growth metrics by region and tier.

naftiko: "0.5"
info:
  label: "Snowflake Subscriber Growth Query"
  description: "Queries Snowflake for subscriber growth metrics by region and tier."
  tags:
    - analytics
    - snowflake
    - subscribers
capability:
  exposes:
    - type: mcp
      namespace: sub-analytics
      port: 8080
      tools:
        - name: get-subscriber-growth
          description: "Given a region and period, return subscriber growth from Snowflake."
          inputParameters:
            - name: region
              in: body
              type: string
              description: "Region."
            - name: period
              in: body
              type: string
              description: "Period."
          call: "snowflake-subs.run-query"
          with:
            region: "{{region}}"
            period: "{{period}}"
          outputParameters:
            - name: growth
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-subs
      baseUri: "https://netflix.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 subscriber retention and churn cohort analysis.

naftiko: "0.5"
info:
  label: "Snowflake Subscriber Retention Query"
  description: "Queries Snowflake for subscriber retention and churn cohort analysis."
  tags:
    - analytics
    - snowflake
    - retention
capability:
  exposes:
    - type: mcp
      namespace: snowflake_subscriber
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for subscriber retention and churn cohort analysis."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.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 title performance metrics including views, completion rate, and audience demographics.

naftiko: "0.5"
info:
  label: "Snowflake Title Performance Query"
  description: "Queries Snowflake for title performance metrics including views, completion rate, and audience demographics."
  tags:
    - streaming
    - snowflake
    - content-analytics
capability:
  exposes:
    - type: mcp
      namespace: snowflake_title_perf
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for title performance metrics including views, completion rate, and audience demographics."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Retrieves compensation band details from Workday.

naftiko: "0.5"
info:
  label: "Workday Compensation Band Lookup"
  description: "Retrieves compensation band details from Workday."
  tags:
    - hr
    - workday
    - compensation
capability:
  exposes:
    - type: mcp
      namespace: comp-ops
      port: 8080
      tools:
        - name: get-comp-band
          description: "Given a job profile ID, return compensation band."
          inputParameters:
            - name: job_profile_id
              in: body
              type: string
              description: "Job profile ID."
          call: "workday-comp.get-band"
          with:
            job_profile_id: "{{job_profile_id}}"
          outputParameters:
            - name: band
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: workday-comp
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/netflix"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: bands
          path: "/compensationBands/{{job_profile_id}}"
          inputParameters:
            - name: job_profile_id
              in: path
          operations:
            - name: get-band
              method: GET

Returns content team headcount and open positions from Workday.

naftiko: "0.5"
info:
  label: "Workday Content Team Headcount Lookup"
  description: "Returns content team headcount and open positions from Workday."
  tags:
    - hr
    - workday
    - workforce
capability:
  exposes:
    - type: mcp
      namespace: workday_content_team
      port: 8080
      tools:
        - name: query-data
          description: "Returns content team headcount and open positions from Workday."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://netflix.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Retrieves engineering team headcount from Workday.

naftiko: "0.5"
info:
  label: "Workday Engineering Headcount"
  description: "Retrieves engineering team headcount from Workday."
  tags:
    - hr
    - workday
    - engineering
capability:
  exposes:
    - type: mcp
      namespace: hr-analytics
      port: 8080
      tools:
        - name: get-eng-headcount
          description: "Given a department, return headcount from Workday."
          inputParameters:
            - name: department
              in: body
              type: string
              description: "Department name."
          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/netflix"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: headcount
          path: "/headcountReport"
          inputParameters:
            - name: department
              in: query
          operations:
            - name: get-headcount
              method: GET

Returns active Netflix headcount grouped by cost center and department from Workday, used for workforce planning and finance allocation.

naftiko: "0.5"
info:
  label: "Workday Headcount by Cost Center"
  description: "Returns active Netflix headcount grouped by cost center and department from Workday, used for workforce planning and finance allocation."
  tags:
    - hr
    - workforce-planning
    - reporting
    - workday
capability:
  exposes:
    - type: mcp
      namespace: hr-reporting
      port: 8080
      tools:
        - name: get-headcount-snapshot
          description: "Returns all active Netflix employees grouped by cost center and department from Workday. Use for headcount planning, budget allocation, and executive workforce reports."
          call: "workday-hc.list-workers"
          outputParameters:
            - name: workers
              type: array
              mapping: "$.data[*]"
  consumes:
    - type: http
      namespace: workday-hc
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/netflix/workers"
          operations:
            - name: list-workers
              method: GET

When a job requisition is approved in Workday, publishes the role to LinkedIn and notifies the talent acquisition team in Slack with the posting URL.

naftiko: "0.5"
info:
  label: "Workday Job Requisition to LinkedIn Publisher"
  description: "When a job requisition is approved in Workday, publishes the role to LinkedIn and notifies the talent acquisition team in Slack with the posting URL."
  tags:
    - hr
    - recruiting
    - workday
    - linkedin
    - slack
capability:
  exposes:
    - type: mcp
      namespace: talent-acquisition
      port: 8080
      tools:
        - name: publish-job-posting
          description: "Given a Workday job requisition ID, fetch job details and publish the posting to LinkedIn, then notify the TA team in Slack. Use when a new requisition is approved in Workday."
          inputParameters:
            - name: requisition_id
              in: body
              type: string
              description: "The Workday job requisition ID."
          steps:
            - name: get-requisition
              type: call
              call: "workday-rec.get-job-requisition"
              with:
                req_id: "{{requisition_id}}"
            - name: post-linkedin
              type: call
              call: "linkedin.create-job-posting"
              with:
                title: "{{get-requisition.job_title}}"
                description: "{{get-requisition.description}}"
                location: "{{get-requisition.location}}"
                company_urn: "$secrets.netflix_linkedin_org_urn"
            - name: notify-ta
              type: call
              call: "slack-ta.post-message"
              with:
                channel: "talent-acquisition"
                text: "New role posted: {{get-requisition.job_title}} | LinkedIn: {{post-linkedin.job_url}}"
  consumes:
    - type: http
      namespace: workday-rec
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: job-requisitions
          path: "/netflix/jobRequisitions/{{req_id}}"
          inputParameters:
            - name: req_id
              in: path
          operations:
            - name: get-job-requisition
              method: GET
    - type: http
      namespace: linkedin
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_token"
      resources:
        - name: job-postings
          path: "/jobPostings"
          operations:
            - name: create-job-posting
              method: POST
    - type: http
      namespace: slack-ta
      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, provisions their Okta account, opens a Jira onboarding epic, creates a GitHub organization membership, and sends a Slack welcome message.

naftiko: "0.5"
info:
  label: "Workday New Hire Onboarding Orchestrator"
  description: "When a new hire is created in Workday, provisions their Okta account, opens a Jira onboarding epic, creates a GitHub organization membership, and sends a Slack welcome message."
  tags:
    - hr
    - onboarding
    - workday
    - okta
    - jira
    - github
    - slack
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 new hire onboarding sequence across Okta, Jira, GitHub, and Slack. Invoke when HR creates a new worker record in Workday."
          inputParameters:
            - name: 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 first day in YYYY-MM-DD format."
            - name: github_team
              in: body
              type: string
              description: "The GitHub team slug the new hire should join (e.g., platform-engineering)."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: provision-okta
              type: call
              call: "okta.create-user"
              with:
                first_name: "{{get-employee.first_name}}"
                last_name: "{{get-employee.last_name}}"
                email: "{{get-employee.work_email}}"
                department: "{{get-employee.department}}"
            - name: open-jira-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ONBOARD"
                issuetype: "Epic"
                summary: "Onboarding: {{get-employee.full_name}} (start: {{start_date}})"
            - name: add-github-member
              type: call
              call: "github.add-team-member"
              with:
                org: "netflix"
                team_slug: "{{github_team}}"
                username: "{{get-employee.github_username}}"
            - name: send-slack-welcome
              type: call
              call: "slack.post-message"
              with:
                channel: "new-hire-welcome"
                text: "Welcome to Netflix, {{get-employee.first_name}}! Jira epic: {{open-jira-epic.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: "/netflix/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta
      baseUri: "https://netflix.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users"
          operations:
            - name: create-user
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://netflix.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: 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: 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 open job requisitions from Workday.

naftiko: "0.5"
info:
  label: "Workday Open Requisitions"
  description: "Returns open job requisitions from Workday."
  tags:
    - hr
    - workday
    - recruiting
capability:
  exposes:
    - type: mcp
      namespace: talent-ops
      port: 8080
      tools:
        - name: get-open-reqs
          description: "Given a team, return open requisitions."
          inputParameters:
            - name: team
              in: body
              type: string
              description: "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/netflix"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: requisitions
          path: "/jobRequisitions"
          inputParameters:
            - name: team
              in: query
          operations:
            - name: get-requisitions
              method: GET

Before a payroll run, queries Workday for employees with missing or incomplete pay data (bank accounts, tax forms) and creates a Jira checklist for the payroll team to resolve.

naftiko: "0.5"
info:
  label: "Workday Payroll Pre-Run Validation"
  description: "Before a payroll run, queries Workday for employees with missing or incomplete pay data (bank accounts, tax forms) and creates a Jira checklist for the payroll team to resolve."
  tags:
    - hr
    - payroll
    - workday
    - jira
capability:
  exposes:
    - type: mcp
      namespace: payroll-ops
      port: 8080
      tools:
        - name: validate-payroll-pre-run
          description: "Given a payroll period and country code, query Workday for workers with incomplete pay data and create a Jira resolution checklist. Use before each payroll processing run."
          inputParameters:
            - name: payroll_period
              in: body
              type: string
              description: "The payroll period identifier (e.g., 2026-06)."
            - name: country_code
              in: body
              type: string
              description: "Two-letter country code for the payroll run (e.g., US, GB)."
          steps:
            - name: get-incomplete-workers
              type: call
              call: "workday-payroll.get-workers-incomplete"
              with:
                period: "{{payroll_period}}"
                country: "{{country_code}}"
            - name: create-checklist
              type: call
              call: "jira-payroll.create-issue"
              with:
                project_key: "PAYROLL"
                issuetype: "Task"
                summary: "Payroll pre-run validation {{payroll_period}} ({{country_code}})"
                description: "Workers with incomplete data: {{get-incomplete-workers.count}}"
  consumes:
    - type: http
      namespace: workday-payroll
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers-incomplete
          path: "/netflix/workers"
          inputParameters:
            - name: period
              in: query
            - name: country
              in: query
          operations:
            - name: get-workers-incomplete
              method: GET
    - type: http
      namespace: jira-payroll
      baseUri: "https://netflix.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

At the start of a performance review cycle, fetches eligible employees from Workday by department and creates a Jira task for each manager to complete their team's reviews.

naftiko: "0.5"
info:
  label: "Workday Performance Review Campaign"
  description: "At the start of a performance review cycle, fetches eligible employees from Workday by department and creates a Jira task for each manager to complete their team's reviews."
  tags:
    - hr
    - performance-management
    - workday
    - jira
capability:
  exposes:
    - type: mcp
      namespace: hr-performance
      port: 8080
      tools:
        - name: launch-review-campaign
          description: "Given a review cycle name and department, fetch eligible employees from Workday and create individual performance review Jira tasks for each manager. Use to kick off annual or bi-annual performance cycles."
          inputParameters:
            - name: review_cycle
              in: body
              type: string
              description: "Name of the performance review cycle (e.g., 2026-Annual)."
            - name: department
              in: body
              type: string
              description: "Department name to scope the launch."
          steps:
            - name: get-eligible-employees
              type: call
              call: "workday-pr.get-workers-by-department"
              with:
                department: "{{department}}"
            - name: create-review-tasks
              type: call
              call: "jira-pr.create-issue"
              with:
                project_key: "HR"
                issuetype: "Task"
                summary: "Performance reviews {{review_cycle}}: {{department}}"
                description: "Eligible employees: {{get-eligible-employees.count}}"
  consumes:
    - type: http
      namespace: workday-pr
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers-by-department
          path: "/netflix/workers"
          inputParameters:
            - name: department
              in: query
          operations:
            - name: get-workers-by-department
              method: GET
    - type: http
      namespace: jira-pr
      baseUri: "https://netflix.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 an employee's role changes in Workday, updates their Okta group memberships to reflect the new access profile and posts a confirmation to the HR Slack channel.

naftiko: "0.5"
info:
  label: "Workday Role Change Access Sync"
  description: "When an employee's role changes in Workday, updates their Okta group memberships to reflect the new access profile and posts a confirmation to the HR Slack channel."
  tags:
    - hr
    - identity
    - role-change
    - workday
    - okta
    - slack
capability:
  exposes:
    - type: mcp
      namespace: hr-identity
      port: 8080
      tools:
        - name: sync-role-change-access
          description: "Given a Workday employee ID and new role, update Okta group memberships to match the new access profile and notify HR in Slack. Invoke when an employee transfers departments or changes positions."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday worker ID of the employee whose role changed."
            - name: new_role
              in: body
              type: string
              description: "The new job title or role."
            - name: new_department
              in: body
              type: string
              description: "The new department the employee is moving to."
          steps:
            - name: get-employee
              type: call
              call: "workday-role.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: update-okta
              type: call
              call: "okta-role.update-user-groups"
              with:
                login: "{{get-employee.work_email}}"
                department: "{{new_department}}"
            - name: notify-hr
              type: call
              call: "slack-role.post-message"
              with:
                channel: "hr-ops"
                text: "Role change complete: {{get-employee.full_name}} is now {{new_role}} in {{new_department}}. Okta access updated."
  consumes:
    - type: http
      namespace: workday-role
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/netflix/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta-role
      baseUri: "https://netflix.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: user-groups
          path: "/users/{{login}}/groups"
          inputParameters:
            - name: login
              in: path
          operations:
            - name: update-user-groups
              method: PUT
    - type: http
      namespace: slack-role
      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

Schedules a company all-hands Zoom meeting, creates a Confluence agenda page, and sends Slack announcements to all-company channels.

naftiko: "0.5"
info:
  label: "Zoom All-Hands Meeting Scheduler"
  description: "Schedules a company all-hands Zoom meeting, creates a Confluence agenda page, and sends Slack announcements to all-company channels."
  tags:
    - communication
    - zoom
    - confluence
    - slack
capability:
  exposes:
    - type: mcp
      namespace: comms-ops
      port: 8080
      tools:
        - name: schedule-all-hands
          description: "Given an all-hands title, datetime, duration, and agenda content, schedule a Zoom meeting, publish the agenda to Confluence, and announce in Slack. Use for quarterly all-hands, town halls, and leadership briefings."
          inputParameters:
            - name: meeting_title
              in: body
              type: string
              description: "Title of the all-hands meeting."
            - name: meeting_start
              in: body
              type: string
              description: "Meeting start time in ISO 8601 format."
            - name: duration_minutes
              in: body
              type: integer
              description: "Duration of the meeting in minutes."
            - name: agenda_content
              in: body
              type: string
              description: "Agenda content in plain text or Confluence wiki markup."
          steps:
            - name: create-zoom-meeting
              type: call
              call: "zoom.create-meeting"
              with:
                topic: "{{meeting_title}}"
                start_time: "{{meeting_start}}"
                duration: "{{duration_minutes}}"
            - name: publish-agenda
              type: call
              call: "confluence-comms.create-page"
              with:
                space_key: "ALLHANDS"
                title: "Agenda: {{meeting_title}}"
                body: "Join URL: {{create-zoom-meeting.join_url}}\n\n{{agenda_content}}"
            - name: announce-slack
              type: call
              call: "slack-comms.post-message"
              with:
                channel: "company-all"
                text: "All-Hands: {{meeting_title}} scheduled for {{meeting_start}}. Join: {{create-zoom-meeting.join_url}} | Agenda: {{publish-agenda.page_url}}"
  consumes:
    - type: http
      namespace: zoom
      baseUri: "https://api.zoom.us/v2"
      authentication:
        type: bearer
        token: "$secrets.zoom_token"
      resources:
        - name: meetings
          path: "/users/me/meetings"
          operations:
            - name: create-meeting
              method: POST
    - type: http
      namespace: confluence-comms
      baseUri: "https://netflix.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: slack-comms
      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