Server definition

Hash: sha256:c64c4681bdf71c82676edc651c9f3ecf7b5f891e893d7115e10b200996697c1c
What it is: What a remote MCP server returned when asked what it offers: 6 tools

The blob, as servednamed by its sha256

{
  "instructions": "Cloud FinOps knowledge by OptimNow. Two retrieval surfaces: REFERENCES (long-form provider/discipline files) and PLAYBOOKS (small named-pattern runbooks for specific waste patterns). REFERENCES: list_references() to discover, find_references(domain=, capability=, phase=, persona=, maturity=, persona_primary_only=) to narrow by FinOps Capability/Phase facets, get_reference(name=, section=) to fetch one body. Every listing entry carries approx_tokens. Read it before fetching: references run from about 3,000 to over 25,000 tokens. Above roughly 10,000, call get_reference(name=, section=\"<heading phrase>\") and take the section you need - section matches H2 and H3 headings case-insensitively and partially, and a miss returns the file's available_sections rather than the whole body. The provider pattern catalogues (finops-aws-patterns, finops-azure-patterns) are enumerated lists and should almost always be read by section. PLAYBOOKS: list_playbooks() to discover, find_playbooks(scope=, service=, waste_category=, confidence=) to narrow by pattern facets, get_playbook(name=) to fetch one body. Use a playbook for 'how do I detect/fix this specific pattern' (zombie NAT, snapshot sprawl, idle ELB, etc.). Use a reference for billing mechanics, commitment strategy, allocation methodology, or any cross-pattern reasoning. The server cannot see the user's cloud account. For questions about the user's own resources ('which of my RIs are about to expire', 'which of our VMs run for nothing'), the matching playbook carries a detection query written to be run in that account, so the answer does not depend on a data export. For a specific waste or cost-fix question ('my NAT gateway processes 10TB to S3', 'should I delete these old snapshots'), find_playbooks returns the named runbook with its tested detection query. Runbooks exist for NAT gateways and VPC endpoints, expiring Savings Plans / RIs / reservations, snapshots, S3 lifecycle, idle or stopped VMs, orphaned disks and IPs, GPU and SageMaker sizing, and more. References carry billing mechanics, not current prices: any figure inside is illustrative and dated inline; a live pricing tool, if one is connected in the session, is the source for a current price. Advisory questions - how much to commit, how to size, how to allocate or charge back - are served by a matching reference (finops-aws-commitments for Savings Plan sizing, finops-chargeback for recharge design), which carries the decision rules and cadence tables behind a defensible answer.",
  "tools": [
    {
      "description": "Finds the runbook for a specific cloud waste pattern, filtered by\n    provider, service, waste category or detection confidence. Useful\n    before answering a specific waste or cost-fix question: each runbook\n    includes a tested detection query the user can run in their own\n    account, so it also serves questions about the user's own resources.\n\n    Use this for questions like \"which VMs are running for nothing\",\n    \"why is our NAT bill so high\", \"my NAT gateway processes 10TB to S3\",\n    \"should I delete these old snapshots\", \"which of our RIs are about to\n    expire\", \"what waste can we clean up safely without review\" - anything\n    that names a provider, a waste category, or how confident the\n    detection needs to be before acting. Patterns\n    covered include NAT gateways and VPC endpoints, expiring Savings\n    Plans / RIs / reservations, snapshot sprawl, S3 lifecycle gaps, idle\n    or stopped VMs, orphaned disks / public IPs / EBS volumes, GPU and\n    SageMaker sizing, Kubernetes idle capacity, and schedule blindness.\n\n    All filters are optional and combine with AND semantics. String matching\n    is case-insensitive and exact. Examples:\n\n    - ``find_playbooks(scope=\"aws\")`` - all AWS-specific playbooks\n    - ``find_playbooks(waste_category=\"idle\")`` - every idle-resource pattern\n    - ``find_playbooks(scope=\"cross-cloud\", confidence=\"obvious\")``\n\n    Args:\n        scope: ``\"aws\"``, ``\"azure\"``, ``\"gcp\"``, or ``\"cross-cloud\"``.\n        service: Provider service exact-match (e.g. ``\"AWS NAT Gateway\"``).\n        waste_category: ``\"orphaned\"``, ``\"idle\"``, ``\"overprovisioned\"``,\n            ``\"commitment-mismatch\"``, ``\"schedule-blindness\"``,\n            ``\"modernization\"``, ``\"ai-ml-inefficiency\"``, or ``\"egress\"``.\n        confidence: ``\"obvious\"`` (single signal is enough),\n            ``\"likely\"`` (two signals required), or ``\"possible\"``\n            (needs human review). From the OptimNow three-tier confidence\n            model in `finops-waste-detection-playbooks`.\n\n    Returns ``{\"filters\": {...}, \"playbooks\": [...], \"total\": N}``. A query\n    that matches nothing also returns `hint` and `valid_values`, so a typo is\n    distinguishable from a genuine gap in coverage.\n    ",
      "inputSchema": {
        "properties": {
          "confidence": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Confidence"
          },
          "scope": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Scope"
          },
          "service": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Service"
          },
          "waste_category": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Waste Category"
          }
        },
        "title": "find_playbooksArguments",
        "type": "object"
      },
      "name": "find_playbooks",
      "outputSchema": {
        "additionalProperties": true,
        "title": "find_playbooksDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Find which guidance serves a FinOps question - how to commit, size,\n    allocate, charge back, forecast, or govern cloud and AI spend.\n\n    Use this for questions like \"how should we size Savings Plans\",\n    \"what should Finance own in chargeback\", \"what does a Crawl-stage org\n    tackle first\" - anything that maps to FinOps Framework facets (domain,\n    capability, phase, persona, maturity) - and you want only the\n    references that serve it, instead of scanning the full list.\n\n    All filters are optional and combine with AND semantics. String matching\n    is case-insensitive and exact (not substring). Examples:\n\n    - ``find_references(domain=\"Optimize Usage & Cost\")``\n    - ``find_references(phase=\"Optimize\", persona=\"Engineering\")``\n    - ``find_references(persona=\"Engineering\", persona_primary_only=True)``\n    - ``find_references(capability=\"Rate Optimization\")``\n    - ``find_references(maturity=\"Crawl\")``\n\n    Args:\n        domain: FinOps Framework domain (e.g. ``\"Optimize Usage & Cost\"``,\n            ``\"Quantify Business Value\"``, ``\"Manage the FinOps Practice\"``).\n        capability: FinOps capability (matches ``fcp_capability`` and\n            ``fcp_capabilities_secondary``).\n        phase: FinOps phase (``\"Inform\"``, ``\"Optimize\"``, ``\"Operate\"``).\n        persona: Persona (matches ``fcp_personas_primary`` and\n            ``fcp_personas_collaborating``).\n        maturity: Entry maturity level (``\"Crawl\"``, ``\"Walk\"``, ``\"Run\"``).\n        persona_primary_only: when True, ``persona`` matches only the primary\n            list. Use it when the default match barely narrows the set -\n            broad personas like Engineering collaborate on nearly every file,\n            so filtering on collaboration is descriptive, not discriminating.\n            ``persona=\"Engineering\", persona_primary_only=True`` is the\n            engineering reading list; the default is the everything-they-touch\n            view.\n\n    Returns ``{\"filters\": {...}, \"references\": [...], \"total\": N}``. A query\n    that matches nothing also returns `hint` and `valid_values`, so a typo is\n    distinguishable from a genuine gap in coverage.\n    ",
      "inputSchema": {
        "properties": {
          "capability": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Capability"
          },
          "domain": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Domain"
          },
          "maturity": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Maturity"
          },
          "persona": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Persona"
          },
          "persona_primary_only": {
            "default": false,
            "title": "Persona Primary Only",
            "type": "boolean"
          },
          "phase": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Phase"
          }
        },
        "title": "find_referencesArguments",
        "type": "object"
      },
      "name": "find_references",
      "outputSchema": {
        "additionalProperties": true,
        "title": "find_referencesDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Fetch the step-by-step runbook for one specific waste pattern:\n    symptoms, the detection queries to run, the fix, and the anti-pattern\n    to avoid.\n\n    Use this when the user asks how to detect, confirm, or fix one specific\n    named waste pattern (zombie NAT gateway, snapshot sprawl, idle SageMaker\n    endpoint, ...). It also serves questions about the user's own resources\n    (\"which of my X...\"): the runbook's detection query is written to be run\n    in the user's account, so the answer does not depend on access to that\n    account.\n\n    Args:\n        name: Playbook slug as returned by ``list_playbooks`` (e.g.\n            ``\"aws-zombie-nat-gateway\"``, ``\"azure-orphan-disks\"``,\n            ``\"cross-cloud-untagged-spend-drift\"``).\n\n    Returns ``{\"name\": ..., \"title\": ..., \"content\": \"...\", \"lines\": N}``.\n    On miss, returns ``{\"error\": ..., \"suggestions\": [...]}`` with up to\n    three string-distance matches so the caller can self-correct.\n\n    A host with MCP Apps (SEP-1865) support may render this result via the\n    linked ``ui://cloud-finops/playbook-viewer`` resource instead of showing\n    the raw markdown.\n    ",
      "inputSchema": {
        "properties": {
          "name": {
            "title": "Name",
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "title": "get_playbookArguments",
        "type": "object"
      },
      "name": "get_playbook",
      "outputSchema": {
        "additionalProperties": true,
        "title": "get_playbookDictOutput",
        "type": "object"
      }
    },
    {
      "description": "Fetch the guidance on one FinOps topic - the billing mechanics,\n    decision rules and worked examples behind a defensible answer - either\n    whole or one section at a time.\n\n    Use this when you need the actual content of one known reference,\n    after ``list_references`` or ``find_references`` told you which one\n    serves the question. Advisory questions (commitment sizing, chargeback\n    design, allocation methodology) are served by the reference's decision\n    rules and worked examples, which a summary does not carry.\n\n    Pass ``section`` when the question is narrower than the file. The\n    ``approx_tokens`` hint in the listing tells you when this matters: the\n    provider pattern catalogues run past 25,000 tokens and are enumerated\n    lists, so a question about S3 lifecycle wants one section of\n    ``finops-aws-patterns``, not all of it. Omit ``section`` for the whole\n    file when you need the cross-cutting reasoning.\n\n    Args:\n        name: Reference name as returned by ``list_references`` (e.g.\n            ``\"finops-aws\"``, ``\"finops-genai-capacity\"``,\n            ``\"optimnow-methodology\"``).\n        section: Optional H2 or H3 heading to return on its own. Matched\n            case-insensitively and partially against the headings, so a\n            natural phrase works - ``\"storage\"``, ``\"commitment decision\n            tree\"``. A heading's trailing count is ignored, so\n            ``\"storage optimization patterns\"`` matches\n            ``\"Storage Optimization Patterns (28)\"``. If it matches nothing\n            you get the list of available headings back, not the whole file.\n\n    Without ``section``, returns ``{\"name\": ..., \"content\": \"...\",\n    \"lines\": N}`` where ``content`` is the file verbatim. With ``section``,\n    returns ``{\"name\", \"title\", \"section\", \"section_level\", \"partial\": true,\n    \"content\", \"lines\", \"full_lines\"}`` where ``content`` is that section\n    prefixed by the reference's title, plus ``other_matching_sections`` when\n    the phrase matched more than one heading.\n\n    On a miss, returns ``{\"error\": ..., \"suggestions\": [...]}``. An unknown\n    name gives up to three string-distance matches; an unmatched ``section``\n    gives ``available_sections`` - every heading in the file - so the retry\n    is exact.\n    ",
      "inputSchema": {
        "properties": {
          "name": {
            "title": "Name",
            "type": "string"
          },
          "section": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Section"
          }
        },
        "required": [
          "name"
        ],
        "title": "get_referenceArguments",
        "type": "object"
      },
      "name": "get_reference",
      "outputSchema": {
        "additionalProperties": true,
        "title": "get_referenceDictOutput",
        "type": "object"
      }
    },
    {
      "description": "See every ready-made runbook for finding and fixing cloud waste:\n    idle, orphaned and overprovisioned resources, egress surprises,\n    schedule blindness and AI/ML inefficiency across AWS, Azure and GCP.\n\n    Use this to discover which waste patterns have a runbook. When the\n    question already names a provider, waste category, or confidence tier,\n    call ``find_playbooks`` instead.\n\n    Each playbook is a small (~80-130 line) runbook scoped to one waste\n    pattern (e.g. ``aws-zombie-nat-gateway``, ``azure-orphan-disks``). Returns\n    ``{\"playbooks\": [...], \"total\": N}`` where each entry includes ``name``,\n    ``title``, ``scope`` (aws/azure/gcp/cross-cloud), ``service``,\n    ``waste_category``, ``confidence`` (obvious/likely/possible), and\n    ``approx_tokens`` - the same size hint the reference listing carries, so a\n    multi-playbook answer can be budgeted before fetching.\n    ",
      "inputSchema": {
        "properties": {},
        "title": "list_playbooksArguments",
        "type": "object"
      },
      "name": "list_playbooks",
      "outputSchema": {
        "additionalProperties": true,
        "title": "list_playbooksDictOutput",
        "type": "object"
      }
    },
    {
      "description": "See what FinOps guidance is available: billing mechanics, commitment\n    strategy, allocation and chargeback, AI cost management, and per-provider\n    cost handbooks (AWS, Azure, GCP, OCI, Databricks, Snowflake, ...).\n\n    Use this to discover what the library covers before deciding what to\n    fetch. When the question already names a FinOps domain, phase, persona\n    or maturity, call ``find_references`` instead of scanning this full\n    list.\n\n    Returns a dict shaped ``{\"references\": [...], \"total\": N}`` where each\n    entry includes ``name``, ``title``, a one-line ``description``, the\n    discriminating FCP facets (``fcp_domain``, ``fcp_capability``,\n    ``fcp_phases``, ``fcp_personas_primary``, ``fcp_maturity_entry``) and\n    ``approx_tokens``.\n\n    Read ``approx_tokens`` before fetching: the library runs from about 3,000\n    to over 25,000 tokens per file. Above roughly 10,000, prefer\n    ``get_reference(name, section=...)`` and pull the part you need.\n    ",
      "inputSchema": {
        "properties": {},
        "title": "list_referencesArguments",
        "type": "object"
      },
      "name": "list_references",
      "outputSchema": {
        "additionalProperties": true,
        "title": "list_referencesDictOutput",
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:c64c4681bdf71c82676edc651c9f3ecf7b5f891e893d7115e10b200996697c1c | sha256sum