Palantir Capabilities

Given a document URL or Confluence page ID, retrieves the content and generates an executive summary using Anthropic Claude, then posts it to a Teams channel.

naftiko: "0.5"
info:
  label: "AI-Assisted Document Summarization"
  description: "Given a document URL or Confluence page ID, retrieves the content and generates an executive summary using Anthropic Claude, then posts it to a Teams channel."
  tags:
    - ai
    - automation
    - anthropic
    - confluence
    - microsoft-teams
    - summarization
capability:
  exposes:
    - type: mcp
      namespace: ai-assist
      port: 8080
      tools:
        - name: summarize-document
          description: "Given a Confluence page ID, retrieve the page content, generate a concise executive summary via Anthropic Claude, and post the summary to a Teams channel."
          inputParameters:
            - name: confluence_page_id
              in: body
              type: string
              description: "The Confluence page ID to summarize."
            - name: teams_channel_id
              in: body
              type: string
              description: "The Teams channel ID where the summary should be posted."
          steps:
            - name: get-page
              type: call
              call: confluence.get-page
              with:
                page_id: "{{confluence_page_id}}"
            - name: generate-summary
              type: call
              call: anthropic.create-message
              with:
                model: "claude-3-5-sonnet-20241022"
                prompt: "Summarize the following document in 3-5 bullet points for an executive audience:\n\n{{get-page.body}}"
            - name: post-summary
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{teams_channel_id}}"
                text: "Summary of '{{get-page.title}}':\n{{generate-summary.content}}"
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: pages
          path: "/content/{{page_id}}"
          inputParameters:
            - name: page_id
              in: path
          operations:
            - name: get-page
              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: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a new ServiceNow incident is created, generates an AI-powered triage recommendation using Anthropic Claude and appends it as a work note on the incident.

naftiko: "0.5"
info:
  label: "AI-Assisted Incident Triage"
  description: "When a new ServiceNow incident is created, generates an AI-powered triage recommendation using Anthropic Claude and appends it as a work note on the incident."
  tags:
    - itsm
    - ai
    - servicenow
    - anthropic
    - incident-response
    - automation
capability:
  exposes:
    - type: mcp
      namespace: ai-triage
      port: 8080
      tools:
        - name: triage-incident
          description: "Given a ServiceNow incident number and description, generate an AI triage recommendation with likely cause, priority suggestion, and routing advice, then append it to the incident as a work note."
          inputParameters:
            - name: incident_number
              in: body
              type: string
              description: "The ServiceNow incident number to triage (e.g., 'INC0045678')."
            - name: incident_description
              in: body
              type: string
              description: "The full incident description text to analyze."
          steps:
            - name: generate-triage
              type: call
              call: anthropic.create-message
              with:
                model: "claude-3-5-sonnet-20241022"
                prompt: "You are an IT operations expert. Analyze this incident and provide: 1) Likely cause, 2) Recommended priority (P1-P4), 3) Best assignment group. Incident: {{incident_description}}"
            - name: add-work-note
              type: call
              call: servicenow.update-incident
              with:
                number: "{{incident_number}}"
                work_notes: "AI Triage Recommendation:\n{{generate-triage.content}}"
  consumes:
    - type: http
      namespace: anthropic
      baseUri: "https://api.anthropic.com/v1"
      authentication:
        type: apikey
        key: "x-api-key"
        value: "$secrets.anthropic_api_key"
        placement: header
      resources:
        - name: messages
          path: "/messages"
          operations:
            - name: create-message
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          inputParameters:
            - name: number
              in: query
          operations:
            - name: update-incident
              method: PATCH

Updates an AIP agent configuration by validating the new prompt template in Foundry, deploying the updated config, running a test suite, and notifying the team via Slack with test results.

naftiko: "0.5"
info:
  label: "AIP Agent Configuration Update Orchestrator"
  description: "Updates an AIP agent configuration by validating the new prompt template in Foundry, deploying the updated config, running a test suite, and notifying the team via Slack with test results."
  tags:
    - data-analytics
    - aip
    - foundry
    - slack
capability:
  exposes:
    - type: mcp
      namespace: aip-config
      port: 8080
      tools:
        - name: update-agent-config
          description: "Orchestrate AIP agent config update: validate template, deploy, test, and notify."
          inputParameters:
            - name: agent_rid
              in: body
              type: string
              description: "The AIP agent resource identifier."
            - name: prompt_template
              in: body
              type: string
              description: "The new prompt template content."
          steps:
            - name: validate-template
              type: call
              call: "foundry.validate-prompt-template"
              with:
                agent_rid: "{{agent_rid}}"
                template: "{{prompt_template}}"
            - name: deploy-config
              type: call
              call: "foundry.update-agent-config"
              with:
                agent_rid: "{{agent_rid}}"
                template: "{{prompt_template}}"
            - name: run-tests
              type: call
              call: "foundry.run-agent-tests"
              with:
                agent_rid: "{{agent_rid}}"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "aip-agents"
                text: "Agent {{agent_rid}} config updated. Tests: {{run-tests.passed}}/{{run-tests.total}} passed."
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: agents
          path: "/aip/agents/{{agent_rid}}"
          inputParameters:
            - name: agent_rid
              in: path
          operations:
            - name: validate-prompt-template
              method: POST
            - name: update-agent-config
              method: PUT
            - name: run-agent-tests
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Deploys an AIP agent by validating configuration, running tests, and notifying the team via Slack.

naftiko: "0.5"
info:
  label: "AIP Agent Deployment Orchestrator"
  description: "Deploys an AIP agent by validating configuration, running tests, and notifying the team via Slack."
  tags:
    - ai
    - foundry
    - slack
capability:
  exposes:
    - type: mcp
      namespace: aip-agent-deployment
      port: 8080
      tools:
        - name: aip-agent-deployment
          description: "Deploys an AIP agent by validating configuration."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "AIP Agent Deployment processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors Palantir AIP agent executions, tracks success rates, and posts operational metrics to Slack.

naftiko: "0.5"
info:
  label: "AIP Agent Execution Monitor"
  description: "Monitors Palantir AIP agent executions, tracks success rates, and posts operational metrics to Slack."
  tags:
    - ai
    - aip
    - palantir
    - monitoring
    - slack
capability:
  exposes:
    - type: mcp
      namespace: aip-monitor
      port: 8080
      tools:
        - name: monitor-aip-agents
          description: "Query AIP agent execution history and post operational metrics."
          inputParameters:
            - name: agent_name
              in: body
              type: string
              description: "AIP agent name."
            - name: hours
              in: body
              type: string
              description: "Hours to look back."
          steps:
            - name: get-executions
              type: call
              call: "foundry.get-agent-executions"
              with:
                agentName: "{{agent_name}}"
                lookback: "{{hours}}"
            - name: post-metrics
              type: call
              call: "slack.post-message"
              with:
                channel: "aip-ops"
                text: "AIP Agent Monitor: {{agent_name}} | Executions: {{get-executions.total}} | Success: {{get-executions.success_rate}}% | Avg latency: {{get-executions.avg_latency_ms}}ms"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: agents
          path: "/aip/agents/{{agentName}}/executions"
          inputParameters:
            - name: agentName
              in: path
            - name: lookback
              in: query
          operations:
            - name: get-agent-executions
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the operational status of a Palantir AIP agent.

naftiko: "0.5"
info:
  label: "AIP Agent Status Lookup"
  description: "Retrieves the operational status of a Palantir AIP agent."
  tags:
    - ai
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: aip-status
      port: 8080
      tools:
        - name: get-agent-status
          description: "Look up AIP agent operational status."
          inputParameters:
            - name: agent_id
              in: body
              type: string
              description: "AIP agent identifier."
          call: "foundry.get-agent-status"
          with:
            agent_id: "{{agent_id}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.agent.status"
            - name: last_run
              type: string
              mapping: "$.agent.lastExecution"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: agents
          path: "/aip/agents/{{agent_id}}"
          inputParameters:
            - name: agent_id
              in: path
          operations:
            - name: get-agent-status
              method: GET

Retrieves the definition and execution history of an AIP Logic function, returning function name, last execution time, and success rate.

naftiko: "0.5"
info:
  label: "AIP Logic Function Lookup"
  description: "Retrieves the definition and execution history of an AIP Logic function, returning function name, last execution time, and success rate."
  tags:
    - data-analytics
    - aip
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: aip-platform
      port: 8080
      tools:
        - name: get-logic-function
          description: "Look up an AIP Logic function definition and execution stats."
          inputParameters:
            - name: function_rid
              in: body
              type: string
              description: "The Logic function resource identifier."
          call: "foundry.get-logic-function"
          with:
            function_rid: "{{function_rid}}"
          outputParameters:
            - name: function_name
              type: string
              mapping: "$.name"
            - name: last_execution
              type: string
              mapping: "$.lastExecution.timestamp"
            - name: success_rate_pct
              type: number
              mapping: "$.metrics.successRate"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: logic-functions
          path: "/functions/{{function_rid}}"
          inputParameters:
            - name: function_rid
              in: path
          operations:
            - name: get-logic-function
              method: GET

Evaluates AIP model outputs, compares against benchmarks in Foundry, and publishes evaluation report to Confluence.

naftiko: "0.5"
info:
  label: "AIP Model Evaluation Orchestrator"
  description: "Evaluates AIP model outputs, compares against benchmarks in Foundry, and publishes evaluation report to Confluence."
  tags:
    - ai
    - foundry
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: aip-model-evaluation
      port: 8080
      tools:
        - name: aip-model-evaluation
          description: "Evaluates AIP model outputs."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: publish
              type: call
              call: "confluence.create-page"
              with:
                space_key: "PLAT"
                title: "AIP Model Evaluation"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: content
          path: "/content"
          operations:
            - name: create-page
              method: POST

Reviews AIP prompt templates for compliance, logs reviews in ServiceNow, and publishes guidelines to Confluence.

naftiko: "0.5"
info:
  label: "AIP Prompt Template Review Orchestrator"
  description: "Reviews AIP prompt templates for compliance, logs reviews in ServiceNow, and publishes guidelines to Confluence."
  tags:
    - ai
    - foundry
    - servicenow
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: aip-prompt-template-revie
      port: 8080
      tools:
        - name: aip-prompt-template-review
          description: "Reviews AIP prompt templates for compliance."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "AIP Prompt Template Review for {{entity_id}}"
            - name: publish
              type: call
              call: "confluence.create-page"
              with:
                space_key: "PLAT"
                title: "AIP Prompt Template Review"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
        - name: changes
          path: "/table/change_request"
          operations:
            - name: create-change
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: content
          path: "/content"
          operations:
            - name: create-page
              method: POST

Pulls AWS cost and usage reports, maps costs to Foundry projects using tag-based allocation, stores the results in a Foundry dataset, and sends a weekly cost summary to Slack.

naftiko: "0.5"
info:
  label: "AWS Cost Allocation to Foundry Orchestrator"
  description: "Pulls AWS cost and usage reports, maps costs to Foundry projects using tag-based allocation, stores the results in a Foundry dataset, and sends a weekly cost summary to Slack."
  tags:
    - data-analytics
    - aws
    - foundry
    - finance
    - slack
capability:
  exposes:
    - type: mcp
      namespace: cloud-cost
      port: 8080
      tools:
        - name: allocate-aws-costs
          description: "Orchestrate AWS cost allocation: pull costs, map to projects, store in Foundry, and summarize."
          inputParameters:
            - name: billing_period
              in: body
              type: string
              description: "Billing period in YYYY-MM format."
          steps:
            - name: get-cost-report
              type: call
              call: "aws-ce.get-cost-and-usage"
              with:
                period: "{{billing_period}}"
            - name: map-to-projects
              type: call
              call: "foundry.run-cost-allocation"
              with:
                cost_data: "{{get-cost-report.results}}"
            - name: store-allocations
              type: call
              call: "foundry.write-dataset"
              with:
                dataset_rid: "aws-cost-allocations"
                data: "{{map-to-projects.allocations}}"
            - name: post-summary
              type: call
              call: "slack.post-message"
              with:
                channel: "cloud-costs"
                text: "AWS costs for {{billing_period}}: ${{get-cost-report.total_cost}}. Top project: {{map-to-projects.top_project}} (${{map-to-projects.top_project_cost}})."
  consumes:
    - type: http
      namespace: aws-ce
      baseUri: "https://ce.us-east-1.amazonaws.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.aws_auth_header"
        placement: header
      resources:
        - name: cost-usage
          path: "/"
          operations:
            - name: get-cost-and-usage
              method: POST
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: transforms
          path: "/transforms/cost-allocation/execute"
          operations:
            - name: run-cost-allocation
              method: POST
        - name: datasets
          path: "/datasets/{{dataset_rid}}/records"
          inputParameters:
            - name: dataset_rid
              in: path
          operations:
            - name: write-dataset
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When AWS Cost Anomaly Detection raises an alert, annotates Datadog, opens a ServiceNow incident, and posts a cost alert to the FinOps Microsoft Teams channel.

naftiko: "0.5"
info:
  label: "AWS Cost Anomaly Responder"
  description: "When AWS Cost Anomaly Detection raises an alert, annotates Datadog, opens a ServiceNow incident, and posts a cost alert to the FinOps Microsoft Teams channel."
  tags:
    - finops
    - cloud
    - datadog
    - servicenow
    - microsoft-teams
    - aws
capability:
  exposes:
    - type: mcp
      namespace: finops
      port: 8080
      tools:
        - name: handle-cost-anomaly
          description: "Given an AWS cost anomaly ID, affected service, and estimated overage in USD, create a Datadog event annotation, open a ServiceNow incident, and post a FinOps Teams alert."
          inputParameters:
            - name: anomaly_id
              in: body
              type: string
              description: "The AWS Cost Anomaly Detection anomaly ID."
            - name: service
              in: body
              type: string
              description: "The AWS service generating the cost anomaly (e.g., 'EC2', 'S3')."
            - name: estimated_overage_usd
              in: body
              type: number
              description: "The estimated overage amount in US dollars."
          steps:
            - name: annotate-datadog
              type: call
              call: datadog.create-event
              with:
                title: "AWS Cost Anomaly: {{service}}"
                text: "Anomaly {{anomaly_id}} — estimated overage: ${{estimated_overage_usd}}"
                alert_type: "warning"
            - name: create-incident
              type: call
              call: servicenow.create-incident
              with:
                short_description: "AWS Cost Anomaly — {{service}} — ${{estimated_overage_usd}} overage"
                category: "cloud_cost"
                urgency: "2"
            - name: post-alert
              type: call
              call: msteams.send-message
              with:
                channel_id: "finops-alerts"
                text: "AWS Cost Anomaly: {{service}} | Overage: ${{estimated_overage_usd}} | SNOW: {{create-incident.number}} | Datadog: {{annotate-datadog.url}}"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Searches Confluence for pages matching a query and returns the top results with titles, excerpts, and URLs for agent-assisted knowledge retrieval.

naftiko: "0.5"
info:
  label: "Confluence Knowledge Base Search"
  description: "Searches Confluence for pages matching a query and returns the top results with titles, excerpts, and URLs for agent-assisted knowledge retrieval."
  tags:
    - knowledge-management
    - confluence
    - lookup
capability:
  exposes:
    - type: mcp
      namespace: knowledge-base
      port: 8080
      tools:
        - name: search-confluence
          description: "Given a search query and optional Confluence space key, search Confluence for matching pages and return titles, excerpts, and URLs."
          inputParameters:
            - name: query
              in: body
              type: string
              description: "The search query to find relevant Confluence pages."
            - name: space_key
              in: body
              type: string
              description: "Optional Confluence space key to scope the search (e.g., 'ENG', 'IT')."
          call: confluence.search-content
          with:
            cql: "text ~ \"{{query}}\" AND space = \"{{space_key}}\""
          outputParameters:
            - name: results
              type: array
              mapping: "$.results"
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: search
          path: "/content/search"
          inputParameters:
            - name: cql
              in: query
          operations:
            - name: search-content
              method: GET

Checks customer deployment health in Foundry, validates SLOs via Datadog, and publishes reports to Confluence.

naftiko: "0.5"
info:
  label: "Customer Deployment Health Check Orchestrator"
  description: "Checks customer deployment health in Foundry, validates SLOs via Datadog, and publishes reports to Confluence."
  tags:
    - operations
    - foundry
    - datadog
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: customer-deployment-healt
      port: 8080
      tools:
        - name: customer-deployment-health-check
          description: "Checks customer deployment health in Foundry."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: check-metrics
              type: call
              call: "datadog.get-monitors"
              with:
                entity_id: "{{entity_id}}"
            - name: publish
              type: call
              call: "confluence.create-page"
              with:
                space_key: "PLAT"
                title: "Customer Deployment Health Check"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          operations:
            - name: get-monitors
              method: GET
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: content
          path: "/content"
          operations:
            - name: create-page
              method: POST

When a new customer signs a contract in Salesforce, provisions a Foundry project, sets up data connections, creates an onboarding checklist in Jira, and notifies the customer success team via Slack.

naftiko: "0.5"
info:
  label: "Customer Onboarding Data Pipeline Orchestrator"
  description: "When a new customer signs a contract in Salesforce, provisions a Foundry project, sets up data connections, creates an onboarding checklist in Jira, and notifies the customer success team via Slack."
  tags:
    - data-analytics
    - salesforce
    - foundry
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: customer-onboarding
      port: 8080
      tools:
        - name: onboard-customer-data
          description: "Orchestrate customer data onboarding: provision Foundry project, set up connections, create checklist, and notify team."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity identifier."
          steps:
            - name: get-opportunity
              type: call
              call: "salesforce.get-opportunity"
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: provision-project
              type: call
              call: "foundry.create-project"
              with:
                name: "{{get-opportunity.account_name}}-data"
                description: "Data project for {{get-opportunity.account_name}}"
            - name: create-jira-checklist
              type: call
              call: "jira.create-issue"
              with:
                project: "ONBOARD"
                issue_type: "Epic"
                summary: "Data onboarding: {{get-opportunity.account_name}}"
                description: "Foundry project: {{provision-project.project_rid}}"
            - name: notify-cs-team
              type: call
              call: "slack.post-message"
              with:
                channel: "customer-success"
                text: "New customer data onboarding started: {{get-opportunity.account_name}}. Foundry project: {{provision-project.project_rid}}. Jira epic: {{create-jira-checklist.key}}."
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://palantir.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: projects
          path: "/projects"
          operations:
            - name: create-project
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Calculates customer health scores from Foundry data, updates Salesforce records, and alerts CSMs via Slack.

naftiko: "0.5"
info:
  label: "Customer Success Health Score Orchestrator"
  description: "Calculates customer health scores from Foundry data, updates Salesforce records, and alerts CSMs via Slack."
  tags:
    - sales
    - foundry
    - salesforce
    - slack
capability:
  exposes:
    - type: mcp
      namespace: customer-success-health-s
      port: 8080
      tools:
        - name: customer-success-health-score
          description: "Calculates customer health scores from Foundry data."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: update-sf
              type: call
              call: "salesforce.update-record"
              with:
                entity_id: "{{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Customer Success Health Score processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: salesforce
      baseUri: "https://palantir.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: objects
          path: "/sobjects"
          operations:
            - name: update-record
              method: PATCH
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Datadog monitor fires, creates a ServiceNow incident, opens a Jira bug, and posts a real-time alert to the engineering Microsoft Teams channel.

naftiko: "0.5"
info:
  label: "Datadog Monitor Alert Handler"
  description: "When a Datadog monitor fires, creates a ServiceNow incident, opens a Jira bug, and posts a real-time alert to the engineering Microsoft Teams channel."
  tags:
    - observability
    - datadog
    - servicenow
    - jira
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: observability-ops
      port: 8080
      tools:
        - name: handle-monitor-alert
          description: "Given a Datadog monitor ID, monitor name, and alert severity, create a ServiceNow incident and Jira bug, then post a Teams alert with all cross-system links."
          inputParameters:
            - name: monitor_id
              in: body
              type: string
              description: "The Datadog monitor ID that fired the alert."
            - name: monitor_name
              in: body
              type: string
              description: "The human-readable name of the Datadog monitor."
            - name: severity
              in: body
              type: string
              description: "Alert severity level: 'critical', 'warning', or 'info'."
            - name: affected_host
              in: body
              type: string
              description: "The hostname or service impacted by the alert."
          steps:
            - name: create-snow-incident
              type: call
              call: servicenow.create-incident
              with:
                short_description: "Datadog Alert: {{monitor_name}} on {{affected_host}}"
                category: "monitoring"
                urgency: "{{severity}}"
            - name: create-jira-bug
              type: call
              call: jira.create-issue
              with:
                project_key: "OPS"
                issuetype: "Bug"
                summary: "[Datadog] {{monitor_name}} — {{affected_host}}"
                description: "Monitor {{monitor_id}} fired at {{severity}}. SNOW: {{create-snow-incident.number}}"
            - name: post-alert
              type: call
              call: msteams.send-message
              with:
                channel_id: "engineering-alerts"
                text: "Datadog Alert [{{severity}}]: {{monitor_name}} | Host: {{affected_host}} | SNOW: {{create-snow-incident.number}} | Jira: {{create-jira-bug.key}}"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_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.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Fetches current SLO compliance status from Datadog for a service and posts a weekly report to the engineering leadership Teams channel.

naftiko: "0.5"
info:
  label: "Datadog SLO Compliance Report"
  description: "Fetches current SLO compliance status from Datadog for a service and posts a weekly report to the engineering leadership Teams channel."
  tags:
    - observability
    - datadog
    - slo
    - reporting
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: slo-reporting
      port: 8080
      tools:
        - name: publish-slo-report
          description: "Given a Datadog SLO ID and reporting period, fetch current compliance percentage and error budget remaining, then post a formatted report to Teams."
          inputParameters:
            - name: slo_id
              in: body
              type: string
              description: "The Datadog SLO ID to report on."
            - name: timeframe
              in: body
              type: string
              description: "The SLO reporting timeframe: '7d', '30d', or '90d'."
            - name: teams_channel_id
              in: body
              type: string
              description: "Teams channel ID for the leadership report."
          steps:
            - name: get-slo-status
              type: call
              call: datadog.get-slo
              with:
                slo_id: "{{slo_id}}"
                timeframe: "{{timeframe}}"
            - name: post-report
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{teams_channel_id}}"
                text: "SLO Report ({{timeframe}}): {{get-slo-status.name}} | Compliance: {{get-slo-status.sli_value}}% | Error budget remaining: {{get-slo-status.error_budget_remaining}}%"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: slos
          path: "/slo/{{slo_id}}"
          inputParameters:
            - name: slo_id
              in: path
          operations:
            - name: get-slo
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_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, creates a ServiceNow offboarding ticket, deactivates accounts via Okta, and notifies the IT team in Microsoft Teams.

