BP Capabilities

Pulls a summary report from Adobe Analytics for a given report suite and date range.

naftiko: "0.5"
info:
  label: "Adobe Analytics Report Pull"
  description: "Pulls a summary report from Adobe Analytics for a given report suite and date range."
  tags:
    - analytics
    - adobe-analytics
    - marketing
capability:
  exposes:
    - type: mcp
      namespace: marketing-analytics
      port: 8080
      tools:
        - name: get-report
          description: "Given an Adobe Analytics report suite ID and date range, retrieve a summary report with page views, visits, and unique visitors. Use for marketing performance reviews."
          inputParameters:
            - name: report_suite_id
              in: body
              type: string
              description: "The Adobe Analytics report suite ID."
            - name: date_from
              in: body
              type: string
              description: "Start date in YYYY-MM-DD format."
            - name: date_to
              in: body
              type: string
              description: "End date in YYYY-MM-DD format."
          call: "adobe-analytics.get-report"
          with:
            rsid: "{{report_suite_id}}"
            date_from: "{{date_from}}"
            date_to: "{{date_to}}"
          outputParameters:
            - name: page_views
              type: integer
              mapping: "$.rows[0].data[0]"
            - name: visits
              type: integer
              mapping: "$.rows[0].data[1]"
  consumes:
    - type: http
      namespace: adobe-analytics
      baseUri: "https://analytics.adobe.io/api"
      authentication:
        type: bearer
        token: "$secrets.adobe_analytics_token"
      resources:
        - name: reports
          path: "/{{report_suite_id}}/reports"
          inputParameters:
            - name: report_suite_id
              in: path
          operations:
            - name: get-report
              method: POST

Compares Workday headcount data against ADP payroll records, identifies discrepancies, logs them in Snowflake, and alerts the payroll team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "ADP Payroll Discrepancy Detector"
  description: "Compares Workday headcount data against ADP payroll records, identifies discrepancies, logs them in Snowflake, and alerts the payroll team via Microsoft Teams."
  tags:
    - hr
    - payroll
    - workday
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: payroll-ops
      port: 8080
      tools:
        - name: detect-payroll-discrepancies
          description: "Given a pay period, compare Workday headcount against ADP payroll records and flag mismatches. Use before payroll finalization each pay cycle."
          inputParameters:
            - name: pay_period
              in: body
              type: string
              description: "The pay period in YYYY-MM-DD format."
          steps:
            - name: get-workday-headcount
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT * FROM HR.WORKDAY_ACTIVE_EMPLOYEES WHERE as_of_date = '{{pay_period}}'"
            - name: get-adp-payroll
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT * FROM HR.ADP_PAYROLL_RECORDS WHERE pay_period = '{{pay_period}}'"
            - name: log-discrepancies
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO HR.PAYROLL_DISCREPANCIES SELECT w.employee_id, '{{pay_period}}' FROM HR.WORKDAY_ACTIVE_EMPLOYEES w LEFT JOIN HR.ADP_PAYROLL_RECORDS a ON w.employee_id = a.employee_id WHERE a.employee_id IS NULL AND w.as_of_date = '{{pay_period}}'"
            - name: notify-payroll
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_payroll_channel"
                text: "Payroll discrepancy check for {{pay_period}} complete. Workday count: {{get-workday-headcount.row_count}}, ADP count: {{get-adp-payroll.row_count}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Given a resolved ServiceNow incident, uses Anthropic Claude to generate a structured post-mortem summary and publishes it to the knowledge base in Confluence.

naftiko: "0.5"
info:
  label: "AI-Assisted Incident Post-Mortem Summarizer"
  description: "Given a resolved ServiceNow incident, uses Anthropic Claude to generate a structured post-mortem summary and publishes it to the knowledge base in Confluence."
  tags:
    - ai
    - automation
    - anthropic
    - servicenow
    - confluence
    - knowledge-management
capability:
  exposes:
    - type: mcp
      namespace: ai-ops
      port: 8080
      tools:
        - name: generate-postmortem
          description: "Given a resolved ServiceNow incident number, retrieve the full incident timeline, generate a structured post-mortem using Anthropic Claude, and publish to Confluence. Use for all P1 and P2 incidents after resolution."
          inputParameters:
            - name: incident_number
              in: body
              type: string
              description: "The resolved ServiceNow incident number, e.g. 'INC0011111'."
            - name: confluence_space_key
              in: body
              type: string
              description: "The Confluence space key for the post-mortem page, e.g. 'INFRA'."
          steps:
            - name: get-incident
              type: call
              call: "servicenow.get-incident"
              with:
                number: "{{incident_number}}"
            - name: generate-summary
              type: call
              call: "anthropic.create-message"
              with:
                model: "claude-opus-4-5"
                max_tokens: 2048
                system: "You are an incident management specialist. Generate a structured post-mortem with sections: Summary, Timeline, Root Cause, Impact, Remediation, Action Items."
                content: "Generate a post-mortem for this incident: {{get-incident.short_description}}. Resolution: {{get-incident.close_notes}}. Duration: {{get-incident.resolved_at}}."
            - name: publish-postmortem
              type: call
              call: "confluence.create-page"
              with:
                space_key: "{{confluence_space_key}}"
                title: "Post-mortem: {{incident_number}} — {{get-incident.short_description}}"
                body: "{{generate-summary.content}}"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: get-incident
              method: GET
    - 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: confluence
      baseUri: "https://bp.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

Scans Amazon S3 buckets for objects exceeding retention policies, logs non-compliant objects in Snowflake, and alerts the cloud governance team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Amazon S3 Data Lifecycle Enforcer"
  description: "Scans Amazon S3 buckets for objects exceeding retention policies, logs non-compliant objects in Snowflake, and alerts the cloud governance team via Microsoft Teams."
  tags:
    - cloud
    - amazon-web-services
    - snowflake
    - microsoft-teams
    - data-governance
capability:
  exposes:
    - type: mcp
      namespace: cloud-governance
      port: 8080
      tools:
        - name: enforce-s3-lifecycle
          description: "Given an S3 bucket name and retention policy in days, identify objects exceeding retention, log findings, and alert the team. Use for cloud data governance enforcement."
          inputParameters:
            - name: bucket_name
              in: body
              type: string
              description: "The Amazon S3 bucket name."
            - name: retention_days
              in: body
              type: integer
              description: "Maximum retention period in days."
          steps:
            - name: scan-bucket
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT COUNT(*) as expired_count, SUM(size_bytes) as total_size FROM CLOUD.S3_INVENTORY WHERE bucket = '{{bucket_name}}' AND DATEDIFF(day, last_modified, CURRENT_DATE) > {{retention_days}}"
            - name: log-findings
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO GOVERNANCE.S3_LIFECYCLE_AUDIT VALUES ('{{bucket_name}}', {{retention_days}}, {{scan-bucket.expired_count}}, {{scan-bucket.total_size}}, CURRENT_TIMESTAMP)"
            - name: alert-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_cloud_governance_channel"
                text: "S3 lifecycle audit for {{bucket_name}}: {{scan-bucket.expired_count}} objects exceed {{retention_days}}-day retention ({{scan-bucket.total_size}} bytes)."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When Azure Cost Management detects a spend anomaly for a BP subscription, creates a Jira ticket for the cloud platform team and posts an alert to the FinOps Teams channel.

naftiko: "0.5"
info:
  label: "Azure Cloud Cost Anomaly Responder"
  description: "When Azure Cost Management detects a spend anomaly for a BP subscription, creates a Jira ticket for the cloud platform team and posts an alert to the FinOps Teams channel."
  tags:
    - cloud
    - finops
    - azure
    - jira
    - microsoft-teams
    - cost-management
capability:
  exposes:
    - type: mcp
      namespace: finops-ops
      port: 8080
      tools:
        - name: handle-cost-anomaly
          description: "Given an Azure subscription ID, anomaly amount, and owning team name, fetch cost breakdown from Azure, open a Jira FinOps ticket, and alert the FinOps channel in Teams. Use when cloud spend exceeds expected baseline."
          inputParameters:
            - name: subscription_id
              in: body
              type: string
              description: "The Azure subscription ID where the anomaly was detected."
            - name: anomaly_amount
              in: body
              type: number
              description: "The dollar amount exceeding the expected spend baseline."
            - name: team_name
              in: body
              type: string
              description: "The team name owning the subscription for Jira routing."
          steps:
            - name: get-cost-detail
              type: call
              call: "azure.get-subscription-costs"
              with:
                subscription_id: "{{subscription_id}}"
            - name: create-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "FINOPS"
                issuetype: "Task"
                summary: "Azure cost anomaly: {{subscription_id}} — ${{anomaly_amount}} overage"
                description: "Subscription: {{subscription_id}}\nOverage: ${{anomaly_amount}}\nTeam: {{team_name}}"
            - name: notify-finops
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.finops_channel_id"
                text: "Cloud cost anomaly on {{subscription_id}}: ${{anomaly_amount}} over baseline. Team: {{team_name}}. Jira: {{create-ticket.key}}."
  consumes:
    - type: http
      namespace: azure
      baseUri: "https://management.azure.com"
      authentication:
        type: bearer
        token: "$secrets.azure_token"
      resources:
        - name: subscription-costs
          path: "/subscriptions/{{subscription_id}}/providers/Microsoft.CostManagement/query"
          inputParameters:
            - name: subscription_id
              in: path
          operations:
            - name: get-subscription-costs
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Triggers an Azure Databricks notebook run, monitors completion status, logs results in Snowflake, and notifies the data engineering team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Azure Databricks Notebook Scheduler"
  description: "Triggers an Azure Databricks notebook run, monitors completion status, logs results in Snowflake, and notifies the data engineering team via Microsoft Teams."
  tags:
    - data-engineering
    - azure-databricks
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: notebook-ops
      port: 8080
      tools:
        - name: run-notebook
          description: "Given a Databricks workspace path and parameters, trigger the notebook run, log results, and notify the team. Use for scheduled data processing jobs."
          inputParameters:
            - name: notebook_path
              in: body
              type: string
              description: "The Databricks notebook path."
            - name: parameters
              in: body
              type: string
              description: "JSON string of notebook parameters."
          steps:
            - name: submit-run
              type: call
              call: "databricks.submit-run"
              with:
                notebook_path: "{{notebook_path}}"
                parameters: "{{parameters}}"
            - name: log-execution
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO DATA_ENG.NOTEBOOK_RUNS VALUES ('{{notebook_path}}', '{{submit-run.run_id}}', CURRENT_TIMESTAMP)"
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_data_engineering_channel"
                text: "Databricks notebook {{notebook_path}} submitted. Run ID: {{submit-run.run_id}}."
  consumes:
    - type: http
      namespace: databricks
      baseUri: "https://bp-databricks.cloud.databricks.com/api/2.1"
      authentication:
        type: bearer
        token: "$secrets.databricks_token"
      resources:
        - name: runs
          path: "/jobs/runs/submit"
          operations:
            - name: submit-run
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When an Azure DevOps release pipeline requires approval, fetches release details, validates change management in ServiceNow, and notifies the approver via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Azure DevOps Release Approval Chain"
  description: "When an Azure DevOps release pipeline requires approval, fetches release details, validates change management in ServiceNow, and notifies the approver via Microsoft Teams."
  tags:
    - devops
    - azure-devops
    - servicenow
    - microsoft-teams
    - change-management
capability:
  exposes:
    - type: mcp
      namespace: release-mgmt
      port: 8080
      tools:
        - name: process-release-approval
          description: "Given an Azure DevOps release ID and project, fetch release details, validate the associated ServiceNow change request, and notify the approver. Use for release governance."
          inputParameters:
            - name: release_id
              in: body
              type: string
              description: "The Azure DevOps release ID."
            - name: project
              in: body
              type: string
              description: "The Azure DevOps project name."
          steps:
            - name: get-release
              type: call
              call: "azdo.get-release"
              with:
                project: "{{project}}"
                release_id: "{{release_id}}"
            - name: validate-change
              type: call
              call: "servicenow.get-change-request"
              with:
                change_number: "{{get-release.change_request_id}}"
            - name: notify-approver
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{get-release.approver_email}}"
                text: "Release {{release_id}} in {{project}} requires your approval. Change request {{validate-change.number}} status: {{validate-change.state}}."
  consumes:
    - type: http
      namespace: azdo
      baseUri: "https://vsrm.dev.azure.com/bp"
      authentication:
        type: bearer
        token: "$secrets.azdo_token"
      resources:
        - name: releases
          path: "/{{project}}/_apis/release/releases/{{release_id}}"
          inputParameters:
            - name: project
              in: path
            - name: release_id
              in: path
          operations:
            - name: get-release
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-requests
          path: "/table/change_request?sysparm_query=number={{change_number}}"
          inputParameters:
            - name: change_number
              in: query
          operations:
            - name: get-change-request
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST

Checks the health status of a specified Azure resource, returning availability state and summary.

naftiko: "0.5"
info:
  label: "Azure Resource Health Check"
  description: "Checks the health status of a specified Azure resource, returning availability state and summary."
  tags:
    - cloud
    - microsoft-azure
    - infrastructure
capability:
  exposes:
    - type: mcp
      namespace: cloud
      port: 8080
      tools:
        - name: get-resource-health
          description: "Given an Azure resource ID, retrieve its current availability status and health summary. Use for infrastructure monitoring and incident triage."
          inputParameters:
            - name: resource_id
              in: body
              type: string
              description: "The full Azure resource ID path."
          call: "azure.get-resource-health"
          with:
            resource_id: "{{resource_id}}"
          outputParameters:
            - name: availability_state
              type: string
              mapping: "$.properties.availabilityState"
            - name: summary
              type: string
              mapping: "$.properties.summary"
  consumes:
    - type: http
      namespace: azure
      baseUri: "https://management.azure.com"
      authentication:
        type: bearer
        token: "$secrets.azure_mgmt_token"
      resources:
        - name: resource-health
          path: "/{{resource_id}}/providers/Microsoft.ResourceHealth/availabilityStatuses/current?api-version=2023-07-01"
          inputParameters:
            - name: resource_id
              in: path
          operations:
            - name: get-resource-health
              method: GET

Ingests Bloomberg market data feeds into Snowflake, validates data completeness, and notifies the trading analytics team via Microsoft Teams with quality metrics.

naftiko: "0.5"
info:
  label: "Bloomberg Market Data Ingestion Pipeline"
  description: "Ingests Bloomberg market data feeds into Snowflake, validates data completeness, and notifies the trading analytics team via Microsoft Teams with quality metrics."
  tags:
    - trading
    - bloomberg
    - snowflake
    - microsoft-teams
    - market-data
capability:
  exposes:
    - type: mcp
      namespace: market-data
      port: 8080
      tools:
        - name: ingest-market-data
          description: "Given a Bloomberg data feed and trade date, ingest market data into Snowflake and validate completeness. Use for daily market data loading."
          inputParameters:
            - name: feed_name
              in: body
              type: string
              description: "The Bloomberg data feed name."
            - name: trade_date
              in: body
              type: string
              description: "The trade date in YYYY-MM-DD format."
          steps:
            - name: load-data
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "CALL TRADING.LOAD_BLOOMBERG_FEED('{{feed_name}}', '{{trade_date}}')"
            - name: validate-completeness
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT COUNT(*) as record_count, COUNT(DISTINCT symbol) as symbol_count FROM TRADING.BLOOMBERG_{{feed_name}} WHERE trade_date = '{{trade_date}}'"
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_trading_analytics_channel"
                text: "Bloomberg {{feed_name}} loaded for {{trade_date}}: {{validate-completeness.record_count}} records, {{validate-completeness.symbol_count}} symbols."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves metadata for a file stored in Box including name, size, owner, and shared link status.

naftiko: "0.5"
info:
  label: "Box File Metadata Lookup"
  description: "Retrieves metadata for a file stored in Box including name, size, owner, and shared link status."
  tags:
    - storage
    - box
    - document-management
capability:
  exposes:
    - type: mcp
      namespace: storage
      port: 8080
      tools:
        - name: get-file-info
          description: "Given a Box file ID, retrieve the file name, size, owner, modification date, and sharing status. Use for document governance and compliance audits."
          inputParameters:
            - name: file_id
              in: body
              type: string
              description: "The Box file ID."
          call: "box.get-file"
          with:
            file_id: "{{file_id}}"
          outputParameters:
            - name: name
              type: string
              mapping: "$.name"
            - name: size
              type: integer
              mapping: "$.size"
            - name: owner
              type: string
              mapping: "$.owned_by.login"
  consumes:
    - type: http
      namespace: box
      baseUri: "https://api.box.com/2.0"
      authentication:
        type: bearer
        token: "$secrets.box_token"
      resources:
        - name: files
          path: "/files/{{file_id}}"
          inputParameters:
            - name: file_id
              in: path
          operations:
            - name: get-file
              method: GET

Pulls carbon emissions data from SAP EHS, aggregates it in Snowflake, generates a Power BI dashboard refresh, and sends the report link to the sustainability team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Carbon Emissions Quarterly Report Generator"
  description: "Pulls carbon emissions data from SAP EHS, aggregates it in Snowflake, generates a Power BI dashboard refresh, and sends the report link to the sustainability team via Microsoft Teams."
  tags:
    - sustainability
    - sap
    - snowflake
    - power-bi
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: sustainability-reporting
      port: 8080
      tools:
        - name: generate-emissions-report
          description: "Given a fiscal quarter and business unit, pull emissions data from SAP EHS, aggregate in Snowflake, trigger a Power BI refresh, and notify the sustainability team. Use for quarterly ESG reporting."
          inputParameters:
            - name: fiscal_quarter
              in: body
              type: string
              description: "Fiscal quarter in YYYY-QN format."
            - name: business_unit
              in: body
              type: string
              description: "BP business unit code."
          steps:
            - name: pull-emissions
              type: call
              call: "sap-ehs.get-emissions-data"
              with:
                quarter: "{{fiscal_quarter}}"
                business_unit: "{{business_unit}}"
            - name: aggregate-data
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO SUSTAINABILITY.EMISSIONS_QUARTERLY SELECT * FROM staging WHERE quarter='{{fiscal_quarter}}'"
            - name: refresh-dashboard
              type: call
              call: "powerbi.trigger-refresh"
              with:
                dataset_id: "$secrets.powerbi_emissions_dataset_id"
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_sustainability_channel"
                text: "Q{{fiscal_quarter}} emissions report ready for {{business_unit}}. Dashboard refreshed: {{refresh-dashboard.status}}."
  consumes:
    - type: http
      namespace: sap-ehs
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_EHS_EMISSIONS"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: emissions
          path: "/EmissionsData"
          operations:
            - name: get-emissions-data
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: powerbi
      baseUri: "https://api.powerbi.com/v1.0/myorg"
      authentication:
        type: bearer
        token: "$secrets.powerbi_token"
      resources:
        - name: datasets
          path: "/datasets/{{dataset_id}}/refreshes"
          inputParameters:
            - name: dataset_id
              in: path
          operations:
            - name: trigger-refresh
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a change request for a critical infrastructure or OT system is submitted in ServiceNow, retrieves risk details and routes to the Change Advisory Board via Teams for review.

naftiko: "0.5"
info:
  label: "Change Management Approval Gate for Critical Infrastructure"
  description: "When a change request for a critical infrastructure or OT system is submitted in ServiceNow, retrieves risk details and routes to the Change Advisory Board via Teams for review."
  tags:
    - itsm
    - change-management
    - servicenow
    - microsoft-teams
    - operations
    - oil-gas
capability:
  exposes:
    - type: mcp
      namespace: change-management
      port: 8080
      tools:
        - name: route-change-request
          description: "Given a ServiceNow change request number, retrieve the change details and risk assessment, notify the CAB in Teams, and update the change record to under review. Use for all changes to critical energy infrastructure and OT systems."
          inputParameters:
            - name: change_number
              in: body
              type: string
              description: "The ServiceNow change request number, e.g. 'CHG0003456'."
          steps:
            - name: get-change
              type: call
              call: "servicenow.get-change"
              with:
                number: "{{change_number}}"
            - name: notify-cab
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.cab_channel_id"
                text: "CAB Review: {{change_number}} — {{get-change.short_description}} | Risk: {{get-change.risk}} | System: {{get-change.cmdb_ci}} | Planned: {{get-change.start_date}}"
            - name: update-change
              type: call
              call: "servicenow-update.patch-change"
              with:
                sys_id: "{{get-change.sys_id}}"
                state: "2"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: changes
          path: "/table/change_request"
          operations:
            - name: get-change
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST
    - type: http
      namespace: servicenow-update
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-patch
          path: "/table/change_request/{{sys_id}}"
          inputParameters:
            - name: sys_id
              in: path
          operations:
            - name: patch-change
              method: PATCH