naftiko: "0.5"
info:
  label: "Employee Offboarding Workflow"
  description: "When an employee termination is processed in Workday, creates a ServiceNow offboarding ticket, deactivates accounts via Okta, and notifies the IT team in Microsoft Teams."
  tags:
    - hr
    - offboarding
    - workday
    - servicenow
    - 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, create a ServiceNow offboarding ticket, deactivate the Okta user, and alert IT via Teams."
          inputParameters:
            - name: worker_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 date in YYYY-MM-DD format."
          steps:
            - name: get-employee
              type: call
              call: workday-off.get-worker
              with:
                worker_id: "{{worker_id}}"
            - name: create-offboard-ticket
              type: call
              call: servicenow-off.create-incident
              with:
                short_description: "Offboarding: {{get-employee.full_name}} — last day {{termination_date}}"
                category: "hr_offboarding"
                assigned_group: "IT_Security"
            - name: deactivate-okta
              type: call
              call: okta.deactivate-user
              with:
                email: "{{get-employee.email}}"
            - name: notify-it
              type: call
              call: msteams-off.send-message
              with:
                channel_id: "it-ops-channel"
                text: "Offboarding initiated for {{get-employee.full_name}} (last day: {{termination_date}}). SNOW: {{create-offboard-ticket.number}}. Okta deactivated: {{deactivate-okta.status}}."
  consumes:
    - type: http
      namespace: workday-off
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/palantir/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: servicenow-off
      baseUri: "https://palantir.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://palantir.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_key"
        placement: header
      resources:
        - name: users
          path: "/users/{{email}}/lifecycle/deactivate"
          inputParameters:
            - name: email
              in: path
          operations:
            - name: deactivate-user
              method: POST
    - type: http
      namespace: msteams-off
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Provisions Foundry access for new hires by creating Okta accounts, assigning Foundry projects, and notifying via Slack.

naftiko: "0.5"
info:
  label: "Employee Onboarding Foundry Access Orchestrator"
  description: "Provisions Foundry access for new hires by creating Okta accounts, assigning Foundry projects, and notifying via Slack."
  tags:
    - hr
    - foundry
    - okta
    - slack
capability:
  exposes:
    - type: mcp
      namespace: employee-onboarding-found
      port: 8080
      tools:
        - name: employee-onboarding-foundry-access
          description: "Provisions Foundry access for new hires by creating Okta accounts."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Employee Onboarding Foundry Access processed for {{entity_id}}"
            - name: provision-access
              type: call
              call: "okta.assign-user"
              with:
                entity_id: "{{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: okta
      baseUri: "https://palantir.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users"
          operations:
            - name: assign-user
              method: POST

Retrieves execution history for a Foundry Ontology action type, returning recent execution count, success rate, and average execution duration.

naftiko: "0.5"
info:
  label: "Foundry Action Type Execution Lookup"
  description: "Retrieves execution history for a Foundry Ontology action type, returning recent execution count, success rate, and average execution duration."
  tags:
    - data-analytics
    - foundry
    - ontology
capability:
  exposes:
    - type: mcp
      namespace: ontology-actions
      port: 8080
      tools:
        - name: get-action-execution-history
          description: "Look up execution history for an Ontology action type. Returns count, success rate, and duration."
          inputParameters:
            - name: action_type
              in: body
              type: string
              description: "The Ontology action type API name."
          call: "foundry.get-action-history"
          with:
            action_type: "{{action_type}}"
          outputParameters:
            - name: execution_count_7d
              type: number
              mapping: "$.executionCount7d"
            - name: success_rate_pct
              type: number
              mapping: "$.successRate"
            - name: avg_duration_ms
              type: number
              mapping: "$.avgDurationMs"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: actions
          path: "/ontologies/default/actionTypes/{{action_type}}/executions"
          inputParameters:
            - name: action_type
              in: path
          operations:
            - name: get-action-history
              method: GET

Triggers a model training job in Foundry, monitors completion, validates metrics, and notifies the ML team via Slack.

naftiko: "0.5"
info:
  label: "Foundry AI Model Training Orchestrator"
  description: "Triggers a model training job in Foundry, monitors completion, validates metrics, and notifies the ML team via Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - machine-learning
    - slack
capability:
  exposes:
    - type: mcp
      namespace: ml-training
      port: 8080
      tools:
        - name: orchestrate-model-training
          description: "Given a model RID and training dataset, trigger training, validate results, and notify the team."
          inputParameters:
            - name: model_rid
              in: body
              type: string
              description: "Foundry model RID."
            - name: training_dataset
              in: body
              type: string
              description: "Training dataset path."
          steps:
            - name: trigger-training
              type: call
              call: "foundry.start-training"
              with:
                modelRid: "{{model_rid}}"
                datasetPath: "{{training_dataset}}"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "ml-ops"
                text: "Model training started: {{model_rid}} | Dataset: {{training_dataset}} | Job: {{trigger-training.job_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: training
          path: "/models/{{modelRid}}/train"
          inputParameters:
            - name: modelRid
              in: path
          operations:
            - name: start-training
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves subscription configuration for Foundry alerting rules, returning subscribed users, delivery method, and escalation settings.

naftiko: "0.5"
info:
  label: "Foundry Alert Subscription Config Lookup"
  description: "Retrieves subscription configuration for Foundry alerting rules, returning subscribed users, delivery method, and escalation settings."
  tags:
    - data-analytics
    - foundry
    - alerts
capability:
  exposes:
    - type: mcp
      namespace: foundry-alerts
      port: 8080
      tools:
        - name: get-alert-subscription
          description: "Look up an alert subscription configuration. Returns subscribers and delivery settings."
          inputParameters:
            - name: alert_rid
              in: body
              type: string
              description: "The alert rule resource identifier."
          call: "foundry.get-alert-config"
          with:
            rid: "{{alert_rid}}"
          outputParameters:
            - name: subscriber_count
              type: number
              mapping: "$.subscriberCount"
            - name: delivery_method
              type: string
              mapping: "$.deliveryMethod"
            - name: escalation_enabled
              type: boolean
              mapping: "$.escalationEnabled"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: alerts
          path: "/alerts/{{rid}}/subscriptions"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-alert-config
              method: GET

Identifies deprecated API usage in Foundry, notifies consumers via Slack, and creates Jira migration tickets.

naftiko: "0.5"
info:
  label: "Foundry API Deprecation Orchestrator"
  description: "Identifies deprecated API usage in Foundry, notifies consumers via Slack, and creates Jira migration tickets."
  tags:
    - data-platform
    - foundry
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: foundry-api-deprecation
      port: 8080
      tools:
        - name: foundry-api-deprecation
          description: "Identifies deprecated API usage in Foundry."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-issue
              type: call
              call: "jira.create-issue"
              with:
                project: "PLAT"
                summary: "Foundry API Deprecation"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Foundry API Deprecation processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves details for a Foundry third-party application token including scopes, expiry, and last used time.

naftiko: "0.5"
info:
  label: "Foundry API Token Lookup"
  description: "Retrieves details for a Foundry third-party application token including scopes, expiry, and last used time."
  tags:
    - data-platform
    - foundry
    - palantir
    - api-management
capability:
  exposes:
    - type: mcp
      namespace: foundry-tokens
      port: 8080
      tools:
        - name: get-token-details
          description: "Given a token ID, return its name, scopes, expiry, and last used timestamp."
          inputParameters:
            - name: token_id
              in: body
              type: string
              description: "Foundry API token ID."
          call: "foundry.get-token"
          with:
            tokenId: "{{token_id}}"
          outputParameters:
            - name: name
              type: string
              mapping: "$.name"
            - name: scopes
              type: string
              mapping: "$.scopes"
            - name: expiry
              type: string
              mapping: "$.expiresAt"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: tokens
          path: "/tokens/{{tokenId}}"
          inputParameters:
            - name: tokenId
              in: path
          operations:
            - name: get-token
              method: GET

Reviews and merges a Foundry dataset branch, validates data quality, and notifies the data team via Slack.

naftiko: "0.5"
info:
  label: "Foundry Branch Merge Workflow"
  description: "Reviews and merges a Foundry dataset branch, validates data quality, and notifies the data team via Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - data-quality
    - slack
capability:
  exposes:
    - type: mcp
      namespace: branch-merge
      port: 8080
      tools:
        - name: merge-dataset-branch
          description: "Given a dataset and branch, validate data quality then merge and notify."
          inputParameters:
            - name: dataset_rid
              in: body
              type: string
              description: "Foundry dataset RID."
            - name: branch_name
              in: body
              type: string
              description: "Branch name to merge."
          steps:
            - name: merge-branch
              type: call
              call: "foundry.merge-branch"
              with:
                datasetRid: "{{dataset_rid}}"
                branchName: "{{branch_name}}"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "data-engineering"
                text: "Branch merged: {{branch_name}} into master for dataset {{dataset_rid}} | Status: {{merge-branch.status}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: branches
          path: "/datasets/{{datasetRid}}/branches/{{branchName}}/merge"
          inputParameters:
            - name: datasetRid
              in: path
            - name: branchName
              in: path
          operations:
            - name: merge-branch
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the latest build status for a Foundry code repository.

naftiko: "0.5"
info:
  label: "Foundry Code Repository Build Status Lookup"
  description: "Retrieves the latest build status for a Foundry code repository."
  tags:
    - cicd
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: repo-builds
      port: 8080
      tools:
        - name: get-build-status
          description: "Look up Foundry code repository build status."
          inputParameters:
            - name: repo_rid
              in: body
              type: string
              description: "Foundry code repository RID."
          call: "foundry.get-build-status"
          with:
            rid: "{{repo_rid}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.build.status"
            - name: commit
              type: string
              mapping: "$.build.commitHash"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: repos
          path: "/codeRepositories/{{rid}}/builds"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-build-status
              method: GET

Retrieves recent commits from a Foundry Code Repository, returning commit hash, author, message, and timestamp.

naftiko: "0.5"
info:
  label: "Foundry Code Repository Commit Lookup"
  description: "Retrieves recent commits from a Foundry Code Repository, returning commit hash, author, message, and timestamp."
  tags:
    - data-analytics
    - foundry
    - engineering
capability:
  exposes:
    - type: mcp
      namespace: foundry-dev
      port: 8080
      tools:
        - name: get-recent-commits
          description: "Look up recent commits in a Foundry code repository. Returns commit details."
          inputParameters:
            - name: repo_rid
              in: body
              type: string
              description: "The Foundry code repository resource identifier."
          call: "foundry.list-commits"
          with:
            repo_rid: "{{repo_rid}}"
          outputParameters:
            - name: commits
              type: array
              mapping: "$.data"
              items:
                - name: commit_hash
                  type: string
                  mapping: "$.hash"
                - name: author
                  type: string
                  mapping: "$.author"
                - name: message
                  type: string
                  mapping: "$.message"
                - name: timestamp
                  type: string
                  mapping: "$.timestamp"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: code-repos
          path: "/repositories/{{repo_rid}}/commits"
          inputParameters:
            - name: repo_rid
              in: path
          operations:
            - name: list-commits
              method: GET

Exports the results of a Contour analysis board as a Foundry dataset, returning the output dataset RID, row count, and column schema.

naftiko: "0.5"
info:
  label: "Foundry Contour Analysis Export"
  description: "Exports the results of a Contour analysis board as a Foundry dataset, returning the output dataset RID, row count, and column schema."
  tags:
    - data-analytics
    - foundry
    - contour
capability:
  exposes:
    - type: mcp
      namespace: foundry-analysis
      port: 8080
      tools:
        - name: export-contour-analysis
          description: "Export a Contour analysis board to a Foundry dataset. Returns output dataset details."
          inputParameters:
            - name: analysis_rid
              in: body
              type: string
              description: "The Contour analysis resource identifier."
            - name: output_dataset_rid
              in: body
              type: string
              description: "The target Foundry dataset RID for export."
          call: "foundry.export-contour"
          with:
            analysis_rid: "{{analysis_rid}}"
            target_rid: "{{output_dataset_rid}}"
          outputParameters:
            - name: row_count
              type: number
              mapping: "$.rowCount"
            - name: column_count
              type: number
              mapping: "$.columnCount"
            - name: export_status
              type: string
              mapping: "$.status"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: contour
          path: "/contour/analyses/{{analysis_rid}}/export"
          inputParameters:
            - name: analysis_rid
              in: path
          operations:
            - name: export-contour
              method: POST

Allocates Foundry compute costs to teams, publishes reports to Confluence, and notifies finance via email.

naftiko: "0.5"
info:
  label: "Foundry Cost Allocation Orchestrator"
  description: "Allocates Foundry compute costs to teams, publishes reports to Confluence, and notifies finance via email."
  tags:
    - finops
    - foundry
    - confluence
    - email
capability:
  exposes:
    - type: mcp
      namespace: foundry-cost-allocation
      port: 8080
      tools:
        - name: foundry-cost-allocation
          description: "Allocates Foundry compute costs to teams."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: publish
              type: call
              call: "confluence.create-page"
              with:
                space_key: "PLAT"
                title: "Foundry Cost Allocation"
            - name: send-email
              type: call
              call: "email.send-message"
              with:
                to: "team@palantir.com"
                subject: "Foundry Cost Allocation"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: content
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: email
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.graph_token"
      resources:
        - name: mail
          path: "/me/sendMail"
          operations:
            - name: send-message
              method: POST

Sets up cross-project data sharing in Foundry by creating a data sharing request, validating governance policies, applying data masking rules, and granting read access to the requesting project.

naftiko: "0.5"
info:
  label: "Foundry Cross-Project Data Sharing Orchestrator"
  description: "Sets up cross-project data sharing in Foundry by creating a data sharing request, validating governance policies, applying data masking rules, and granting read access to the requesting project."
  tags:
    - data-analytics
    - foundry
    - governance
    - data-sharing
capability:
  exposes:
    - type: mcp
      namespace: data-governance
      port: 8080
      tools:
        - name: setup-data-sharing
          description: "Orchestrate cross-project data sharing: validate governance, apply masking, and grant access."
          inputParameters:
            - name: source_dataset_rid
              in: body
              type: string
              description: "The source dataset resource identifier."
            - name: target_project_rid
              in: body
              type: string
              description: "The requesting project resource identifier."
            - name: requester_email
              in: body
              type: string
              description: "Email of the user requesting access."
          steps:
            - name: check-governance
              type: call
              call: "foundry.check-governance-policy"
              with:
                dataset_rid: "{{source_dataset_rid}}"
                target_project: "{{target_project_rid}}"
            - name: apply-masking
              type: call
              call: "foundry.create-masked-view"
              with:
                dataset_rid: "{{source_dataset_rid}}"
                masking_policy: "{{check-governance.required_masking}}"
            - name: grant-access
              type: call
              call: "foundry.grant-dataset-access"
              with:
                dataset_rid: "{{apply-masking.masked_dataset_rid}}"
                project_rid: "{{target_project_rid}}"
            - name: notify-requester
              type: call
              call: "slack.post-message"
              with:
                channel: "{{requester_email}}"
                text: "Data sharing approved for dataset {{source_dataset_rid}}. Masked view available in your project."
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: governance
          path: "/governance/policies/check"
          operations:
            - name: check-governance-policy
              method: POST
        - name: datasets
          path: "/datasets/{{dataset_rid}}/views"
          inputParameters:
            - name: dataset_rid
              in: path
          operations:
            - name: create-masked-view
              method: POST
            - name: grant-dataset-access
              method: PUT
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Enriches a customer profile in Foundry by pulling CRM data from Salesforce, support history from ServiceNow, product usage from Snowflake, and merging into a unified customer 360 Ontology object.

naftiko: "0.5"
info:
  label: "Foundry Customer 360 Enrichment Orchestrator"
  description: "Enriches a customer profile in Foundry by pulling CRM data from Salesforce, support history from ServiceNow, product usage from Snowflake, and merging into a unified customer 360 Ontology object."
  tags:
    - data-analytics
    - foundry
    - salesforce
    - servicenow
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: customer-360
      port: 8080
      tools:
        - name: enrich-customer-profile
          description: "Orchestrate customer 360 enrichment: pull CRM, support, and usage data, then merge into Ontology."
          inputParameters:
            - name: customer_id
              in: body
              type: string
              description: "The customer identifier."
          steps:
            - name: get-crm-data
              type: call
              call: "salesforce.get-account"
              with:
                account_id: "{{customer_id}}"
            - name: get-support-history
              type: call
              call: "servicenow.get-customer-tickets"
              with:
                customer_id: "{{customer_id}}"
            - name: get-product-usage
              type: call
              call: "snowflake.query-product-usage"
              with:
                customer_id: "{{customer_id}}"
            - name: merge-to-ontology
              type: call
              call: "foundry.upsert-ontology-object"
              with:
                object_type: "Customer"
                primary_key: "{{customer_id}}"
                properties:
                  account_name: "{{get-crm-data.Name}}"
                  open_tickets: "{{get-support-history.open_count}}"
                  monthly_active_users: "{{get-product-usage.mau}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://palantir.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: servicenow
      baseUri: "https://palantir.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.snow_user"
        password: "$secrets.snow_password"
      resources:
        - name: tickets
          path: "/table/incident"
          operations:
            - name: get-customer-tickets
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://palantir.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: queries
          path: "/statements"
          operations:
            - name: query-product-usage
              method: POST
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: ontology
          path: "/ontologies/default/objectTypes/Customer/objects"
          operations:
            - name: upsert-ontology-object
              method: PUT

Searches the Foundry data catalog for datasets matching a keyword query, returning dataset names, RIDs, descriptions, and last modified dates.

naftiko: "0.5"
info:
  label: "Foundry Data Catalog Search Lookup"
  description: "Searches the Foundry data catalog for datasets matching a keyword query, returning dataset names, RIDs, descriptions, and last modified dates."
  tags:
    - data-analytics
    - foundry
    - data-catalog
capability:
  exposes:
    - type: mcp
      namespace: data-discovery
      port: 8080
      tools:
        - name: search-data-catalog
          description: "Search the Foundry data catalog by keyword. Returns matching datasets with metadata."
          inputParameters:
            - name: query
              in: body
              type: string
              description: "The search keyword or phrase."
          call: "foundry.search-catalog"
          with:
            query: "{{query}}"
          outputParameters:
            - name: results
              type: array
              mapping: "$.data"
              items:
                - name: dataset_name
                  type: string
                  mapping: "$.name"
                - name: dataset_rid
                  type: string
                  mapping: "$.rid"
                - name: description
                  type: string
                  mapping: "$.description"
                - name: last_modified
                  type: string
                  mapping: "$.lastModified"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: catalog
          path: "/catalog/search"
          operations:
            - name: search-catalog
              method: POST

Checks the health of Foundry data connections, identifies failed syncs, and creates Jira tickets for broken connectors.

naftiko: "0.5"
info:
  label: "Foundry Data Connection Health Check"
  description: "Checks the health of Foundry data connections, identifies failed syncs, and creates Jira tickets for broken connectors."
  tags:
    - data-platform
    - foundry
    - palantir
    - data-integration
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: connection-health
      port: 8080
      tools:
        - name: check-connection-health
          description: "Query Foundry data connections for failed syncs and create Jira tickets for remediation."
          inputParameters:
            - name: source_type
              in: body
              type: string
              description: "Data source type filter, e.g. jdbc, s3, rest."
          steps:
            - name: get-connections
              type: call
              call: "foundry.get-connections"
              with:
                sourceType: "{{source_type}}"
            - name: create-jira
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "Data connection failures: {{get-connections.failed_count}} {{source_type}} connectors"
                description: "Failed connections: {{get-connections.failed_list}}"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "data-engineering"
                text: "Connection Health: {{get-connections.failed_count}}/{{get-connections.total}} {{source_type}} connections failed. Jira: {{create-jira.key}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: connections
          path: "/data-connections"
          inputParameters:
            - name: sourceType
              in: query
          operations:
            - name: get-connections
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves sync status for a Foundry data connection.

naftiko: "0.5"
info:
  label: "Foundry Data Connection Sync Status Lookup"
  description: "Retrieves sync status for a Foundry data connection."
  tags:
    - data-platform
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: sync-status
      port: 8080
      tools:
        - name: get-sync-status
          description: "Look up data connection sync status."
          inputParameters:
            - name: connection_rid
              in: body
              type: string
              description: "Foundry data connection RID."
          call: "foundry.get-sync-status"
          with:
            rid: "{{connection_rid}}"
          outputParameters:
            - name: last_sync
              type: string
              mapping: "$.sync.lastSuccessfulSync"
            - name: status
              type: string
              mapping: "$.sync.status"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: connections
          path: "/dataConnections/{{rid}}/sync"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-sync-status
              method: GET

Validates data export requests against governance policies, logs in ServiceNow, and notifies requesters.

naftiko: "0.5"
info:
  label: "Foundry Data Export Compliance Orchestrator"
  description: "Validates data export requests against governance policies, logs in ServiceNow, and notifies requesters."
  tags:
    - compliance
    - foundry
    - servicenow
    - email
capability:
  exposes:
    - type: mcp
      namespace: foundry-data-export-compl
      port: 8080
      tools:
        - name: foundry-data-export-compliance
          description: "Validates data export requests against governance policies."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Foundry Data Export Compliance for {{entity_id}}"
            - name: send-email
              type: call
              call: "email.send-message"
              with:
                to: "team@palantir.com"
                subject: "Foundry Data Export Compliance"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
        - name: changes
          path: "/table/change_request"
          operations:
            - name: create-change
              method: POST
    - type: http
      namespace: email
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.graph_token"
      resources:
        - name: mail
          path: "/me/sendMail"
          operations:
            - name: send-message
              method: POST

Exports a Foundry dataset to an AWS S3 bucket, validates the export, and notifies the data team via Slack.

naftiko: "0.5"
info:
  label: "Foundry Data Export to S3"
  description: "Exports a Foundry dataset to an AWS S3 bucket, validates the export, and notifies the data team via Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - aws
    - slack
capability:
  exposes:
    - type: mcp
      namespace: data-export
      port: 8080
      tools:
        - name: export-to-s3
          description: "Given a dataset path and S3 destination, trigger an export and confirm via Slack."
          inputParameters:
            - name: dataset_path
              in: body
              type: string
              description: "Foundry dataset path."
            - name: s3_bucket
              in: body
              type: string
              description: "Target S3 bucket name."
            - name: s3_prefix
              in: body
              type: string
              description: "S3 key prefix."
          steps:
            - name: trigger-export
              type: call
              call: "foundry.export-dataset"
              with:
                datasetPath: "{{dataset_path}}"
                destination: "s3://{{s3_bucket}}/{{s3_prefix}}"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "data-ops"
                text: "Data export started: {{dataset_path}} -> s3://{{s3_bucket}}/{{s3_prefix}} | Job: {{trigger-export.job_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: exports
          path: "/datasets/export"
          operations:
            - name: export-dataset
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks data freshness for critical Foundry datasets, flags stale data, and creates Jira tickets for data engineering.

naftiko: "0.5"
info:
  label: "Foundry Data Freshness Check"
  description: "Checks data freshness for critical Foundry datasets, flags stale data, and creates Jira tickets for data engineering."
  tags:
    - data-platform
    - foundry
    - palantir
    - data-quality
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: data-freshness
      port: 8080
      tools:
        - name: check-data-freshness
          description: "Given a dataset path and max age in hours, check if data is fresh and alert if stale."
          inputParameters:
            - name: dataset_path
              in: body
              type: string
              description: "Foundry dataset path."
            - name: max_age_hours
              in: body
              type: string
              description: "Maximum acceptable data age in hours."
          steps:
            - name: get-metadata
              type: call
              call: "foundry.get-dataset"
              with:
                datasetPath: "{{dataset_path}}"
            - name: create-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "Stale data: {{dataset_path}} last updated {{get-metadata.last_modified}}"
                description: "Dataset: {{dataset_path}}\nLast modified: {{get-metadata.last_modified}}\nMax age: {{max_age_hours}}h"
            - name: alert-team
              type: call
              call: "slack.post-message"
              with:
                channel: "data-engineering"
                text: "Data Freshness Alert: {{dataset_path}} is stale (last updated: {{get-metadata.last_modified}}). Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets/{{datasetPath}}"
          inputParameters:
            - name: datasetPath
              in: path
          operations:
            - name: get-dataset
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates a weekly data health report by querying Foundry dataset freshness and quality checks, aggregating metrics in Snowflake, and publishing the summary to Confluence for stakeholder review.

naftiko: "0.5"
info:
  label: "Foundry Data Health Report Orchestrator"
  description: "Generates a weekly data health report by querying Foundry dataset freshness and quality checks, aggregating metrics in Snowflake, and publishing the summary to Confluence for stakeholder review."
  tags:
    - data-analytics
    - foundry
    - snowflake
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: data-health
      port: 8080
      tools:
        - name: generate-data-health-report
          description: "Orchestrate weekly data health reporting: check freshness, aggregate metrics, and publish to Confluence."
          inputParameters:
            - name: project_rid
              in: body
              type: string
              description: "The Foundry project resource identifier."
          steps:
            - name: check-dataset-freshness
              type: call
              call: "foundry.check-freshness"
              with:
                project_rid: "{{project_rid}}"
            - name: aggregate-quality-metrics
              type: call
              call: "snowflake.query-quality-metrics"
              with:
                project_rid: "{{project_rid}}"
            - name: publish-report
              type: call
              call: "confluence.create-page"
              with:
                space: "DATA"
                title: "Data Health Report - {{project_rid}}"
                body: "Datasets checked: {{check-dataset-freshness.total_datasets}}. Fresh: {{check-dataset-freshness.fresh_count}}. Stale: {{check-dataset-freshness.stale_count}}. Quality score: {{aggregate-quality-metrics.avg_quality_score}}."
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: health
          path: "/projects/{{project_rid}}/health"
          inputParameters:
            - name: project_rid
              in: path
          operations:
            - name: check-freshness
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://palantir.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: queries
          path: "/statements"
          operations:
            - name: query-quality-metrics
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST

Retrieves the health status of a configured data integration source in Foundry, returning connection state, last successful sync, and record throughput.

naftiko: "0.5"
info:
  label: "Foundry Data Integration Source Status Lookup"
  description: "Retrieves the health status of a configured data integration source in Foundry, returning connection state, last successful sync, and record throughput."
  tags:
    - data-analytics
    - foundry
    - data-pipeline
capability:
  exposes:
    - type: mcp
      namespace: data-integration
      port: 8080
      tools:
        - name: get-source-status
          description: "Look up a data integration source status. Returns connection health, sync time, and throughput."
          inputParameters:
            - name: source_rid
              in: body
              type: string
              description: "The data source resource identifier."
          call: "foundry.get-source-health"
          with:
            rid: "{{source_rid}}"
          outputParameters:
            - name: connection_state
              type: string
              mapping: "$.connectionState"
            - name: last_successful_sync
              type: string
              mapping: "$.lastSuccessfulSync"
            - name: records_per_minute
              type: number
              mapping: "$.throughput.recordsPerMinute"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: sources
          path: "/dataIntegration/sources/{{rid}}/health"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-source-health
              method: GET

Analyzes impact of dataset changes on downstream consumers, creates Jira notifications, and alerts via Slack.

naftiko: "0.5"
info:
  label: "Foundry Data Lineage Impact Analysis Orchestrator"
  description: "Analyzes impact of dataset changes on downstream consumers, creates Jira notifications, and alerts via Slack."
  tags:
    - data-platform
    - foundry
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: foundry-data-lineage-impa
      port: 8080
      tools:
        - name: foundry-data-lineage-impact-analysis
          description: "Analyzes impact of dataset changes on downstream consumers."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-issue
              type: call
              call: "jira.create-issue"
              with:
                project: "PLAT"
                summary: "Foundry Data Lineage Impact Analysis"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Foundry Data Lineage Impact Analysis processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves upstream and downstream data lineage for a Foundry dataset, returning source and consumer datasets.

naftiko: "0.5"
info:
  label: "Foundry Data Lineage Lookup"
  description: "Retrieves upstream and downstream data lineage for a Foundry dataset, returning source and consumer datasets."
  tags:
    - data-platform
    - foundry
    - palantir
    - data-lineage
capability:
  exposes:
    - type: mcp
      namespace: foundry-lineage
      port: 8080
      tools:
        - name: get-data-lineage
          description: "Given a dataset RID, return its upstream sources and downstream consumers."
          inputParameters:
            - name: dataset_rid
              in: body
              type: string
              description: "Foundry dataset RID."
          call: "foundry.get-lineage"
          with:
            datasetRid: "{{dataset_rid}}"
          outputParameters:
            - name: upstream_count
              type: string
              mapping: "$.upstream.length"
            - name: downstream_count
              type: string
              mapping: "$.downstream.length"
            - name: primary_source
              type: string
              mapping: "$.upstream[0].name"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: lineage
          path: "/datasets/{{datasetRid}}/lineage"
          inputParameters:
            - name: datasetRid
              in: path
          operations:
            - name: get-lineage
              method: GET

Checks data quality metrics for a Foundry dataset, flags anomalies, and posts alerts to Slack.

naftiko: "0.5"
info:
  label: "Foundry Data Quality Monitor"
  description: "Checks data quality metrics for a Foundry dataset, flags anomalies, and posts alerts to Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - data-quality
    - slack