When an Azure DevOps pipeline fails on a protected branch, creates a Jira bug, posts an alert to Microsoft Teams, and triggers a PagerDuty incident for the on-call engineering team.

naftiko: "0.5"
info:
  label: "CI/CD Pipeline Failure Handler"
  description: "When an Azure DevOps pipeline fails on a protected branch, creates a Jira bug, posts an alert to Microsoft Teams, and triggers a PagerDuty incident for the on-call engineering team."
  tags:
    - devops
    - cicd
    - azure-devops
    - jira
    - microsoft-teams
    - pagerduty
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: devops-ops
      port: 8080
      tools:
        - name: handle-pipeline-failure
          description: "Given an Azure DevOps pipeline failure with project, pipeline name, branch, and run ID, create a Jira bug, alert the engineering Teams channel, and trigger PagerDuty for on-call response. Use for critical pipeline failures in production branches."
          inputParameters:
            - name: project
              in: body
              type: string
              description: "The Azure DevOps project name."
            - name: pipeline_name
              in: body
              type: string
              description: "The Azure DevOps pipeline name that failed."
            - name: branch
              in: body
              type: string
              description: "The Git branch where the failure occurred."
            - name: run_id
              in: body
              type: string
              description: "The Azure DevOps pipeline run ID."
          steps:
            - name: create-bug
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Bug"
                summary: "[CI Failure] {{project}} / {{pipeline_name}} on {{branch}}"
                description: "Project: {{project}}\nPipeline: {{pipeline_name}}\nBranch: {{branch}}\nRun ID: {{run_id}}"
            - name: alert-teams
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.engineering_alerts_channel_id"
                text: "Pipeline failure: {{pipeline_name}} on {{branch}} in {{project}}. Jira: {{create-bug.key}}. Run: {{run_id}}."
            - name: page-oncall
              type: call
              call: "pagerduty.create-incident"
              with:
                title: "CI Failure: {{project}} {{pipeline_name}} {{branch}}"
                service_id: "$secrets.pagerduty_engineering_service_id"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              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: create-incident
              method: POST

When a Cisco firewall rule change is detected, validates it against the approved ServiceNow change request, logs the audit trail in Splunk, and alerts the security team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Cisco Firewall Rule Change Auditor"
  description: "When a Cisco firewall rule change is detected, validates it against the approved ServiceNow change request, logs the audit trail in Splunk, and alerts the security team via Microsoft Teams."
  tags:
    - security
    - cisco
    - servicenow
    - splunk
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: firewall-audit
      port: 8080
      tools:
        - name: audit-firewall-change
          description: "Given a Cisco device ID and change timestamp, validate the change against approved change requests and log the audit. Use for firewall compliance monitoring."
          inputParameters:
            - name: device_id
              in: body
              type: string
              description: "The Cisco firewall device identifier."
            - name: change_timestamp
              in: body
              type: string
              description: "The timestamp of the detected change."
          steps:
            - name: get-change-request
              type: call
              call: "servicenow.get-change-requests"
              with:
                ci_id: "{{device_id}}"
                timestamp: "{{change_timestamp}}"
            - name: log-audit
              type: call
              call: "splunk.index-event"
              with:
                index: "firewall_audit"
                event: "Firewall rule change on {{device_id}} at {{change_timestamp}}. Approved CR: {{get-change-request.number}}"
            - name: alert-security
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_security_channel"
                text: "Firewall rule change detected on {{device_id}} at {{change_timestamp}}. Associated CR: {{get-change-request.number}}, Status: {{get-change-request.state}}."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-requests
          path: "/table/change_request"
          operations:
            - name: get-change-requests
              method: GET
    - type: http
      namespace: splunk
      baseUri: "https://bp-splunk.example.com:8089/services"
      authentication:
        type: bearer
        token: "$secrets.splunk_token"
      resources:
        - name: events
          path: "/receivers/simple"
          operations:
            - name: index-event
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Checks the current state of an AWS CloudWatch alarm, returning state value and reason.

naftiko: "0.5"
info:
  label: "CloudWatch Alarm Status Check"
  description: "Checks the current state of an AWS CloudWatch alarm, returning state value and reason."
  tags:
    - monitoring
    - amazon-web-services
    - cloudwatch
capability:
  exposes:
    - type: mcp
      namespace: aws-monitoring
      port: 8080
      tools:
        - name: get-alarm-status
          description: "Given an AWS CloudWatch alarm name, retrieve its current state and state reason. Use for operational monitoring dashboards."
          inputParameters:
            - name: alarm_name
              in: body
              type: string
              description: "The CloudWatch alarm name."
          call: "cloudwatch.describe-alarm"
          with:
            alarm_name: "{{alarm_name}}"
          outputParameters:
            - name: state_value
              type: string
              mapping: "$.MetricAlarms[0].StateValue"
            - name: state_reason
              type: string
              mapping: "$.MetricAlarms[0].StateReason"
  consumes:
    - type: http
      namespace: cloudwatch
      baseUri: "https://monitoring.us-east-1.amazonaws.com"
      authentication:
        type: apikey
        key: "X-Amz-Security-Token"
        value: "$secrets.aws_session_token"
        placement: header
      resources:
        - name: alarms
          path: "/?Action=DescribeAlarms&AlarmNames.member.1={{alarm_name}}"
          inputParameters:
            - name: alarm_name
              in: query
          operations:
            - name: describe-alarm
              method: GET

Identifies SAP Concur expense reports pending approval beyond the policy threshold and sends reminder messages to approving managers via Teams.

naftiko: "0.5"
info:
  label: "Concur Expense Report Approval Escalation"
  description: "Identifies SAP Concur expense reports pending approval beyond the policy threshold and sends reminder messages to approving managers via Teams."
  tags:
    - finance
    - expense-management
    - sap-concur
    - microsoft-teams
    - approval
capability:
  exposes:
    - type: mcp
      namespace: expense-ops
      port: 8080
      tools:
        - name: escalate-pending-expenses
          description: "Retrieve expense reports pending approval for more than the specified number of days from SAP Concur and send Teams reminders to the responsible approvers. Use for weekly expense compliance monitoring."
          inputParameters:
            - name: pending_days
              in: body
              type: integer
              description: "Minimum pending days before escalating. BP policy threshold is typically 5 days."
          steps:
            - name: get-pending-reports
              type: call
              call: "concur.list-pending-reports"
              with:
                approvalStatusCode: "A_PEND"
                limit: "100"
            - name: notify-approvers
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{get-pending-reports.approver_email}}"
                text: "Reminder: You have expense reports pending approval in SAP Concur. Please review within {{pending_days}} days per BP expense policy."
  consumes:
    - type: http
      namespace: concur
      baseUri: "https://www.concursolutions.com/api/v3.0"
      authentication:
        type: bearer
        token: "$secrets.concur_token"
      resources:
        - name: expense-reports
          path: "/expense/reports"
          operations:
            - name: list-pending-reports
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: mail
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST

When SAP Concur flags a travel booking that violates policy, logs the violation in Snowflake, creates a ServiceNow request for review, and notifies the traveler's manager via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Concur Travel Policy Violation Handler"
  description: "When SAP Concur flags a travel booking that violates policy, logs the violation in Snowflake, creates a ServiceNow request for review, and notifies the traveler's manager via Microsoft Teams."
  tags:
    - travel
    - sap
    - snowflake
    - servicenow
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: travel-compliance
      port: 8080
      tools:
        - name: handle-policy-violation
          description: "Given a Concur report ID and violation type, log the violation, create a review request, and notify the manager. Use when travel policy violations are detected."
          inputParameters:
            - name: report_id
              in: body
              type: string
              description: "The SAP Concur expense report ID."
            - name: violation_type
              in: body
              type: string
              description: "Type of policy violation."
            - name: employee_email
              in: body
              type: string
              description: "The employee's email address."
          steps:
            - name: log-violation
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO FINANCE.TRAVEL_VIOLATIONS VALUES ('{{report_id}}', '{{violation_type}}', '{{employee_email}}', CURRENT_TIMESTAMP)"
            - name: create-review
              type: call
              call: "servicenow.create-request"
              with:
                category: "travel_compliance"
                short_description: "Travel policy violation: {{violation_type}} on report {{report_id}}"
            - name: notify-manager
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_travel_compliance_channel"
                text: "Travel policy violation on report {{report_id}} ({{violation_type}}) by {{employee_email}}. Review request: {{create-review.number}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Analyzes ServiceNow incident trends, identifies knowledge gaps in Confluence, creates Jira tasks for documentation, and notifies the knowledge management team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Confluence Knowledge Base Gap Analyzer"
  description: "Analyzes ServiceNow incident trends, identifies knowledge gaps in Confluence, creates Jira tasks for documentation, and notifies the knowledge management team via Microsoft Teams."
  tags:
    - knowledge-management
    - servicenow
    - confluence
    - jira
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: knowledge-ops
      port: 8080
      tools:
        - name: analyze-knowledge-gaps
          description: "Given a ServiceNow category and time range, identify frequently recurring incidents without knowledge articles, create documentation tasks, and notify the team. Use for continuous improvement."
          inputParameters:
            - name: category
              in: body
              type: string
              description: "The ServiceNow incident category to analyze."
            - name: lookback_days
              in: body
              type: integer
              description: "Number of days to look back for incident patterns."
          steps:
            - name: get-incident-trends
              type: call
              call: "servicenow.get-incidents"
              with:
                category: "{{category}}"
                days: "{{lookback_days}}"
            - name: search-knowledge
              type: call
              call: "confluence.search"
              with:
                query: "{{category}} troubleshooting"
            - name: create-doc-task
              type: call
              call: "jira.create-issue"
              with:
                project: "KBASE"
                issue_type: "Task"
                summary: "Knowledge gap: {{category}} - {{get-incident-trends.top_issue}} ({{get-incident-trends.count}} incidents)"
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_knowledge_channel"
                text: "Knowledge gap found: {{get-incident-trends.top_issue}} in {{category}} with {{get-incident-trends.count}} incidents. Only {{search-knowledge.result_count}} articles found. Task: {{create-doc-task.key}}."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: get-incidents
              method: GET
    - type: http
      namespace: confluence
      baseUri: "https://bp.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: search
          path: "/search?cql={{query}}"
          inputParameters:
            - name: query
              in: query
          operations:
            - name: search
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves a Confluence wiki page by ID, returning the title, space, last modifier, and version number.

naftiko: "0.5"
info:
  label: "Confluence Page Lookup"
  description: "Retrieves a Confluence wiki page by ID, returning the title, space, last modifier, and version number."
  tags:
    - documentation
    - confluence
    - knowledge-management
capability:
  exposes:
    - type: mcp
      namespace: knowledge
      port: 8080
      tools:
        - name: get-page
          description: "Given a Confluence page ID, retrieve the page title, space key, body content excerpt, and last modified date. Use for documentation reviews and audit trails."
          inputParameters:
            - name: page_id
              in: body
              type: string
              description: "The Confluence page ID, e.g. '12345678'."
          call: "confluence.get-page"
          with:
            page_id: "{{page_id}}"
          outputParameters:
            - name: title
              type: string
              mapping: "$.title"
            - name: space_key
              type: string
              mapping: "$.space.key"
            - name: version
              type: integer
              mapping: "$.version.number"
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://bp.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content/{{page_id}}?expand=version,space"
          inputParameters:
            - name: page_id
              in: path
          operations:
            - name: get-page
              method: GET

Promotes a validated ML model from Databricks staging to production, updates the model registry, and notifies the data science team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Databricks ML Model Deployment Pipeline"
  description: "Promotes a validated ML model from Databricks staging to production, updates the model registry, and notifies the data science team via Microsoft Teams."
  tags:
    - data-science
    - databricks
    - microsoft-teams
    - mlops
capability:
  exposes:
    - type: mcp
      namespace: mlops
      port: 8080
      tools:
        - name: deploy-ml-model
          description: "Given a Databricks model name and version, promote it to production, update the registry, and notify the team. Use after model validation passes."
          inputParameters:
            - name: model_name
              in: body
              type: string
              description: "The registered model name in Databricks."
            - name: model_version
              in: body
              type: string
              description: "The model version to promote."
          steps:
            - name: promote-model
              type: call
              call: "databricks.transition-model-stage"
              with:
                name: "{{model_name}}"
                version: "{{model_version}}"
                stage: "Production"
            - name: log-deployment
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO MLOPS.DEPLOYMENTS VALUES ('{{model_name}}', '{{model_version}}', CURRENT_TIMESTAMP, 'Production')"
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_data_science_channel"
                text: "Model {{model_name}} v{{model_version}} promoted to Production. Status: {{promote-model.status}}."
  consumes:
    - type: http
      namespace: databricks
      baseUri: "https://bp-databricks.cloud.databricks.com/api/2.0"
      authentication:
        type: bearer
        token: "$secrets.databricks_token"
      resources:
        - name: model-versions
          path: "/mlflow/model-versions/transition-stage"
          operations:
            - name: transition-model-stage
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Queries Datadog for the current health status of a specified service, returning uptime percentage and active alert count.

naftiko: "0.5"
info:
  label: "Datadog Service Health Check"
  description: "Queries Datadog for the current health status of a specified service, returning uptime percentage and active alert count."
  tags:
    - monitoring
    - datadog
    - observability
capability:
  exposes:
    - type: mcp
      namespace: monitoring
      port: 8080
      tools:
        - name: get-service-health
          description: "Given a Datadog service name, retrieve its current health status, uptime metric, and active monitor alert count. Use for operational readiness checks."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "The Datadog service name, e.g. 'bp-trading-api'."
          call: "datadog.get-service-health"
          with:
            service_name: "{{service_name}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.data.attributes.status"
            - name: uptime_pct
              type: string
              mapping: "$.data.attributes.uptime"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: services
          path: "/service_level_objectives?query={{service_name}}"
          inputParameters:
            - name: service_name
              in: query
          operations:
            - name: get-service-health
              method: GET

When Dynatrace detects application performance degradation, captures the problem details, creates a ServiceNow incident, and alerts the SRE team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Dynatrace APM Degradation Handler"
  description: "When Dynatrace detects application performance degradation, captures the problem details, creates a ServiceNow incident, and alerts the SRE team via Microsoft Teams."
  tags:
    - monitoring
    - dynatrace
    - servicenow
    - microsoft-teams
    - sre
capability:
  exposes:
    - type: mcp
      namespace: apm-ops
      port: 8080
      tools:
        - name: handle-degradation
          description: "Given a Dynatrace problem ID, retrieve details, create a ServiceNow incident, and notify the SRE team. Use when Dynatrace detects performance anomalies."
          inputParameters:
            - name: problem_id
              in: body
              type: string
              description: "The Dynatrace problem ID."
          steps:
            - name: get-problem
              type: call
              call: "dynatrace.get-problem"
              with:
                problem_id: "{{problem_id}}"
            - name: create-incident
              type: call
              call: "servicenow.create-incident"
              with:
                category: "application_performance"
                priority: "2"
                short_description: "Dynatrace: {{get-problem.title}} affecting {{get-problem.impactedEntities}}"
            - name: notify-sre
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_sre_channel"
                text: "APM Degradation: {{get-problem.title}}. Impact: {{get-problem.impactLevel}}. Incident: {{create-incident.number}}."
  consumes:
    - type: http
      namespace: dynatrace
      baseUri: "https://bp.live.dynatrace.com/api/v2"
      authentication:
        type: apikey
        key: "Authorization"
        value: "Api-Token $secrets.dynatrace_api_token"
        placement: header
      resources:
        - name: problems
          path: "/problems/{{problem_id}}"
          inputParameters:
            - name: problem_id
              in: path
          operations:
            - name: get-problem
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When an emergency is declared at a facility, creates a ServiceNow major incident, notifies the emergency response team via Microsoft Teams, and opens a Jira war room tracker.

naftiko: "0.5"
info:
  label: "Emergency Response Coordination Chain"
  description: "When an emergency is declared at a facility, creates a ServiceNow major incident, notifies the emergency response team via Microsoft Teams, and opens a Jira war room tracker."
  tags:
    - safety
    - emergency-response
    - servicenow
    - jira
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: emergency-response
      port: 8080
      tools:
        - name: coordinate-emergency-response
          description: "Given a facility, emergency type, and severity level, activate emergency response procedures across all relevant systems. Use for declared facility emergencies."
          inputParameters:
            - name: facility
              in: body
              type: string
              description: "The facility name or code."
            - name: emergency_type
              in: body
              type: string
              description: "Type of emergency: fire, chemical_release, explosion, medical."
            - name: severity
              in: body
              type: string
              description: "Severity: TIER1, TIER2, TIER3."
          steps:
            - name: create-major-incident
              type: call
              call: "servicenow.create-incident"
              with:
                category: "emergency"
                priority: "1"
                short_description: "EMERGENCY at {{facility}}: {{emergency_type}} ({{severity}})"
            - name: create-war-room
              type: call
              call: "jira.create-issue"
              with:
                project: "EMERG"
                issue_type: "Epic"
                summary: "War Room: {{facility}} {{emergency_type}} - {{severity}}"
            - name: notify-ert
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_emergency_channel"
                text: "EMERGENCY DECLARED at {{facility}}: {{emergency_type}} ({{severity}}). Major incident: {{create-major-incident.number}}. War room: {{create-war-room.key}}."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When an employee termination is processed in Workday, revokes Okta access and notifies the IT offboarding team via Teams to complete systems deprovisioning.

naftiko: "0.5"
info:
  label: "Employee Offboarding Workflow"
  description: "When an employee termination is processed in Workday, revokes Okta access and notifies the IT offboarding team via Teams to complete systems deprovisioning."
  tags:
    - hr
    - offboarding
    - workday
    - okta
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: hr-offboarding
      port: 8080
      tools:
        - name: trigger-offboarding
          description: "Given a Workday employee ID and termination date, retrieve employee details, deactivate their Okta account, and notify the IT offboarding team in Teams. Invoke when an employee departure is confirmed."
          inputParameters:
            - name: workday_employee_id
              in: body
              type: string
              description: "The Workday worker ID of the departing employee."
            - name: termination_date
              in: body
              type: string
              description: "The employee's last working day in ISO 8601 format."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{workday_employee_id}}"
            - name: deactivate-okta
              type: call
              call: "okta.deactivate-user"
              with:
                user_login: "{{get-employee.work_email}}"
            - name: notify-it
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.it_offboarding_channel_id"
                text: "Offboarding: {{get-employee.full_name}} ({{get-employee.work_email}}). Okta deactivated. Last day: {{termination_date}}. Please complete system deprovisioning."
  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: "/bp/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta
      baseUri: "https://bp.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: user-deactivate
          path: "/users/{{user_login}}/lifecycle/deactivate"
          inputParameters:
            - name: user_login
              in: path
          operations:
            - name: deactivate-user
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

When a new hire is created in Workday, opens a ServiceNow onboarding ticket, provisions an Okta identity account, and sends a Microsoft Teams welcome message to the employee and their manager.

naftiko: "0.5"
info:
  label: "Employee Onboarding Orchestrator"
  description: "When a new hire is created in Workday, opens a ServiceNow onboarding ticket, provisions an Okta identity account, and sends a Microsoft Teams welcome message to the employee and their manager."
  tags:
    - hr
    - onboarding
    - workday
    - servicenow
    - okta
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: hr-onboarding
      port: 8080
      tools:
        - name: trigger-onboarding
          description: "Given a Workday employee ID and start date, orchestrate the full onboarding sequence across ServiceNow, Okta, and Microsoft Teams. Invoke when a new hire record is confirmed in Workday for any BP business."
          inputParameters:
            - name: workday_employee_id
              in: body
              type: string
              description: "The Workday worker ID for the new hire."
            - name: start_date
              in: body
              type: string
              description: "The employee's start date in ISO 8601 format, e.g. '2026-05-01'."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{workday_employee_id}}"
            - name: open-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                category: "hr_onboarding"
                short_description: "New hire onboarding: {{get-employee.full_name}}"
                assigned_group: "IT_Onboarding"
            - name: 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}}"
            - name: send-welcome
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{get-employee.work_email}}"
                text: "Welcome to BP, {{get-employee.first_name}}! Your onboarding ticket is {{open-ticket.number}}."
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/bp/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: okta
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: mail
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST

Reconciles energy trading positions between the ETRM system and Snowflake, flags discrepancies in a Jira ticket, and notifies the trading risk team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Energy Trading Position Reconciliation"
  description: "Reconciles energy trading positions between the ETRM system and Snowflake, flags discrepancies in a Jira ticket, and notifies the trading risk team via Microsoft Teams."
  tags:
    - trading
    - snowflake
    - jira
    - microsoft-teams
    - risk
capability:
  exposes:
    - type: mcp
      namespace: trading-ops
      port: 8080
      tools:
        - name: reconcile-positions
          description: "Given a trade date and commodity code, pull positions from ETRM and Snowflake, compare them, and flag mismatches. Use at end-of-day for position reconciliation."
          inputParameters:
            - name: trade_date
              in: body
              type: string
              description: "Trade date in YYYY-MM-DD format."
            - name: commodity_code
              in: body
              type: string
              description: "Commodity code, e.g. 'CRUDE_WTI'."
          steps:
            - name: get-etrm-positions
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT * FROM TRADING.ETRM_POSITIONS WHERE trade_date='{{trade_date}}' AND commodity='{{commodity_code}}'"
            - name: get-warehouse-positions
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT * FROM TRADING.WAREHOUSE_POSITIONS WHERE trade_date='{{trade_date}}' AND commodity='{{commodity_code}}'"
            - name: flag-discrepancies
              type: call
              call: "jira.create-issue"
              with:
                project: "TRDRISK"
                issue_type: "Bug"
                summary: "Position discrepancy: {{commodity_code}} on {{trade_date}}"
            - name: notify-risk
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_trading_risk_channel"
                text: "Position reconciliation complete for {{commodity_code}} on {{trade_date}}. Discrepancy ticket: {{flag-discrepancies.key}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Scans F5 load balancers for SSL certificates nearing expiration, creates ServiceNow change requests for renewal, and alerts the infrastructure security team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "F5 Load Balancer Certificate Expiry Checker"
  description: "Scans F5 load balancers for SSL certificates nearing expiration, creates ServiceNow change requests for renewal, and alerts the infrastructure security team via Microsoft Teams."
  tags:
    - security
    - f5-networks
    - servicenow
    - microsoft-teams
    - certificates
capability:
  exposes:
    - type: mcp
      namespace: cert-mgmt
      port: 8080
      tools:
        - name: check-certificate-expiry
          description: "Given an F5 partition and expiry threshold in days, scan for certificates nearing expiration, create renewal change requests, and notify the team. Use for proactive certificate lifecycle management."
          inputParameters:
            - name: partition
              in: body
              type: string
              description: "The F5 partition to scan."
            - name: days_threshold
              in: body
              type: integer
              description: "Number of days before expiry to flag."
          steps:
            - name: scan-certificates
              type: call
              call: "f5.get-certificates"
              with:
                partition: "{{partition}}"
                expiring_within_days: "{{days_threshold}}"
            - name: create-change-request
              type: call
              call: "servicenow.create-change-request"
              with:
                category: "certificate_renewal"
                short_description: "{{scan-certificates.count}} SSL certificates expiring within {{days_threshold}} days on F5 partition {{partition}}"
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_infra_security_channel"
                text: "{{scan-certificates.count}} SSL certificates on F5 partition {{partition}} expire within {{days_threshold}} days. Change request: {{create-change-request.number}}."
  consumes:
    - type: http
      namespace: f5
      baseUri: "https://bp-f5.example.com/mgmt/tm"
      authentication:
        type: basic
        username: "$secrets.f5_user"
        password: "$secrets.f5_password"
      resources:
        - name: certificates
          path: "/sys/crypto/cert?$filter=partition eq '{{partition}}'"
          inputParameters:
            - name: partition
              in: query
          operations:
            - name: get-certificates
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-requests
          path: "/table/change_request"
          operations:
            - name: create-change-request
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a GitHub Actions workflow fails, retrieves the failure details, creates a Jira bug ticket, and notifies the engineering team via Microsoft Teams with remediation context.

naftiko: "0.5"
info:
  label: "GitHub Actions CI/CD Quality Gate"
  description: "When a GitHub Actions workflow fails, retrieves the failure details, creates a Jira bug ticket, and notifies the engineering team via Microsoft Teams with remediation context."
  tags:
    - devops
    - github
    - jira
    - microsoft-teams
    - cicd
capability:
  exposes:
    - type: mcp
      namespace: cicd-quality
      port: 8080
      tools:
        - name: handle-workflow-failure
          description: "Given a GitHub repository and workflow run ID, retrieve failure logs, create a Jira ticket, and notify the team. Use when a CI/CD pipeline fails."
          inputParameters:
            - name: repo
              in: body
              type: string
              description: "The GitHub repository in org/repo format."
            - name: run_id
              in: body
              type: string
              description: "The GitHub Actions workflow run ID."
          steps:
            - name: get-run-details
              type: call
              call: "github.get-workflow-run"
              with:
                repo: "{{repo}}"
                run_id: "{{run_id}}"
            - name: create-bug
              type: call
              call: "jira.create-issue"
              with:
                project: "BPENG"
                issue_type: "Bug"
                summary: "CI/CD failure in {{repo}}: {{get-run-details.display_title}}"
                description: "Workflow run {{run_id}} failed. Conclusion: {{get-run-details.conclusion}}. Branch: {{get-run-details.head_branch}}."
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_engineering_channel"
                text: "CI/CD failure in {{repo}} ({{get-run-details.head_branch}}): {{get-run-details.display_title}}. Jira: {{create-bug.key}}."
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: workflow-runs
          path: "/repos/{{repo}}/actions/runs/{{run_id}}"
          inputParameters:
            - name: repo
              in: path
            - name: run_id
              in: path
          operations:
            - name: get-workflow-run
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves metadata for a GitHub repository including description, default branch, open issues count, and last push date.

naftiko: "0.5"
info:
  label: "GitHub Repository Info Lookup"
  description: "Retrieves metadata for a GitHub repository including description, default branch, open issues count, and last push date."
  tags:
    - devops
    - github
    - source-control
capability:
  exposes:
    - type: mcp
      namespace: devops
      port: 8080
      tools:
        - name: get-repo-info
          description: "Given a GitHub org and repository name, retrieve the repository metadata including visibility, default branch, and open issue count. Use for developer experience audits and onboarding."
          inputParameters:
            - name: org
              in: body
              type: string
              description: "The GitHub organization, e.g. 'bp-digital'."
            - name: repo
              in: body
              type: string
              description: "The repository name, e.g. 'trading-platform'."
          call: "github.get-repo"
          with:
            org: "{{org}}"
            repo: "{{repo}}"
          outputParameters:
            - name: full_name
              type: string
              mapping: "$.full_name"
            - name: default_branch
              type: string
              mapping: "$.default_branch"
            - name: open_issues
              type: integer
              mapping: "$.open_issues_count"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: repos
          path: "/repos/{{org}}/{{repo}}"
          inputParameters:
            - name: org
              in: path
            - name: repo
              in: path
          operations:
            - name: get-repo
              method: GET

When GitHub Advanced Security flags a critical vulnerability in a repository, creates a Jira security ticket and triggers a PagerDuty alert for the security team.

naftiko: "0.5"
info:
  label: "GitHub Security Vulnerability Triage"
  description: "When GitHub Advanced Security flags a critical vulnerability in a repository, creates a Jira security ticket and triggers a PagerDuty alert for the security team."
  tags:
    - devops
    - security
    - github
    - jira
    - pagerduty
    - vulnerability-management
capability:
  exposes:
    - type: mcp
      namespace: security-ops
      port: 8080
      tools:
        - name: triage-security-vulnerability
          description: "Given a GitHub repository, CVE ID, and severity level, create a Jira security ticket and page the BP security team via PagerDuty. Use for critical and high-severity CVE findings in BP code repositories."
          inputParameters:
            - name: repo
              in: body
              type: string
              description: "The GitHub repository full name, e.g. 'bp/trading-platform'."
            - name: cve_id
              in: body
              type: string
              description: "The CVE identifier, e.g. 'CVE-2025-5678'."
            - name: severity
              in: body
              type: string
              description: "Severity level: 'critical', 'high', 'medium', 'low'."
          steps:
            - name: create-sec-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Bug"
                summary: "[{{severity}}] {{cve_id}} in {{repo}}"
                description: "Repository: {{repo}}\nCVE: {{cve_id}}\nSeverity: {{severity}}"
            - name: page-security
              type: call
              call: "pagerduty.create-incident"
              with:
                title: "Security vulnerability {{cve_id}} in {{repo}} — {{severity}}"
                service_id: "$secrets.pagerduty_security_service_id"
                body: "Jira: {{create-sec-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://bp.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: create-incident
              method: POST

Pulls Google Analytics campaign metrics, joins with Salesforce pipeline data in Snowflake, and sends an ROI summary to the marketing leadership via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Google Analytics Campaign ROI Reporter"
  description: "Pulls Google Analytics campaign metrics, joins with Salesforce pipeline data in Snowflake, and sends an ROI summary to the marketing leadership via Microsoft Teams."
  tags:
    - marketing
    - google-analytics
    - snowflake
    - salesforce
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: marketing-roi
      port: 8080
      tools:
        - name: generate-campaign-roi
          description: "Given a campaign ID and date range, pull GA metrics, join with Salesforce pipeline, and send ROI summary. Use for monthly marketing performance reviews."
          inputParameters:
            - name: campaign_id
              in: body
              type: string
              description: "The Google Analytics campaign ID."
            - name: date_range
              in: body
              type: string
              description: "Date range in YYYY-MM-DD/YYYY-MM-DD format."
          steps:
            - name: get-ga-metrics
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT sessions, conversions, revenue FROM MARKETING.GA_CAMPAIGNS WHERE campaign_id = '{{campaign_id}}'"
            - name: get-pipeline-impact
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT SUM(amount) as pipeline_value FROM SALES.SFDC_OPPORTUNITIES WHERE campaign_id = '{{campaign_id}}'"
            - name: notify-leadership
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_marketing_leadership_channel"
                text: "Campaign {{campaign_id}} ROI: Sessions={{get-ga-metrics.sessions}}, Conversions={{get-ga-metrics.conversions}}, Pipeline impact={{get-pipeline-impact.pipeline_value}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Monitors Google Cloud Dataflow streaming jobs, logs performance metrics in Snowflake, and alerts the data platform team via Microsoft Teams when jobs fall behind.

naftiko: "0.5"
info:
  label: "Google Cloud Dataflow Job Health Monitor"
  description: "Monitors Google Cloud Dataflow streaming jobs, logs performance metrics in Snowflake, and alerts the data platform team via Microsoft Teams when jobs fall behind."
  tags:
    - data-engineering
    - google-cloud-platform
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: dataflow-monitoring
      port: 8080
      tools:
        - name: monitor-dataflow-job
          description: "Given a GCP project and Dataflow job ID, check job health metrics, log in Snowflake, and alert if lagging. Use for streaming pipeline health monitoring."
          inputParameters:
            - name: project_id
              in: body
              type: string
              description: "The GCP project ID."
            - name: job_id
              in: body
              type: string
              description: "The Dataflow job ID."
          steps:
            - name: get-job-metrics
              type: call
              call: "gcp-dataflow.get-job"
              with:
                project_id: "{{project_id}}"
                job_id: "{{job_id}}"
            - name: log-metrics
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO DATA_PLATFORM.DATAFLOW_METRICS VALUES ('{{job_id}}', '{{get-job-metrics.currentState}}', {{get-job-metrics.backlog_seconds}}, CURRENT_TIMESTAMP)"
            - name: alert-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_data_platform_channel"
                text: "Dataflow job {{job_id}}: State={{get-job-metrics.currentState}}, Backlog={{get-job-metrics.backlog_seconds}}s."
  consumes:
    - type: http
      namespace: gcp-dataflow
      baseUri: "https://dataflow.googleapis.com/v1b3"
      authentication:
        type: bearer
        token: "$secrets.gcp_token"
      resources:
        - name: jobs
          path: "/projects/{{project_id}}/jobs/{{job_id}}"
          inputParameters:
            - name: project_id
              in: path
            - name: job_id
              in: path
          operations:
            - name: get-job
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Scans Google Drive shared folders for sensitive data patterns, logs findings in Snowflake, and alerts the data protection team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Google Drive Sensitive Data Scanner"
  description: "Scans Google Drive shared folders for sensitive data patterns, logs findings in Snowflake, and alerts the data protection team via Microsoft Teams."
  tags:
    - security
    - google-drive
    - snowflake
    - microsoft-teams
    - data-protection
capability:
  exposes:
    - type: mcp
      namespace: data-protection
      port: 8080
      tools:
        - name: scan-sensitive-data
          description: "Given a Google Drive folder ID, scan for files containing sensitive data patterns, log findings, and alert the team. Use for data loss prevention audits."
          inputParameters:
            - name: folder_id
              in: body
              type: string
              description: "The Google Drive folder ID to scan."
          steps:
            - name: list-files
              type: call
              call: "gdrive.list-files"
              with:
                folder_id: "{{folder_id}}"
            - name: log-findings
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO SECURITY.DLP_SCAN_RESULTS VALUES ('{{folder_id}}', {{list-files.sensitive_count}}, {{list-files.total_files}}, CURRENT_TIMESTAMP)"
            - name: alert-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_data_protection_channel"
                text: "DLP scan of Google Drive folder {{folder_id}}: {{list-files.sensitive_count}} files with sensitive data out of {{list-files.total_files}} scanned."
  consumes:
    - type: http
      namespace: gdrive
      baseUri: "https://www.googleapis.com/drive/v3"
      authentication:
        type: bearer
        token: "$secrets.google_drive_token"
      resources:
        - name: files
          path: "/files?q='{{folder_id}}' in parents"
          inputParameters:
            - name: folder_id
              in: query
          operations:
            - name: list-files
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Creates a snapshot of a Grafana dashboard and returns the shareable URL.

naftiko: "0.5"
info:
  label: "Grafana Dashboard Snapshot"
  description: "Creates a snapshot of a Grafana dashboard and returns the shareable URL."
  tags:
    - monitoring
    - grafana
    - observability
capability:
  exposes:
    - type: mcp
      namespace: observability
      port: 8080
      tools:
        - name: create-dashboard-snapshot
          description: "Given a Grafana dashboard UID, create a point-in-time snapshot and return the shareable link. Use for incident reports and executive briefings."
          inputParameters:
            - name: dashboard_uid
              in: body
              type: string
              description: "The Grafana dashboard UID."
          call: "grafana.create-snapshot"
          with:
            dashboard_uid: "{{dashboard_uid}}"
          outputParameters:
            - name: snapshot_url
              type: string
              mapping: "$.url"
            - name: delete_url
              type: string
              mapping: "$.deleteUrl"
  consumes:
    - type: http
      namespace: grafana
      baseUri: "https://bp-grafana.example.com/api"
      authentication:
        type: bearer
        token: "$secrets.grafana_token"
      resources:
        - name: snapshots
          path: "/snapshots"
          operations:
            - name: create-snapshot
              method: POST

When a Harness deployment fails health checks, triggers an automatic rollback, creates a Jira incident ticket, and notifies the DevOps team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Harness Deployment Rollback Automation"
  description: "When a Harness deployment fails health checks, triggers an automatic rollback, creates a Jira incident ticket, and notifies the DevOps team via Microsoft Teams."
  tags:
    - devops
    - harness
    - jira
    - microsoft-teams
    - deployment
capability:
  exposes:
    - type: mcp
      namespace: deployment-ops
      port: 8080
      tools:
        - name: rollback-deployment
          description: "Given a Harness pipeline execution ID, trigger a rollback, create a Jira incident, and notify DevOps. Use when deployment health checks fail."
          inputParameters:
            - name: execution_id
              in: body
              type: string
              description: "The Harness pipeline execution ID."
            - name: service_name
              in: body
              type: string
              description: "The service that was being deployed."
          steps:
            - name: trigger-rollback
              type: call
              call: "harness.rollback-execution"
              with:
                execution_id: "{{execution_id}}"
            - name: create-incident
              type: call
              call: "jira.create-issue"
              with:
                project: "BPENG"
                issue_type: "Bug"
                summary: "Deployment rollback: {{service_name}} (execution {{execution_id}})"
                description: "Automatic rollback triggered due to failed health checks. Rollback status: {{trigger-rollback.status}}."
            - name: notify-devops
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_devops_channel"
                text: "Deployment ROLLBACK for {{service_name}}: Execution {{execution_id}} rolled back ({{trigger-rollback.status}}). Jira: {{create-incident.key}}."
  consumes:
    - type: http
      namespace: harness
      baseUri: "https://app.harness.io/gateway/pipeline/api"
      authentication:
        type: apikey
        key: "x-api-key"
        value: "$secrets.harness_api_key"
        placement: header
      resources:
        - name: executions
          path: "/pipeline/execute/rollback/{{execution_id}}"
          inputParameters:
            - name: execution_id
              in: path
          operations:
            - name: rollback-execution
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Syncs new marketing qualified leads from HubSpot to Salesforce, enriches them with ZoomInfo data, and notifies the BDR team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "HubSpot Marketing Lead Sync"
  description: "Syncs new marketing qualified leads from HubSpot to Salesforce, enriches them with ZoomInfo data, and notifies the BDR team via Microsoft Teams."
  tags:
    - marketing
    - hubspot
    - salesforce
    - zoominfo
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: lead-sync
      port: 8080
      tools:
        - name: sync-marketing-leads
          description: "Given a HubSpot list ID, sync MQLs to Salesforce, enrich with ZoomInfo, and notify the BDR team. Use for marketing-to-sales handoff automation."
          inputParameters:
            - name: list_id
              in: body
              type: string
              description: "The HubSpot contact list ID."
          steps:
            - name: get-leads
              type: call
              call: "hubspot.get-contacts"
              with:
                list_id: "{{list_id}}"
            - name: enrich-leads
              type: call
              call: "zoominfo.enrich-contacts"
              with:
                emails: "{{get-leads.emails}}"
            - name: push-to-salesforce
              type: call
              call: "salesforce.create-leads"
              with:
                leads: "{{enrich-leads.enriched_contacts}}"
            - name: notify-bdr
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_bdr_channel"
                text: "{{get-leads.count}} new MQLs synced from HubSpot to Salesforce. Enriched with ZoomInfo data."
  consumes:
    - type: http
      namespace: hubspot
      baseUri: "https://api.hubapi.com"
      authentication:
        type: bearer
        token: "$secrets.hubspot_token"
      resources:
        - name: contacts
          path: "/contacts/v1/lists/{{list_id}}/contacts/all"
          inputParameters:
            - name: list_id
              in: path
          operations:
            - name: get-contacts
              method: GET
    - type: http
      namespace: zoominfo
      baseUri: "https://api.zoominfo.com"
      authentication:
        type: bearer
        token: "$secrets.zoominfo_token"
      resources:
        - name: contacts
          path: "/enrich/contact"
          operations:
            - name: enrich-contacts
              method: POST
    - type: http
      namespace: salesforce
      baseUri: "https://bp.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: leads
          path: "/composite/sobjects/Lead"
          operations:
            - name: create-leads
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Pulls Indeed job posting performance metrics, compares against Workday requisition targets, logs results in Snowflake, and notifies the recruiting team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Indeed Job Posting Performance Tracker"
  description: "Pulls Indeed job posting performance metrics, compares against Workday requisition targets, logs results in Snowflake, and notifies the recruiting team via Microsoft Teams."
  tags:
    - hr
    - recruiting
    - indeed
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: recruiting-analytics
      port: 8080
      tools:
        - name: track-posting-performance
          description: "Given an Indeed campaign ID, pull application metrics, compare to targets, and notify recruiting. Use for weekly job posting performance reviews."
          inputParameters:
            - name: campaign_id
              in: body
              type: string
              description: "The Indeed sponsored job campaign ID."
          steps:
            - name: get-metrics
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT views, applications, cost_per_application FROM HR.INDEED_METRICS WHERE campaign_id = '{{campaign_id}}'"
            - name: get-target
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT target_applications FROM HR.REQUISITION_TARGETS WHERE indeed_campaign_id = '{{campaign_id}}'"
            - name: log-performance
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO HR.POSTING_PERFORMANCE VALUES ('{{campaign_id}}', {{get-metrics.views}}, {{get-metrics.applications}}, {{get-target.target_applications}}, CURRENT_TIMESTAMP)"
            - name: notify-recruiting
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_recruiting_channel"
                text: "Indeed campaign {{campaign_id}}: {{get-metrics.applications}}/{{get-target.target_applications}} applications ({{get-metrics.views}} views, ${{get-metrics.cost_per_application}} CPA)."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves a Jira issue by key, returning summary, status, assignee, and priority.