capability:
  exposes:
    - type: mcp
      namespace: dq-monitor
      port: 8080
      tools:
        - name: check-data-quality
          description: "Given a dataset path, check data quality metrics and post alerts for any anomalies."
          inputParameters:
            - name: dataset_path
              in: body
              type: string
              description: "Foundry dataset path."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel for alerts."
          steps:
            - name: get-dataset
              type: call
              call: "foundry.get-dataset-stats"
              with:
                datasetPath: "{{dataset_path}}"
            - name: post-alert
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Data Quality Check: {{dataset_path}} | Rows: {{get-dataset.row_count}} | Null rate: {{get-dataset.null_rate}} | Schema changes: {{get-dataset.schema_changes}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets/{{datasetPath}}/stats"
          inputParameters:
            - name: datasetPath
              in: path
          operations:
            - name: get-dataset-stats
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Audits who has accessed a sensitive Foundry dataset, creates a compliance report, and alerts the data governance team.

naftiko: "0.5"
info:
  label: "Foundry Dataset Access Audit"
  description: "Audits who has accessed a sensitive Foundry dataset, creates a compliance report, and alerts the data governance team."
  tags:
    - data-platform
    - foundry
    - palantir
    - compliance
    - slack
capability:
  exposes:
    - type: mcp
      namespace: access-audit
      port: 8080
      tools:
        - name: audit-dataset-access
          description: "Given a dataset path, pull access logs, and post an audit summary to Slack."
          inputParameters:
            - name: dataset_path
              in: body
              type: string
              description: "Foundry dataset path to audit."
          steps:
            - name: get-access-logs
              type: call
              call: "foundry.get-audit-logs"
              with:
                resourcePath: "{{dataset_path}}"
            - name: post-audit
              type: call
              call: "slack.post-message"
              with:
                channel: "data-governance"
                text: "Access Audit: {{dataset_path}} | Total accesses: {{get-access-logs.total}} | Unique users: {{get-access-logs.unique_users}} | Last access: {{get-access-logs.last_access}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: audit
          path: "/audit/logs"
          inputParameters:
            - name: resourcePath
              in: query
          operations:
            - name: get-audit-logs
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves data expectation check results for a Foundry dataset, returning pass/fail status, checked expectations count, and failed expectation details.

naftiko: "0.5"
info:
  label: "Foundry Dataset Expectation Check Lookup"
  description: "Retrieves data expectation check results for a Foundry dataset, returning pass/fail status, checked expectations count, and failed expectation details."
  tags:
    - data-analytics
    - foundry
    - data-quality
capability:
  exposes:
    - type: mcp
      namespace: data-quality
      port: 8080
      tools:
        - name: get-expectation-results
          description: "Look up data expectation check results for a dataset. Returns pass/fail and failed expectations."
          inputParameters:
            - name: dataset_rid
              in: body
              type: string
              description: "The Foundry dataset resource identifier."
          call: "foundry.get-expectations"
          with:
            dataset_rid: "{{dataset_rid}}"
          outputParameters:
            - name: overall_status
              type: string
              mapping: "$.overallStatus"
            - name: total_checks
              type: number
              mapping: "$.totalChecks"
            - name: failed_checks
              type: number
              mapping: "$.failedChecks"
            - name: failures
              type: array
              mapping: "$.failures"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: expectations
          path: "/datasets/{{dataset_rid}}/expectations/results"
          inputParameters:
            - name: dataset_rid
              in: path
          operations:
            - name: get-expectations
              method: GET

Retrieves metadata for a Palantir Foundry dataset by path, returning schema, row count, and last modified timestamp.

naftiko: "0.5"
info:
  label: "Foundry Dataset Lookup"
  description: "Retrieves metadata for a Palantir Foundry dataset by path, returning schema, row count, and last modified timestamp."
  tags:
    - data-platform
    - foundry
    - palantir
    - lookup
capability:
  exposes:
    - type: mcp
      namespace: foundry-data
      port: 8080
      tools:
        - name: get-dataset-metadata
          description: "Given a Foundry dataset path, return its schema, row count, and last modified time."
          inputParameters:
            - name: dataset_path
              in: body
              type: string
              description: "Foundry dataset resource path."
          call: "foundry.get-dataset"
          with:
            datasetPath: "{{dataset_path}}"
          outputParameters:
            - name: rid
              type: string
              mapping: "$.rid"
            - name: row_count
              type: string
              mapping: "$.stats.rowCount"
            - name: last_modified
              type: string
              mapping: "$.lastModified"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets/{{datasetPath}}"
          inputParameters:
            - name: datasetPath
              in: path
          operations:
            - name: get-dataset
              method: GET

Audits dataset quality in Foundry, creates Jira tickets for issues, and notifies data stewards via Slack.

naftiko: "0.5"
info:
  label: "Foundry Dataset Quality Audit Orchestrator"
  description: "Audits dataset quality in Foundry, creates Jira tickets for issues, and notifies data stewards via Slack."
  tags:
    - data-platform
    - foundry
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: foundry-dataset-quality-a
      port: 8080
      tools:
        - name: foundry-dataset-quality-audit
          description: "Audits dataset quality in Foundry."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-issue
              type: call
              call: "jira.create-issue"
              with:
                project: "PLAT"
                summary: "Foundry Dataset Quality Audit"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Foundry Dataset Quality Audit processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns the current row count and size in bytes for a Foundry dataset, useful for monitoring data pipeline output volumes.

naftiko: "0.5"
info:
  label: "Foundry Dataset Row Count Lookup"
  description: "Returns the current row count and size in bytes for a Foundry dataset, useful for monitoring data pipeline output volumes."
  tags:
    - data-analytics
    - foundry
    - monitoring
capability:
  exposes:
    - type: mcp
      namespace: foundry-data
      port: 8080
      tools:
        - name: get-dataset-row-count
          description: "Look up the row count and size of a Foundry dataset by resource identifier."
          inputParameters:
            - name: dataset_rid
              in: body
              type: string
              description: "The Foundry dataset resource identifier."
          call: "foundry.get-dataset-stats"
          with:
            dataset_rid: "{{dataset_rid}}"
          outputParameters:
            - name: row_count
              type: number
              mapping: "$.rowCount"
            - name: size_bytes
              type: number
              mapping: "$.sizeBytes"
            - name: last_updated
              type: string
              mapping: "$.lastTransaction.timestamp"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets/{{dataset_rid}}/stats"
          inputParameters:
            - name: dataset_rid
              in: path
          operations:
            - name: get-dataset-stats
              method: GET

Detects schema changes in Foundry datasets, creates a Jira ticket for review, and notifies downstream consumers via Slack.

naftiko: "0.5"
info:
  label: "Foundry Dataset Schema Change Detector"
  description: "Detects schema changes in Foundry datasets, creates a Jira ticket for review, and notifies downstream consumers via Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - data-governance
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: schema-change
      port: 8080
      tools:
        - name: detect-schema-changes
          description: "Given a dataset path, compare current schema to previous version and alert on changes."
          inputParameters:
            - name: dataset_path
              in: body
              type: string
              description: "Foundry dataset path."
          steps:
            - name: get-schema
              type: call
              call: "foundry.get-schema"
              with:
                datasetPath: "{{dataset_path}}"
            - name: create-review
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Task"
                summary: "Schema change detected: {{dataset_path}}"
                description: "Columns added: {{get-schema.added_columns}}\nColumns removed: {{get-schema.removed_columns}}\nType changes: {{get-schema.type_changes}}"
            - name: notify-consumers
              type: call
              call: "slack.post-message"
              with:
                channel: "data-platform"
                text: "Schema change: {{dataset_path}} | Added: {{get-schema.added_columns}} | Removed: {{get-schema.removed_columns}} | Jira: {{create-review.key}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: schemas
          path: "/datasets/{{datasetPath}}/schema"
          inputParameters:
            - name: datasetPath
              in: path
          operations:
            - name: get-schema
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Runs DR tests for Foundry deployments, validates recovery metrics, and publishes results to Confluence.

naftiko: "0.5"
info:
  label: "Foundry Disaster Recovery Test Orchestrator"
  description: "Runs DR tests for Foundry deployments, validates recovery metrics, and publishes results to Confluence."
  tags:
    - infrastructure
    - foundry
    - servicenow
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: foundry-disaster-recovery
      port: 8080
      tools:
        - name: foundry-disaster-recovery-test
          description: "Runs DR tests for Foundry deployments."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Foundry Disaster Recovery Test for {{entity_id}}"
            - name: publish
              type: call
              call: "confluence.create-page"
              with:
                space_key: "PLAT"
                title: "Foundry Disaster Recovery Test"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
        - name: changes
          path: "/table/change_request"
          operations:
            - name: create-change
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: content
          path: "/content"
          operations:
            - name: create-page
              method: POST

Identifies unused Foundry resources in a project by checking last access dates, archives stale datasets, revokes unused user permissions, and generates a cleanup report in Confluence.

naftiko: "0.5"
info:
  label: "Foundry Environment Resource Cleanup Orchestrator"
  description: "Identifies unused Foundry resources in a project by checking last access dates, archives stale datasets, revokes unused user permissions, and generates a cleanup report in Confluence."
  tags:
    - data-analytics
    - foundry
    - governance
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: foundry-governance
      port: 8080
      tools:
        - name: cleanup-stale-resources
          description: "Orchestrate resource cleanup: identify stale resources, archive datasets, revoke permissions, and report."
          inputParameters:
            - name: project_rid
              in: body
              type: string
              description: "The Foundry project resource identifier."
            - name: stale_days_threshold
              in: body
              type: number
              description: "Days of inactivity before a resource is considered stale."
          steps:
            - name: identify-stale
              type: call
              call: "foundry.find-stale-resources"
              with:
                project_rid: "{{project_rid}}"
                days: "{{stale_days_threshold}}"
            - name: archive-datasets
              type: call
              call: "foundry.archive-resources"
              with:
                resource_rids: "{{identify-stale.stale_dataset_rids}}"
            - name: revoke-permissions
              type: call
              call: "foundry.revoke-unused-permissions"
              with:
                project_rid: "{{project_rid}}"
                user_rids: "{{identify-stale.inactive_user_rids}}"
            - name: generate-report
              type: call
              call: "confluence.create-page"
              with:
                space: "GOVERNANCE"
                title: "Resource Cleanup Report - {{project_rid}}"
                body: "Archived {{archive-datasets.count}} datasets. Revoked {{revoke-permissions.count}} permissions. Total freed: {{archive-datasets.freed_gb}} GB."
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: resources
          path: "/projects/{{project_rid}}/resources"
          inputParameters:
            - name: project_rid
              in: path
          operations:
            - name: find-stale-resources
              method: GET
            - name: archive-resources
              method: POST
            - name: revoke-unused-permissions
              method: DELETE
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST

Validates a Foundry dataset against governance policies including PII classification and retention rules, posts compliance findings.

naftiko: "0.5"
info:
  label: "Foundry Governance Policy Check"
  description: "Validates a Foundry dataset against governance policies including PII classification and retention rules, posts compliance findings."
  tags:
    - data-platform
    - foundry
    - palantir
    - data-governance
    - slack
capability:
  exposes:
    - type: mcp
      namespace: governance-check
      port: 8080
      tools:
        - name: check-governance-policy
          description: "Given a dataset path, validate against governance policies and post findings."
          inputParameters:
            - name: dataset_path
              in: body
              type: string
              description: "Foundry dataset path."
          steps:
            - name: get-classifications
              type: call
              call: "foundry.get-markings"
              with:
                datasetPath: "{{dataset_path}}"
            - name: post-findings
              type: call
              call: "slack.post-message"
              with:
                channel: "data-governance"
                text: "Governance Check: {{dataset_path}} | Classifications: {{get-classifications.markings}} | PII detected: {{get-classifications.pii_columns}} | Retention: {{get-classifications.retention_policy}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: markings
          path: "/datasets/{{datasetPath}}/markings"
          inputParameters:
            - name: datasetPath
              in: path
          operations:
            - name: get-markings
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Triggers a historical data backfill for a Foundry incremental pipeline by setting the backfill window, submitting the build, monitoring progress, and verifying output row counts.

naftiko: "0.5"
info:
  label: "Foundry Incremental Pipeline Backfill Orchestrator"
  description: "Triggers a historical data backfill for a Foundry incremental pipeline by setting the backfill window, submitting the build, monitoring progress, and verifying output row counts."
  tags:
    - data-analytics
    - foundry
    - data-pipeline
capability:
  exposes:
    - type: mcp
      namespace: pipeline-backfill
      port: 8080
      tools:
        - name: run-pipeline-backfill
          description: "Orchestrate an incremental pipeline backfill: set window, submit build, monitor, and verify."
          inputParameters:
            - name: pipeline_rid
              in: body
              type: string
              description: "The Foundry pipeline resource identifier."
            - name: start_date
              in: body
              type: string
              description: "Backfill start date in YYYY-MM-DD format."
            - name: end_date
              in: body
              type: string
              description: "Backfill end date in YYYY-MM-DD format."
          steps:
            - name: configure-backfill
              type: call
              call: "foundry.set-backfill-window"
              with:
                pipeline_rid: "{{pipeline_rid}}"
                start: "{{start_date}}"
                end: "{{end_date}}"
            - name: submit-build
              type: call
              call: "foundry.trigger-build"
              with:
                pipeline_rid: "{{pipeline_rid}}"
                mode: "backfill"
            - name: monitor-build
              type: call
              call: "foundry.get-build-status"
              with:
                build_rid: "{{submit-build.build_rid}}"
            - name: verify-output
              type: call
              call: "foundry.get-dataset-stats"
              with:
                dataset_rid: "{{configure-backfill.output_dataset_rid}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: pipelines
          path: "/pipelines/{{pipeline_rid}}"
          inputParameters:
            - name: pipeline_rid
              in: path
          operations:
            - name: set-backfill-window
              method: PUT
            - name: trigger-build
              method: POST
        - name: builds
          path: "/builds/{{build_rid}}"
          inputParameters:
            - name: build_rid
              in: path
          operations:
            - name: get-build-status
              method: GET
        - name: datasets
          path: "/datasets/{{dataset_rid}}/stats"
          inputParameters:
            - name: dataset_rid
              in: path
          operations:
            - name: get-dataset-stats
              method: GET

Monitors Foundry compute utilization via Datadog, triggers scaling, and notifies platform team via Slack.

naftiko: "0.5"
info:
  label: "Foundry Infrastructure Scaling Orchestrator"
  description: "Monitors Foundry compute utilization via Datadog, triggers scaling, and notifies platform team via Slack."
  tags:
    - infrastructure
    - foundry
    - datadog
    - slack
capability:
  exposes:
    - type: mcp
      namespace: foundry-infrastructure-sc
      port: 8080
      tools:
        - name: foundry-infrastructure-scaling
          description: "Monitors Foundry compute utilization via Datadog."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: check-metrics
              type: call
              call: "datadog.get-monitors"
              with:
                entity_id: "{{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Foundry Infrastructure Scaling processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          operations:
            - name: get-monitors
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current job queue depth for a Foundry compute cluster.

naftiko: "0.5"
info:
  label: "Foundry Job Queue Depth Lookup"
  description: "Retrieves the current job queue depth for a Foundry compute cluster."
  tags:
    - infrastructure
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: job-queue
      port: 8080
      tools:
        - name: get-queue-depth
          description: "Look up Foundry job queue depth."
          inputParameters:
            - name: cluster_id
              in: body
              type: string
              description: "Foundry compute cluster ID."
          call: "foundry.get-queue-depth"
          with:
            cluster_id: "{{cluster_id}}"
          outputParameters:
            - name: pending_jobs
              type: number
              mapping: "$.queue.pending"
            - name: running_jobs
              type: number
              mapping: "$.queue.running"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: compute
          path: "/compute/clusters/{{cluster_id}}/queue"
          inputParameters:
            - name: cluster_id
              in: path
          operations:
            - name: get-queue-depth
              method: GET

Retrieves details about a Foundry Marketplace application including version, author, and installation status.

naftiko: "0.5"
info:
  label: "Foundry Marketplace App Lookup"
  description: "Retrieves details about a Foundry Marketplace application including version, author, and installation status."
  tags:
    - data-platform
    - foundry
    - palantir
    - marketplace
capability:
  exposes:
    - type: mcp
      namespace: foundry-marketplace
      port: 8080
      tools:
        - name: get-marketplace-app
          description: "Given an app name, return its version, author, and installation status."
          inputParameters:
            - name: app_name
              in: body
              type: string
              description: "Marketplace application name."
          call: "foundry.get-app"
          with:
            name: "{{app_name}}"
          outputParameters:
            - name: version
              type: string
              mapping: "$.version"
            - name: author
              type: string
              mapping: "$.author"
            - name: installed
              type: string
              mapping: "$.installationStatus"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: apps
          path: "/marketplace/apps"
          inputParameters:
            - name: name
              in: query
          operations:
            - name: get-app
              method: GET

Reviews marketplace app submissions, validates security, and creates Jira approval tickets.

naftiko: "0.5"
info:
  label: "Foundry Marketplace App Review Orchestrator"
  description: "Reviews marketplace app submissions, validates security, and creates Jira approval tickets."
  tags:
    - data-platform
    - foundry
    - jira
capability:
  exposes:
    - type: mcp
      namespace: foundry-marketplace-app-r
      port: 8080
      tools:
        - name: foundry-marketplace-app-review
          description: "Reviews marketplace app submissions."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-issue
              type: call
              call: "jira.create-issue"
              with:
                project: "PLAT"
                summary: "Foundry Marketplace App Review"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

Retrieves metadata for a Foundry media set, returning file count, total size, and supported media types for document and image storage.

naftiko: "0.5"
info:
  label: "Foundry Media Set Lookup"
  description: "Retrieves metadata for a Foundry media set, returning file count, total size, and supported media types for document and image storage."
  tags:
    - data-analytics
    - foundry
    - media
capability:
  exposes:
    - type: mcp
      namespace: foundry-media
      port: 8080
      tools:
        - name: get-media-set-info
          description: "Look up a Foundry media set by RID. Returns file count, total size, and media types."
          inputParameters:
            - name: media_set_rid
              in: body
              type: string
              description: "The Foundry media set resource identifier."
          call: "foundry.get-media-set"
          with:
            rid: "{{media_set_rid}}"
          outputParameters:
            - name: file_count
              type: number
              mapping: "$.fileCount"
            - name: total_size_bytes
              type: number
              mapping: "$.totalSizeBytes"
            - name: media_types
              type: array
              mapping: "$.supportedMediaTypes"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: media-sets
          path: "/mediaSets/{{rid}}"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-media-set
              method: GET

Retrieves the deployment status of a machine learning model in Palantir Foundry, returning version, health, and inference endpoint.

naftiko: "0.5"
info:
  label: "Foundry Model Deployment Status Lookup"
  description: "Retrieves the deployment status of a machine learning model in Palantir Foundry, returning version, health, and inference endpoint."
  tags:
    - data-platform
    - foundry
    - palantir
    - machine-learning
capability:
  exposes:
    - type: mcp
      namespace: foundry-ml
      port: 8080
      tools:
        - name: get-model-status
          description: "Given a model RID, return deployment status, version, and health metrics."
          inputParameters:
            - name: model_rid
              in: body
              type: string
              description: "Foundry model RID."
          call: "foundry.get-model"
          with:
            modelRid: "{{model_rid}}"
          outputParameters:
            - name: version
              type: string
              mapping: "$.version"
            - name: status
              type: string
              mapping: "$.deploymentStatus"
            - name: endpoint
              type: string
              mapping: "$.inferenceEndpoint"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: models
          path: "/models/{{modelRid}}"
          inputParameters:
            - name: modelRid
              in: path
          operations:
            - name: get-model
              method: GET

Monitors ML model prediction drift in Foundry, triggers retraining when drift exceeds threshold, and alerts the ML team.

naftiko: "0.5"
info:
  label: "Foundry Model Drift Detector"
  description: "Monitors ML model prediction drift in Foundry, triggers retraining when drift exceeds threshold, and alerts the ML team."
  tags:
    - data-platform
    - foundry
    - palantir
    - machine-learning
    - slack
capability:
  exposes:
    - type: mcp
      namespace: model-drift
      port: 8080
      tools:
        - name: detect-model-drift
          description: "Given a model RID, check prediction drift metrics and alert if threshold exceeded."
          inputParameters:
            - name: model_rid
              in: body
              type: string
              description: "Foundry model RID."
            - name: drift_threshold
              in: body
              type: string
              description: "Maximum acceptable drift score."
          steps:
            - name: get-drift-metrics
              type: call
              call: "foundry.get-model-metrics"
              with:
                modelRid: "{{model_rid}}"
            - name: alert-team
              type: call
              call: "slack.post-message"
              with:
                channel: "ml-ops"
                text: "Model Drift Alert: {{model_rid}} | Drift score: {{get-drift-metrics.drift_score}} | Threshold: {{drift_threshold}} | Retraining recommended."
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: metrics
          path: "/models/{{modelRid}}/metrics"
          inputParameters:
            - name: modelRid
              in: path
          operations:
            - name: get-model-metrics
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Runs batch inference on a trained Foundry ML model by pulling input features from a dataset, invoking the model endpoint, storing predictions back in Foundry, and logging metrics to Datadog.

naftiko: "0.5"
info:
  label: "Foundry Model Inference Orchestrator"
  description: "Runs batch inference on a trained Foundry ML model by pulling input features from a dataset, invoking the model endpoint, storing predictions back in Foundry, and logging metrics to Datadog."
  tags:
    - data-analytics
    - foundry
    - machine-learning
    - datadog
capability:
  exposes:
    - type: mcp
      namespace: ml-inference
      port: 8080
      tools:
        - name: run-batch-inference
          description: "Orchestrate batch inference: pull features, invoke model, store predictions, and log metrics."
          inputParameters:
            - name: model_rid
              in: body
              type: string
              description: "The Foundry model resource identifier."
            - name: input_dataset_rid
              in: body
              type: string
              description: "The input features dataset RID."
            - name: output_dataset_rid
              in: body
              type: string
              description: "The predictions output dataset RID."
          steps:
            - name: get-input-data
              type: call
              call: "foundry.read-dataset"
              with:
                dataset_rid: "{{input_dataset_rid}}"
            - name: invoke-model
              type: call
              call: "foundry.invoke-model"
              with:
                model_rid: "{{model_rid}}"
                input: "{{get-input-data.data}}"
            - name: store-predictions
              type: call
              call: "foundry.write-dataset"
              with:
                dataset_rid: "{{output_dataset_rid}}"
                data: "{{invoke-model.predictions}}"
            - name: log-metrics
              type: call
              call: "datadog.submit-metrics"
              with:
                metric_name: "foundry.model.inference.records"
                value: "{{invoke-model.prediction_count}}"
                tags:
                  - "model:{{model_rid}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets/{{dataset_rid}}/records"
          inputParameters:
            - name: dataset_rid
              in: path
          operations:
            - name: read-dataset
              method: GET
            - name: write-dataset
              method: POST
        - name: models
          path: "/models/{{model_rid}}/invoke"
          inputParameters:
            - name: model_rid
              in: path
          operations:
            - name: invoke-model
              method: POST
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v2"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: metrics
          path: "/series"
          operations:
            - name: submit-metrics
              method: POST

Triggers model retraining in Foundry, validates performance, and updates deployment via Slack notification.

naftiko: "0.5"
info:
  label: "Foundry Model Retraining Orchestrator"
  description: "Triggers model retraining in Foundry, validates performance, and updates deployment via Slack notification."
  tags:
    - ml
    - foundry
    - slack
capability:
  exposes:
    - type: mcp
      namespace: foundry-model-retraining
      port: 8080
      tools:
        - name: foundry-model-retraining
          description: "Triggers model retraining in Foundry."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Foundry Model Retraining processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves group details from Foundry Multipass identity service, returning group name, member count, and group description.

naftiko: "0.5"
info:
  label: "Foundry Multipass Group Lookup"
  description: "Retrieves group details from Foundry Multipass identity service, returning group name, member count, and group description."
  tags:
    - security
    - foundry
    - identity
capability:
  exposes:
    - type: mcp
      namespace: identity-mgmt
      port: 8080
      tools:
        - name: get-multipass-group
          description: "Look up a Multipass group by ID. Returns group details and member count."
          inputParameters:
            - name: group_id
              in: body
              type: string
              description: "The Multipass group identifier."
          call: "foundry.get-group"
          with:
            group_id: "{{group_id}}"
          outputParameters:
            - name: group_name
              type: string
              mapping: "$.name"
            - name: member_count
              type: number
              mapping: "$.memberCount"
            - name: description
              type: string
              mapping: "$.description"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/multipass/api"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: groups
          path: "/groups/{{group_id}}"
          inputParameters:
            - name: group_id
              in: path
          operations:
            - name: get-group
              method: GET

Retrieves configuration for a Foundry notification channel.

naftiko: "0.5"
info:
  label: "Foundry Notification Channel Lookup"
  description: "Retrieves configuration for a Foundry notification channel."
  tags:
    - operations
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: notifications
      port: 8080
      tools:
        - name: get-channel-config
          description: "Look up Foundry notification channel config."
          inputParameters:
            - name: channel_rid
              in: body
              type: string
              description: "Notification channel RID."
          call: "foundry.get-channel"
          with:
            rid: "{{channel_rid}}"
          outputParameters:
            - name: name
              type: string
              mapping: "$.channel.name"
            - name: type
              type: string
              mapping: "$.channel.type"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: notifications
          path: "/notifications/channels/{{rid}}"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-channel
              method: GET

Performs aggregation queries against a Foundry Ontology object set, returning count, sum, average, and groupBy results for specified properties.

naftiko: "0.5"
info:
  label: "Foundry Object Set Aggregation Lookup"
  description: "Performs aggregation queries against a Foundry Ontology object set, returning count, sum, average, and groupBy results for specified properties."
  tags:
    - data-analytics
    - foundry
    - ontology
capability:
  exposes:
    - type: mcp
      namespace: ontology-analytics
      port: 8080
      tools:
        - name: aggregate-object-set
          description: "Run aggregation on an Ontology object set. Returns count, sum, avg for specified properties."
          inputParameters:
            - name: object_type
              in: body
              type: string
              description: "The Ontology object type API name."
            - name: aggregation
              in: body
              type: string
              description: "Aggregation type: count, sum, avg, min, max."
            - name: property
              in: body
              type: string
              description: "The property to aggregate on."
          call: "foundry.aggregate-objects"
          with:
            object_type: "{{object_type}}"
            aggregation: "{{aggregation}}"
            property: "{{property}}"
          outputParameters:
            - name: result
              type: number
              mapping: "$.aggregationResult"
            - name: object_count
              type: number
              mapping: "$.totalObjects"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: ontology
          path: "/ontologies/default/objectTypes/{{object_type}}/objects/aggregate"
          inputParameters:
            - name: object_type
              in: path
          operations:
            - name: aggregate-objects
              method: POST

Retrieves the schema definition of an Ontology object type, returning property names, types, and link definitions.

naftiko: "0.5"
info:
  label: "Foundry Object Type Definition Lookup"
  description: "Retrieves the schema definition of an Ontology object type, returning property names, types, and link definitions."
  tags:
    - data-analytics
    - foundry
    - ontology
capability:
  exposes:
    - type: mcp
      namespace: ontology-mgmt
      port: 8080
      tools:
        - name: get-object-type-definition
          description: "Look up an Ontology object type schema. Returns properties and links."
          inputParameters:
            - name: object_type_api_name
              in: body
              type: string
              description: "The API name of the Ontology object type."
          call: "foundry.get-object-type"
          with:
            api_name: "{{object_type_api_name}}"
          outputParameters:
            - name: display_name
              type: string
              mapping: "$.displayName"
            - name: properties
              type: array
              mapping: "$.properties"
            - name: links
              type: array
              mapping: "$.links"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: ontology
          path: "/ontologies/default/objectTypes/{{api_name}}"
          inputParameters:
            - name: api_name
              in: path
          operations:
            - name: get-object-type
              method: GET

Executes an ontology action in Palantir Foundry, validates the result, and posts confirmation to Slack.

naftiko: "0.5"
info:
  label: "Foundry Ontology Action Executor"
  description: "Executes an ontology action in Palantir Foundry, validates the result, and posts confirmation to Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - ontology
    - slack
capability:
  exposes:
    - type: mcp
      namespace: ontology-action
      port: 8080
      tools:
        - name: execute-ontology-action
          description: "Given an action type and parameters, execute the Foundry ontology action and confirm via Slack."
          inputParameters:
            - name: action_type
              in: body
              type: string
              description: "Foundry ontology action type."
            - name: object_type
              in: body
              type: string
              description: "Target object type."
            - name: primary_key
              in: body
              type: string
              description: "Primary key of the target object."
          steps:
            - name: execute-action
              type: call
              call: "foundry.apply-action"
              with:
                actionType: "{{action_type}}"
                objectType: "{{object_type}}"
                primaryKey: "{{primary_key}}"
            - name: confirm
              type: call
              call: "slack.post-message"
              with:
                channel: "data-ops"
                text: "Ontology action executed: {{action_type}} on {{object_type}}/{{primary_key}} | Status: {{execute-action.status}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: actions
          path: "/ontologies/default/actions/{{actionType}}/apply"
          inputParameters:
            - name: actionType
              in: path
          operations:
            - name: apply-action
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves recent events from a Foundry Ontology event stream, returning event type, timestamp, affected object IDs, and payload summary.

naftiko: "0.5"
info:
  label: "Foundry Ontology Event Stream Lookup"
  description: "Retrieves recent events from a Foundry Ontology event stream, returning event type, timestamp, affected object IDs, and payload summary."
  tags:
    - data-analytics
    - foundry
    - ontology
    - events
capability:
  exposes:
    - type: mcp
      namespace: ontology-events
      port: 8080
      tools:
        - name: get-event-stream
          description: "Look up recent events from an Ontology event stream. Returns event details and payloads."
          inputParameters:
            - name: stream_rid
              in: body
              type: string
              description: "The event stream resource identifier."
            - name: limit
              in: body
              type: number
              description: "Number of recent events to retrieve."
          call: "foundry.get-events"
          with:
            stream_rid: "{{stream_rid}}"
            limit: "{{limit}}"
          outputParameters:
            - name: events
              type: array
              mapping: "$.data"
              items:
                - name: event_type
                  type: string
                  mapping: "$.eventType"
                - name: timestamp
                  type: string
                  mapping: "$.timestamp"
                - name: object_id
                  type: string
                  mapping: "$.objectId"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: events
          path: "/ontologies/default/eventStreams/{{stream_rid}}/events"
          inputParameters:
            - name: stream_rid
              in: path
          operations:
            - name: get-events
              method: GET

Analyzes linked objects in the Foundry ontology for a given entity, generates a relationship summary, and posts to Slack.

naftiko: "0.5"
info:
  label: "Foundry Ontology Link Analysis"
  description: "Analyzes linked objects in the Foundry ontology for a given entity, generates a relationship summary, and posts to Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - ontology
    - slack
capability:
  exposes:
    - type: mcp
      namespace: link-analysis
      port: 8080
      tools:
        - name: analyze-links
          description: "Given an object type and primary key, analyze linked objects and post a summary."
          inputParameters:
            - name: object_type
              in: body
              type: string
              description: "Ontology object type."
            - name: primary_key
              in: body
              type: string
              description: "Primary key of the entity."
          steps:
            - name: get-links
              type: call
              call: "foundry.get-links"
              with:
                objectType: "{{object_type}}"
                primaryKey: "{{primary_key}}"
            - name: post-analysis
              type: call
              call: "slack.post-message"
              with:
                channel: "analytics"
                text: "Link Analysis: {{object_type}}/{{primary_key}} | Total links: {{get-links.total}} | Link types: {{get-links.link_types}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: links
          path: "/ontologies/default/objects/{{objectType}}/{{primaryKey}}/links"
          inputParameters:
            - name: objectType
              in: path
            - name: primaryKey
              in: path
          operations:
            - name: get-links
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the object count for a Foundry ontology type.

naftiko: "0.5"
info:
  label: "Foundry Ontology Object Count Lookup"
  description: "Retrieves the object count for a Foundry ontology type."
  tags:
    - data-platform
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: ontology-metrics
      port: 8080
      tools:
        - name: get-object-count
          description: "Look up ontology object count by type."
          inputParameters:
            - name: object_type
              in: body
              type: string
              description: "Foundry ontology object type."
          call: "foundry.get-ontology-count"
          with:
            type: "{{object_type}}"
          outputParameters:
            - name: count
              type: number
              mapping: "$.totalCount"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: ontology
          path: "/ontologies/{{ontology_rid}}/objectTypes/{{type}}/objects"
          inputParameters:
            - name: type
              in: path
          operations:
            - name: get-ontology-count
              method: GET

Retrieves an ontology object from Palantir Foundry by type and primary key, returning properties and linked objects.

naftiko: "0.5"
info:
  label: "Foundry Ontology Object Lookup"
  description: "Retrieves an ontology object from Palantir Foundry by type and primary key, returning properties and linked objects."
  tags:
    - data-platform
    - foundry
    - palantir
    - ontology
capability:
  exposes:
    - type: mcp
      namespace: foundry-ontology
      port: 8080
      tools:
        - name: get-ontology-object
          description: "Given an object type and primary key, return the object's properties and linked object count."
          inputParameters:
            - name: object_type
              in: body
              type: string
              description: "Foundry ontology object type."
            - name: primary_key
              in: body
              type: string
              description: "Primary key of the object."
          call: "foundry.get-object"
          with:
            objectType: "{{object_type}}"
            primaryKey: "{{primary_key}}"
          outputParameters:
            - name: rid
              type: string
              mapping: "$.rid"
            - name: properties
              type: string
              mapping: "$.properties"
            - name: link_count
              type: string
              mapping: "$.linkCount"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: objects
          path: "/ontologies/default/objects/{{objectType}}/{{primaryKey}}"
          inputParameters:
            - name: objectType
              in: path
            - name: primaryKey
              in: path
          operations:
            - name: get-object
              method: GET

Migrates ontology schemas by validating changes, creating ServiceNow change requests, and notifying teams.

naftiko: "0.5"
info:
  label: "Foundry Ontology Schema Migration Orchestrator"
  description: "Migrates ontology schemas by validating changes, creating ServiceNow change requests, and notifying teams."
  tags:
    - data-platform
    - foundry
    - servicenow
    - slack
capability:
  exposes:
    - type: mcp
      namespace: foundry-ontology-schema-m
      port: 8080
      tools:
        - name: foundry-ontology-schema-migration
          description: "Migrates ontology schemas by validating changes."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Foundry Ontology Schema Migration for {{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Foundry Ontology Schema Migration processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
        - name: changes
          path: "/table/change_request"
          operations:
            - name: create-change
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Searches the Palantir Foundry ontology for objects matching a query, returning matching objects with properties.

naftiko: "0.5"
info:
  label: "Foundry Ontology Search"
  description: "Searches the Palantir Foundry ontology for objects matching a query, returning matching objects with properties."
  tags:
    - data-platform
    - foundry
    - palantir
    - ontology
    - lookup
capability:
  exposes:
    - type: mcp
      namespace: ontology-search
      port: 8080
      tools:
        - name: search-ontology
          description: "Given an object type and search query, return matching ontology objects."
          inputParameters:
            - name: object_type
              in: body
              type: string
              description: "Ontology object type."
            - name: query
              in: body
              type: string
              description: "Search query string."
          call: "foundry.search-objects"
          with:
            objectType: "{{object_type}}"
            q: "{{query}}"
          outputParameters:
            - name: total_count
              type: string
              mapping: "$.totalCount"
            - name: first_result
              type: string
              mapping: "$.data[0].properties"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: objects
          path: "/ontologies/default/objects/{{objectType}}/search"
          inputParameters:
            - name: objectType
              in: path
            - name: q
              in: query
          operations:
            - name: search-objects
              method: GET

Exports Ontology object data from Foundry, transforms it for analytics consumption, loads it into Snowflake, and verifies row counts match between source and destination.

naftiko: "0.5"
info:
  label: "Foundry Ontology Sync to Snowflake Orchestrator"
  description: "Exports Ontology object data from Foundry, transforms it for analytics consumption, loads it into Snowflake, and verifies row counts match between source and destination."
  tags:
    - data-analytics
    - foundry
    - snowflake
    - data-pipeline
capability:
  exposes:
    - type: mcp
      namespace: data-sync
      port: 8080
      tools:
        - name: sync-ontology-to-snowflake
          description: "Orchestrate Ontology-to-Snowflake data sync: export objects, transform, load, and verify."
          inputParameters:
            - name: object_type
              in: body
              type: string
              description: "The Ontology object type API name."
            - name: target_table
              in: body
              type: string
              description: "The Snowflake target table name."
          steps:
            - name: export-objects
              type: call
              call: "foundry.export-ontology-objects"
              with:
                object_type: "{{object_type}}"
            - name: load-to-snowflake
              type: call
              call: "snowflake.load-data"
              with:
                table: "{{target_table}}"
                data: "{{export-objects.data}}"
            - name: verify-counts
              type: call
              call: "snowflake.query-row-count"
              with:
                table: "{{target_table}}"
            - name: log-sync-result
              type: call
              call: "foundry.log-sync-event"
              with:
                object_type: "{{object_type}}"
                source_count: "{{export-objects.row_count}}"
                target_count: "{{verify-counts.row_count}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: ontology-export
          path: "/ontologies/default/objectTypes/{{object_type}}/objects"
          inputParameters:
            - name: object_type
              in: path
          operations:
            - name: export-ontology-objects
              method: GET
        - name: sync-logs
          path: "/datasets/sync-logs/records"
          operations:
            - name: log-sync-event
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://palantir.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: queries
          path: "/statements"
          operations:
            - name: load-data
              method: POST
            - name: query-row-count
              method: POST

When a Foundry pipeline build fails, retrieves the build error details, creates a Jira ticket for the data engineering team, and sends a Slack alert with the failure summary.

naftiko: "0.5"
info:
  label: "Foundry Pipeline Build to Jira Orchestrator"
  description: "When a Foundry pipeline build fails, retrieves the build error details, creates a Jira ticket for the data engineering team, and sends a Slack alert with the failure summary."
  tags:
    - data-analytics
    - foundry
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: pipeline-ops
      port: 8080
      tools:
        - name: handle-build-failure
          description: "Orchestrate pipeline build failure response: get error details, create Jira ticket, and send Slack alert."
          inputParameters:
            - name: build_rid
              in: body
              type: string
              description: "The Foundry pipeline build resource identifier."
          steps:
            - name: get-build-details
              type: call
              call: "foundry.get-build"
              with:
                build_rid: "{{build_rid}}"
            - name: create-jira-ticket
              type: call
              call: "jira.create-issue"
              with:
                project: "DATA"
                issue_type: "Bug"
                summary: "Pipeline build failure: {{get-build-details.pipeline_name}}"
                description: "Error: {{get-build-details.error_message}}. Build: {{build_rid}}"
            - name: send-slack-alert
              type: call
              call: "slack.post-message"
              with:
                channel: "data-eng-alerts"
                text: "Pipeline build failed: {{get-build-details.pipeline_name}}. Jira: {{create-jira-ticket.key}}. Error: {{get-build-details.error_message}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: builds
          path: "/builds/{{build_rid}}"
          inputParameters:
            - name: build_rid
              in: path
          operations:
            - name: get-build
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Remediates pipeline failures by analyzing logs, creating Jira tickets, and notifying engineers via Slack.

naftiko: "0.5"
info:
  label: "Foundry Pipeline Failure Remediation Orchestrator"
  description: "Remediates pipeline failures by analyzing logs, creating Jira tickets, and notifying engineers via Slack."
  tags:
    - data-platform
    - foundry
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: foundry-pipeline-failure-
      port: 8080
      tools:
        - name: foundry-pipeline-failure-remediation
          description: "Remediates pipeline failures by analyzing logs."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-issue
              type: call
              call: "jira.create-issue"
              with:
                project: "PLAT"
                summary: "Foundry Pipeline Failure Remediation"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Foundry Pipeline Failure Remediation processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Foundry pipeline build fails, creates a Jira bug ticket with build context and notifies the data engineering team via Slack.

naftiko: "0.5"
info:
  label: "Foundry Pipeline Failure to Jira"
  description: "When a Foundry pipeline build fails, creates a Jira bug ticket with build context and notifies the data engineering team via Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: pipeline-failure
      port: 8080
      tools:
        - name: handle-pipeline-failure
          description: "Given a failed pipeline RID, fetch build details, create a Jira ticket, and alert the team."
          inputParameters:
            - name: pipeline_rid
              in: body
              type: string
              description: "Foundry pipeline RID."
            - name: build_id
              in: body
              type: string
              description: "Failed build ID."
          steps:
            - name: get-build
              type: call
              call: "foundry.get-build"
              with:
                pipelineRid: "{{pipeline_rid}}"
                buildId: "{{build_id}}"
            - name: create-jira
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "Pipeline failure: {{get-build.pipeline_name}}"
                description: "Build: {{build_id}}\nStatus: {{get-build.status}}\nError: {{get-build.error_message}}\nDuration: {{get-build.duration_seconds}}s"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "data-engineering"
                text: "Pipeline failure: {{get-build.pipeline_name}} | Build: {{build_id}} | Jira: {{create-jira.key}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: builds
          path: "/builds/{{pipelineRid}}/{{buildId}}"
          inputParameters:
            - name: pipelineRid
              in: path
            - name: buildId
              in: path
          operations:
            - name: get-build
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors data pipeline SLA compliance by checking Foundry transform completion times, comparing against defined thresholds, creating ServiceNow tickets for breaches, and posting a daily summary to Slack.

naftiko: "0.5"
info:
  label: "Foundry Pipeline SLA Monitoring Orchestrator"
  description: "Monitors data pipeline SLA compliance by checking Foundry transform completion times, comparing against defined thresholds, creating ServiceNow tickets for breaches, and posting a daily summary to Slack."
  tags:
    - data-analytics
    - foundry
    - servicenow
    - slack
    - monitoring
capability:
  exposes:
    - type: mcp
      namespace: pipeline-sla
      port: 8080
      tools:
        - name: monitor-pipeline-slas
          description: "Orchestrate pipeline SLA monitoring: check completion times, flag breaches, create tickets, and post summary."
          inputParameters:
            - name: project_rid
              in: body
              type: string
              description: "The Foundry project resource identifier."
          steps:
            - name: check-pipeline-times
              type: call
              call: "foundry.get-pipeline-completion-times"
              with:
                project_rid: "{{project_rid}}"
            - name: identify-breaches
              type: call
              call: "foundry.check-sla-thresholds"
              with:
                completion_data: "{{check-pipeline-times.pipelines}}"
            - name: create-breach-tickets
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Pipeline SLA breach in project {{project_rid}}"
                description: "{{identify-breaches.breach_count}} pipelines breached SLA. Worst: {{identify-breaches.worst_pipeline}} ({{identify-breaches.worst_delay_minutes}} min late)."
                category: "data_pipeline"
            - name: post-summary
              type: call
              call: "slack.post-message"
              with:
                channel: "data-ops"
                text: "Pipeline SLA report: {{check-pipeline-times.total_pipelines}} monitored, {{identify-breaches.breach_count}} breaches. On-time rate: {{identify-breaches.on_time_pct}}%."
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: pipelines
          path: "/projects/{{project_rid}}/pipelines/completionTimes"
          inputParameters:
            - name: project_rid
              in: path
          operations:
            - name: get-pipeline-completion-times
              method: GET
        - name: sla
          path: "/pipelines/sla/check"
          operations:
            - name: check-sla-thresholds
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.snow_user"
        password: "$secrets.snow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the status of a Foundry data pipeline build by RID, returning build state, duration, and output datasets.

naftiko: "0.5"
info:
  label: "Foundry Pipeline Status Lookup"
  description: "Retrieves the status of a Foundry data pipeline build by RID, returning build state, duration, and output datasets."
  tags:
    - data-platform
    - foundry
    - palantir
    - pipeline
capability:
  exposes:
    - type: mcp
      namespace: foundry-pipeline
      port: 8080
      tools:
        - name: get-pipeline-status
          description: "Given a pipeline RID, return the latest build status, duration, and output dataset count."
          inputParameters:
            - name: pipeline_rid
              in: body
              type: string
              description: "Foundry pipeline resource identifier."
          call: "foundry.get-build"
          with:
            pipelineRid: "{{pipeline_rid}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.status"
            - name: duration_seconds
              type: string
              mapping: "$.durationSeconds"
            - name: output_count
              type: string
              mapping: "$.outputDatasets.length"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: builds
          path: "/builds/{{pipelineRid}}/latest"
          inputParameters:
            - name: pipelineRid
              in: path
          operations:
            - name: get-build
              method: GET

Retrieves a Foundry project by name, returning owner, description, and resource count.

naftiko: "0.5"
info:
  label: "Foundry Project Lookup"
  description: "Retrieves a Foundry project by name, returning owner, description, and resource count."
  tags:
    - data-platform
    - foundry
    - palantir
    - lookup
capability:
  exposes:
    - type: mcp
      namespace: foundry-project
      port: 8080
      tools:
        - name: get-project
          description: "Given a project name, return its owner, description, and number of resources."
          inputParameters:
            - name: project_name
              in: body
              type: string
              description: "Foundry project name."
          call: "foundry.get-project"
          with:
            name: "{{project_name}}"
          outputParameters:
            - name: rid
              type: string
              mapping: "$.rid"
            - name: owner
              type: string
              mapping: "$.owner"
            - name: resource_count
              type: string
              mapping: "$.resourceCount"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: projects
          path: "/projects"
          inputParameters:
            - name: name
              in: query
          operations:
            - name: get-project
              method: GET

Triggers a refresh of underlying datasets for a Palantir Quiver dashboard and posts completion status to Slack.

naftiko: "0.5"
info:
  label: "Foundry Quiver Dashboard Refresh"
  description: "Triggers a refresh of underlying datasets for a Palantir Quiver dashboard and posts completion status to Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - analytics
    - slack
capability:
  exposes:
    - type: mcp
      namespace: quiver-refresh
      port: 8080
      tools:
        - name: refresh-dashboard
          description: "Given a dashboard RID, trigger a refresh of all underlying datasets and notify upon completion."
          inputParameters:
            - name: dashboard_rid
              in: body
              type: string
              description: "Quiver dashboard RID."
          steps:
            - name: trigger-refresh
              type: call
              call: "foundry.refresh-dashboard"
              with:
                dashboardRid: "{{dashboard_rid}}"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "analytics"
                text: "Dashboard refresh triggered: {{dashboard_rid}} | Status: {{trigger-refresh.status}} | Datasets: {{trigger-refresh.dataset_count}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: dashboards
          path: "/quiver/dashboards/{{dashboardRid}}/refresh"
          inputParameters:
            - name: dashboardRid
              in: path
          operations:
            - name: refresh-dashboard
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves performance metrics for individual widgets in a Quiver dashboard, returning render time, query count, and data freshness for each widget.

naftiko: "0.5"
info:
  label: "Foundry Quiver Widget Performance Lookup"
  description: "Retrieves performance metrics for individual widgets in a Quiver dashboard, returning render time, query count, and data freshness for each widget."
  tags:
    - data-analytics
    - foundry
    - quiver
    - performance
capability:
  exposes:
    - type: mcp
      namespace: quiver-monitoring
      port: 8080
      tools:
        - name: get-widget-performance
          description: "Look up Quiver widget performance by dashboard RID. Returns render times and query counts per widget."
          inputParameters:
            - name: dashboard_rid
              in: body
              type: string
              description: "The Quiver dashboard resource identifier."
          call: "foundry.get-quiver-widget-metrics"
          with:
            rid: "{{dashboard_rid}}"
          outputParameters:
            - name: widgets
              type: array
              mapping: "$.widgets"
              items:
                - name: widget_name
                  type: string
                  mapping: "$.name"
                - name: avg_render_ms
                  type: number
                  mapping: "$.avgRenderMs"
                - name: query_count
                  type: number
                  mapping: "$.queryCount"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: quiver
          path: "/quiver/dashboards/{{rid}}/widgets/metrics"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-quiver-widget-metrics
              method: GET

Generates a Foundry compute and storage utilization report, identifies expensive pipelines, and posts to Slack for FinOps review.

naftiko: "0.5"
info:
  label: "Foundry Resource Utilization Report"
  description: "Generates a Foundry compute and storage utilization report, identifies expensive pipelines, and posts to Slack for FinOps review."
  tags:
    - data-platform
    - foundry
    - palantir
    - finops
    - slack
capability:
  exposes:
    - type: mcp
      namespace: resource-util
      port: 8080
      tools:
        - name: generate-utilization-report
          description: "Aggregate compute and storage usage from Foundry and post a FinOps report."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period, e.g. last-7d, last-30d."
          steps:
            - name: get-usage
              type: call
              call: "foundry.get-usage"
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: "slack.post-message"
              with:
                channel: "data-finops"
                text: "Foundry Utilization ({{period}}): Compute hours: {{get-usage.compute_hours}} | Storage GB: {{get-usage.storage_gb}} | Top pipeline: {{get-usage.top_pipeline}} ({{get-usage.top_cost}})"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: usage
          path: "/usage/summary"
          inputParameters:
            - name: period
              in: query
          operations:
            - name: get-usage
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves schedule details for a Foundry pipeline, returning cron expression, next run time, and enabled status.

naftiko: "0.5"
info:
  label: "Foundry Schedule Lookup"
  description: "Retrieves schedule details for a Foundry pipeline, returning cron expression, next run time, and enabled status."
  tags:
    - data-platform
    - foundry
    - palantir
    - scheduling
capability:
  exposes:
    - type: mcp
      namespace: foundry-schedule
      port: 8080
      tools:
        - name: get-schedule
          description: "Given a schedule RID, return the cron expression, next run time, and enabled status."
          inputParameters:
            - name: schedule_rid
              in: body
              type: string
              description: "Foundry schedule RID."
          call: "foundry.get-schedule"
          with:
            scheduleRid: "{{schedule_rid}}"
          outputParameters:
            - name: cron
              type: string
              mapping: "$.cronExpression"
            - name: next_run
              type: string
              mapping: "$.nextRunTime"
            - name: enabled
              type: string
              mapping: "$.enabled"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: schedules
          path: "/schedules/{{scheduleRid}}"
          inputParameters:
            - name: scheduleRid
              in: path
          operations:
            - name: get-schedule
              method: GET

Audits security markings across Foundry datasets, logs findings in ServiceNow, and notifies compliance.

naftiko: "0.5"
info:
  label: "Foundry Security Marking Audit Orchestrator"
  description: "Audits security markings across Foundry datasets, logs findings in ServiceNow, and notifies compliance."
  tags:
    - security
    - foundry
    - servicenow
    - slack
capability:
  exposes:
    - type: mcp
      namespace: foundry-security-marking-
      port: 8080
      tools:
        - name: foundry-security-marking-audit
          description: "Audits security markings across Foundry datasets."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Foundry Security Marking Audit for {{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Foundry Security Marking Audit processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
        - name: changes
          path: "/table/change_request"
          operations:
            - name: create-change
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves security markings and classification labels for a Foundry resource.

naftiko: "0.5"
info:
  label: "Foundry Security Marking Lookup"
  description: "Retrieves security markings and classification labels for a Foundry resource."
  tags:
    - data-platform
    - foundry
    - palantir
    - security
capability:
  exposes:
    - type: mcp
      namespace: foundry-markings
      port: 8080
      tools:
        - name: get-security-markings
          description: "Given a resource RID, return the security markings and classification labels."
          inputParameters:
            - name: resource_rid
              in: body
              type: string
              description: "Foundry resource RID."
          call: "foundry.get-markings"
          with:
            resourceRid: "{{resource_rid}}"
          outputParameters:
            - name: marking_ids
              type: string
              mapping: "$.markingIds"
            - name: classification
              type: string
              mapping: "$.classification"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: markings
          path: "/resources/{{resourceRid}}/markings"
          inputParameters:
            - name: resourceRid
              in: path
          operations:
            - name: get-markings
              method: GET

Generates SLA compliance reports from Datadog and Foundry metrics, publishes to Confluence.

naftiko: "0.5"
info:
  label: "Foundry SLA Compliance Report Orchestrator"
  description: "Generates SLA compliance reports from Datadog and Foundry metrics, publishes to Confluence."
  tags:
    - operations
    - foundry
    - datadog
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: foundry-sla-compliance-re
      port: 8080
      tools:
        - name: foundry-sla-compliance-report
          description: "Generates SLA compliance reports from Datadog and Foundry metrics."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: check-metrics
              type: call
              call: "datadog.get-monitors"
              with:
                entity_id: "{{entity_id}}"
            - name: publish
              type: call
              call: "confluence.create-page"
              with:
                space_key: "PLAT"
                title: "Foundry SLA Compliance Report"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          operations:
            - name: get-monitors
              method: GET
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: content
          path: "/content"
          operations:
            - name: create-page
              method: POST

Retrieves metadata for a Foundry Slate application, returning app name, connected datasets, and last published timestamp.

naftiko: "0.5"
info:
  label: "Foundry Slate App Lookup"
  description: "Retrieves metadata for a Foundry Slate application, returning app name, connected datasets, and last published timestamp."
  tags:
    - data-analytics
    - foundry
    - slate
capability:
  exposes:
    - type: mcp
      namespace: foundry-apps
      port: 8080
      tools:
        - name: get-slate-app
          description: "Look up a Slate application by RID. Returns app details and connected datasets."
          inputParameters:
            - name: app_rid
              in: body
              type: string
              description: "The Slate application resource identifier."
          call: "foundry.get-slate-app"
          with:
            rid: "{{app_rid}}"
          outputParameters:
            - name: app_name
              type: string
              mapping: "$.name"
            - name: connected_datasets
              type: number
              mapping: "$.connectedDatasetCount"
            - name: last_published
              type: string
              mapping: "$.lastPublished"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: slate
          path: "/slate/applications/{{rid}}"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-slate-app
              method: GET

Monitors Foundry-Snowflake sync health, validates row counts, and creates Jira tickets for mismatches.

naftiko: "0.5"
info:
  label: "Foundry Snowflake Sync Health Orchestrator"
  description: "Monitors Foundry-Snowflake sync health, validates row counts, and creates Jira tickets for mismatches."
  tags:
    - data-platform
    - foundry
    - snowflake
    - jira
capability:
  exposes:
    - type: mcp
      namespace: foundry-snowflake-sync-he
      port: 8080
      tools:
        - name: foundry-snowflake-sync-health
          description: "Monitors Foundry-Snowflake sync health."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: query-snowflake
              type: call
              call: "snowflake.run-query"
              with:
                entity_id: "{{entity_id}}"
            - name: create-issue
              type: call
              call: "jira.create-issue"
              with:
                project: "PLAT"
                summary: "Foundry Snowflake Sync Health"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://palantir.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.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

Monitors Foundry-to-Snowflake data sync jobs, detects failures, and alerts the data platform team via Slack.

naftiko: "0.5"
info:
  label: "Foundry Snowflake Sync Monitor"
  description: "Monitors Foundry-to-Snowflake data sync jobs, detects failures, and alerts the data platform team via Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: snowflake-sync
      port: 8080
      tools:
        - name: monitor-snowflake-sync
          description: "Check Foundry data sync status to Snowflake and alert on failures."
          inputParameters:
            - name: sync_name
              in: body
              type: string
              description: "Name of the Foundry-Snowflake sync."
          steps:
            - name: get-sync-status
              type: call
              call: "foundry.get-sync"
              with:
                syncName: "{{sync_name}}"
            - name: check-snowflake
              type: call
              call: "snowflake.query"
              with:
                sql: "SELECT COUNT(*) as row_count FROM {{sync_name}}"
            - name: post-status
              type: call
              call: "slack.post-message"
              with:
                channel: "data-platform"
                text: "Sync Monitor: {{sync_name}} | Foundry status: {{get-sync-status.status}} | Snowflake rows: {{check-snowflake.row_count}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: syncs
          path: "/data-connections/syncs/{{syncName}}"
          inputParameters:
            - name: syncName
              in: path
          operations:
            - name: get-sync
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://palantir.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: queries
          path: "/statements"
          operations:
            - name: query
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves Spark job compute resource usage for a Foundry pipeline build, returning executor count, peak memory utilization, and total compute hours consumed.

naftiko: "0.5"
info:
  label: "Foundry Spark Job Resource Usage Lookup"
  description: "Retrieves Spark job compute resource usage for a Foundry pipeline build, returning executor count, peak memory utilization, and total compute hours consumed."
  tags:
    - data-analytics
    - foundry
    - performance
    - spark
capability:
  exposes:
    - type: mcp
      namespace: compute-monitoring
      port: 8080
      tools:
        - name: get-spark-resource-usage
          description: "Look up Spark resource usage for a build. Returns executors, memory, and compute hours."
          inputParameters:
            - name: build_rid
              in: body
              type: string
              description: "The Foundry build resource identifier."
          call: "foundry.get-spark-metrics"
          with:
            build_rid: "{{build_rid}}"
          outputParameters:
            - name: executor_count
              type: number
              mapping: "$.executorCount"
            - name: peak_memory_gb
              type: number
              mapping: "$.peakMemoryGb"
            - name: compute_hours
              type: number
              mapping: "$.computeHours"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: builds
          path: "/builds/{{build_rid}}/spark/metrics"
          inputParameters:
            - name: build_rid
              in: path
          operations:
            - name: get-spark-metrics
              method: GET

Retrieves the configuration and alert status of a Foundry time series monitor, returning monitored metric, threshold values, and current alert state.

naftiko: "0.5"
info:
  label: "Foundry Time Series Monitor Lookup"
  description: "Retrieves the configuration and alert status of a Foundry time series monitor, returning monitored metric, threshold values, and current alert state."
  tags:
    - data-analytics
    - foundry
    - monitoring
capability:
  exposes:
    - type: mcp
      namespace: foundry-monitoring
      port: 8080
      tools:
        - name: get-time-series-monitor
          description: "Look up a Foundry time series monitor. Returns metric, thresholds, and alert state."
          inputParameters:
            - name: monitor_rid
              in: body
              type: string
              description: "The time series monitor resource identifier."
          call: "foundry.get-ts-monitor"
          with:
            rid: "{{monitor_rid}}"
          outputParameters:
            - name: metric_name
              type: string
              mapping: "$.metricName"
            - name: upper_threshold
              type: number
              mapping: "$.upperThreshold"
            - name: lower_threshold
              type: number
              mapping: "$.lowerThreshold"
            - name: alert_state
              type: string
              mapping: "$.currentAlertState"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: monitors
          path: "/timeSeries/monitors/{{rid}}"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-ts-monitor
              method: GET

Retrieves the upstream and downstream dependency graph for a Foundry transform, returning parent datasets, child datasets, and total depth of the dependency chain.

naftiko: "0.5"
info:
  label: "Foundry Transform Dependency Graph Lookup"
  description: "Retrieves the upstream and downstream dependency graph for a Foundry transform, returning parent datasets, child datasets, and total depth of the dependency chain."
  tags:
    - data-analytics
    - foundry
    - data-pipeline
capability:
  exposes:
    - type: mcp
      namespace: foundry-lineage
      port: 8080
      tools:
        - name: get-transform-dependencies
          description: "Look up the dependency graph for a Foundry transform. Returns upstream and downstream datasets."
          inputParameters:
            - name: transform_rid
              in: body
              type: string
              description: "The Foundry transform resource identifier."
          call: "foundry.get-dependency-graph"
          with:
            rid: "{{transform_rid}}"
          outputParameters:
            - name: upstream_datasets
              type: array
              mapping: "$.upstream"
            - name: downstream_datasets
              type: array
              mapping: "$.downstream"
            - name: chain_depth
              type: number
              mapping: "$.maxDepth"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: transforms
          path: "/transforms/{{rid}}/dependencies"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-dependency-graph
              method: GET

Retrieves execution time metrics for a Foundry transform.

naftiko: "0.5"
info:
  label: "Foundry Transform Execution Time Lookup"
  description: "Retrieves execution time metrics for a Foundry transform."
  tags:
    - data-platform
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: transform-metrics
      port: 8080
      tools:
        - name: get-transform-time
          description: "Look up Foundry transform execution time."
          inputParameters:
            - name: transform_rid
              in: body
              type: string
              description: "Foundry transform RID."
          call: "foundry.get-transform-metrics"
          with:
            rid: "{{transform_rid}}"
          outputParameters:
            - name: last_execution_ms
              type: number
              mapping: "$.metrics.lastExecutionMs"
            - name: status
              type: string
              mapping: "$.metrics.status"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: transforms
          path: "/transforms/{{rid}}/metrics"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-transform-metrics
              method: GET

Aggregates Foundry transform build health metrics, identifies failing pipelines, and distributes a health report via Slack.

naftiko: "0.5"
info:
  label: "Foundry Transform Health Report"
  description: "Aggregates Foundry transform build health metrics, identifies failing pipelines, and distributes a health report via Slack."
  tags:
    - data-platform
    - foundry
    - palantir
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: transform-health
      port: 8080
      tools:
        - name: generate-transform-health
          description: "Query recent Foundry builds, aggregate success/failure rates, and post a health report."
          inputParameters:
            - name: hours
              in: body
              type: string
              description: "Hours to look back."
          steps:
            - name: get-builds
              type: call
              call: "foundry.query-builds"
              with:
                lookback_hours: "{{hours}}"
            - name: post-report
              type: call
              call: "slack.post-message"
              with:
                channel: "data-engineering"
                text: "Transform Health ({{hours}}h): Total: {{get-builds.total}} | Success: {{get-builds.success_count}} | Failed: {{get-builds.failure_count}} | Rate: {{get-builds.success_rate}}%"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: builds
          path: "/builds"
          inputParameters:
            - name: lookback_hours
              in: query
          operations:
            - name: query-builds
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves code quality check results for a Foundry TypeScript transform, returning lint error count, warning count, and overall pass/fail status.

naftiko: "0.5"
info:
  label: "Foundry TypeScript Transform Linting Lookup"
  description: "Retrieves code quality check results for a Foundry TypeScript transform, returning lint error count, warning count, and overall pass/fail status."
  tags:
    - data-analytics
    - foundry
    - engineering
    - code-quality
capability:
  exposes:
    - type: mcp
      namespace: foundry-code-quality
      port: 8080
      tools:
        - name: get-transform-lint-results
          description: "Look up lint check results for a TypeScript transform. Returns errors, warnings, and status."
          inputParameters:
            - name: transform_rid
              in: body
              type: string
              description: "The Foundry transform resource identifier."
          call: "foundry.get-lint-results"
          with:
            rid: "{{transform_rid}}"
          outputParameters:
            - name: error_count
              type: number
              mapping: "$.errors"
            - name: warning_count
              type: number
              mapping: "$.warnings"
            - name: status
              type: string
              mapping: "$.overallStatus"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: transforms
          path: "/transforms/{{rid}}/checks/lint"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-lint-results
              method: GET

Reviews Foundry user permissions, validates against Okta groups, and creates ServiceNow tickets for anomalies.

naftiko: "0.5"
info:
  label: "Foundry User Access Review Orchestrator"
  description: "Reviews Foundry user permissions, validates against Okta groups, and creates ServiceNow tickets for anomalies."
  tags:
    - security
    - foundry
    - okta
    - servicenow
capability:
  exposes:
    - type: mcp
      namespace: foundry-user-access-revie
      port: 8080
      tools:
        - name: foundry-user-access-review
          description: "Reviews Foundry user permissions."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: create-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Foundry User Access Review for {{entity_id}}"
            - name: provision-access
              type: call
              call: "okta.assign-user"
              with:
                entity_id: "{{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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
        - name: requests
          path: "/table/sc_request"
          operations:
            - name: create-request
              method: POST
        - name: changes
          path: "/table/change_request"
          operations:
            - name: create-change
              method: POST
    - type: http
      namespace: okta
      baseUri: "https://palantir.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users"
          operations:
            - name: assign-user
              method: POST

Onboards a new user to Palantir Foundry by creating their account, assigning project access, granting Okta groups, and notifying their manager.

naftiko: "0.5"
info:
  label: "Foundry User Onboarding Workflow"
  description: "Onboards a new user to Palantir Foundry by creating their account, assigning project access, granting Okta groups, and notifying their manager."
  tags:
    - data-platform
    - foundry
    - palantir
    - okta
    - slack
    - onboarding
capability:
  exposes:
    - type: mcp
      namespace: foundry-onboard
      port: 8080
      tools:
        - name: onboard-foundry-user
          description: "Given user details, create Foundry account, assign projects, and notify via Slack."
          inputParameters:
            - name: email
              in: body
              type: string
              description: "User email address."
            - name: team
              in: body
              type: string
              description: "Team name for project assignment."
          steps:
            - name: create-user
              type: call
              call: "foundry.create-user"
              with:
                email: "{{email}}"
                group: "{{team}}-analysts"
            - name: add-okta-group
              type: call
              call: "okta.add-group-member"
              with:
                user_id: "{{email}}"
                group_id: "foundry-{{team}}"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "{{team}}"
                text: "New Foundry user onboarded: {{email}} | Team: {{team}} | Projects assigned."
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: users
          path: "/users"
          operations:
            - name: create-user
              method: POST
    - type: http
      namespace: okta
      baseUri: "https://palantir.okta.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.okta_api_token"
      resources:
        - name: group-members
          path: "/groups/{{group_id}}/users/{{user_id}}"
          inputParameters:
            - name: group_id
              in: path
            - name: user_id
              in: path
          operations:
            - name: add-group-member
              method: PUT
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves user permissions for a Foundry resource, returning role assignments and access level.

naftiko: "0.5"
info:
  label: "Foundry User Permissions Lookup"
  description: "Retrieves user permissions for a Foundry resource, returning role assignments and access level."
  tags:
    - data-platform
    - foundry
    - palantir
    - access-management
capability:
  exposes:
    - type: mcp
      namespace: foundry-perms
      port: 8080
      tools:
        - name: get-user-permissions
          description: "Given a user ID and resource RID, return the user's role and access level."
          inputParameters:
            - name: user_id
              in: body
              type: string
              description: "Foundry user ID."
            - name: resource_rid
              in: body
              type: string
              description: "Resource RID to check permissions for."
          call: "foundry.get-permissions"
          with:
            userId: "{{user_id}}"
            resourceRid: "{{resource_rid}}"
          outputParameters:
            - name: role
              type: string
              mapping: "$.role"
            - name: access_level
              type: string
              mapping: "$.accessLevel"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: permissions
          path: "/permissions/{{resourceRid}}/users/{{userId}}"
          inputParameters:
            - name: userId
              in: path
            - name: resourceRid
              in: path
          operations:
            - name: get-permissions
              method: GET

Retrieves recent webhook event deliveries from Foundry by webhook ID, returning status and payload summary.

naftiko: "0.5"
info:
  label: "Foundry Webhook Event Lookup"
  description: "Retrieves recent webhook event deliveries from Foundry by webhook ID, returning status and payload summary."
  tags:
    - data-platform
    - foundry
    - palantir
    - webhook
capability:
  exposes:
    - type: mcp
      namespace: foundry-webhook
      port: 8080
      tools:
        - name: get-webhook-events
          description: "Given a webhook ID, return recent delivery statuses and payloads."
          inputParameters:
            - name: webhook_id
              in: body
              type: string
              description: "Foundry webhook ID."
          call: "foundry.get-webhook-events"
          with:
            webhookId: "{{webhook_id}}"
          outputParameters:
            - name: total_deliveries
              type: string
              mapping: "$.totalCount"
            - name: last_status
              type: string
              mapping: "$.events[0].status"
            - name: last_timestamp
              type: string
              mapping: "$.events[0].timestamp"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: webhooks
          path: "/webhooks/{{webhookId}}/events"
          inputParameters:
            - name: webhookId
              in: path
          operations:
            - name: get-webhook-events
              method: GET

Generates weekly platform usage reports from Foundry metrics, publishes to Confluence, and distributes via email.

naftiko: "0.5"
info:
  label: "Foundry Weekly Platform Report Orchestrator"
  description: "Generates weekly platform usage reports from Foundry metrics, publishes to Confluence, and distributes via email."
  tags:
    - operations
    - foundry
    - confluence
    - email
capability:
  exposes:
    - type: mcp
      namespace: foundry-weekly-platform-r
      port: 8080
      tools:
        - name: foundry-weekly-platform-report
          description: "Generates weekly platform usage reports from Foundry metrics."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: publish
              type: call
              call: "confluence.create-page"
              with:
                space_key: "PLAT"
                title: "Foundry Weekly Platform Report"
            - name: send-email
              type: call
              call: "email.send-message"
              with:
                to: "team@palantir.com"
                subject: "Foundry Weekly Platform Report"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: content
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: email
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.graph_token"
      resources:
        - name: mail
          path: "/me/sendMail"
          operations:
            - name: send-message
              method: POST

Retrieves usage analytics for a Foundry Workshop application, returning daily active users, page views, and average session duration over the last 30 days.

naftiko: "0.5"
info:
  label: "Foundry Workshop App Usage Lookup"
  description: "Retrieves usage analytics for a Foundry Workshop application, returning daily active users, page views, and average session duration over the last 30 days."
  tags:
    - data-analytics
    - foundry
    - workshop
    - usage
capability:
  exposes:
    - type: mcp
      namespace: foundry-analytics
      port: 8080
      tools:
        - name: get-workshop-usage
          description: "Look up Workshop app usage metrics. Returns DAU, page views, and session duration."
          inputParameters:
            - name: app_rid
              in: body
              type: string
              description: "The Workshop application resource identifier."
          call: "foundry.get-app-usage"
          with:
            app_rid: "{{app_rid}}"
          outputParameters:
            - name: daily_active_users
              type: number
              mapping: "$.metrics.dau"
            - name: page_views_30d
              type: number
              mapping: "$.metrics.pageViews30d"
            - name: avg_session_minutes
              type: number
              mapping: "$.metrics.avgSessionMinutes"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: usage
          path: "/applications/{{app_rid}}/usage"
          inputParameters:
            - name: app_rid
              in: path
          operations:
            - name: get-app-usage
              method: GET

Retrieves metadata for a Foundry Workshop module.

naftiko: "0.5"
info:
  label: "Foundry Workshop Module Lookup"
  description: "Retrieves metadata for a Foundry Workshop module."
  tags:
    - analytics
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: workshop-info
      port: 8080
      tools:
        - name: get-module-info
          description: "Look up Workshop module metadata."
          inputParameters:
            - name: module_rid
              in: body
              type: string
              description: "Workshop module RID."
          call: "foundry.get-module"
          with:
            rid: "{{module_rid}}"
          outputParameters:
            - name: title
              type: string
              mapping: "$.module.title"
            - name: last_modified
              type: string
              mapping: "$.module.lastModified"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: workshop
          path: "/workshop/modules/{{rid}}"
          inputParameters:
            - name: rid
              in: path
          operations:
            - name: get-module
              method: GET

Pulls code scanning alerts from GitHub repositories, ingests findings into a Foundry dataset for trend analysis, and creates Jira tickets for critical vulnerabilities.

naftiko: "0.5"
info:
  label: "GitHub Code Scanning to Foundry Orchestrator"
  description: "Pulls code scanning alerts from GitHub repositories, ingests findings into a Foundry dataset for trend analysis, and creates Jira tickets for critical vulnerabilities."
  tags:
    - security
    - data-analytics
    - github
    - foundry
    - jira
capability:
  exposes:
    - type: mcp
      namespace: devsecops
      port: 8080
      tools:
        - name: ingest-code-scanning-alerts
          description: "Orchestrate code scanning alert ingestion: pull alerts, store in Foundry, and create tickets for criticals."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository (org/repo)."
          steps:
            - name: get-alerts
              type: call
              call: "github.get-code-scanning-alerts"
              with:
                repo: "{{repo_name}}"
            - name: ingest-to-foundry
              type: call
              call: "foundry.write-dataset"
              with:
                dataset_rid: "code-scanning-alerts"
                data: "{{get-alerts.alerts}}"
            - name: create-critical-tickets
              type: call
              call: "jira.create-issue"
              with:
                project: "SEC"
                issue_type: "Bug"
                summary: "Critical code scan: {{repo_name}} - {{get-alerts.critical_count}} findings"
                priority: "Critical"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: code-scanning
          path: "/repos/{{repo}}/code-scanning/alerts"
          inputParameters:
            - name: repo
              in: path
          operations:
            - name: get-code-scanning-alerts
              method: GET
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets/{{dataset_rid}}/records"
          inputParameters:
            - name: dataset_rid
              in: path
          operations:
            - name: write-dataset
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

Retrieves the latest release for a Palantir Foundry plugin on GitHub.

naftiko: "0.5"
info:
  label: "GitHub Foundry Plugin Release Lookup"
  description: "Retrieves the latest release for a Palantir Foundry plugin on GitHub."
  tags:
    - cicd
    - github
capability:
  exposes:
    - type: mcp
      namespace: plugin-releases
      port: 8080
      tools:
        - name: get-latest-release
          description: "Look up latest Foundry plugin release."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "GitHub repository name."
          call: "github.get-release"
          with:
            repo: "{{repo_name}}"
          outputParameters:
            - name: tag
              type: string
              mapping: "$.tag_name"
            - name: published_at
              type: string
              mapping: "$.published_at"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/palantir/{{repo}}/releases/latest"
          inputParameters:
            - name: repo
              in: path
          operations:
            - name: get-release
              method: GET

When a pull request is opened or updated on a protected branch in GitHub, creates a Jira review task and notifies the reviewer in Microsoft Teams.

naftiko: "0.5"
info:
  label: "GitHub Pull Request Review Notifier"
  description: "When a pull request is opened or updated on a protected branch in GitHub, creates a Jira review task and notifies the reviewer in Microsoft Teams."
  tags:
    - devops
    - github
    - jira
    - microsoft-teams
    - code-review
capability:
  exposes:
    - type: mcp
      namespace: devops-pr
      port: 8080
      tools:
        - name: notify-pr-review
          description: "Given a GitHub pull request URL, repo, and reviewer Teams UPN, create a Jira review task and send a Teams notification to the assigned reviewer."
          inputParameters:
            - name: repo
              in: body
              type: string
              description: "The GitHub repository name in 'org/repo' format."
            - name: pr_number
              in: body
              type: integer
              description: "The GitHub pull request number."
            - name: reviewer_upn
              in: body
              type: string
              description: "The Microsoft Teams UPN of the reviewer to notify."
          steps:
            - name: get-pr
              type: call
              call: github.get-pr
              with:
                repo: "{{repo}}"
                pr_number: "{{pr_number}}"
            - name: create-review-task
              type: call
              call: jira.create-issue
              with:
                project_key: "ENG"
                issuetype: "Task"
                summary: "PR Review: {{get-pr.title}}"
                description: "Review required for {{repo}}#{{pr_number}}: {{get-pr.html_url}}"
            - name: notify-reviewer
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{reviewer_upn}}"
                text: "PR review requested: {{get-pr.title}} in {{repo}}. Jira: {{create-review-task.key}}. Link: {{get-pr.html_url}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pull-requests
          path: "/repos/{{repo}}/pulls/{{pr_number}}"
          inputParameters:
            - name: repo
              in: path
            - name: pr_number
              in: path
          operations:
            - name: get-pr
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_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.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a GitHub release is published, creates a Datadog deployment marker, transitions the Jira release issue to Done, and posts a deployment notice in Teams.

naftiko: "0.5"
info:
  label: "GitHub Release Deployment Tracker"
  description: "When a GitHub release is published, creates a Datadog deployment marker, transitions the Jira release issue to Done, and posts a deployment notice in Teams."
  tags:
    - devops
    - github
    - datadog
    - jira
    - deployment
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: deployment-ops
      port: 8080
      tools:
        - name: track-release-deployment
          description: "Given a GitHub repository, release tag, and linked Jira release key, create a Datadog deployment marker, close the Jira release, and post a deployment announcement in Teams."
          inputParameters:
            - name: repo
              in: body
              type: string
              description: "The GitHub repository in 'org/repo' format."
            - name: release_tag
              in: body
              type: string
              description: "The GitHub release tag (e.g., 'v2.4.1')."
            - name: jira_release_key
              in: body
              type: string
              description: "The Jira issue key for the release ticket (e.g., 'PLAT-200')."
            - name: teams_channel_id
              in: body
              type: string
              description: "Teams channel ID where the deployment notice should be posted."
          steps:
            - name: get-release
              type: call
              call: github.get-release
              with:
                repo: "{{repo}}"
                tag: "{{release_tag}}"
            - name: create-dd-marker
              type: call
              call: datadog.create-event
              with:
                title: "Deployment: {{repo}} {{release_tag}}"
                text: "{{get-release.body}}"
                alert_type: "info"
            - name: close-jira-release
              type: call
              call: jira.transition-issue
              with:
                issue_key: "{{jira_release_key}}"
                transition_id: "31"
            - name: announce-deployment
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{teams_channel_id}}"
                text: "Deployed: {{repo}} {{release_tag}} | Jira: {{jira_release_key}} closed | Datadog: {{create-dd-marker.url}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/{{repo}}/releases/tags/{{tag}}"
          inputParameters:
            - name: repo
              in: path
            - name: tag
              in: path
          operations:
            - name: get-release
              method: GET
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: transitions
          path: "/issue/{{issue_key}}/transitions"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: transition-issue
              method: POST
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a Dependabot or code scanning alert is raised in GitHub, creates a Jira security task and notifies the security team in Microsoft Teams.

naftiko: "0.5"
info:
  label: "GitHub Repository Security Scan Alert"
  description: "When a Dependabot or code scanning alert is raised in GitHub, creates a Jira security task and notifies the security team in Microsoft Teams."
  tags:
    - security
    - devops
    - github
    - jira
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: security-ops
      port: 8080
      tools:
        - name: handle-security-alert
          description: "Given a GitHub repository, alert number, and severity, create a Jira security task and post a Teams notification to the security channel."
          inputParameters:
            - name: repo
              in: body
              type: string
              description: "The GitHub repository in 'org/repo' format."
            - name: alert_number
              in: body
              type: integer
              description: "The GitHub security alert number."
            - name: severity
              in: body
              type: string
              description: "Alert severity: 'critical', 'high', 'medium', or 'low'."
          steps:
            - name: get-alert
              type: call
              call: github.get-security-alert
              with:
                repo: "{{repo}}"
                alert_number: "{{alert_number}}"
            - name: create-security-task
              type: call
              call: jira.create-issue
              with:
                project_key: "SEC"
                issuetype: "Task"
                summary: "[{{severity}}] Security alert in {{repo}} — {{get-alert.rule_id}}"
                description: "GitHub alert {{alert_number}} in {{repo}}. Severity: {{severity}}. Rule: {{get-alert.rule_description}}. URL: {{get-alert.html_url}}"
            - name: notify-security-team
              type: call
              call: msteams.send-message
              with:
                channel_id: "security-alerts"
                text: "Security Alert [{{severity}}]: {{repo}} | Rule: {{get-alert.rule_id}} | Jira: {{create-security-task.key}} | GitHub: {{get-alert.html_url}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: code-scanning-alerts
          path: "/repos/{{repo}}/code-scanning/alerts/{{alert_number}}"
          inputParameters:
            - name: repo
              in: path
            - name: alert_number
              in: path
          operations:
            - name: get-security-alert
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_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.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Assigns Gotham cases based on workload, updates case records, and notifies assignees via Slack.

naftiko: "0.5"
info:
  label: "Gotham Case Assignment Orchestrator"
  description: "Assigns Gotham cases based on workload, updates case records, and notifies assignees via Slack."
  tags:
    - investigations
    - gotham
    - slack
capability:
  exposes:
    - type: mcp
      namespace: gotham-case-assignment
      port: 8080
      tools:
        - name: gotham-case-assignment
          description: "Assigns Gotham cases based on workload."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: search-gotham
              type: call
              call: "gotham.search-objects"
              with:
                entity_id: "{{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Gotham Case Assignment processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: gotham
      baseUri: "https://palantir.palantirfoundry.com/gotham/api/v1"
      authentication:
        type: bearer
        token: "$secrets.gotham_token"
      resources:
        - name: objects
          path: "/objects"
          operations:
            - name: search-objects
              method: GET
            - name: create-investigation
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves investigation case status from Palantir Gotham.

naftiko: "0.5"
info:
  label: "Gotham Case Status Lookup"
  description: "Retrieves investigation case status from Palantir Gotham."
  tags:
    - investigations
    - gotham
capability:
  exposes:
    - type: mcp
      namespace: case-status
      port: 8080
      tools:
        - name: get-case-status
          description: "Look up Gotham investigation case status."
          inputParameters:
            - name: case_id
              in: body
              type: string
              description: "Gotham case identifier."
          call: "gotham.get-case"
          with:
            case_id: "{{case_id}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.case.status"
            - name: assigned_to
              type: string
              mapping: "$.case.assignedTo"
  consumes:
    - type: http
      namespace: gotham
      baseUri: "https://palantir.palantirfoundry.com/gotham/api/v1"
      authentication:
        type: bearer
        token: "$secrets.gotham_token"
      resources:
        - name: cases
          path: "/cases/{{case_id}}"
          inputParameters:
            - name: case_id
              in: path
          operations:
            - name: get-case
              method: GET

Performs entity resolution in Gotham by searching for matching person or organization entities, returning matched entity IDs, confidence scores, and linked properties.

naftiko: "0.5"
info:
  label: "Gotham Entity Resolution Lookup"
  description: "Performs entity resolution in Gotham by searching for matching person or organization entities, returning matched entity IDs, confidence scores, and linked properties."
  tags:
    - data-analytics
    - gotham
    - entity-resolution
capability:
  exposes:
    - type: mcp
      namespace: gotham-analytics
      port: 8080
      tools:
        - name: resolve-entity
          description: "Search Gotham for matching entities by name and attributes. Returns entity matches with confidence scores."
          inputParameters:
            - name: entity_name
              in: body
              type: string
              description: "The entity name to resolve."
            - name: entity_type
              in: body
              type: string
              description: "Entity type: person or organization."
          call: "gotham.resolve-entity"
          with:
            name: "{{entity_name}}"
            type: "{{entity_type}}"
          outputParameters:
            - name: matches
              type: array
              mapping: "$.results"
              items:
                - name: entity_id
                  type: string
                  mapping: "$.entityId"
                - name: confidence
                  type: number
                  mapping: "$.confidenceScore"
                - name: display_name
                  type: string
                  mapping: "$.displayName"
  consumes:
    - type: http
      namespace: gotham
      baseUri: "https://palantir.gotham.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.gotham_token"
      resources:
        - name: entities
          path: "/entities/resolve"
          operations:
            - name: resolve-entity
              method: POST

Enriches Gotham investigations with Foundry data, updates case records, and notifies analysts.

naftiko: "0.5"
info:
  label: "Gotham Investigation Enrichment Orchestrator"
  description: "Enriches Gotham investigations with Foundry data, updates case records, and notifies analysts."
  tags:
    - investigations
    - gotham
    - foundry
    - slack
capability:
  exposes:
    - type: mcp
      namespace: gotham-investigation-enri
      port: 8080
      tools:
        - name: gotham-investigation-enrichment
          description: "Enriches Gotham investigations with Foundry data."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: search-gotham
              type: call
              call: "gotham.search-objects"
              with:
                entity_id: "{{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Gotham Investigation Enrichment processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: gotham
      baseUri: "https://palantir.palantirfoundry.com/gotham/api/v1"
      authentication:
        type: bearer
        token: "$secrets.gotham_token"
      resources:
        - name: objects
          path: "/objects"
          operations:
            - name: search-objects
              method: GET
            - name: create-investigation
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves an investigation from Palantir Gotham by ID, returning status, assigned analyst, and entity count.

naftiko: "0.5"
info:
  label: "Gotham Investigation Lookup"
  description: "Retrieves an investigation from Palantir Gotham by ID, returning status, assigned analyst, and entity count."
  tags:
    - intelligence
    - gotham
    - palantir
    - lookup
capability:
  exposes:
    - type: mcp
      namespace: gotham-investigation
      port: 8080
      tools:
        - name: get-investigation
          description: "Given an investigation ID, return its status, assigned analyst, and linked entity count."
          inputParameters:
            - name: investigation_id
              in: body
              type: string
              description: "Gotham investigation ID."
          call: "gotham.get-investigation"
          with:
            id: "{{investigation_id}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.status"
            - name: analyst
              type: string
              mapping: "$.assignedAnalyst"
            - name: entity_count
              type: string
              mapping: "$.entityCount"
  consumes:
    - type: http
      namespace: gotham
      baseUri: "https://palantir.palantirgotham.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.gotham_token"
      resources:
        - name: investigations
          path: "/investigations/{{id}}"
          inputParameters:
            - name: id
              in: path
          operations:
            - name: get-investigation
              method: GET

Assesses threats using Gotham and Foundry data, creates investigation cases, and alerts analysts via Slack.

naftiko: "0.5"
info:
  label: "Gotham Threat Assessment Orchestrator"
  description: "Assesses threats using Gotham and Foundry data, creates investigation cases, and alerts analysts via Slack."
  tags:
    - investigations
    - gotham
    - foundry
    - slack
capability:
  exposes:
    - type: mcp
      namespace: gotham-threat-assessment
      port: 8080
      tools:
        - name: gotham-threat-assessment
          description: "Assesses threats using Gotham and Foundry data."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: search-gotham
              type: call
              call: "gotham.search-objects"
              with:
                entity_id: "{{entity_id}}"
            - name: notify
              type: call
              call: "slack.post-message"
              with:
                channel: "#platform-ops"
                text: "Gotham Threat Assessment processed for {{entity_id}}"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: gotham
      baseUri: "https://palantir.palantirfoundry.com/gotham/api/v1"
      authentication:
        type: bearer
        token: "$secrets.gotham_token"
      resources:
        - name: objects
          path: "/objects"
          operations:
            - name: search-objects
              method: GET
            - name: create-investigation
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Submits a change request to ServiceNow Change Management and blocks a Jira release issue from moving to Done until the change is approved.

naftiko: "0.5"
info:
  label: "Jira Change Management Approval Gate"
  description: "Submits a change request to ServiceNow Change Management and blocks a Jira release issue from moving to Done until the change is approved."
  tags:
    - itsm
    - change-management
    - servicenow
    - jira
    - approval
capability:
  exposes:
    - type: mcp
      namespace: change-mgmt
      port: 8080
      tools:
        - name: submit-change-request
          description: "Given a Jira release issue key and change description, submit a ServiceNow change request and transition the Jira issue to 'Awaiting Approval' status."
          inputParameters:
            - name: jira_issue_key
              in: body
              type: string
              description: "The Jira release issue key requiring change approval (e.g., 'PLAT-789')."
            - name: change_description
              in: body
              type: string
              description: "Description of the change being requested, including scope and rollback plan."
            - name: planned_start
              in: body
              type: string
              description: "Planned change start datetime in ISO 8601 format."
          steps:
            - name: create-change-request
              type: call
              call: servicenow.create-change
              with:
                short_description: "Change for {{jira_issue_key}}: {{change_description}}"
                planned_start: "{{planned_start}}"
                category: "software"
            - name: update-jira-status
              type: call
              call: jira.transition-issue
              with:
                issue_key: "{{jira_issue_key}}"
                transition_id: "41"
                comment: "Change request submitted: {{create-change-request.number}}"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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: create-change
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: transitions
          path: "/issue/{{issue_key}}/transitions"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: transition-issue
              method: POST

Fetches open Jira issues for a given sprint and project, then posts a status summary to a Microsoft Teams channel. Use for automated sprint stand-up reporting.

naftiko: "0.5"
info:
  label: "Jira Sprint Status Digest"
  description: "Fetches open Jira issues for a given sprint and project, then posts a status summary to a Microsoft Teams channel. Use for automated sprint stand-up reporting."
  tags:
    - devops
    - jira
    - reporting
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: devops-reporting
      port: 8080
      tools:
        - name: digest-sprint-status
          description: "Given a Jira project key and sprint ID, fetch all open issues and post a formatted digest to a Teams channel."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "The Jira project key (e.g., 'PLAT')."
            - name: sprint_id
              in: body
              type: integer
              description: "The Jira sprint ID number."
            - name: teams_channel_id
              in: body
              type: string
              description: "The Teams channel ID where the sprint digest should be posted."
          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.send-message
              with:
                channel_id: "{{teams_channel_id}}"
                text: "Sprint {{sprint_id}} digest for {{project_key}}: {{get-issues.total}} open issues. Blockers: {{get-issues.blockers}}."
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Fetches LinkedIn company page follower statistics and posts a weekly growth digest to the marketing Microsoft Teams channel.

naftiko: "0.5"
info:
  label: "LinkedIn Company Follower Growth Digest"
  description: "Fetches LinkedIn company page follower statistics and posts a weekly growth digest to the marketing Microsoft Teams channel."
  tags:
    - marketing
    - linkedin
    - reporting
    - microsoft-teams
    - social
capability:
  exposes:
    - type: mcp
      namespace: marketing-reporting
      port: 8080
      tools:
        - name: digest-linkedin-followers
          description: "Retrieve LinkedIn company page follower count and growth metrics for the past 30 days, then post a formatted digest to the marketing Teams channel."
          inputParameters:
            - name: organization_id
              in: body
              type: string
              description: "The LinkedIn organization ID for Palantir's company page."
            - name: teams_channel_id
              in: body
              type: string
              description: "Teams channel ID where the follower growth digest should be posted."
          steps:
            - name: get-follower-stats
              type: call
              call: linkedin.get-follower-stats
              with:
                organization_id: "{{organization_id}}"
            - name: post-digest
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{teams_channel_id}}"
                text: "LinkedIn Follower Digest: {{get-follower-stats.follower_count}} total followers | +{{get-follower-stats.gained_30d}} new this month | Organic growth rate: {{get-follower-stats.growth_rate}}%"
  consumes:
    - type: http
      namespace: linkedin
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_token"
      resources:
        - name: follower-statistics
          path: "/organizationalEntityFollowerStatistics"
          inputParameters:
            - name: organization_id
              in: query
          operations:
            - name: get-follower-stats
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When a new hire is created in Workday, provisions a ServiceNow onboarding ticket, sends a Microsoft Teams welcome message, and creates a Jira onboarding task for IT setup.

naftiko: "0.5"
info:
  label: "New Hire Onboarding Orchestrator"
  description: "When a new hire is created in Workday, provisions a ServiceNow onboarding ticket, sends a Microsoft Teams welcome message, and creates a Jira onboarding task for IT setup."
  tags:
    - hr
    - onboarding
    - workday
    - servicenow
    - microsoft-teams
    - jira
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 by creating a ServiceNow ticket, sending a Teams welcome card, and opening a Jira IT setup task."
          inputParameters:
            - name: worker_id
              in: body
              type: string
              description: "The Workday worker ID for the new hire."
            - name: start_date
              in: body
              type: string
              description: "The new hire's start date in YYYY-MM-DD format."
            - name: team_channel
              in: body
              type: string
              description: "The Microsoft Teams channel ID where the welcome message should be posted."
          steps:
            - name: get-employee
              type: call
              call: workday.get-worker
              with:
                worker_id: "{{worker_id}}"
            - name: create-snow-ticket
              type: call
              call: servicenow.create-incident
              with:
                short_description: "New hire onboarding: {{get-employee.full_name}}"
                category: "hr_onboarding"
                assigned_group: "IT_Onboarding"
            - name: send-welcome
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{team_channel}}"
                text: "Welcome to Palantir, {{get-employee.full_name}}! Your IT onboarding ticket is {{create-snow-ticket.number}}. Start date: {{start_date}}."
            - name: create-jira-task
              type: call
              call: jira.create-issue
              with:
                project_key: "IT"
                issuetype: "Task"
                summary: "IT Setup — {{get-employee.full_name}} starting {{start_date}}"
                description: "Provision laptop, accounts, and access for new hire. ServiceNow: {{create-snow-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: "/palantir/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

Lists Okta users who do not have MFA enrolled and reports them in a ServiceNow security task for remediation follow-up.

naftiko: "0.5"
info:
  label: "Okta MFA Enforcement Audit"
  description: "Lists Okta users who do not have MFA enrolled and reports them in a ServiceNow security task for remediation follow-up."
  tags:
    - security
    - identity
    - okta
    - servicenow
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: security-audit
      port: 8080
      tools:
        - name: audit-mfa-enrollment
          description: "List all active Okta users who lack MFA enrollment and create a ServiceNow security task listing the non-compliant accounts."
          inputParameters:
            - name: okta_group_id
              in: body
              type: string
              description: "The Okta group ID to scope the MFA enrollment audit."
          steps:
            - name: list-users-without-mfa
              type: call
              call: okta.list-users
              with:
                group_id: "{{okta_group_id}}"
                mfa_enrolled: "false"
            - name: create-security-task
              type: call
              call: servicenow.create-incident
              with:
                short_description: "MFA Enrollment Audit — {{list-users-without-mfa.count}} non-compliant users"
                category: "security_compliance"
                description: "Users without MFA: {{list-users-without-mfa.emails}}"
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://palantir.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_key"
        placement: header
      resources:
        - name: users
          path: "/groups/{{group_id}}/users"
          inputParameters:
            - name: group_id
              in: path
            - name: mfa_enrolled
              in: query
          operations:
            - name: list-users
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.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

Retrieves all Okta users assigned to a specific application group and cross-references with Workday active headcount to flag access anomalies.

naftiko: "0.5"
info:
  label: "Okta User Access Review"
  description: "Retrieves all Okta users assigned to a specific application group and cross-references with Workday active headcount to flag access anomalies."
  tags:
    - identity
    - security
    - okta
    - workday
    - access-review
capability:
  exposes:
    - type: mcp
      namespace: identity-ops
      port: 8080
      tools:
        - name: review-app-access
          description: "Given an Okta application ID, list all assigned users and identify any who are no longer active in Workday, returning them as anomalies requiring revocation."
          inputParameters:
            - name: okta_app_id
              in: body
              type: string
              description: "The Okta application client ID to audit user assignments for."
          steps:
            - name: get-okta-users
              type: call
              call: okta.list-app-users
              with:
                app_id: "{{okta_app_id}}"
            - name: get-workday-workers
              type: call
              call: workday.list-workers
              with:
                status: "active"
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://palantir.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_key"
        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: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/palantir/workers"
          inputParameters:
            - name: status
              in: query
          operations:
            - name: list-workers
              method: GET

When a new employee is added in Workday, creates an Okta account, assigns application groups based on role, provisions Foundry access, and sends a welcome email with credentials.

naftiko: "0.5"
info:
  label: "Okta User Provisioning Orchestrator"
  description: "When a new employee is added in Workday, creates an Okta account, assigns application groups based on role, provisions Foundry access, and sends a welcome email with credentials."
  tags:
    - hr
    - security
    - workday
    - okta
    - foundry
capability:
  exposes:
    - type: mcp
      namespace: identity-provisioning
      port: 8080
      tools:
        - name: provision-new-user
          description: "Orchestrate new user provisioning: create Okta account, assign groups, provision Foundry, and send welcome."
          inputParameters:
            - name: worker_id
              in: body
              type: string
              description: "The Workday worker ID."
          steps:
            - name: get-worker
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{worker_id}}"
            - name: create-okta-user
              type: call
              call: "okta.create-user"
              with:
                login: "{{get-worker.email}}"
                firstName: "{{get-worker.first_name}}"
                lastName: "{{get-worker.last_name}}"
            - name: provision-foundry
              type: call
              call: "foundry.create-user"
              with:
                email: "{{get-worker.email}}"
                role: "{{get-worker.job_title}}"
            - name: send-welcome
              type: call
              call: "slack.post-message"
              with:
                channel: "{{get-worker.email}}"
                text: "Welcome to Palantir, {{get-worker.first_name}}! Your Okta and Foundry accounts are ready. Log in at foundry.palantir.com."
  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: "/palantir/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta
      baseUri: "https://palantir.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: foundry
      baseUri: "https://palantir.foundry.com/multipass/api"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: users
          path: "/users"
          operations:
            - name: create-user
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Enriches ontology links with external data, validates in Foundry, and publishes findings to Confluence.

naftiko: "0.5"
info:
  label: "Ontology Link Analysis Enrichment Orchestrator"
  description: "Enriches ontology links with external data, validates in Foundry, and publishes findings to Confluence."
  tags:
    - data-platform
    - foundry
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: ontology-link-analysis-en
      port: 8080
      tools:
        - name: ontology-link-analysis-enrichment
          description: "Enriches ontology links with external data."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: publish
              type: call
              call: "confluence.create-page"
              with:
                space_key: "PLAT"
                title: "Ontology Link Analysis Enrichment"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://palantir.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: content
          path: "/content"
          operations:
            - name: create-page
              method: POST

When a P1 incident is raised in ServiceNow, creates a Datadog event annotation, posts an alert in Microsoft Teams, and opens a Jira incident bug for engineering tracking.

naftiko: "0.5"
info:
  label: "P1 Incident Response Chain"
  description: "When a P1 incident is raised in ServiceNow, creates a Datadog event annotation, posts an alert in Microsoft Teams, and opens a Jira incident bug for engineering tracking."
  tags:
    - itsm
    - incident-response
    - servicenow
    - datadog
    - microsoft-teams
    - jira
capability:
  exposes:
    - type: mcp
      namespace: itsm-ops
      port: 8080
      tools:
        - name: handle-p1-incident
          description: "Given a P1 ServiceNow incident number and affected service, create a Datadog event, open a Jira bug, and alert the engineering team in Teams."
          inputParameters:
            - name: incident_number
              in: body
              type: string
              description: "The ServiceNow incident number for the P1 event."
            - name: affected_service
              in: body
              type: string
              description: "The name of the affected service or platform."
            - name: impact_summary
              in: body
              type: string
              description: "A brief description of the impact on users or operations."
          steps:
            - name: annotate-datadog
              type: call
              call: datadog.create-event
              with:
                title: "P1 Incident: {{affected_service}}"
                text: "SNOW {{incident_number}} — {{impact_summary}}"
                alert_type: "error"
            - name: create-jira-bug
              type: call
              call: jira.create-issue
              with:
                project_key: "ENG"
                issuetype: "Bug"
                summary: "[P1] {{affected_service}} — {{incident_number}}"
                description: "ServiceNow: {{incident_number}}\nImpact: {{impact_summary}}\nDatadog event: {{annotate-datadog.id}}"
                priority: "Highest"
            - name: alert-teams
              type: call
              call: msteams.send-message
              with:
                channel_id: "engineering-incidents"
                text: "P1 INCIDENT: {{affected_service}} | SNOW: {{incident_number}} | Jira: {{create-jira-bug.key}} | Datadog: {{annotate-datadog.url}}"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_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.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Refreshes Quiver dashboards in Foundry, validates data freshness, and notifies stakeholders via email.