naftiko: "0.5"
info:
  label: "Jira Issue Lookup"
  description: "Retrieves a Jira issue by key, returning summary, status, assignee, and priority."
  tags:
    - project-management
    - jira
    - issue-tracking
capability:
  exposes:
    - type: mcp
      namespace: project-management
      port: 8080
      tools:
        - name: get-issue
          description: "Given a Jira issue key, retrieve the issue summary, status, assignee, priority, and sprint. Use for status updates and triage workflows."
          inputParameters:
            - name: issue_key
              in: body
              type: string
              description: "The Jira issue key, e.g. 'BPENG-1234'."
          call: "jira.get-issue"
          with:
            issue_key: "{{issue_key}}"
          outputParameters:
            - name: summary
              type: string
              mapping: "$.fields.summary"
            - name: status
              type: string
              mapping: "$.fields.status.name"
            - name: assignee
              type: string
              mapping: "$.fields.assignee.displayName"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://bp.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

Generates a sprint planning digest from Jira for a given engineering project and posts the summary to the team's Microsoft Teams channel.

naftiko: "0.5"
info:
  label: "Jira Sprint Planning Digest"
  description: "Generates a sprint planning digest from Jira for a given engineering project and posts the summary to the team's Microsoft Teams channel."
  tags:
    - devops
    - jira
    - microsoft-teams
    - sprint-planning
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: sprint-reporting
      port: 8080
      tools:
        - name: digest-sprint-board
          description: "Given a Jira project key and sprint ID, fetch all open issues, count by priority, and post a structured sprint digest to the engineering Teams channel. Use at the start of sprint planning and weekly stand-ups."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "The Jira project key, e.g. 'BPDT'."
            - name: sprint_id
              in: body
              type: integer
              description: "The Jira sprint ID for the current sprint."
          steps:
            - name: get-issues
              type: call
              call: "jira.search-issues"
              with:
                jql: "project={{project_key}} AND sprint={{sprint_id}} AND status != Done"
            - name: post-digest
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.engineering_channel_id"
                text: "Sprint {{sprint_id}} digest for {{project_key}}: {{get-issues.total}} open issues."
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issue-search
          path: "/search"
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Monitors Kong API gateway for services approaching rate limits, logs usage trends in Snowflake, and alerts the API platform team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Kong API Gateway Rate Limit Alerter"
  description: "Monitors Kong API gateway for services approaching rate limits, logs usage trends in Snowflake, and alerts the API platform team via Microsoft Teams."
  tags:
    - api-management
    - kong
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: api-ops
      port: 8080
      tools:
        - name: check-rate-limits
          description: "Given a Kong service name, check current rate limit usage, log trends, and alert if approaching thresholds. Use for API capacity management."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "The Kong service name."
          steps:
            - name: get-usage
              type: call
              call: "kong.get-service-metrics"
              with:
                service_name: "{{service_name}}"
            - name: log-usage
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO API_PLATFORM.RATE_LIMIT_USAGE VALUES ('{{service_name}}', {{get-usage.requests_per_minute}}, {{get-usage.rate_limit}}, CURRENT_TIMESTAMP)"
            - name: alert-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_api_platform_channel"
                text: "Kong rate limit check for {{service_name}}: {{get-usage.requests_per_minute}} RPM / {{get-usage.rate_limit}} limit ({{get-usage.pct_used}}% utilized)."
  consumes:
    - type: http
      namespace: kong
      baseUri: "https://bp-kong.example.com/admin-api"
      authentication:
        type: apikey
        key: "apikey"
        value: "$secrets.kong_admin_key"
        placement: header
      resources:
        - name: services
          path: "/services/{{service_name}}/plugins"
          inputParameters:
            - name: service_name
              in: path
          operations:
            - name: get-service-metrics
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Fetches engagement metrics for BP's LinkedIn sustainability and low-carbon content posts for the reporting period and posts a digest to the corporate communications Teams channel.

naftiko: "0.5"
info:
  label: "LinkedIn Sustainability Content Performance Digest"
  description: "Fetches engagement metrics for BP's LinkedIn sustainability and low-carbon content posts for the reporting period and posts a digest to the corporate communications Teams channel."
  tags:
    - marketing
    - social
    - linkedin
    - microsoft-teams
    - reporting
    - sustainability
capability:
  exposes:
    - type: mcp
      namespace: social-reporting
      port: 8080
      tools:
        - name: digest-linkedin-performance
          description: "Fetch follower growth and post engagement metrics from BP's LinkedIn company page for the specified period and post a digest to the corporate communications Teams channel. Use for weekly sustainability communications reporting."
          inputParameters:
            - name: start_date
              in: body
              type: string
              description: "Start date for the reporting period in ISO 8601 format."
            - name: end_date
              in: body
              type: string
              description: "End date for the reporting period in ISO 8601 format."
          steps:
            - name: get-follower-stats
              type: call
              call: "linkedin.get-follower-stats"
              with:
                organization_id: "$secrets.bp_linkedin_org_id"
            - name: get-share-stats
              type: call
              call: "linkedin-shares.get-share-stats"
              with:
                organization_id: "$secrets.bp_linkedin_org_id"
                start: "{{start_date}}"
                end: "{{end_date}}"
            - name: post-digest
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.comms_channel_id"
                text: "LinkedIn digest ({{start_date}} to {{end_date}}): followers {{get-follower-stats.follower_count}}, impressions {{get-share-stats.impression_count}}, engagements {{get-share-stats.engagement_count}}."
  consumes:
    - type: http
      namespace: linkedin
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_token"
      resources:
        - name: follower-stats
          path: "/organizationalEntityFollowerStatistics"
          operations:
            - name: get-follower-stats
              method: GET
    - type: http
      namespace: linkedin-shares
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_token"
      resources:
        - name: share-stats
          path: "/organizationalEntityShareStatistics"
          operations:
            - name: get-share-stats
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Syncs open requisitions from Workday to LinkedIn job postings, tracks application counts in Snowflake, and sends a weekly digest to hiring managers via Microsoft Teams.

naftiko: "0.5"
info:
  label: "LinkedIn Talent Pipeline Sync"
  description: "Syncs open requisitions from Workday to LinkedIn job postings, tracks application counts in Snowflake, and sends a weekly digest to hiring managers via Microsoft Teams."
  tags:
    - hr
    - recruiting
    - workday
    - linkedin
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: talent-pipeline
      port: 8080
      tools:
        - name: sync-talent-pipeline
          description: "Given a Workday requisition ID, sync it as a LinkedIn job posting, record applicant stats in Snowflake, and notify the hiring manager. Use for recruiting pipeline management."
          inputParameters:
            - name: requisition_id
              in: body
              type: string
              description: "The Workday job requisition ID."
          steps:
            - name: get-requisition
              type: call
              call: "workday.get-requisition"
              with:
                requisition_id: "{{requisition_id}}"
            - name: post-to-linkedin
              type: call
              call: "linkedin.create-job-posting"
              with:
                title: "{{get-requisition.title}}"
                description: "{{get-requisition.description}}"
                location: "{{get-requisition.location}}"
            - name: log-stats
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO HR.TALENT_PIPELINE VALUES ('{{requisition_id}}', '{{post-to-linkedin.posting_id}}', CURRENT_TIMESTAMP)"
            - name: notify-hiring-manager
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{get-requisition.hiring_manager_email}}"
                text: "Job posting for {{get-requisition.title}} is live on LinkedIn. Posting ID: {{post-to-linkedin.posting_id}}."
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: requisitions
          path: "/bp/jobRequisitions/{{requisition_id}}"
          inputParameters:
            - name: requisition_id
              in: path
          operations:
            - name: get-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: "/simpleJobPostings"
          operations:
            - name: create-job-posting
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST

Syncs customer segments from Salesforce to MailChimp audience lists, triggers a campaign send, and logs delivery metrics in Snowflake.

naftiko: "0.5"
info:
  label: "MailChimp Customer Newsletter Sync"
  description: "Syncs customer segments from Salesforce to MailChimp audience lists, triggers a campaign send, and logs delivery metrics in Snowflake."
  tags:
    - marketing
    - mailchimp
    - salesforce
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: email-marketing
      port: 8080
      tools:
        - name: sync-and-send-newsletter
          description: "Given a Salesforce report ID and MailChimp campaign ID, sync the audience segment and trigger the campaign. Use for monthly customer newsletter distribution."
          inputParameters:
            - name: sf_report_id
              in: body
              type: string
              description: "The Salesforce report ID containing the audience segment."
            - name: campaign_id
              in: body
              type: string
              description: "The MailChimp campaign ID to send."
          steps:
            - name: get-audience
              type: call
              call: "salesforce.run-report"
              with:
                report_id: "{{sf_report_id}}"
            - name: update-list
              type: call
              call: "mailchimp.update-audience"
              with:
                list_id: "$secrets.mailchimp_list_id"
                contacts: "{{get-audience.records}}"
            - name: send-campaign
              type: call
              call: "mailchimp.send-campaign"
              with:
                campaign_id: "{{campaign_id}}"
            - name: log-metrics
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO MARKETING.EMAIL_CAMPAIGNS VALUES ('{{campaign_id}}', {{get-audience.record_count}}, CURRENT_TIMESTAMP)"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://bp.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: reports
          path: "/analytics/reports/{{report_id}}"
          inputParameters:
            - name: report_id
              in: path
          operations:
            - name: run-report
              method: GET
    - type: http
      namespace: mailchimp
      baseUri: "https://us1.api.mailchimp.com/3.0"
      authentication:
        type: basic
        username: "anystring"
        password: "$secrets.mailchimp_api_key"
      resources:
        - name: audiences
          path: "/lists/{{list_id}}/members"
          inputParameters:
            - name: list_id
              in: path
          operations:
            - name: update-audience
              method: POST
        - name: campaigns
          path: "/campaigns/{{campaign_id}}/actions/send"
          inputParameters:
            - name: campaign_id
              in: path
          operations:
            - name: send-campaign
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://bp.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

When a Power Automate flow fails, captures the error details, creates a ServiceNow incident, and notifies the citizen developer and IT support via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Microsoft Power Automate Flow Failure Handler"
  description: "When a Power Automate flow fails, captures the error details, creates a ServiceNow incident, and notifies the citizen developer and IT support via Microsoft Teams."
  tags:
    - automation
    - microsoft-power-automate
    - servicenow
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: flow-ops
      port: 8080
      tools:
        - name: handle-flow-failure
          description: "Given a Power Automate flow run ID and environment, capture failure details, create an incident, and notify. Use when automated business flows fail."
          inputParameters:
            - name: flow_id
              in: body
              type: string
              description: "The Power Automate flow ID."
            - name: run_id
              in: body
              type: string
              description: "The failed flow run ID."
          steps:
            - name: get-run-details
              type: call
              call: "power-automate.get-flow-run"
              with:
                flow_id: "{{flow_id}}"
                run_id: "{{run_id}}"
            - name: create-incident
              type: call
              call: "servicenow.create-incident"
              with:
                category: "automation"
                priority: "3"
                short_description: "Power Automate flow failure: {{get-run-details.flow_name}}"
                description: "Error: {{get-run-details.error_message}}"
            - name: notify-support
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_automation_support_channel"
                text: "Power Automate flow {{get-run-details.flow_name}} failed. Error: {{get-run-details.error_message}}. Incident: {{create-incident.number}}."
  consumes:
    - type: http
      namespace: power-automate
      baseUri: "https://api.flow.microsoft.com/providers/Microsoft.ProcessSimple"
      authentication:
        type: bearer
        token: "$secrets.power_automate_token"
      resources:
        - name: flow-runs
          path: "/environments/$secrets.power_automate_env/flows/{{flow_id}}/runs/{{run_id}}"
          inputParameters:
            - name: flow_id
              in: path
            - name: run_id
              in: path
          operations:
            - name: get-flow-run
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Sends a message to a specified Microsoft Teams channel.

naftiko: "0.5"
info:
  label: "Microsoft Teams Channel Message Sender"
  description: "Sends a message to a specified Microsoft Teams channel."
  tags:
    - collaboration
    - microsoft-teams
    - messaging
capability:
  exposes:
    - type: mcp
      namespace: collaboration
      port: 8080
      tools:
        - name: send-channel-message
          description: "Given a Teams team ID, channel ID, and message text, post a message to the specified channel. Use for automated notifications and alerts."
          inputParameters:
            - name: team_id
              in: body
              type: string
              description: "The Microsoft Teams team ID."
            - name: channel_id
              in: body
              type: string
              description: "The Microsoft Teams channel ID."
            - name: message_text
              in: body
              type: string
              description: "The message body to post."
          call: "msteams.send-channel-message"
          with:
            team_id: "{{team_id}}"
            channel_id: "{{channel_id}}"
            text: "{{message_text}}"
          outputParameters:
            - name: message_id
              type: string
              mapping: "$.id"
  consumes:
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: team_id
              in: path
            - name: channel_id
              in: path
          operations:
            - name: send-channel-message
              method: POST

When a new hire start date approaches, provisions Okta account, creates a ServiceNow hardware request, sets up GitHub organization membership, and notifies the hiring manager via Microsoft Teams.

naftiko: "0.5"
info:
  label: "New Hire IT Provisioning Workflow"
  description: "When a new hire start date approaches, provisions Okta account, creates a ServiceNow hardware request, sets up GitHub organization membership, and notifies the hiring manager via Microsoft Teams."
  tags:
    - hr
    - onboarding
    - okta
    - servicenow
    - github
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: it-provisioning
      port: 8080
      tools:
        - name: provision-new-hire
          description: "Given a Workday employee ID, provision all IT resources for the new hire including identity, hardware, and source control access. Use when a new hire record is approaching its start date."
          inputParameters:
            - name: workday_employee_id
              in: body
              type: string
              description: "The Workday worker ID for the new hire."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{workday_employee_id}}"
            - name: create-okta-user
              type: call
              call: "okta.create-user"
              with:
                first_name: "{{get-employee.first_name}}"
                last_name: "{{get-employee.last_name}}"
                email: "{{get-employee.work_email}}"
            - name: create-hw-request
              type: call
              call: "servicenow.create-request"
              with:
                category: "hardware"
                short_description: "Laptop for new hire {{get-employee.full_name}}"
            - name: add-github-member
              type: call
              call: "github.add-org-member"
              with:
                org: "bp-digital"
                username: "{{get-employee.github_username}}"
            - name: notify-manager
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{get-employee.manager_email}}"
                text: "IT provisioning complete for {{get-employee.full_name}}. Okta: {{create-okta-user.status}}, Hardware: {{create-hw-request.number}}."
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/bp/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta
      baseUri: "https://bp.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: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-members
          path: "/orgs/{{org}}/memberships/{{username}}"
          inputParameters:
            - name: org
              in: path
            - name: username
              in: path
          operations:
            - name: add-org-member
              method: PUT
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves application performance metrics from New Relic including response time, throughput, and error rate.

naftiko: "0.5"
info:
  label: "New Relic Application Performance Check"
  description: "Retrieves application performance metrics from New Relic including response time, throughput, and error rate."
  tags:
    - monitoring
    - new-relic
    - apm
capability:
  exposes:
    - type: mcp
      namespace: apm
      port: 8080
      tools:
        - name: get-app-performance
          description: "Given a New Relic application ID, retrieve current response time, throughput, and error rate metrics. Use for performance reviews and capacity planning."
          inputParameters:
            - name: app_id
              in: body
              type: string
              description: "The New Relic application ID."
          call: "newrelic.get-application"
          with:
            app_id: "{{app_id}}"
          outputParameters:
            - name: response_time
              type: string
              mapping: "$.application.application_summary.response_time"
            - name: throughput
              type: string
              mapping: "$.application.application_summary.throughput"
            - name: error_rate
              type: string
              mapping: "$.application.application_summary.error_rate"
  consumes:
    - type: http
      namespace: newrelic
      baseUri: "https://api.newrelic.com/v2"
      authentication:
        type: apikey
        key: "Api-Key"
        value: "$secrets.newrelic_api_key"
        placement: header
      resources:
        - name: applications
          path: "/applications/{{app_id}}.json"
          inputParameters:
            - name: app_id
              in: path
          operations:
            - name: get-application
              method: GET

When an offshore platform sensor threshold is breached, logs the alert in Snowflake, creates a ServiceNow incident, and notifies the offshore operations team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Offshore Platform Sensor Alert Handler"
  description: "When an offshore platform sensor threshold is breached, logs the alert in Snowflake, creates a ServiceNow incident, and notifies the offshore operations team via Microsoft Teams."
  tags:
    - operations
    - energy
    - snowflake
    - servicenow
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: offshore-ops
      port: 8080
      tools:
        - name: handle-sensor-alert
          description: "Given a platform ID, sensor type, and reading value, log the alert, create an incident, and notify operations. Use when offshore IoT sensors breach defined thresholds."
          inputParameters:
            - name: platform_id
              in: body
              type: string
              description: "The offshore platform identifier."
            - name: sensor_type
              in: body
              type: string
              description: "Type of sensor, e.g. 'pressure', 'temperature', 'gas_detection'."
            - name: reading_value
              in: body
              type: string
              description: "The sensor reading value that triggered the alert."
          steps:
            - name: log-alert
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO OPERATIONS.SENSOR_ALERTS VALUES ('{{platform_id}}', '{{sensor_type}}', '{{reading_value}}', CURRENT_TIMESTAMP)"
            - name: create-incident
              type: call
              call: "servicenow.create-incident"
              with:
                category: "offshore_operations"
                priority: "2"
                short_description: "Sensor alert on {{platform_id}}: {{sensor_type}} reading {{reading_value}}"
            - name: notify-ops
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_offshore_ops_channel"
                text: "SENSOR ALERT on {{platform_id}}: {{sensor_type}} = {{reading_value}}. Incident: {{create-incident.number}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Fetches all users assigned to a critical OT or financial system application in Okta and creates a ServiceNow review task for the security compliance team.

naftiko: "0.5"
info:
  label: "Okta User Access Review for Critical Systems"
  description: "Fetches all users assigned to a critical OT or financial system application in Okta and creates a ServiceNow review task for the security compliance team."
  tags:
    - identity
    - security
    - okta
    - servicenow
    - compliance
    - access-management
capability:
  exposes:
    - type: mcp
      namespace: identity-compliance
      port: 8080
      tools:
        - name: run-access-review
          description: "Given an Okta application ID and ServiceNow assignment group, list all application users, count active accounts, and create a ServiceNow access review task. Use for quarterly reviews of critical infrastructure system access."
          inputParameters:
            - name: okta_app_id
              in: body
              type: string
              description: "The Okta application ID for the critical system."
            - name: assignment_group
              in: body
              type: string
              description: "The ServiceNow group to assign the review task to."
          steps:
            - name: list-app-users
              type: call
              call: "okta.list-app-users"
              with:
                app_id: "{{okta_app_id}}"
            - name: create-review-task
              type: call
              call: "servicenow.create-incident"
              with:
                category: "access_review"
                short_description: "Access review: {{okta_app_id}} — {{list-app-users.count}} users"
                assigned_group: "{{assignment_group}}"
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://bp.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: app-users
          path: "/apps/{{app_id}}/users"
          inputParameters:
            - name: app_id
              in: path
          operations:
            - name: list-app-users
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST

Looks up an Okta user by login email, returning profile status, last login time, and assigned groups count.

naftiko: "0.5"
info:
  label: "Okta User Lookup"
  description: "Looks up an Okta user by login email, returning profile status, last login time, and assigned groups count."
  tags:
    - identity
    - okta
    - access-management