naftiko: "0.5"
info:
  label: "Quiver Dashboard Refresh and Validate Orchestrator"
  description: "Refreshes Quiver dashboards in Foundry, validates data freshness, and notifies stakeholders via email."
  tags:
    - analytics
    - foundry
    - email
capability:
  exposes:
    - type: mcp
      namespace: quiver-dashboard-refresh-
      port: 8080
      tools:
        - name: quiver-dashboard-refresh-and-validate
          description: "Refreshes Quiver dashboards in Foundry."
          inputParameters:
            - name: entity_id
              in: body
              type: string
              description: "Primary entity identifier."
          steps:
            - name: query-foundry
              type: call
              call: "foundry.get-dataset"
              with:
                entity_id: "{{entity_id}}"
            - name: send-email
              type: call
              call: "email.send-message"
              with:
                to: "team@palantir.com"
                subject: "Quiver Dashboard Refresh and Validate"
  consumes:
    - type: http
      namespace: foundry
      baseUri: "https://palantir.palantirfoundry.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: datasets
          path: "/datasets"
          operations:
            - name: get-dataset
              method: GET
            - name: create-dataset
              method: POST
            - name: run-transform
              method: POST
    - type: http
      namespace: email
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.graph_token"
      resources:
        - name: mail
          path: "/me/sendMail"
          operations:
            - name: send-message
              method: POST

Retrieves open opportunities and recent activity for a Salesforce account and posts an account health summary to the owning rep's Teams channel.

naftiko: "0.5"
info:
  label: "Salesforce Account Health Digest"
  description: "Retrieves open opportunities and recent activity for a Salesforce account and posts an account health summary to the owning rep's Teams channel."
  tags:
    - sales
    - crm
    - salesforce
    - reporting
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: sales-reporting
      port: 8080
      tools:
        - name: digest-account-health
          description: "Given a Salesforce account ID and the owning rep's Teams UPN, fetch open opportunities and recent activity, then post an account health digest to the rep's channel."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "The Salesforce account ID to report on."
            - name: rep_teams_upn
              in: body
              type: string
              description: "The Teams UPN of the account owner to receive the digest."
          steps:
            - name: get-account
              type: call
              call: salesforce.get-account
              with:
                account_id: "{{account_id}}"
            - name: get-opportunities
              type: call
              call: salesforce-opps.query-opportunities
              with:
                account_id: "{{account_id}}"
            - name: post-digest
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{rep_teams_upn}}"
                text: "Account Health: {{get-account.Name}} | Open Opps: {{get-opportunities.count}} | Total Pipeline: ${{get-opportunities.total_amount}} | Last Activity: {{get-account.LastActivityDate}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://palantir.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://palantir.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/query"
          inputParameters:
            - name: q
              in: query
          operations:
            - name: query-opportunities
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Queries Salesforce for contracts expiring within 60 days and posts a renewal digest to the responsible account executives in Microsoft Teams.

naftiko: "0.5"
info:
  label: "Salesforce Contract Renewal Alert"
  description: "Queries Salesforce for contracts expiring within 60 days and posts a renewal digest to the responsible account executives in Microsoft Teams."
  tags:
    - sales
    - crm
    - salesforce
    - contracts
    - microsoft-teams
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: contract-mgmt
      port: 8080
      tools:
        - name: alert-expiring-contracts
          description: "Query Salesforce for contracts expiring in the next 60 days and post a renewal alert digest to the sales leadership Teams channel."
          inputParameters:
            - name: days_ahead
              in: body
              type: integer
              description: "Number of days ahead to look for expiring contracts (default: 60)."
            - name: teams_channel_id
              in: body
              type: string
              description: "Teams channel ID for the renewal alert digest."
          steps:
            - name: query-expiring
              type: call
              call: salesforce.query-contracts
              with:
                days_ahead: "{{days_ahead}}"
            - name: post-renewal-alert
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{teams_channel_id}}"
                text: "Contract Renewal Alert: {{query-expiring.count}} contracts expiring in {{days_ahead}} days. Total value at risk: ${{query-expiring.total_value}}."
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://palantir.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: contracts
          path: "/query"
          inputParameters:
            - name: q
              in: query
          operations:
            - name: query-contracts
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Syncs Salesforce opportunity data into Foundry for pipeline analytics, computes win probability scores using a Foundry ML model, and updates the Salesforce opportunity with the predicted score.

naftiko: "0.5"
info:
  label: "Salesforce Deal Analytics Pipeline Orchestrator"
  description: "Syncs Salesforce opportunity data into Foundry for pipeline analytics, computes win probability scores using a Foundry ML model, and updates the Salesforce opportunity with the predicted score."
  tags:
    - data-analytics
    - salesforce
    - foundry
    - machine-learning