capability:
  exposes:
    - type: mcp
      namespace: identity
      port: 8080
      tools:
        - name: get-user
          description: "Given an Okta user login email, retrieve the user profile including status, last login, and MFA enrollment state. Use for access reviews and identity verification."
          inputParameters:
            - name: user_login
              in: body
              type: string
              description: "The Okta user login email, e.g. 'john.doe@bp.com'."
          call: "okta.get-user"
          with:
            user_login: "{{user_login}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.status"
            - name: last_login
              type: string
              mapping: "$.lastLogin"
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://bp.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users/{{user_login}}"
          inputParameters:
            - name: user_login
              in: path
          operations:
            - name: get-user
              method: GET

When a headcount request is approved in Workday, creates a job requisition and publishes the opening to LinkedIn to attract energy sector talent.

naftiko: "0.5"
info:
  label: "Open Role Job Posting Publisher"
  description: "When a headcount request is approved in Workday, creates a job requisition and publishes the opening to LinkedIn to attract energy sector talent."
  tags:
    - hr
    - recruiting
    - workday
    - linkedin
capability:
  exposes:
    - type: mcp
      namespace: recruiting
      port: 8080
      tools:
        - name: publish-job-posting
          description: "Given a Workday department ID, role title, location, and hiring manager ID, create a job requisition in Workday and publish a LinkedIn job posting. Use when headcount approval is granted."
          inputParameters:
            - name: role_title
              in: body
              type: string
              description: "The job title for the position, e.g. 'Petroleum Engineer', 'Data Scientist — Energy Transition'."
            - name: department_id
              in: body
              type: string
              description: "The Workday department ID for the open role."
            - name: hiring_manager_id
              in: body
              type: string
              description: "The Workday worker ID of the hiring manager."
          steps:
            - name: get-manager
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{hiring_manager_id}}"
            - name: create-req
              type: call
              call: "workday-rec.create-job-req"
              with:
                title: "{{role_title}}"
                department_id: "{{department_id}}"
                manager_id: "{{hiring_manager_id}}"
            - name: post-linkedin
              type: call
              call: "linkedin.create-job-posting"
              with:
                title: "{{role_title}}"
                company_id: "$secrets.bp_linkedin_company_id"
                req_id: "{{create-req.id}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/bp/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - 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: "/bp/recruiting/jobRequisitions"
          operations:
            - name: create-job-req
              method: POST
    - 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

When a safety incident is detected on a drilling platform or refinery via sensor data, creates a ServiceNow high-priority incident, pages the HSE team via PagerDuty, and posts an emergency alert to the operations Teams channel.

naftiko: "0.5"
info:
  label: "Operational Technology Safety Incident Reporter"
  description: "When a safety incident is detected on a drilling platform or refinery via sensor data, creates a ServiceNow high-priority incident, pages the HSE team via PagerDuty, and posts an emergency alert to the operations Teams channel."
  tags:
    - operations
    - safety
    - hse
    - servicenow
    - pagerduty
    - microsoft-teams
    - oil-gas
capability:
  exposes:
    - type: mcp
      namespace: hse-ops
      port: 8080
      tools:
        - name: report-safety-incident
          description: "Given a facility ID, incident type, and severity, create a P1 ServiceNow safety incident, trigger PagerDuty alert for the HSE on-call team, and post an emergency notification to the operations Teams channel. Use immediately when a safety event is detected."
          inputParameters:
            - name: facility_id
              in: body
              type: string
              description: "The BP facility or platform identifier, e.g. 'NA-THUNDER-HORSE' or 'REF-ROTTERDAM'."
            - name: incident_type
              in: body
              type: string
              description: "Incident category, e.g. 'Hydrocarbon Release', 'Fire', 'Personnel Injury', 'Equipment Failure'."
            - name: severity
              in: body
              type: string
              description: "Severity tier: 'Tier 1' (Major), 'Tier 2' (Significant), 'Tier 3' (Minor)."
          steps:
            - name: create-safety-incident
              type: call
              call: "servicenow.create-incident"
              with:
                priority: "1"
                category: "hse_safety"
                short_description: "{{severity}} {{incident_type}} at {{facility_id}}"
                impact: "1"
            - name: page-hse
              type: call
              call: "pagerduty.create-incident"
              with:
                title: "Safety Event: {{incident_type}} at {{facility_id}} — {{severity}}"
                service_id: "$secrets.pagerduty_hse_service_id"
                body: "Facility: {{facility_id}}\nType: {{incident_type}}\nSeverity: {{severity}}\nSNOW: {{create-safety-incident.number}}"
            - name: alert-ops
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.ops_emergency_channel_id"
                text: "SAFETY ALERT — {{severity}} {{incident_type}} at {{facility_id}}. ServiceNow: {{create-safety-incident.number}}. HSE team paged."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Reconciles master data between Oracle E-Business Suite and SAP S/4HANA during the ERP migration, logs findings in Snowflake, and alerts the migration team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Oracle EBS to SAP Migration Reconciler"
  description: "Reconciles master data between Oracle E-Business Suite and SAP S/4HANA during the ERP migration, logs findings in Snowflake, and alerts the migration team via Microsoft Teams."
  tags:
    - erp
    - oracle
    - sap
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: erp-migration
      port: 8080
      tools:
        - name: reconcile-migration-data
          description: "Given an entity type and batch ID, compare records between Oracle EBS and SAP, log discrepancies, and notify the migration team. Use during ERP cutover validation."
          inputParameters:
            - name: entity_type
              in: body
              type: string
              description: "The entity type to reconcile, e.g. 'vendor', 'customer', 'material'."
            - name: batch_id
              in: body
              type: string
              description: "The migration batch ID."
          steps:
            - name: get-oracle-count
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT COUNT(*) as count FROM MIGRATION.ORACLE_{{entity_type}} WHERE batch_id = '{{batch_id}}'"
            - name: get-sap-count
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT COUNT(*) as count FROM MIGRATION.SAP_{{entity_type}} WHERE batch_id = '{{batch_id}}'"
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_migration_channel"
                text: "Migration reconciliation for {{entity_type}} batch {{batch_id}}: Oracle count={{get-oracle-count.count}}, SAP count={{get-sap-count.count}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a Palo Alto Networks firewall detects a critical threat, logs the event in Splunk, creates a ServiceNow security incident, and alerts the SOC team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Palo Alto Security Incident Response"
  description: "When a Palo Alto Networks firewall detects a critical threat, logs the event in Splunk, creates a ServiceNow security incident, and alerts the SOC team via Microsoft Teams."
  tags:
    - security
    - palo-alto-networks
    - splunk
    - servicenow
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: security-ops
      port: 8080
      tools:
        - name: handle-firewall-threat
          description: "Given a Palo Alto threat ID and severity, log to Splunk, create a security incident, and alert SOC. Use when critical firewall threats are detected."
          inputParameters:
            - name: threat_id
              in: body
              type: string
              description: "The Palo Alto Networks threat ID."
            - name: severity
              in: body
              type: string
              description: "Threat severity: critical, high, medium, low."
            - name: source_ip
              in: body
              type: string
              description: "The source IP address of the threat."
          steps:
            - name: log-to-splunk
              type: call
              call: "splunk.index-event"
              with:
                index: "security"
                event: "Palo Alto threat {{threat_id}} from {{source_ip}}, severity: {{severity}}"
            - name: create-incident
              type: call
              call: "servicenow.create-incident"
              with:
                category: "security"
                priority: "1"
                short_description: "Firewall threat {{threat_id}} ({{severity}}) from {{source_ip}}"
            - name: alert-soc
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_soc_channel"
                text: "SECURITY ALERT: Palo Alto threat {{threat_id}} ({{severity}}) from {{source_ip}}. Incident: {{create-incident.number}}."
  consumes:
    - type: http
      namespace: splunk
      baseUri: "https://bp-splunk.example.com:8089/services"
      authentication:
        type: bearer
        token: "$secrets.splunk_token"
      resources:
        - name: events
          path: "/receivers/simple"
          operations:
            - name: index-event
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Queries SAP for pipelines due for integrity inspection, creates ServiceNow work orders, and notifies the pipeline operations team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Pipeline Integrity Inspection Scheduler"
  description: "Queries SAP for pipelines due for integrity inspection, creates ServiceNow work orders, and notifies the pipeline operations team via Microsoft Teams."
  tags:
    - operations
    - energy
    - sap
    - servicenow
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: pipeline-ops
      port: 8080
      tools:
        - name: schedule-inspections
          description: "Given an inspection type and region, find pipelines due for inspection, create work orders, and notify the team. Use for proactive pipeline integrity management."
          inputParameters:
            - name: inspection_type
              in: body
              type: string
              description: "Type of inspection, e.g. 'inline', 'external', 'cathodic_protection'."
            - name: region
              in: body
              type: string
              description: "Operating region, e.g. 'Gulf_of_Mexico', 'North_Sea'."
          steps:
            - name: get-due-pipelines
              type: call
              call: "sap.get-equipment-list"
              with:
                equipment_type: "pipeline"
                inspection_type: "{{inspection_type}}"
                region: "{{region}}"
            - name: create-work-orders
              type: call
              call: "servicenow.create-request"
              with:
                category: "pipeline_inspection"
                short_description: "{{inspection_type}} inspection for {{get-due-pipelines.count}} pipelines in {{region}}"
                assigned_group: "Pipeline_Integrity"
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_pipeline_ops_channel"
                text: "{{get-due-pipelines.count}} pipelines in {{region}} due for {{inspection_type}} inspection. Work order: {{create-work-orders.number}}."
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_EQUIPMENT"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: equipment
          path: "/Equipment"
          operations:
            - name: get-equipment-list
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Analyzes Pluralsight skill assessment results against role requirements in Workday, creates learning plan recommendations in Jira, and notifies managers via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Pluralsight Skill Gap Analyzer"
  description: "Analyzes Pluralsight skill assessment results against role requirements in Workday, creates learning plan recommendations in Jira, and notifies managers via Microsoft Teams."
  tags:
    - learning
    - pluralsight
    - workday
    - jira
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: skill-development
      port: 8080
      tools:
        - name: analyze-skill-gaps
          description: "Given a team or department, compare Pluralsight skill levels against Workday role requirements, create learning recommendations, and notify managers. Use for quarterly skill development planning."
          inputParameters:
            - name: department
              in: body
              type: string
              description: "The department or team to analyze."
          steps:
            - name: get-skill-assessments
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT * FROM LEARNING.PLURALSIGHT_SKILLS WHERE department = '{{department}}'"
            - name: get-role-requirements
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT * FROM HR.ROLE_SKILL_REQUIREMENTS WHERE department = '{{department}}'"
            - name: create-learning-plan
              type: call
              call: "jira.create-issue"
              with:
                project: "LEARN"
                issue_type: "Task"
                summary: "Skill gap analysis: {{department}} - {{get-skill-assessments.gap_count}} gaps identified"
            - name: notify-managers
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_learning_channel"
                text: "Skill gap analysis for {{department}}: {{get-skill-assessments.gap_count}} gaps identified across {{get-skill-assessments.employee_count}} employees. Learning plan: {{create-learning-plan.key}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Checks the last refresh status and timestamp for a Power BI dataset.

naftiko: "0.5"
info:
  label: "Power BI Dataset Refresh Status"
  description: "Checks the last refresh status and timestamp for a Power BI dataset."
  tags:
    - analytics
    - power-bi
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: analytics
      port: 8080
      tools:
        - name: get-dataset-refresh-status
          description: "Given a Power BI workspace and dataset ID, retrieve the last refresh status, start time, and end time. Use for monitoring report freshness and troubleshooting stale dashboards."
          inputParameters:
            - name: workspace_id
              in: body
              type: string
              description: "The Power BI workspace ID."
            - name: dataset_id
              in: body
              type: string
              description: "The Power BI dataset ID."
          call: "powerbi.get-refresh-history"
          with:
            workspace_id: "{{workspace_id}}"
            dataset_id: "{{dataset_id}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.value[0].status"
            - name: end_time
              type: string
              mapping: "$.value[0].endTime"
  consumes:
    - type: http
      namespace: powerbi
      baseUri: "https://api.powerbi.com/v1.0/myorg"
      authentication:
        type: bearer
        token: "$secrets.powerbi_token"
      resources:
        - name: datasets
          path: "/groups/{{workspace_id}}/datasets/{{dataset_id}}/refreshes"
          inputParameters:
            - name: workspace_id
              in: path
            - name: dataset_id
              in: path
          operations:
            - name: get-refresh-history
              method: GET

Triggers a Power BI dataset refresh for the energy production KPI dashboard and notifies operations leadership via Teams when the refresh completes.

naftiko: "0.5"
info:
  label: "Power BI Energy Production Dashboard Refresh"
  description: "Triggers a Power BI dataset refresh for the energy production KPI dashboard and notifies operations leadership via Teams when the refresh completes."
  tags:
    - data
    - analytics
    - power-bi
    - microsoft-teams
    - reporting
    - operations
capability:
  exposes:
    - type: mcp
      namespace: ops-reporting
      port: 8080
      tools:
        - name: refresh-production-dashboard
          description: "Given a Power BI workspace and dataset ID for the production KPI dashboard, trigger a dataset refresh and notify the operations leadership Teams channel when complete. Use before daily operations briefings."
          inputParameters:
            - name: workspace_id
              in: body
              type: string
              description: "The Power BI workspace (group) ID."
            - name: dataset_id
              in: body
              type: string
              description: "The Power BI dataset ID to refresh."
          steps:
            - name: trigger-refresh
              type: call
              call: "powerbi.refresh-dataset"
              with:
                workspace_id: "{{workspace_id}}"
                dataset_id: "{{dataset_id}}"
            - name: notify-ops
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.ops_leadership_channel_id"
                text: "Energy production KPI dashboard dataset {{dataset_id}} has been refreshed and is ready for the daily briefing."
  consumes:
    - type: http
      namespace: powerbi
      baseUri: "https://api.powerbi.com/v1.0/myorg"
      authentication:
        type: bearer
        token: "$secrets.powerbi_token"
      resources:
        - name: dataset-refreshes
          path: "/groups/{{workspace_id}}/datasets/{{dataset_id}}/refreshes"
          inputParameters:
            - name: workspace_id
              in: path
            - name: dataset_id
              in: path
          operations:
            - name: refresh-dataset
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Traces data lineage through Qlik applications back to Snowflake source tables, logs the lineage map, and notifies the data governance team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Qlik Data Lineage Tracker"
  description: "Traces data lineage through Qlik applications back to Snowflake source tables, logs the lineage map, and notifies the data governance team via Microsoft Teams."
  tags:
    - data-governance
    - qlik
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: data-governance
      port: 8080
      tools:
        - name: trace-data-lineage
          description: "Given a Qlik app ID and a field name, trace the data lineage back to source tables and log the mapping. Use for data governance and audit compliance."
          inputParameters:
            - name: app_id
              in: body
              type: string
              description: "The Qlik application ID."
            - name: field_name
              in: body
              type: string
              description: "The field name to trace."
          steps:
            - name: get-lineage
              type: call
              call: "qlik.get-app-lineage"
              with:
                app_id: "{{app_id}}"
                field: "{{field_name}}"
            - name: log-lineage
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO GOVERNANCE.DATA_LINEAGE VALUES ('{{app_id}}', '{{field_name}}', '{{get-lineage.source_table}}', CURRENT_TIMESTAMP)"
            - name: notify-governance
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_governance_channel"
                text: "Data lineage for {{field_name}} in Qlik app {{app_id}}: Source table {{get-lineage.source_table}}, {{get-lineage.transformation_count}} transformations."
  consumes:
    - type: http
      namespace: qlik
      baseUri: "https://bp-qlik.example.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.qlik_token"
      resources:
        - name: apps
          path: "/apps/{{app_id}}/lineage"
          inputParameters:
            - name: app_id
              in: path
          operations:
            - name: get-app-lineage
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Queries Red Hat Satellite for servers with outstanding security patches, logs compliance status in Snowflake, and alerts the Linux team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Red Hat Satellite Patch Compliance Reporter"
  description: "Queries Red Hat Satellite for servers with outstanding security patches, logs compliance status in Snowflake, and alerts the Linux team via Microsoft Teams."
  tags:
    - infrastructure
    - red-hat
    - snowflake
    - microsoft-teams
    - patch-management
capability:
  exposes:
    - type: mcp
      namespace: patch-compliance
      port: 8080
      tools:
        - name: report-patch-compliance
          description: "Given a server group and severity filter, check patch compliance via Red Hat Satellite, log results, and alert the team. Use for weekly security patch compliance reporting."
          inputParameters:
            - name: host_group
              in: body
              type: string
              description: "The Red Hat Satellite host group name."
            - name: severity
              in: body
              type: string
              description: "Minimum severity to report: Critical, Important, Moderate."
          steps:
            - name: get-compliance
              type: call
              call: "satellite.get-errata-compliance"
              with:
                host_group: "{{host_group}}"
                severity: "{{severity}}"
            - name: log-report
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO INFRA.PATCH_COMPLIANCE VALUES ('{{host_group}}', '{{severity}}', {{get-compliance.non_compliant_count}}, {{get-compliance.total_hosts}}, CURRENT_TIMESTAMP)"
            - name: alert-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_linux_channel"
                text: "Patch compliance for {{host_group}} ({{severity}}+): {{get-compliance.non_compliant_count}}/{{get-compliance.total_hosts}} servers non-compliant."
  consumes:
    - type: http
      namespace: satellite
      baseUri: "https://bp-satellite.example.com/api/v2"
      authentication:
        type: basic
        username: "$secrets.satellite_user"
        password: "$secrets.satellite_password"
      resources:
        - name: errata
          path: "/hostgroups/{{host_group}}/errata"
          inputParameters:
            - name: host_group
              in: path
          operations:
            - name: get-errata-compliance
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a refinery downtime event is reported, creates a ServiceNow P1 incident, pages the on-call engineer via Microsoft Teams, and opens a Jira tracking issue for root cause analysis.

naftiko: "0.5"
info:
  label: "Refinery Downtime Incident Chain"
  description: "When a refinery downtime event is reported, creates a ServiceNow P1 incident, pages the on-call engineer via Microsoft Teams, and opens a Jira tracking issue for root cause analysis."
  tags:
    - operations
    - servicenow
    - jira
    - microsoft-teams
    - incident-management
capability:
  exposes:
    - type: mcp
      namespace: refinery-ops
      port: 8080
      tools:
        - name: handle-refinery-downtime
          description: "Given a refinery site code and downtime description, create a ServiceNow P1 incident, page the on-call engineer, and open a Jira RCA ticket. Use when a refinery unit goes offline unexpectedly."
          inputParameters:
            - name: site_code
              in: body
              type: string
              description: "BP refinery site code, e.g. 'WHI' for Whiting."
            - name: downtime_description
              in: body
              type: string
              description: "Description of the downtime event."
          steps:
            - name: create-incident
              type: call
              call: "servicenow.create-incident"
              with:
                category: "refinery_ops"
                priority: "1"
                short_description: "Refinery downtime at {{site_code}}: {{downtime_description}}"
            - name: page-oncall
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_refinery_oncall_channel"
                text: "P1 REFINERY DOWNTIME at {{site_code}}: {{downtime_description}}. Incident: {{create-incident.number}}."
            - name: create-rca-ticket
              type: call
              call: "jira.create-issue"
              with:
                project: "REFOPS"
                issue_type: "Task"
                summary: "RCA: {{site_code}} downtime - {{downtime_description}}"
                description: "Root cause analysis for ServiceNow incident {{create-incident.number}}."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://bp.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

Pulls wind and solar generation forecasts, stores them in Snowflake, updates the trading desk Power BI dashboard, and notifies the renewables operations team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Renewable Energy Generation Forecast Sync"
  description: "Pulls wind and solar generation forecasts, stores them in Snowflake, updates the trading desk Power BI dashboard, and notifies the renewables operations team via Microsoft Teams."
  tags:
    - energy
    - renewables
    - snowflake
    - power-bi
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: renewables-ops
      port: 8080
      tools:
        - name: sync-generation-forecast
          description: "Given a forecast date and asset portfolio, pull generation forecasts, store in Snowflake, and refresh dashboards. Use for daily renewables trading preparation."
          inputParameters:
            - name: forecast_date
              in: body
              type: string
              description: "The forecast date in YYYY-MM-DD format."
            - name: portfolio
              in: body
              type: string
              description: "The renewables asset portfolio, e.g. 'WIND_US' or 'SOLAR_UK'."
          steps:
            - name: store-forecast
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "CALL RENEWABLES.LOAD_GENERATION_FORECAST('{{forecast_date}}', '{{portfolio}}')"
            - name: refresh-dashboard
              type: call
              call: "powerbi.trigger-refresh"
              with:
                dataset_id: "$secrets.powerbi_renewables_dataset_id"
            - name: notify-ops
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_renewables_channel"
                text: "Generation forecast loaded for {{portfolio}} on {{forecast_date}}. Dashboard refresh status: {{refresh-dashboard.status}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: powerbi
      baseUri: "https://api.powerbi.com/v1.0/myorg"
      authentication:
        type: bearer
        token: "$secrets.powerbi_token"
      resources:
        - name: datasets
          path: "/datasets/{{dataset_id}}/refreshes"
          inputParameters:
            - name: dataset_id
              in: path
          operations:
            - name: trigger-refresh
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a safety near-miss is reported, logs the event in ServiceNow, creates a Jira investigation ticket, updates SAP EHS module, and notifies HSE leadership via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Safety Near-Miss Report Escalation"
  description: "When a safety near-miss is reported, logs the event in ServiceNow, creates a Jira investigation ticket, updates SAP EHS module, and notifies HSE leadership via Microsoft Teams."
  tags:
    - safety
    - servicenow
    - jira
    - sap
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: safety-ops
      port: 8080
      tools:
        - name: escalate-near-miss
          description: "Given a near-miss report with location, description, and severity, log it across safety systems and notify HSE leadership. Use for all safety near-miss events."
          inputParameters:
            - name: location
              in: body
              type: string
              description: "Site or facility location."
            - name: description
              in: body
              type: string
              description: "Description of the near-miss event."
            - name: severity
              in: body
              type: string
              description: "Severity level: LOW, MEDIUM, HIGH."
          steps:
            - name: log-incident
              type: call
              call: "servicenow.create-incident"
              with:
                category: "safety"
                priority: "{{severity}}"
                short_description: "Near-miss at {{location}}: {{description}}"
            - name: create-investigation
              type: call
              call: "jira.create-issue"
              with:
                project: "SAFETY"
                issue_type: "Task"
                summary: "Investigate near-miss at {{location}}"
                description: "{{description}}. ServiceNow: {{log-incident.number}}"
            - name: update-ehs
              type: call
              call: "sap-ehs.create-event"
              with:
                location: "{{location}}"
                event_type: "NEAR_MISS"
                description: "{{description}}"
            - name: notify-hse
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_hse_channel"
                text: "Near-miss reported at {{location}} ({{severity}}): {{description}}. Incident: {{log-incident.number}}, Investigation: {{create-investigation.key}}."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://bp.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: sap-ehs
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_EHS_INCIDENT"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: events
          path: "/EHSIncident"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Fetches key account metrics from Salesforce for a given B2B energy client, and delivers a briefing to the account manager via Teams before client meetings.

naftiko: "0.5"
info:
  label: "Salesforce Account Health Digest for Energy Clients"
  description: "Fetches key account metrics from Salesforce for a given B2B energy client, and delivers a briefing to the account manager via Teams before client meetings."
  tags:
    - crm
    - sales
    - salesforce
    - microsoft-teams
    - account-management
capability:
  exposes:
    - type: mcp
      namespace: crm-reporting
      port: 8080
      tools:
        - name: digest-account-health
          description: "Given a Salesforce account ID and account manager Teams user ID, retrieve account health data including open opportunities and last activity, then post a briefing to the manager's Teams DM. Use before client meetings."
          inputParameters:
            - name: salesforce_account_id
              in: body
              type: string
              description: "The Salesforce Account ID (18-character)."
            - name: manager_upn
              in: body
              type: string
              description: "The UPN of the account manager to receive the briefing."
          steps:
            - name: get-account
              type: call
              call: "salesforce.get-account"
              with:
                account_id: "{{salesforce_account_id}}"
            - name: get-opps
              type: call
              call: "salesforce-opps.list-opportunities"
              with:
                account_id: "{{salesforce_account_id}}"
            - name: send-briefing
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{manager_upn}}"
                text: "Account brief for {{get-account.Name}}: {{get-opps.count}} open opportunities. Last activity: {{get-account.LastActivityDate}}."
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://bp.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: get-account
              method: GET
    - type: http
      namespace: salesforce-opps
      baseUri: "https://bp.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity"
          operations:
            - name: list-opportunities
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: mail
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST

Converts a qualified Salesforce lead to an opportunity, enriches the account with ZoomInfo data, and notifies the sales rep via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Salesforce Lead-to-Opportunity Converter"
  description: "Converts a qualified Salesforce lead to an opportunity, enriches the account with ZoomInfo data, and notifies the sales rep via Microsoft Teams."
  tags:
    - sales
    - salesforce
    - zoominfo
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: lead-mgmt
      port: 8080
      tools:
        - name: convert-lead
          description: "Given a Salesforce lead ID, convert it to an opportunity, enrich the account from ZoomInfo, and notify the assigned rep. Use when leads are qualified by the BDR team."
          inputParameters:
            - name: lead_id
              in: body
              type: string
              description: "The Salesforce lead ID."
          steps:
            - name: get-lead
              type: call
              call: "salesforce.get-lead"
              with:
                lead_id: "{{lead_id}}"
            - name: enrich-account
              type: call
              call: "zoominfo.enrich-company"
              with:
                company_name: "{{get-lead.company}}"
                domain: "{{get-lead.website}}"
            - name: convert-to-opportunity
              type: call
              call: "salesforce.convert-lead"
              with:
                lead_id: "{{lead_id}}"
                account_name: "{{get-lead.company}}"
                revenue: "{{enrich-account.revenue}}"
            - name: notify-rep
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{get-lead.owner_email}}"
                text: "Lead {{get-lead.company}} converted to opportunity {{convert-to-opportunity.opportunity_id}}. ZoomInfo revenue: {{enrich-account.revenue}}."
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://bp.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: leads
          path: "/sobjects/Lead/{{lead_id}}"
          inputParameters:
            - name: lead_id
              in: path
          operations:
            - name: get-lead
              method: GET
            - name: convert-lead
              method: POST
    - type: http
      namespace: zoominfo
      baseUri: "https://api.zoominfo.com"
      authentication:
        type: bearer
        token: "$secrets.zoominfo_token"
      resources:
        - name: companies
          path: "/enrich/company"
          operations:
            - name: enrich-company
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves a Salesforce opportunity by ID, returning stage, amount, close date, and account name.

naftiko: "0.5"
info:
  label: "Salesforce Opportunity Lookup"
  description: "Retrieves a Salesforce opportunity by ID, returning stage, amount, close date, and account name."
  tags:
    - sales
    - salesforce
    - crm
capability:
  exposes:
    - type: mcp
      namespace: sales
      port: 8080
      tools:
        - name: get-opportunity
          description: "Given a Salesforce opportunity ID, retrieve the opportunity details including stage, amount, probability, and associated account. Use for pipeline reviews and deal tracking."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity ID, e.g. '006Dn00000ABC123'."
          call: "salesforce.get-opportunity"
          with:
            opportunity_id: "{{opportunity_id}}"
          outputParameters:
            - name: stage
              type: string
              mapping: "$.StageName"
            - name: amount
              type: string
              mapping: "$.Amount"
            - name: close_date
              type: string
              mapping: "$.CloseDate"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://bp.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET

When a new supplier is approved by procurement, creates the supplier profile in SAP Ariba, triggers the supplier qualification workflow, and notifies the procurement team via Teams.

naftiko: "0.5"
info:
  label: "SAP Ariba Supplier Onboarding"
  description: "When a new supplier is approved by procurement, creates the supplier profile in SAP Ariba, triggers the supplier qualification workflow, and notifies the procurement team via Teams."
  tags:
    - procurement
    - sap-ariba
    - microsoft-teams
    - supplier-management
capability:
  exposes:
    - type: mcp
      namespace: procurement-ops
      port: 8080
      tools:
        - name: onboard-supplier
          description: "Given a supplier name, DUNS number, and commodity code, create a supplier profile in SAP Ariba, initiate the qualification survey, and notify the BP procurement team in Teams. Use when a new vendor relationship is approved."
          inputParameters:
            - name: supplier_name
              in: body
              type: string
              description: "The legal name of the supplier company."
            - name: duns_number
              in: body
              type: string
              description: "The DUNS number for the supplier."
            - name: commodity_code
              in: body
              type: string
              description: "The commodity classification code for the supplier."
          steps:
            - name: create-supplier
              type: call
              call: "ariba.create-supplier"
              with:
                name: "{{supplier_name}}"
                duns: "{{duns_number}}"
                commodity: "{{commodity_code}}"
            - name: trigger-qualification
              type: call
              call: "ariba-qual.trigger-survey"
              with:
                supplier_id: "{{create-supplier.id}}"
            - name: notify-procurement
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.procurement_channel_id"
                text: "Supplier {{supplier_name}} onboarded in Ariba (ID: {{create-supplier.id}}). Qualification survey triggered."
  consumes:
    - type: http
      namespace: ariba
      baseUri: "https://openapi.ariba.com/api/supplier-management/v1"
      authentication:
        type: bearer
        token: "$secrets.ariba_token"
      resources:
        - name: suppliers
          path: "/suppliers"
          operations:
            - name: create-supplier
              method: POST
    - type: http
      namespace: ariba-qual
      baseUri: "https://openapi.ariba.com/api/supplier-management/v1"
      authentication:
        type: bearer
        token: "$secrets.ariba_token"
      resources:
        - name: qualification-surveys
          path: "/suppliers/{{supplier_id}}/qualificationSurveys"
          inputParameters:
            - name: supplier_id
              in: path
          operations:
            - name: trigger-survey
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Queries SAP S/4HANA for budget and actuals data by cost center for a given fiscal period and posts a variance summary to the finance leadership Teams channel.

naftiko: "0.5"
info:
  label: "SAP Budget vs Actuals Variance Report"
  description: "Queries SAP S/4HANA for budget and actuals data by cost center for a given fiscal period and posts a variance summary to the finance leadership Teams channel."
  tags:
    - finance
    - erp
    - sap
    - reporting
    - budgeting
capability:
  exposes:
    - type: mcp
      namespace: finance-reporting
      port: 8080
      tools:
        - name: publish-budget-variance
          description: "Given a SAP controlling area and fiscal period, retrieve cost center actuals vs. budget and post a variance summary to the finance Teams channel. Use monthly for budget reviews."
          inputParameters:
            - name: controlling_area
              in: body
              type: string
              description: "The SAP controlling area code."
            - name: fiscal_period
              in: body
              type: string
              description: "The fiscal period in YYYYMM format."
          steps:
            - name: get-actuals
              type: call
              call: "sap.get-cost-center-actuals"
              with:
                controlling_area: "{{controlling_area}}"
                period: "{{fiscal_period}}"
            - name: post-summary
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.finance_leadership_channel_id"
                text: "Budget variance for period {{fiscal_period}}: Actuals {{get-actuals.total_actual}}, Budget {{get-actuals.total_budget}}. Variance: {{get-actuals.variance_pct}}%."
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/FCO_PI_CONTROLLING_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: cost-center-actuals
          path: "/CostCenterActualsSet"
          operations:
            - name: get-cost-center-actuals
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Monitors SAP BW data load process chains, logs execution times in Snowflake, and alerts the data warehouse team via Microsoft Teams when loads fail or exceed SLA thresholds.

naftiko: "0.5"
info:
  label: "SAP BW Data Load Monitor"
  description: "Monitors SAP BW data load process chains, logs execution times in Snowflake, and alerts the data warehouse team via Microsoft Teams when loads fail or exceed SLA thresholds."
  tags:
    - data-engineering
    - sap-bw
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: bw-monitoring
      port: 8080
      tools:
        - name: monitor-bw-loads
          description: "Given a SAP BW process chain ID, check the load status, log execution metrics, and alert on failures. Use for daily data warehouse load monitoring."
          inputParameters:
            - name: process_chain_id
              in: body
              type: string
              description: "The SAP BW process chain ID."
          steps:
            - name: check-load-status
              type: call
              call: "sap-bw.get-process-chain-status"
              with:
                chain_id: "{{process_chain_id}}"
            - name: log-metrics
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO DW.BW_LOAD_METRICS VALUES ('{{process_chain_id}}', '{{check-load-status.status}}', {{check-load-status.duration_seconds}}, CURRENT_TIMESTAMP)"
            - name: alert-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_dw_channel"
                text: "BW process chain {{process_chain_id}}: Status={{check-load-status.status}}, Duration={{check-load-status.duration_seconds}}s."
  consumes:
    - type: http
      namespace: sap-bw
      baseUri: "https://bp-bw.sap.com/sap/opu/odata/sap/RSPC_API_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: process-chains
          path: "/ProcessChains('{{chain_id}}')"
          inputParameters:
            - name: chain_id
              in: path
          operations:
            - name: get-process-chain-status
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves cost center details from SAP S/4HANA including responsible person, company code, and validity dates.

naftiko: "0.5"
info:
  label: "SAP Cost Center Lookup"
  description: "Retrieves cost center details from SAP S/4HANA including responsible person, company code, and validity dates."
  tags:
    - finance
    - sap
    - cost-management
capability:
  exposes:
    - type: mcp
      namespace: finance
      port: 8080
      tools:
        - name: get-cost-center
          description: "Given a SAP cost center ID and controlling area, retrieve the cost center master data including description, responsible person, and hierarchy. Use for budget allocation and financial reporting."
          inputParameters:
            - name: cost_center
              in: body
              type: string
              description: "The SAP cost center ID, e.g. '0000010200'."
          call: "sap.get-cost-center"
          with:
            cost_center: "{{cost_center}}"
          outputParameters:
            - name: description
              type: string
              mapping: "$.d.CostCenterDescription"
            - name: responsible_person
              type: string
              mapping: "$.d.PersonResponsible"
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_COSTCENTER_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: cost-centers
          path: "/A_CostCenter('{{cost_center}}')"
          inputParameters:
            - name: cost_center
              in: path
          operations:
            - name: get-cost-center
              method: GET

Retrieves the general ledger account balance from SAP for a given company code and fiscal period.

naftiko: "0.5"
info:
  label: "SAP General Ledger Balance Lookup"
  description: "Retrieves the general ledger account balance from SAP for a given company code and fiscal period."
  tags:
    - finance
    - sap
    - accounting
capability:
  exposes:
    - type: mcp
      namespace: accounting
      port: 8080
      tools:
        - name: get-gl-balance
          description: "Given a SAP company code, GL account number, and fiscal year, retrieve the account balance. Use for financial close procedures and variance analysis."
          inputParameters:
            - name: company_code
              in: body
              type: string
              description: "The SAP company code, e.g. '1000'."
            - name: gl_account
              in: body
              type: string
              description: "The GL account number, e.g. '0000100000'."
            - name: fiscal_year
              in: body
              type: string
              description: "The fiscal year, e.g. '2026'."
          call: "sap.get-gl-balance"
          with:
            company_code: "{{company_code}}"
            gl_account: "{{gl_account}}"
            fiscal_year: "{{fiscal_year}}"
          outputParameters:
            - name: balance
              type: string
              mapping: "$.d.EndingBalanceAmtInCoCodeCrcy"
            - name: currency
              type: string
              mapping: "$.d.CompanyCodeCurrency"
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_JOURNALENTRYITEMBASIC_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: gl-balances
          path: "/A_GLAccountLineItem?$filter=CompanyCode eq '{{company_code}}' and GLAccount eq '{{gl_account}}'"
          inputParameters:
            - name: company_code
              in: query
            - name: gl_account
              in: query
          operations:
            - name: get-gl-balance
              method: GET

When a goods receipt is posted in SAP, validates the PO match, triggers payment scheduling, and notifies the AP manager via Microsoft Teams.

naftiko: "0.5"
info:
  label: "SAP Goods Receipt to Payment Automation"
  description: "When a goods receipt is posted in SAP, validates the PO match, triggers payment scheduling, and notifies the AP manager via Microsoft Teams."
  tags:
    - finance
    - sap
    - microsoft-teams
    - procure-to-pay
capability:
  exposes:
    - type: mcp
      namespace: procure-to-pay
      port: 8080
      tools:
        - name: process-goods-receipt-payment
          description: "Given a SAP goods receipt number, validate against the PO, schedule payment, and notify AP. Use for automating the procure-to-pay cycle."
          inputParameters:
            - name: gr_number
              in: body
              type: string
              description: "The SAP goods receipt document number."
          steps:
            - name: get-gr-details
              type: call
              call: "sap.get-goods-receipt"
              with:
                gr_number: "{{gr_number}}"
            - name: get-po-details
              type: call
              call: "sap.get-purchase-order"
              with:
                po_number: "{{get-gr-details.po_number}}"
            - name: schedule-payment
              type: call
              call: "sap.create-payment-proposal"
              with:
                vendor: "{{get-po-details.vendor}}"
                amount: "{{get-gr-details.amount}}"
                due_date: "{{get-po-details.payment_due_date}}"
            - name: notify-ap
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_ap_channel"
                text: "GR {{gr_number}} matched to PO {{get-gr-details.po_number}}. Payment of {{get-gr-details.amount}} scheduled for {{get-po-details.payment_due_date}}."
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/MM_PUR_PO_MAINT_V2_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: goods-receipts
          path: "/A_GoodsReceipt('{{gr_number}}')"
          inputParameters:
            - name: gr_number
              in: path
          operations:
            - name: get-goods-receipt
              method: GET
        - name: purchase-orders
          path: "/A_PurchaseOrder('{{po_number}}')"
          inputParameters:
            - name: po_number
              in: path
          operations:
            - name: get-purchase-order
              method: GET
        - name: payment-proposals
          path: "/A_PaymentProposal"
          operations:
            - name: create-payment-proposal
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Monitors SAP HANA database disk usage, logs growth trends in Snowflake, and alerts the DBA team via Microsoft Teams when thresholds are approached.

naftiko: "0.5"
info:
  label: "SAP HANA Data Volume Monitor"
  description: "Monitors SAP HANA database disk usage, logs growth trends in Snowflake, and alerts the DBA team via Microsoft Teams when thresholds are approached."
  tags:
    - database
    - sap-hana
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: db-ops
      port: 8080
      tools:
        - name: monitor-hana-volume
          description: "Given a HANA system ID, check disk utilization, log the trend, and alert if approaching capacity. Use for proactive database capacity management."
          inputParameters:
            - name: system_id
              in: body
              type: string
              description: "The SAP HANA system ID."
          steps:
            - name: get-disk-usage
              type: call
              call: "sap-hana.get-disk-usage"
              with:
                sid: "{{system_id}}"
            - name: log-trend
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO DBA.HANA_DISK_USAGE VALUES ('{{system_id}}', {{get-disk-usage.used_gb}}, {{get-disk-usage.total_gb}}, CURRENT_TIMESTAMP)"
            - name: alert-dba
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_dba_channel"
                text: "HANA {{system_id}} disk usage: {{get-disk-usage.used_gb}}GB / {{get-disk-usage.total_gb}}GB ({{get-disk-usage.pct_used}}%)."
  consumes:
    - type: http
      namespace: sap-hana
      baseUri: "https://bp-hana.example.com/api/v1"
      authentication:
        type: basic
        username: "$secrets.hana_user"
        password: "$secrets.hana_password"
      resources:
        - name: disk-usage
          path: "/monitoring/disk/{{sid}}"
          inputParameters:
            - name: sid
              in: path
          operations:
            - name: get-disk-usage
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Posts intercompany journal entries in SAP S/4HANA, validates balancing entries, and notifies the accounting team via Microsoft Teams with confirmation details.

naftiko: "0.5"
info:
  label: "SAP Intercompany Journal Entry Poster"
  description: "Posts intercompany journal entries in SAP S/4HANA, validates balancing entries, and notifies the accounting team via Microsoft Teams with confirmation details."
  tags:
    - finance
    - sap
    - microsoft-teams
    - accounting