capability:
  exposes:
    - type: mcp
      namespace: sales-analytics
      port: 8080
      tools:
        - name: analyze-deal-pipeline
          description: "Orchestrate deal analytics: sync from Salesforce, score with ML model, and write predictions back."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity identifier."
          steps:
            - name: get-opportunity
              type: call
              call: "salesforce.get-opportunity"
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: predict-win-probability
              type: call
              call: "foundry.invoke-model"
              with:
                model_rid: "deal-scoring-model"
                input:
                  amount: "{{get-opportunity.Amount}}"
                  stage: "{{get-opportunity.StageName}}"
                  days_in_stage: "{{get-opportunity.DaysInStage}}"
            - name: update-salesforce
              type: call
              call: "salesforce.update-opportunity"
              with:
                opportunity_id: "{{opportunity_id}}"
                win_probability: "{{predict-win-probability.score}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://palantir.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
            - name: update-opportunity
              method: PATCH
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: models
          path: "/models/{{model_rid}}/invoke"
          inputParameters:
            - name: model_rid
              in: path
          operations:
            - name: invoke-model
              method: POST

Given a new Salesforce lead, fetches the LinkedIn profile to enrich job title and company details, then updates the Salesforce record.

naftiko: "0.5"
info:
  label: "Salesforce Lead Enrichment from LinkedIn"
  description: "Given a new Salesforce lead, fetches the LinkedIn profile to enrich job title and company details, then updates the Salesforce record."
  tags:
    - sales
    - crm
    - salesforce
    - linkedin
    - lead-enrichment
capability:
  exposes:
    - type: mcp
      namespace: sales-enrichment
      port: 8080
      tools:
        - name: enrich-lead
          description: "Given a Salesforce lead ID and the lead's LinkedIn member URN, fetch LinkedIn profile data and update the Salesforce lead with enriched title, company, and industry fields."
          inputParameters:
            - name: lead_id
              in: body
              type: string
              description: "The Salesforce lead record ID to enrich."
            - name: linkedin_urn
              in: body
              type: string
              description: "The LinkedIn member URN (e.g., 'urn:li:person:abc123') for the lead."
          steps:
            - name: get-linkedin-profile
              type: call
              call: linkedin.get-profile
              with:
                member_urn: "{{linkedin_urn}}"
            - name: update-lead
              type: call
              call: salesforce.update-lead
              with:
                lead_id: "{{lead_id}}"
                title: "{{get-linkedin-profile.headline}}"
                company: "{{get-linkedin-profile.company}}"
                industry: "{{get-linkedin-profile.industry}}"
  consumes:
    - type: http
      namespace: linkedin
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_token"
      resources:
        - name: profiles
          path: "/people/{{member_urn}}"
          inputParameters:
            - name: member_urn
              in: path
          operations:
            - name: get-profile
              method: GET
    - type: http
      namespace: salesforce
      baseUri: "https://palantir.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: leads
          path: "/sobjects/Lead/{{lead_id}}"
          inputParameters:
            - name: lead_id
              in: path
          operations:
            - name: update-lead
              method: PATCH

Retrieves an open Salesforce opportunity and syncs its stage and close date back to an internal Jira tracking issue for pipeline visibility.

naftiko: "0.5"
info:
  label: "Salesforce Opportunity Sync"
  description: "Retrieves an open Salesforce opportunity and syncs its stage and close date back to an internal Jira tracking issue for pipeline visibility."
  tags:
    - sales
    - crm
    - salesforce
    - jira
    - opportunity
capability:
  exposes:
    - type: mcp
      namespace: sales-ops
      port: 8080
      tools:
        - name: sync-opportunity
          description: "Given a Salesforce opportunity ID and a linked Jira issue key, fetch the opportunity stage and close date from Salesforce and update the Jira issue fields to keep pipeline data in sync."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity ID (18-character Salesforce ID)."
            - name: jira_issue_key
              in: body
              type: string
              description: "The Jira issue key linked to this opportunity (e.g., 'SALES-456')."
          steps:
            - name: get-opportunity
              type: call
              call: salesforce.get-opportunity
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: update-jira
              type: call
              call: jira.update-issue
              with:
                issue_key: "{{jira_issue_key}}"
                stage: "{{get-opportunity.StageName}}"
                close_date: "{{get-opportunity.CloseDate}}"
                amount: "{{get-opportunity.Amount}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://palantir.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue/{{issue_key}}"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: update-issue
              method: PUT

When a security alert fires from Datadog, enriches the alert with threat intelligence from Foundry, creates a ServiceNow security incident, and pages the on-call security engineer via PagerDuty.

naftiko: "0.5"
info:
  label: "Security Incident Triage Orchestrator"
  description: "When a security alert fires from Datadog, enriches the alert with threat intelligence from Foundry, creates a ServiceNow security incident, and pages the on-call security engineer via PagerDuty."
  tags:
    - security
    - data-analytics
    - datadog
    - foundry
    - servicenow
    - pagerduty
capability:
  exposes:
    - type: mcp
      namespace: security-ops
      port: 8080
      tools:
        - name: triage-security-incident
          description: "Orchestrate security incident triage: enrich alert, create incident, and page on-call engineer."
          inputParameters:
            - name: alert_id
              in: body
              type: string
              description: "The Datadog security alert identifier."
          steps:
            - name: get-alert-details
              type: call
              call: "datadog.get-alert"
              with:
                alert_id: "{{alert_id}}"
            - name: enrich-with-threat-intel
              type: call
              call: "foundry.query-threat-intelligence"
              with:
                indicators: "{{get-alert-details.indicators}}"
            - name: create-security-incident
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Security alert: {{get-alert-details.title}}"
                category: "security"
                urgency: "{{get-alert-details.severity}}"
                description: "Threat intel match: {{enrich-with-threat-intel.match_count}} indicators. Risk score: {{enrich-with-threat-intel.risk_score}}."
            - name: page-oncall
              type: call
              call: "pagerduty.create-incident"
              with:
                service_id: "security-engineering"
                title: "Security alert: {{get-alert-details.title}}"
                urgency: "high"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v2"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: alerts
          path: "/security_monitoring/signals/{{alert_id}}"
          inputParameters:
            - name: alert_id
              in: path
          operations:
            - name: get-alert
              method: GET
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: threat-intel
          path: "/ontologies/default/objectTypes/ThreatIndicator/objects"
          operations:
            - name: query-threat-intelligence
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.snow_user"
        password: "$secrets.snow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: bearer
        token: "$secrets.pagerduty_token"
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST

Retrieves a ServiceNow incident by ticket number and returns its current status, priority, and assignment details. Use when an agent needs to check incident state before escalation.

naftiko: "0.5"
info:
  label: "ServiceNow Incident Lookup"
  description: "Retrieves a ServiceNow incident by ticket number and returns its current status, priority, and assignment details. Use when an agent needs to check incident state before escalation."
  tags:
    - itsm
    - servicenow
    - lookup
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: itsm-lookup
      port: 8080
      tools:
        - name: get-incident
          description: "Given a ServiceNow incident number, return the incident's status, priority, assigned group, and short description."
          inputParameters:
            - name: incident_number
              in: body
              type: string
              description: "The ServiceNow incident number (e.g., 'INC0012345')."
          call: servicenow.get-incident
          with:
            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"
            - name: short_description
              type: string
              mapping: "$.result.short_description"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://palantir.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          inputParameters:
            - name: number
              in: query
          operations:
            - name: get-incident
              method: GET

Queries Snowflake for failed or stalled pipeline tasks in the past 24 hours and posts a digest to the data engineering Teams channel.

naftiko: "0.5"
info:
  label: "Snowflake Data Pipeline Health Check"
  description: "Queries Snowflake for failed or stalled pipeline tasks in the past 24 hours and posts a digest to the data engineering Teams channel."
  tags:
    - data
    - analytics
    - snowflake
    - monitoring
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: data-ops
      port: 8080
      tools:
        - name: check-pipeline-health
          description: "Query Snowflake for task failures in the last 24 hours within a given database schema, then post a health digest to a Teams channel."
          inputParameters:
            - name: database
              in: body
              type: string
              description: "The Snowflake database name to inspect (e.g., 'ANALYTICS_DB')."
            - name: schema
              in: body
              type: string
              description: "The Snowflake schema name to scope the task failure query."
            - name: teams_channel_id
              in: body
              type: string
              description: "The Teams channel ID where the health digest should be posted."
          steps:
            - name: query-task-failures
              type: call
              call: snowflake.query-task-history
              with:
                database: "{{database}}"
                schema: "{{schema}}"
            - name: post-digest
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{teams_channel_id}}"
                text: "Pipeline health for {{database}}.{{schema}}: {{query-task-failures.failed_count}} failures in last 24h. First failure: {{query-task-failures.first_error}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://palantir.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: task-history
          path: "/databases/{{database}}/schemas/{{schema}}/tasks"
          inputParameters:
            - name: database
              in: path
            - name: schema
              in: path
          operations:
            - name: query-task-history
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Retrieves row count from Snowflake for a Foundry-synced dataset.

naftiko: "0.5"
info:
  label: "Snowflake Foundry Sync Row Count Lookup"
  description: "Retrieves row count from Snowflake for a Foundry-synced dataset."
  tags:
    - data-platform
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: sync-data
      port: 8080
      tools:
        - name: get-row-count
          description: "Look up Snowflake row count for Foundry dataset."
          inputParameters:
            - name: table_name
              in: body
              type: string
              description: "Snowflake table name."
          call: "snowflake.run-query"
          with:
            table_name: "{{table_name}}"
          outputParameters:
            - name: row_count
              type: number
              mapping: "$.data[0][0]"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://palantir.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Monitors Snowflake query history for long-running queries exceeding a threshold and creates a Datadog event and Jira data-engineering task.

naftiko: "0.5"
info:
  label: "Snowflake Query Performance Alert"
  description: "Monitors Snowflake query history for long-running queries exceeding a threshold and creates a Datadog event and Jira data-engineering task."
  tags:
    - data
    - analytics
    - snowflake
    - datadog
    - jira
    - monitoring
capability:
  exposes:
    - type: mcp
      namespace: data-monitoring
      port: 8080
      tools:
        - name: alert-slow-queries
          description: "Given a Snowflake warehouse name and execution time threshold in seconds, find queries exceeding the threshold and create a Datadog event plus Jira task for the data engineering team."
          inputParameters:
            - name: warehouse_name
              in: body
              type: string
              description: "The Snowflake virtual warehouse to monitor (e.g., 'ANALYTICS_WH')."
            - name: threshold_seconds
              in: body
              type: integer
              description: "Execution time threshold in seconds; queries exceeding this are flagged."
          steps:
            - name: get-slow-queries
              type: call
              call: snowflake.query-history
              with:
                warehouse_name: "{{warehouse_name}}"
                threshold_seconds: "{{threshold_seconds}}"
            - name: create-datadog-event
              type: call
              call: datadog.create-event
              with:
                title: "Slow queries detected in {{warehouse_name}}"
                text: "{{get-slow-queries.count}} queries exceeded {{threshold_seconds}}s. Worst: {{get-slow-queries.worst_query_id}} ({{get-slow-queries.worst_duration}}s)"
                alert_type: "warning"
            - name: create-jira-task
              type: call
              call: jira.create-issue
              with:
                project_key: "DATA"
                issuetype: "Task"
                summary: "Slow query investigation: {{warehouse_name}}"
                description: "{{get-slow-queries.count}} queries exceeded {{threshold_seconds}}s threshold. Datadog: {{create-datadog-event.url}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://palantir.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: query-history
          path: "/databases/SNOWFLAKE/schemas/ACCOUNT_USAGE/query-history"
          inputParameters:
            - name: warehouse_name
              in: query
            - name: threshold_seconds
              in: query
          operations:
            - name: query-history
              method: GET
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

Checks the status of a Terraform Cloud workspace run and, if it has errored, creates a Jira infrastructure bug and alerts the platform team in Teams.

naftiko: "0.5"
info:
  label: "Terraform Cloud Run Status Monitor"
  description: "Checks the status of a Terraform Cloud workspace run and, if it has errored, creates a Jira infrastructure bug and alerts the platform team in Teams."
  tags:
    - cloud
    - infra
    - terraform
    - jira
    - microsoft-teams
    - devops
capability:
  exposes:
    - type: mcp
      namespace: infra-ops
      port: 8080
      tools:
        - name: monitor-terraform-run
          description: "Given a Terraform Cloud workspace name and run ID, check the run status. If errored, open a Jira infra bug and alert the platform team in Teams."
          inputParameters:
            - name: workspace_name
              in: body
              type: string
              description: "The Terraform Cloud workspace name."
            - name: run_id
              in: body
              type: string
              description: "The Terraform Cloud run ID to check."
          steps:
            - name: get-run-status
              type: call
              call: terraform.get-run
              with:
                run_id: "{{run_id}}"
            - name: create-infra-bug
              type: call
              call: jira.create-issue
              with:
                project_key: "INFRA"
                issuetype: "Bug"
                summary: "Terraform run failed: {{workspace_name}} — {{run_id}}"
                description: "Status: {{get-run-status.status}}. Message: {{get-run-status.status_timestamps}}. Workspace: {{workspace_name}}"
            - name: alert-platform
              type: call
              call: msteams.send-message
              with:
                channel_id: "platform-ops"
                text: "Terraform run FAILED: {{workspace_name}} | Run: {{run_id}} | Jira: {{create-infra-bug.key}}"
  consumes:
    - type: http
      namespace: terraform
      baseUri: "https://app.terraform.io/api/v2"
      authentication:
        type: bearer
        token: "$secrets.terraform_token"
      resources:
        - name: runs
          path: "/runs/{{run_id}}"
          inputParameters:
            - name: run_id
              in: path
          operations:
            - name: get-run
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://palantir.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_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.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

Provisions new Foundry infrastructure environments by triggering Terraform Cloud runs, monitoring plan and apply phases, tagging resources in Foundry, and notifying the platform team via Slack.

naftiko: "0.5"
info:
  label: "Terraform Foundry Infrastructure Provisioning Orchestrator"
  description: "Provisions new Foundry infrastructure environments by triggering Terraform Cloud runs, monitoring plan and apply phases, tagging resources in Foundry, and notifying the platform team via Slack."
  tags:
    - data-analytics
    - infrastructure
    - terraform
    - foundry
    - slack
capability:
  exposes:
    - type: mcp
      namespace: infra-provisioning
      port: 8080
      tools:
        - name: provision-foundry-infra
          description: "Orchestrate Foundry infrastructure provisioning via Terraform: plan, apply, tag, and notify."
          inputParameters:
            - name: workspace_name
              in: body
              type: string
              description: "The Terraform Cloud workspace name."
            - name: environment
              in: body
              type: string
              description: "Target environment: dev, staging, or production."
          steps:
            - name: trigger-plan
              type: call
              call: "terraform.create-run"
              with:
                workspace: "{{workspace_name}}"
                auto_apply: false
            - name: get-plan-status
              type: call
              call: "terraform.get-run"
              with:
                run_id: "{{trigger-plan.run_id}}"
            - name: tag-resources
              type: call
              call: "foundry.tag-infrastructure"
              with:
                environment: "{{environment}}"
                run_id: "{{trigger-plan.run_id}}"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "platform-infra"
                text: "Foundry infra provisioning for {{environment}}: Terraform run {{trigger-plan.run_id}} status {{get-plan-status.status}}. Resources: {{get-plan-status.resource_count}} planned."
  consumes:
    - type: http
      namespace: terraform
      baseUri: "https://app.terraform.io/api/v2"
      authentication:
        type: bearer
        token: "$secrets.terraform_token"
      resources:
        - name: runs
          path: "/runs"
          operations:
            - name: create-run
              method: POST
            - name: get-run
              method: GET
    - type: http
      namespace: foundry
      baseUri: "https://palantir.foundry.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.foundry_token"
      resources:
        - name: infrastructure
          path: "/infrastructure/tags"
          operations:
            - name: tag-infrastructure
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves Terraform workspace state for Foundry infrastructure.

naftiko: "0.5"
info:
  label: "Terraform Foundry Workspace Lookup"
  description: "Retrieves Terraform workspace state for Foundry infrastructure."
  tags:
    - infrastructure
    - terraform
capability:
  exposes:
    - type: mcp
      namespace: tf-state
      port: 8080
      tools:
        - name: get-tf-workspace
          description: "Look up Terraform workspace for Foundry infra."
          inputParameters:
            - name: workspace_id
              in: body
              type: string
              description: "Terraform workspace ID."
          call: "terraform.get-state"
          with:
            workspace_id: "{{workspace_id}}"
          outputParameters:
            - name: state_version
              type: string
              mapping: "$.data.attributes.serial"
            - name: resources
              type: number
              mapping: "$.data.attributes.resource-count"
  consumes:
    - type: http
      namespace: terraform
      baseUri: "https://app.terraform.io/api/v2"
      authentication:
        type: bearer
        token: "$secrets.terraform_token"
      resources:
        - name: workspaces
          path: "/workspaces/{{workspace_id}}/current-state-version"
          inputParameters:
            - name: workspace_id
              in: path
          operations:
            - name: get-state
              method: GET

Retrieves worker profile details from Workday by employee ID. Use when an agent needs to resolve personnel metadata before performing downstream provisioning or analytics tasks.

naftiko: "0.5"
info:
  label: "Workday Employee Lookup"
  description: "Retrieves worker profile details from Workday by employee ID. Use when an agent needs to resolve personnel metadata before performing downstream provisioning or analytics tasks."
  tags:
    - hr
    - workday
    - lookup
capability:
  exposes:
    - type: mcp
      namespace: hr-lookup
      port: 8080
      tools:
        - name: get-worker
          description: "Given a Workday employee ID, return the worker's full name, job title, department, cost center, and work email."
          inputParameters:
            - name: worker_id
              in: body
              type: string
              description: "The Workday worker ID (e.g., 'WD-00123') for the employee to look up."
          call: workday.get-worker
          with:
            worker_id: "{{worker_id}}"
          outputParameters:
            - name: full_name
              type: string
              mapping: "$.worker.workerData.person.preferredName.fullName"
            - name: email
              type: string
              mapping: "$.worker.workerData.workContactInformation.emailAddresses[0].emailAddress"
            - name: job_title
              type: string
              mapping: "$.worker.workerData.employmentData.positionData.jobTitle"
            - name: department
              type: string
              mapping: "$.worker.workerData.employmentData.positionData.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: "/palantir/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET

Exports a current headcount snapshot from Workday by department and posts the summary to the HR Microsoft Teams channel.

naftiko: "0.5"
info:
  label: "Workday Headcount Snapshot"
  description: "Exports a current headcount snapshot from Workday by department and posts the summary to the HR Microsoft Teams channel."
  tags:
    - hr
    - workforce-planning
    - workday
    - reporting
    - microsoft-teams
capability:
  exposes:
    - type: mcp
      namespace: hr-reporting
      port: 8080
      tools:
        - name: get-headcount-snapshot
          description: "Retrieve current active headcount from Workday grouped by department and post a formatted summary to the HR Teams channel."
          inputParameters:
            - name: as_of_date
              in: body
              type: string
              description: "The date for the headcount snapshot in YYYY-MM-DD format."
            - name: teams_channel_id
              in: body
              type: string
              description: "Teams channel ID where the headcount summary should be posted."
          steps:
            - name: export-headcount
              type: call
              call: workday.list-workers
              with:
                status: "active"
                as_of_date: "{{as_of_date}}"
            - name: post-summary
              type: call
              call: msteams.send-message
              with:
                channel_id: "{{teams_channel_id}}"
                text: "Headcount snapshot as of {{as_of_date}}: {{export-headcount.total}} active employees across {{export-headcount.department_count}} departments."
  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: "/palantir/workers"
          inputParameters:
            - name: status
              in: query
            - name: as_of_date
              in: query
          operations:
            - name: list-workers
              method: GET
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST

When an employee's role changes in Workday, updates their Okta group memberships to reflect the new access profile and notifies IT via Microsoft Teams.

naftiko: "0.5"
info:
  label: "Workday Role Change Provisioning"
  description: "When an employee's role changes in Workday, updates their Okta group memberships to reflect the new access profile and notifies IT via Microsoft Teams."
  tags:
    - hr
    - identity
    - workday
    - okta
    - microsoft-teams
    - access-management
capability:
  exposes:
    - type: mcp
      namespace: hr-access-mgmt
      port: 8080
      tools:
        - name: sync-role-access
          description: "Given a Workday worker ID, old role, and new role, update Okta group memberships to match the new job profile and notify IT of the access changes in Teams."
          inputParameters:
            - name: worker_id
              in: body
              type: string
              description: "The Workday worker ID for the employee whose role changed."
            - name: old_role
              in: body
              type: string
              description: "The previous job role/title being vacated."
            - name: new_role
              in: body
              type: string
              description: "The new job role/title being assumed."
            - name: old_okta_group
              in: body
              type: string
              description: "The Okta group ID corresponding to the old role."
            - name: new_okta_group
              in: body
              type: string
              description: "The Okta group ID corresponding to the new role."
          steps:
            - name: get-employee
              type: call
              call: workday.get-worker
              with:
                worker_id: "{{worker_id}}"
            - name: remove-old-group
              type: call
              call: okta.remove-user-from-group
              with:
                group_id: "{{old_okta_group}}"
                user_email: "{{get-employee.email}}"
            - name: add-new-group
              type: call
              call: okta.add-user-to-group
              with:
                group_id: "{{new_okta_group}}"
                user_email: "{{get-employee.email}}"
            - name: notify-it
              type: call
              call: msteams.send-message
              with:
                channel_id: "it-ops-channel"
                text: "Role change for {{get-employee.full_name}}: {{old_role}} -> {{new_role}}. Okta groups updated."
  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: "/palantir/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta
      baseUri: "https://palantir.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_key"
        placement: header
      resources:
        - name: group-members-remove
          path: "/groups/{{group_id}}/users/{{user_email}}"
          inputParameters:
            - name: group_id
              in: path
            - name: user_email
              in: path
          operations:
            - name: remove-user-from-group
              method: DELETE
        - name: group-members-add
          path: "/groups/{{group_id}}/users/{{user_email}}"
          inputParameters:
            - name: group_id
              in: path
            - name: user_email
              in: path
          operations:
            - name: add-user-to-group
              method: PUT
    - type: http
      namespace: msteams
      baseUri: "https://graph.microsoft.com/v1.0"
      authentication:
        type: bearer
        token: "$secrets.msteams_token"
      resources:
        - name: messages
          path: "/teams/{{channel_id}}/channels/{{channel_id}}/messages"
          inputParameters:
            - name: channel_id
              in: path
          operations:
            - name: send-message
              method: POST