capability:
  exposes:
    - type: mcp
      namespace: intercompany-accounting
      port: 8080
      tools:
        - name: post-intercompany-entry
          description: "Given sending and receiving company codes with amounts, post intercompany journal entries in SAP and notify accounting. Use for monthly intercompany settlement processing."
          inputParameters:
            - name: sending_company
              in: body
              type: string
              description: "The sending SAP company code."
            - name: receiving_company
              in: body
              type: string
              description: "The receiving SAP company code."
            - name: amount
              in: body
              type: string
              description: "The journal entry amount."
          steps:
            - name: post-sending-entry
              type: call
              call: "sap.create-journal-entry"
              with:
                company_code: "{{sending_company}}"
                amount: "{{amount}}"
                entry_type: "intercompany_debit"
            - name: post-receiving-entry
              type: call
              call: "sap.create-journal-entry"
              with:
                company_code: "{{receiving_company}}"
                amount: "{{amount}}"
                entry_type: "intercompany_credit"
            - name: notify-accounting
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_accounting_channel"
                text: "Intercompany entry posted: {{sending_company}} -> {{receiving_company}}, amount {{amount}}. Debit doc: {{post-sending-entry.document_number}}, Credit doc: {{post-receiving-entry.document_number}}."
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_JOURNALENTRYITEMBASIC_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: journal-entries
          path: "/A_JournalEntryItemBasic"
          operations:
            - name: create-journal-entry
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Validates a vendor invoice against the SAP purchase order and goods receipt, flags discrepancies in ServiceNow, and notifies the AP team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "SAP Invoice Three-Way Match Validator"
  description: "Validates a vendor invoice against the SAP purchase order and goods receipt, flags discrepancies in ServiceNow, and notifies the AP team via Microsoft Teams."
  tags:
    - finance
    - sap
    - servicenow
    - microsoft-teams
    - accounts-payable
capability:
  exposes:
    - type: mcp
      namespace: ap-automation
      port: 8080
      tools:
        - name: validate-invoice-match
          description: "Given an invoice number and PO number, perform three-way matching between invoice, PO, and goods receipt. Flag mismatches and notify AP. Use for invoice processing automation."
          inputParameters:
            - name: invoice_number
              in: body
              type: string
              description: "The vendor invoice number."
            - name: po_number
              in: body
              type: string
              description: "The SAP purchase order number."
          steps:
            - name: get-po
              type: call
              call: "sap.get-purchase-order"
              with:
                po_number: "{{po_number}}"
            - name: get-gr
              type: call
              call: "sap.get-goods-receipt"
              with:
                po_number: "{{po_number}}"
            - name: flag-mismatch
              type: call
              call: "servicenow.create-incident"
              with:
                category: "accounts_payable"
                short_description: "Three-way match issue: Invoice {{invoice_number}} vs PO {{po_number}}"
                description: "PO amount: {{get-po.total_amount}}, GR quantity: {{get-gr.quantity}}"
            - name: notify-ap
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_ap_channel"
                text: "Invoice {{invoice_number}} three-way match flagged for PO {{po_number}}. ServiceNow ticket: {{flag-mismatch.number}}."
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/MM_PUR_PO_MAINT_V2_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: purchase-orders
          path: "/A_PurchaseOrder('{{po_number}}')"
          inputParameters:
            - name: po_number
              in: path
          operations:
            - name: get-purchase-order
              method: GET
        - name: goods-receipts
          path: "/A_PurchaseOrder('{{po_number}}')/to_GoodsReceipt"
          inputParameters:
            - name: po_number
              in: path
          operations:
            - name: get-goods-receipt
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves real-time stock levels for a given material number from SAP S/4HANA, returning plant, storage location, and unrestricted quantity.

naftiko: "0.5"
info:
  label: "SAP Material Stock Level Check"
  description: "Retrieves real-time stock levels for a given material number from SAP S/4HANA, returning plant, storage location, and unrestricted quantity."
  tags:
    - supply-chain
    - inventory
    - sap
capability:
  exposes:
    - type: mcp
      namespace: inventory
      port: 8080
      tools:
        - name: get-material-stock
          description: "Given a SAP material number, retrieve current stock levels across plants and storage locations. Use for inventory checks and replenishment decisions."
          inputParameters:
            - name: material_number
              in: body
              type: string
              description: "The SAP material number, e.g. '000000001234'."
          call: "sap.get-material-stock"
          with:
            material_number: "{{material_number}}"
          outputParameters:
            - name: plant
              type: string
              mapping: "$.d.Plant"
            - name: unrestricted_qty
              type: string
              mapping: "$.d.MatlWrhsStkQtyInMatlBaseUnit"
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_MATERIAL_STOCK_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: material-stock
          path: "/A_MatlStkInAcctMod(Material='{{material_number}}')"
          inputParameters:
            - name: material_number
              in: path
          operations:
            - name: get-material-stock
              method: GET

Retrieves a plant maintenance order from SAP by order number, returning equipment, work center, and status.

naftiko: "0.5"
info:
  label: "SAP Plant Maintenance Order Lookup"
  description: "Retrieves a plant maintenance order from SAP by order number, returning equipment, work center, and status."
  tags:
    - operations
    - sap
    - maintenance
capability:
  exposes:
    - type: mcp
      namespace: operations
      port: 8080
      tools:
        - name: get-maintenance-order
          description: "Given a SAP maintenance order number, retrieve the order header including equipment, functional location, work center, and system status. Use for maintenance scheduling and operational planning."
          inputParameters:
            - name: order_number
              in: body
              type: string
              description: "The SAP maintenance order number, e.g. '000004001234'."
          call: "sap.get-maintenance-order"
          with:
            order_number: "{{order_number}}"
          outputParameters:
            - name: equipment
              type: string
              mapping: "$.d.Equipment"
            - name: system_status
              type: string
              mapping: "$.d.MaintenanceOrderSystemStatus"
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_MAINTENANCEORDER"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: maintenance-orders
          path: "/MaintenanceOrder('{{order_number}}')"
          inputParameters:
            - name: order_number
              in: path
          operations:
            - name: get-maintenance-order
              method: GET

Looks up a SAP S/4HANA purchase order by number, returning header status, vendor, total value, and open line item count.

naftiko: "0.5"
info:
  label: "SAP Purchase Order Lookup"
  description: "Looks up a SAP S/4HANA purchase order by number, returning header status, vendor, total value, and open line item count."
  tags:
    - finance
    - erp
    - sap
    - procurement
capability:
  exposes:
    - type: mcp
      namespace: erp
      port: 8080
      tools:
        - name: get-purchase-order
          description: "Given a SAP purchase order number, retrieve the PO header including approval status, vendor, total amount, and currency. Use for procurement validation and AP invoice matching."
          inputParameters:
            - name: po_number
              in: body
              type: string
              description: "The SAP purchase order number, e.g. '4500098765'."
          call: "sap.get-po"
          with:
            po_number: "{{po_number}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.d.OverallStatus"
            - name: vendor
              type: string
              mapping: "$.d.Supplier.CompanyName"
            - name: total_amount
              type: string
              mapping: "$.d.TotalAmount"
            - name: currency
              type: string
              mapping: "$.d.TransactionCurrency"
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/MM_PUR_PO_MAINT_V2_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: purchase-orders
          path: "/A_PurchaseOrder('{{po_number}}')"
          inputParameters:
            - name: po_number
              in: path
          operations:
            - name: get-po
              method: GET

Validates a SAP transport request against the ServiceNow change record, promotes it to production, and notifies the basis team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "SAP Transport Request Promotion Workflow"
  description: "Validates a SAP transport request against the ServiceNow change record, promotes it to production, and notifies the basis team via Microsoft Teams."
  tags:
    - erp
    - sap
    - servicenow
    - microsoft-teams
    - change-management
capability:
  exposes:
    - type: mcp
      namespace: sap-transport
      port: 8080
      tools:
        - name: promote-transport
          description: "Given a SAP transport number and ServiceNow change number, validate approval, promote the transport, and notify the team. Use for controlled SAP change promotion."
          inputParameters:
            - name: transport_number
              in: body
              type: string
              description: "The SAP transport request number."
            - name: change_number
              in: body
              type: string
              description: "The ServiceNow change request number."
          steps:
            - name: validate-change
              type: call
              call: "servicenow.get-change-request"
              with:
                change_number: "{{change_number}}"
            - name: promote-transport
              type: call
              call: "sap.release-transport"
              with:
                transport_number: "{{transport_number}}"
            - name: notify-basis
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_basis_channel"
                text: "SAP transport {{transport_number}} promoted. CR {{change_number}} status: {{validate-change.state}}. Transport status: {{promote-transport.status}}."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-requests
          path: "/table/change_request?sysparm_query=number={{change_number}}"
          inputParameters:
            - name: change_number
              in: query
          operations:
            - name: get-change-request
              method: GET
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_TRANSPORT_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: transports
          path: "/Transport('{{transport_number}}')/release"
          inputParameters:
            - name: transport_number
              in: path
          operations:
            - name: release-transport
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves vendor master data from SAP S/4HANA by vendor number, returning name, payment terms, and company code.

naftiko: "0.5"
info:
  label: "SAP Vendor Master Lookup"
  description: "Retrieves vendor master data from SAP S/4HANA by vendor number, returning name, payment terms, and company code."
  tags:
    - procurement
    - sap
    - vendor-management
capability:
  exposes:
    - type: mcp
      namespace: procurement
      port: 8080
      tools:
        - name: get-vendor
          description: "Given a SAP vendor number, retrieve the vendor master record including name, address, payment terms, and company code data. Use for supplier verification and AP processing."
          inputParameters:
            - name: vendor_number
              in: body
              type: string
              description: "The SAP vendor number, e.g. '0000100234'."
          call: "sap.get-vendor"
          with:
            vendor_number: "{{vendor_number}}"
          outputParameters:
            - name: vendor_name
              type: string
              mapping: "$.d.SupplierName"
            - name: payment_terms
              type: string
              mapping: "$.d.PaymentTerms"
  consumes:
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_BUSINESS_PARTNER"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: vendors
          path: "/A_Supplier('{{vendor_number}}')"
          inputParameters:
            - name: vendor_number
              in: path
          operations:
            - name: get-vendor
              method: GET

Retrieves the current status, priority, and assignment group for a ServiceNow incident by number.

naftiko: "0.5"
info:
  label: "ServiceNow Incident Status Lookup"
  description: "Retrieves the current status, priority, and assignment group for a ServiceNow incident by number."
  tags:
    - itsm
    - servicenow
    - incident-management
capability:
  exposes:
    - type: mcp
      namespace: itsm
      port: 8080
      tools:
        - name: get-incident-status
          description: "Given a ServiceNow incident number, retrieve its current state, priority, assigned group, and short description. Use for status checks and SLA tracking."
          inputParameters:
            - name: incident_number
              in: body
              type: string
              description: "The ServiceNow incident number, e.g. 'INC0012345'."
          call: "servicenow.get-incident"
          with:
            incident_number: "{{incident_number}}"
          outputParameters:
            - name: state
              type: string
              mapping: "$.result.state"
            - name: priority
              type: string
              mapping: "$.result.priority"
            - name: assigned_to
              type: string
              mapping: "$.result.assigned_to.display_value"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident?sysparm_query=number={{incident_number}}"
          inputParameters:
            - name: incident_number
              in: query
          operations:
            - name: get-incident
              method: GET

When a high-priority ServiceNow incident is raised for a critical energy infrastructure system, retrieves on-call information from PagerDuty, assigns the ticket, and posts to the operations Teams channel.

naftiko: "0.5"
info:
  label: "ServiceNow Incident Triage and On-Call Routing"
  description: "When a high-priority ServiceNow incident is raised for a critical energy infrastructure system, retrieves on-call information from PagerDuty, assigns the ticket, and posts to the operations Teams channel."
  tags:
    - itsm
    - incident-response
    - servicenow
    - pagerduty
    - microsoft-teams
    - operations
capability:
  exposes:
    - type: mcp
      namespace: itsm-ops
      port: 8080
      tools:
        - name: triage-incident
          description: "Given a ServiceNow incident number and priority, fetch incident details, identify the on-call engineer from PagerDuty, assign the ticket, and post an alert to the IT operations Teams channel. Use for P1/P2 infrastructure incidents."
          inputParameters:
            - name: incident_number
              in: body
              type: string
              description: "The ServiceNow incident number, e.g. 'INC0011111'."
            - name: priority
              in: body
              type: string
              description: "Incident priority: 1 (Critical), 2 (High)."
          steps:
            - name: get-incident
              type: call
              call: "servicenow.get-incident"
              with:
                number: "{{incident_number}}"
            - name: get-oncall
              type: call
              call: "pagerduty.get-oncall-user"
              with:
                schedule_id: "$secrets.pagerduty_it_schedule_id"
            - name: assign-incident
              type: call
              call: "servicenow-assign.update-incident"
              with:
                sys_id: "{{get-incident.sys_id}}"
                assigned_to: "{{get-oncall.user_email}}"
            - name: notify-ops
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.it_ops_channel_id"
                text: "P{{priority}} {{incident_number}}: {{get-incident.short_description}} — assigned to {{get-oncall.user_name}}."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: get-incident
              method: GET
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: oncalls
          path: "/oncalls"
          operations:
            - name: get-oncall-user
              method: GET
    - type: http
      namespace: servicenow-assign
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incident-update
          path: "/table/incident/{{sys_id}}"
          inputParameters:
            - name: sys_id
              in: path
          operations:
            - name: update-incident
              method: PATCH
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Scans SharePoint document libraries for files missing required metadata tags, logs non-compliant items in Snowflake, and notifies document owners via Microsoft Teams.

naftiko: "0.5"
info:
  label: "SharePoint Document Compliance Reviewer"
  description: "Scans SharePoint document libraries for files missing required metadata tags, logs non-compliant items in Snowflake, and notifies document owners via Microsoft Teams."
  tags:
    - compliance
    - sharepoint
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: doc-compliance
      port: 8080
      tools:
        - name: review-document-compliance
          description: "Given a SharePoint site and library name, scan for documents missing required metadata, log findings, and notify owners. Use for quarterly document governance audits."
          inputParameters:
            - name: site_id
              in: body
              type: string
              description: "The SharePoint site ID."
            - name: library_name
              in: body
              type: string
              description: "The document library name."
          steps:
            - name: scan-library
              type: call
              call: "sharepoint.list-documents"
              with:
                site_id: "{{site_id}}"
                library: "{{library_name}}"
            - name: log-findings
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO COMPLIANCE.DOC_AUDIT VALUES ('{{site_id}}', '{{library_name}}', {{scan-library.non_compliant_count}}, CURRENT_TIMESTAMP)"
            - name: notify-owners
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_compliance_channel"
                text: "SharePoint compliance scan for {{library_name}}: {{scan-library.non_compliant_count}} documents missing required metadata out of {{scan-library.total_count}} total."
  consumes:
    - type: http
      namespace: sharepoint
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: documents
          path: "/sites/{{site_id}}/drives"
          inputParameters:
            - name: site_id
              in: path
          operations:
            - name: list-documents
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Monitors Snowflake for stale or failed data pipeline runs across trading, production, and refinery data domains, and opens Jira tasks for SLA breaches.

naftiko: "0.5"
info:
  label: "Snowflake Production Data Pipeline Health Check"
  description: "Monitors Snowflake for stale or failed data pipeline runs across trading, production, and refinery data domains, and opens Jira tasks for SLA breaches."
  tags:
    - data
    - analytics
    - snowflake
    - jira
    - monitoring
    - data-quality
    - oil-gas
capability:
  exposes:
    - type: mcp
      namespace: data-ops
      port: 8080
      tools:
        - name: check-pipeline-health
          description: "Given a Snowflake task name and SLA threshold in minutes, check if the pipeline completed within SLA and create a Jira task if breached. Use for monitoring oil production, trading, and refinery data pipelines."
          inputParameters:
            - name: pipeline_name
              in: body
              type: string
              description: "The Snowflake task or pipeline name, e.g. 'CRUDE_PRODUCTION_DAILY_LOAD'."
            - name: sla_minutes
              in: body
              type: integer
              description: "Maximum allowed minutes since last successful run."
          steps:
            - name: check-run
              type: call
              call: "snowflake.query-task-history"
              with:
                task_name: "{{pipeline_name}}"
            - name: create-task
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Task"
                summary: "Pipeline SLA breach: {{pipeline_name}} exceeded {{sla_minutes}} minutes"
                description: "Pipeline: {{pipeline_name}}\nLast successful run: {{check-run.last_success_time}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: task-history
          path: "/databases/bp/schemas/monitoring/tasks/{{task_name}}/history"
          inputParameters:
            - name: task_name
              in: path
          operations:
            - name: query-task-history
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://bp.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

Executes a read-only SQL query against the BP Snowflake data warehouse and returns the result set.

naftiko: "0.5"
info:
  label: "Snowflake Query Executor"
  description: "Executes a read-only SQL query against the BP Snowflake data warehouse and returns the result set."
  tags:
    - data
    - snowflake
    - analytics
capability:
  exposes:
    - type: mcp
      namespace: data
      port: 8080
      tools:
        - name: execute-query
          description: "Given a SQL statement, execute it against the BP Snowflake warehouse and return the result set. Use for ad-hoc analytics, data validation, and reporting queries."
          inputParameters:
            - name: sql_statement
              in: body
              type: string
              description: "The read-only SQL query to execute."
          call: "snowflake.execute-statement"
          with:
            statement: "{{sql_statement}}"
          outputParameters:
            - name: row_count
              type: integer
              mapping: "$.data.rowCount"
            - name: rows
              type: array
              mapping: "$.data.rows"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

Executes data quality validation rules on trading and commodity price data in Snowflake and creates Jira tasks for any validation failures found.

naftiko: "0.5"
info:
  label: "Snowflake Trading Data Quality Monitor"
  description: "Executes data quality validation rules on trading and commodity price data in Snowflake and creates Jira tasks for any validation failures found."
  tags:
    - data
    - analytics
    - snowflake
    - jira
    - data-quality
    - trading
capability:
  exposes:
    - type: mcp
      namespace: trading-data-ops
      port: 8080
      tools:
        - name: validate-trading-data
          description: "Given a Snowflake trading data schema and business date, execute data quality checks for completeness and consistency of commodity price feeds, and create Jira tasks for any failures. Use daily before trading operations open."
          inputParameters:
            - name: trading_schema
              in: body
              type: string
              description: "The Snowflake schema containing trading data, e.g. 'TRADING.CRUDE_PRICES'."
            - name: business_date
              in: body
              type: string
              description: "The trading business date to validate in ISO 8601 format."
          steps:
            - name: run-validation
              type: call
              call: "snowflake.execute-validation"
              with:
                schema: "{{trading_schema}}"
                date: "{{business_date}}"
            - name: create-dq-task
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "Trading data quality failure: {{trading_schema}} for {{business_date}}"
                description: "Schema: {{trading_schema}}\nDate: {{business_date}}\nFailed checks: {{run-validation.failed_count}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: sql-statements
          path: "/statements"
          operations:
            - name: execute-validation
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://bp.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 SolarWinds detects a network device outage, creates a ServiceNow P1 incident, logs the event in Splunk, and notifies the network operations center via Microsoft Teams.

naftiko: "0.5"
info:
  label: "SolarWinds Network Outage Responder"
  description: "When SolarWinds detects a network device outage, creates a ServiceNow P1 incident, logs the event in Splunk, and notifies the network operations center via Microsoft Teams."
  tags:
    - networking
    - solarwinds
    - servicenow
    - splunk
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: network-ops
      port: 8080
      tools:
        - name: handle-network-outage
          description: "Given a SolarWinds node ID and alert description, create an incident, log the event, and notify NOC. Use when network devices go offline."
          inputParameters:
            - name: node_id
              in: body
              type: string
              description: "The SolarWinds node ID."
            - name: alert_description
              in: body
              type: string
              description: "Description of the network alert."
          steps:
            - name: create-incident
              type: call
              call: "servicenow.create-incident"
              with:
                category: "network"
                priority: "1"
                short_description: "Network outage: node {{node_id}} - {{alert_description}}"
            - name: log-event
              type: call
              call: "splunk.index-event"
              with:
                index: "network"
                event: "SolarWinds outage: node {{node_id}}, {{alert_description}}"
            - name: notify-noc
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_noc_channel"
                text: "NETWORK OUTAGE: Node {{node_id}} - {{alert_description}}. Incident: {{create-incident.number}}."
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: splunk
      baseUri: "https://bp-splunk.example.com:8089/services"
      authentication:
        type: bearer
        token: "$secrets.splunk_token"
      resources:
        - name: events
          path: "/receivers/simple"
          operations:
            - name: index-event
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Executes a Splunk search query and returns the matching log events for a given time range.

naftiko: "0.5"
info:
  label: "Splunk Log Search"
  description: "Executes a Splunk search query and returns the matching log events for a given time range."
  tags:
    - security
    - splunk
    - logging
capability:
  exposes:
    - type: mcp
      namespace: security
      port: 8080
      tools:
        - name: search-logs
          description: "Given a Splunk search query and time range, execute the search and return matching events. Use for security investigations, troubleshooting, and audit log review."
          inputParameters:
            - name: search_query
              in: body
              type: string
              description: "The Splunk SPL search query."
            - name: earliest_time
              in: body
              type: string
              description: "Search start time, e.g. '-24h'."
          call: "splunk.create-search"
          with:
            search: "{{search_query}}"
            earliest_time: "{{earliest_time}}"
          outputParameters:
            - name: result_count
              type: integer
              mapping: "$.entry.content.resultCount"
            - name: sid
              type: string
              mapping: "$.entry.content.sid"
  consumes:
    - type: http
      namespace: splunk
      baseUri: "https://bp-splunk.example.com:8089/services"
      authentication:
        type: bearer
        token: "$secrets.splunk_token"
      resources:
        - name: searches
          path: "/search/jobs"
          operations:
            - name: create-search
              method: POST

Triggers a Tableau extract refresh, validates data freshness in Snowflake, and sends the dashboard link to executives via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Tableau Executive Dashboard Auto-Refresh"
  description: "Triggers a Tableau extract refresh, validates data freshness in Snowflake, and sends the dashboard link to executives via Microsoft Teams."
  tags:
    - analytics
    - tableau
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: exec-reporting
      port: 8080
      tools:
        - name: refresh-executive-dashboard
          description: "Given a Tableau workbook ID, trigger an extract refresh, validate source data freshness, and notify executives. Use for daily executive dashboard preparation."
          inputParameters:
            - name: workbook_id
              in: body
              type: string
              description: "The Tableau workbook ID."
          steps:
            - name: validate-data
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT MAX(updated_at) as last_update FROM EXEC.DASHBOARD_SOURCE_DATA"
            - name: trigger-refresh
              type: call
              call: "tableau.refresh-extract"
              with:
                workbook_id: "{{workbook_id}}"
            - name: notify-executives
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_executive_channel"
                text: "Executive dashboard refreshed. Data as of {{validate-data.last_update}}. Refresh status: {{trigger-refresh.status}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: tableau
      baseUri: "https://bp-tableau.example.com/api/3.21"
      authentication:
        type: bearer
        token: "$secrets.tableau_token"
      resources:
        - name: workbooks
          path: "/sites/$secrets.tableau_site_id/workbooks/{{workbook_id}}/refresh"
          inputParameters:
            - name: workbook_id
              in: path
          operations:
            - name: refresh-extract
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Compares row counts and checksums between Teradata source tables and Snowflake target tables, logs results, and alerts the data engineering team via Microsoft Teams if discrepancies are found.

naftiko: "0.5"
info:
  label: "Teradata to Snowflake Data Migration Validator"
  description: "Compares row counts and checksums between Teradata source tables and Snowflake target tables, logs results, and alerts the data engineering team via Microsoft Teams if discrepancies are found."
  tags:
    - data-engineering
    - teradata
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: data-migration
      port: 8080
      tools:
        - name: validate-migration
          description: "Given source and target table names, compare row counts and checksums between Teradata and Snowflake. Use during data warehouse migration validation."
          inputParameters:
            - name: source_table
              in: body
              type: string
              description: "The Teradata source table name."
            - name: target_table
              in: body
              type: string
              description: "The Snowflake target table name."
          steps:
            - name: get-source-count
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT COUNT(*) as row_count FROM {{source_table}}@teradata_link"
            - name: get-target-count
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT COUNT(*) as row_count FROM {{target_table}}"
            - name: log-results
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO MIGRATION.VALIDATION_LOG VALUES ('{{source_table}}', '{{target_table}}', {{get-source-count.row_count}}, {{get-target-count.row_count}}, CURRENT_TIMESTAMP)"
            - name: notify-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_data_engineering_channel"
                text: "Migration validation: {{source_table}} -> {{target_table}}. Source rows: {{get-source-count.row_count}}, Target rows: {{get-target-count.row_count}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Scans SAP Ariba for vendor contracts expiring within 90 days, creates a Jira task for procurement review, and sends a summary digest to the procurement team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Vendor Contract Renewal Alert"
  description: "Scans SAP Ariba for vendor contracts expiring within 90 days, creates a Jira task for procurement review, and sends a summary digest to the procurement team via Microsoft Teams."
  tags:
    - procurement
    - sap
    - jira
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: procurement-ops
      port: 8080
      tools:
        - name: scan-contract-renewals
          description: "Given a lookback window in days, scan SAP Ariba for contracts nearing expiration, create Jira review tasks, and notify procurement. Use for proactive contract management."
          inputParameters:
            - name: days_to_expiry
              in: body
              type: integer
              description: "Number of days until contract expiration to scan, e.g. 90."
          steps:
            - name: get-expiring-contracts
              type: call
              call: "sap-ariba.get-contracts"
              with:
                days_to_expiry: "{{days_to_expiry}}"
            - name: create-review-task
              type: call
              call: "jira.create-issue"
              with:
                project: "PROC"
                issue_type: "Task"
                summary: "Contract renewals due within {{days_to_expiry}} days: {{get-expiring-contracts.count}} contracts"
            - name: notify-procurement
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_procurement_channel"
                text: "{{get-expiring-contracts.count}} vendor contracts expire within {{days_to_expiry}} days. Review task: {{create-review-task.key}}."
  consumes:
    - type: http
      namespace: sap-ariba
      baseUri: "https://bp.procurement.ariba.com/api"
      authentication:
        type: bearer
        token: "$secrets.ariba_token"
      resources:
        - name: contracts
          path: "/contracts?expiring_within={{days_to_expiry}}"
          inputParameters:
            - name: days_to_expiry
              in: query
          operations:
            - name: get-contracts
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Collects VMware vCenter cluster utilization metrics, stores them in Snowflake, and sends a weekly capacity planning digest to the infrastructure team via Microsoft Teams.

naftiko: "0.5"
info:
  label: "VMware Capacity Planning Report"
  description: "Collects VMware vCenter cluster utilization metrics, stores them in Snowflake, and sends a weekly capacity planning digest to the infrastructure team via Microsoft Teams."
  tags:
    - infrastructure
    - vmware
    - snowflake
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: infra-capacity
      port: 8080
      tools:
        - name: generate-capacity-report
          description: "Given a vCenter cluster name, collect CPU, memory, and storage utilization, store in Snowflake, and send a digest. Use for weekly infrastructure capacity reviews."
          inputParameters:
            - name: cluster_name
              in: body
              type: string
              description: "The VMware vCenter cluster name."
          steps:
            - name: get-cluster-metrics
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT AVG(cpu_pct) as avg_cpu, AVG(mem_pct) as avg_mem, AVG(storage_pct) as avg_storage FROM INFRA.VMWARE_METRICS WHERE cluster = '{{cluster_name}}' AND metric_date >= DATEADD(day, -7, CURRENT_DATE)"
            - name: log-report
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO INFRA.CAPACITY_REPORTS VALUES ('{{cluster_name}}', {{get-cluster-metrics.avg_cpu}}, {{get-cluster-metrics.avg_mem}}, {{get-cluster-metrics.avg_storage}}, CURRENT_TIMESTAMP)"
            - name: notify-infra
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_infra_channel"
                text: "Weekly capacity for {{cluster_name}}: CPU {{get-cluster-metrics.avg_cpu}}%, Memory {{get-cluster-metrics.avg_mem}}%, Storage {{get-cluster-metrics.avg_storage}}%."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Ingests well integrity test results from the field, stores them in Snowflake, updates the SAP asset record, and alerts the well integrity team via Microsoft Teams if any test fails.

naftiko: "0.5"
info:
  label: "Well Integrity Test Result Processor"
  description: "Ingests well integrity test results from the field, stores them in Snowflake, updates the SAP asset record, and alerts the well integrity team via Microsoft Teams if any test fails."
  tags:
    - operations
    - energy
    - snowflake
    - sap
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: well-integrity
      port: 8080
      tools:
        - name: process-test-result
          description: "Given a well ID and test result payload, store results in Snowflake, update the SAP equipment record, and alert if failure detected. Use after field well integrity tests."
          inputParameters:
            - name: well_id
              in: body
              type: string
              description: "The well identifier, e.g. 'WELL-GOM-0042'."
            - name: test_result
              in: body
              type: string
              description: "Test result: PASS or FAIL."
            - name: test_date
              in: body
              type: string
              description: "Test date in YYYY-MM-DD format."
          steps:
            - name: store-result
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO OPERATIONS.WELL_INTEGRITY_TESTS VALUES ('{{well_id}}', '{{test_result}}', '{{test_date}}')"
            - name: update-sap-asset
              type: call
              call: "sap.update-equipment"
              with:
                equipment_id: "{{well_id}}"
                last_test_date: "{{test_date}}"
                test_status: "{{test_result}}"
            - name: alert-team
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_well_integrity_channel"
                text: "Well integrity test for {{well_id}} on {{test_date}}: {{test_result}}. SAP asset updated."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_EQUIPMENT"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: equipment
          path: "/Equipment('{{equipment_id}}')"
          inputParameters:
            - name: equipment_id
              in: path
          operations:
            - name: update-equipment
              method: PATCH
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a compensation change is submitted in Workday, validates budget in SAP, routes for manager approval via Microsoft Teams, and logs the decision in Snowflake.

naftiko: "0.5"
info:
  label: "Workday Compensation Change Approval Workflow"
  description: "When a compensation change is submitted in Workday, validates budget in SAP, routes for manager approval via Microsoft Teams, and logs the decision in Snowflake."
  tags:
    - hr
    - compensation
    - workday
    - sap
    - microsoft-teams
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: compensation-mgmt
      port: 8080
      tools:
        - name: process-comp-change
          description: "Given a Workday employee ID and proposed compensation amount, validate budget availability, send approval request, and log the outcome. Use for compensation change requests."
          inputParameters:
            - name: worker_id
              in: body
              type: string
              description: "The Workday worker ID."
            - name: proposed_amount
              in: body
              type: string
              description: "The proposed new compensation amount."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{worker_id}}"
            - name: check-budget
              type: call
              call: "sap.get-cost-center-budget"
              with:
                cost_center: "{{get-employee.cost_center}}"
            - name: request-approval
              type: call
              call: "msteams.send-message"
              with:
                recipient_upn: "{{get-employee.manager_email}}"
                text: "Compensation change request for {{get-employee.full_name}}: proposed {{proposed_amount}}. Current budget remaining: {{check-budget.remaining_budget}}. Please approve or deny."
            - name: log-request
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO HR.COMP_CHANGE_REQUESTS VALUES ('{{worker_id}}', '{{proposed_amount}}', '{{check-budget.remaining_budget}}', CURRENT_TIMESTAMP)"
  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: "/bp/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: sap
      baseUri: "https://bp-s4.sap.com/sap/opu/odata/sap/API_COSTCENTER_SRV"
      authentication:
        type: basic
        username: "$secrets.sap_user"
        password: "$secrets.sap_password"
      resources:
        - name: budgets
          path: "/A_CostCenterBudget('{{cost_center}}')"
          inputParameters:
            - name: cost_center
              in: path
          operations:
            - name: get-cost-center-budget
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/users/{{recipient_upn}}/sendMail"
          inputParameters:
            - name: recipient_upn
              in: path
          operations:
            - name: send-message
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://bp.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

Extracts diversity and inclusion metrics from Workday, aggregates them in Snowflake, refreshes the Power BI dashboard, and distributes the report to HR leadership via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Workday Diversity Metrics Quarterly Report"
  description: "Extracts diversity and inclusion metrics from Workday, aggregates them in Snowflake, refreshes the Power BI dashboard, and distributes the report to HR leadership via Microsoft Teams."
  tags:
    - hr
    - diversity
    - workday
    - snowflake
    - power-bi
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: dei-reporting
      port: 8080
      tools:
        - name: generate-dei-report
          description: "Given a fiscal quarter and region, extract DEI metrics, aggregate data, and distribute the report. Use for quarterly diversity and inclusion reporting."
          inputParameters:
            - name: fiscal_quarter
              in: body
              type: string
              description: "Fiscal quarter in YYYY-QN format."
            - name: region
              in: body
              type: string
              description: "Region filter, e.g. 'Global', 'North_America', 'Europe'."
          steps:
            - name: extract-metrics
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "CALL HR.EXTRACT_DEI_METRICS('{{fiscal_quarter}}', '{{region}}')"
            - name: refresh-dashboard
              type: call
              call: "powerbi.trigger-refresh"
              with:
                dataset_id: "$secrets.powerbi_dei_dataset_id"
            - name: notify-hr-leadership
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_hr_leadership_channel"
                text: "Q{{fiscal_quarter}} DEI report for {{region}} is ready. Dashboard refreshed: {{refresh-dashboard.status}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://bp.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: powerbi
      baseUri: "https://api.powerbi.com/v1.0/myorg"
      authentication:
        type: bearer
        token: "$secrets.powerbi_token"
      resources:
        - name: datasets
          path: "/datasets/{{dataset_id}}/refreshes"
          inputParameters:
            - name: dataset_id
              in: path
          operations:
            - name: trigger-refresh
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Returns the current headcount by business unit and cost center from Workday for workforce planning and finance reporting.

naftiko: "0.5"
info:
  label: "Workday Headcount Snapshot"
  description: "Returns the current headcount by business unit and cost center from Workday for workforce planning and finance reporting."
  tags:
    - hr
    - finance
    - workday
    - reporting
    - headcount
capability:
  exposes:
    - type: mcp
      namespace: hr-reporting
      port: 8080
      tools:
        - name: get-headcount-snapshot
          description: "Returns all active BP employees grouped by business unit and cost center from Workday. Use for headcount planning, workforce analytics, and finance budgeting."
          call: "workday.list-workers"
          outputParameters:
            - name: employees
              type: array
              mapping: "$.data[*]"
  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: "/bp/workers"
          operations:
            - name: list-workers
              method: GET

Checks Workday Learning for employees with overdue mandatory training, creates ServiceNow tasks for follow-up, and notifies managers via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Workday Learning Compliance Tracker"
  description: "Checks Workday Learning for employees with overdue mandatory training, creates ServiceNow tasks for follow-up, and notifies managers via Microsoft Teams."
  tags:
    - hr
    - compliance
    - workday
    - servicenow
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: learning-compliance
      port: 8080
      tools:
        - name: track-overdue-training
          description: "Given a training program ID and grace period, identify employees with overdue mandatory training, create follow-up tasks, and notify managers. Use for compliance training enforcement."
          inputParameters:
            - name: program_id
              in: body
              type: string
              description: "The Workday Learning program ID."
            - name: grace_days
              in: body
              type: integer
              description: "Number of grace days past due date."
          steps:
            - name: get-overdue-learners
              type: call
              call: "workday.get-overdue-training"
              with:
                program_id: "{{program_id}}"
                grace_days: "{{grace_days}}"
            - name: create-followup
              type: call
              call: "servicenow.create-request"
              with:
                category: "compliance"
                short_description: "Overdue training: {{get-overdue-learners.count}} employees past due on {{program_id}}"
            - name: notify-managers
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_hr_compliance_channel"
                text: "{{get-overdue-learners.count}} employees overdue on training program {{program_id}} (grace: {{grace_days}} days). Follow-up: {{create-followup.number}}."
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: training
          path: "/bp/learning/overdueTraining"
          operations:
            - name: get-overdue-training
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://bp.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Initiates a performance review cycle in Workday for a BP business unit, creates a Jira tracking epic, and notifies HR business partners via Teams.

naftiko: "0.5"
info:
  label: "Workday Performance Review Cycle Kickoff"
  description: "Initiates a performance review cycle in Workday for a BP business unit, creates a Jira tracking epic, and notifies HR business partners via Teams."
  tags:
    - hr
    - performance-management
    - workday
    - jira
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: hr-performance
      port: 8080
      tools:
        - name: kickoff-review-cycle
          description: "Given a Workday business unit ID and review cycle period, initiate the performance review in Workday, create a Jira epic to track the cycle, and notify HR BPs in Teams. Use at the start of each semi-annual performance review."
          inputParameters:
            - name: business_unit_id
              in: body
              type: string
              description: "The Workday business unit ID, e.g. 'BU-UPSTREAM-AMERICAS'."
            - name: review_period
              in: body
              type: string
              description: "The performance review period, e.g. 'H2-2026'."
          steps:
            - name: initiate-review
              type: call
              call: "workday.create-review-process"
              with:
                business_unit_id: "{{business_unit_id}}"
                period: "{{review_period}}"
            - name: create-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "HR"
                issuetype: "Epic"
                summary: "Performance Review {{review_period}} — {{business_unit_id}}"
            - name: notify-hrbp
              type: call
              call: "msteams.post-channel-message"
              with:
                channel_id: "$secrets.hrbp_channel_id"
                text: "Performance review {{review_period}} initiated for {{business_unit_id}}. Jira epic: {{create-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: review-processes
          path: "/bp/performanceManagement/reviewProcesses"
          operations:
            - name: create-review-process
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: channel-messages
          path: "/teams/{{team_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: post-channel-message
              method: POST

Looks up a Workday worker profile by employee ID, returning name, title, department, and manager information.

naftiko: "0.5"
info:
  label: "Workday Worker Profile Lookup"
  description: "Looks up a Workday worker profile by employee ID, returning name, title, department, and manager information."
  tags:
    - hr
    - workday
    - employee-data
capability:
  exposes:
    - type: mcp
      namespace: hr
      port: 8080
      tools:
        - name: get-worker-profile
          description: "Given a Workday employee ID, retrieve the worker's full profile including job title, department, and reporting chain. Use for HR inquiries and org chart lookups."
          inputParameters:
            - name: worker_id
              in: body
              type: string
              description: "The Workday worker ID, e.g. 'WD-100234'."
          call: "workday.get-worker"
          with:
            worker_id: "{{worker_id}}"
          outputParameters:
            - name: full_name
              type: string
              mapping: "$.worker.fullName"
            - name: job_title
              type: string
              mapping: "$.worker.jobTitle"
            - name: department
              type: string
              mapping: "$.worker.department"
  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: "/bp/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET

After a Zoom meeting ends, retrieves the recording transcript, creates Jira action items from identified tasks, and sends a summary to attendees via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Zoom Meeting Action Item Tracker"
  description: "After a Zoom meeting ends, retrieves the recording transcript, creates Jira action items from identified tasks, and sends a summary to attendees via Microsoft Teams."
  tags:
    - collaboration
    - zoom
    - jira
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: meeting-ops
      port: 8080
      tools:
        - name: track-action-items
          description: "Given a Zoom meeting ID, retrieve the transcript, extract action items, create Jira tickets, and notify attendees. Use after important project meetings."
          inputParameters:
            - name: meeting_id
              in: body
              type: string
              description: "The Zoom meeting ID."
          steps:
            - name: get-transcript
              type: call
              call: "zoom.get-meeting-transcript"
              with:
                meeting_id: "{{meeting_id}}"
            - name: create-action-items
              type: call
              call: "jira.create-issue"
              with:
                project: "BPOPS"
                issue_type: "Task"
                summary: "Action items from Zoom meeting {{meeting_id}}"
                description: "{{get-transcript.summary}}"
            - name: notify-attendees
              type: call
              call: "msteams.send-message"
              with:
                channel_id: "$secrets.teams_general_channel"
                text: "Meeting {{meeting_id}} action items captured in Jira: {{create-action-items.key}}. Summary: {{get-transcript.summary}}"
  consumes:
    - type: http
      namespace: zoom
      baseUri: "https://api.zoom.us/v2"
      authentication:
        type: bearer
        token: "$secrets.zoom_token"
      resources:
        - name: meetings
          path: "/meetings/{{meeting_id}}/recordings"
          inputParameters:
            - name: meeting_id
              in: path
          operations:
            - name: get-meeting-transcript
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://bp.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msgraph_token"
      resources:
        - name: messages
          path: "/teams/$secrets.teams_team_id/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST