{
  "notice": "bxzxxr MCP archive: a record of what public MCP servers declared when we listed them (we never call their tools). It is data, not a rating: nothing here says a server is safe, secure, verified or trustworthy, and a server can change after we looked. Secrets we detected are redacted; redacted tool lists are withheld and only their hash is shown.",
  "infrastructure": {
    "host": "databricks.techfabric.com",
    "site": "techfabric.com",
    "addresses": [
      {
        "address": "104.26.9.103",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "104.26.0.0/20",
          "country": "US"
        }
      },
      {
        "address": "104.26.8.103",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "104.26.0.0/20",
          "country": "US"
        }
      },
      {
        "address": "172.67.72.154",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "172.67.64.0/20",
          "country": "US"
        }
      },
      {
        "address": "2606:4700:20::ac43:489a",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "2606:4700:20::/44",
          "country": "US"
        }
      },
      {
        "address": "2606:4700:20::681a:967",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "prefix": "2606:4700:20::/44",
          "country": "US",
          "name": "CLOUDFLARENET - Cloudflare, Inc."
        }
      },
      {
        "address": "2606:4700:20::681a:867",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "prefix": "2606:4700:20::/44",
          "country": "US",
          "name": "CLOUDFLARENET - Cloudflare, Inc."
        }
      }
    ],
    "addresses_recorded": true,
    "address_history": [
      {
        "addresses": [
          "104.26.9.103",
          "104.26.8.103",
          "172.67.72.154",
          "2606:4700:20::ac43:489a",
          "2606:4700:20::681a:967",
          "2606:4700:20::681a:867"
        ],
        "first_seen": "2026-11-22T16:40:04.415Z",
        "last_seen": "2026-11-22T16:40:04.415Z",
        "checks": 1
      }
    ],
    "hosting": [
      {
        "value": "Cloudflare",
        "evidence": "Server header \"cloudflare\""
      }
    ],
    "software": [],
    "server_info": {
      "name": "databricks-field-guide",
      "version": "1.11.1",
      "protocol_version": "2025-06-18"
    },
    "headers": {
      "server": "cloudflare",
      "access-control-allow-origin": "*"
    },
    "auth": null
  },
  "related": {
    "same_address": {
      "total": 2,
      "sample": [
        {
          "id": "16708",
          "url": "https://www.techfabric.com/mcp",
          "server_name": "com.techfabric/techfabric",
          "last_state": "listed",
          "last_checked_at": "2026-11-22T16:41:03.194Z"
        },
        {
          "id": "59133",
          "url": "https://mcp.magicprices.it/mcp",
          "server_name": "it.magicprices/mcp",
          "last_state": "listed",
          "last_checked_at": "2026-11-22T14:04:33.515Z"
        }
      ]
    },
    "same_site": {
      "total": 1,
      "sample": [
        {
          "id": "16708",
          "url": "https://www.techfabric.com/mcp",
          "server_name": "com.techfabric/techfabric",
          "last_state": "listed",
          "last_checked_at": "2026-11-22T16:41:03.194Z"
        }
      ]
    },
    "same_tool_list": {
      "total": 0,
      "sample": []
    },
    "same_publisher": {
      "publisher": "com.techfabric.databricks",
      "total": 0,
      "sample": []
    },
    "same_repository": {
      "repository_url": "https://github.com/Fabric-Pro/databricks-field-guide-mcp",
      "total": 0,
      "sample": []
    },
    "note": "Shared addresses on big platforms (Cloudflare, Vercel and the like) put unrelated servers together; those are marked shared_infrastructure. A match is a pivot, not a link between operators."
  },
  "endpoint": {
    "id": "16707",
    "server_name": "com.techfabric.databricks/field-guide",
    "url": "https://databricks.techfabric.com/mcp",
    "host": "databricks.techfabric.com",
    "transport": "streamable-http",
    "last_checked_at": "2026-11-22T16:40:04.415Z",
    "last_state": "listed",
    "last_detail": null,
    "consecutive_failures": 0,
    "current_sha": "b16adee045f0abde57ef9ed12f4a51616ce2f38b214c473f10d5d09e36b8d2f2",
    "first_listed_at": "2026-11-21T11:20:02.539Z",
    "created_at": "2026-11-21T06:50:11.323Z",
    "resolved_addresses": [
      "104.26.9.103",
      "104.26.8.103",
      "172.67.72.154",
      "2606:4700:20::ac43:489a",
      "2606:4700:20::681a:967",
      "2606:4700:20::681a:867"
    ]
  },
  "server": {
    "name": "com.techfabric.databricks/field-guide",
    "title": "Databricks Field Guide by TechFabric",
    "description": "Interactive Databricks learning, certification practice and sourced engineering guidance.",
    "version": "1.11.1",
    "registry_status": "active",
    "repository_url": "https://github.com/Fabric-Pro/databricks-field-guide-mcp",
    "website_url": "https://databricks.techfabric.com",
    "published_at": "2026-11-01T01:15:38.246Z",
    "updated_at": "2026-11-01T01:15:38.246Z",
    "first_seen": "2026-11-21T06:50:10.627Z"
  },
  "other_endpoints": [],
  "intel": {
    "capabilities": [],
    "evm_addresses": [],
    "chains": [],
    "tokens": [],
    "computed_at": "2026-11-22T15:23:06.719Z"
  },
  "operator": {
    "key": "techfabric.com",
    "name": "techfabric.com",
    "platform": false
  },
  "needs_sign_in": false,
  "reachability": {
    "window_days": 30,
    "checks": 2,
    "answered": 2,
    "answered_percent": 100,
    "avg_listing_latency_ms": 895,
    "first_check_in_window": "2026-11-21T11:20:02.539Z",
    "consecutive_failures_now": 0,
    "days": [
      {
        "day": "2026-11-21",
        "checks": 1,
        "answered": 1,
        "last_state": "listed"
      },
      {
        "day": "2026-11-22",
        "checks": 1,
        "answered": 1,
        "last_state": "listed"
      }
    ]
  },
  "tool_list": {
    "sha256": "b16adee045f0abde57ef9ed12f4a51616ce2f38b214c473f10d5d09e36b8d2f2",
    "tools": 18,
    "resources": 72,
    "prompts": 15,
    "first_seen": "2026-11-21T11:20:03.412Z",
    "tool_names": [
      "start_here",
      "search_guide",
      "get_chapter",
      "get_code_examples",
      "whats_new",
      "list_chapters",
      "review_databricks_code",
      "estimate_cost",
      "explore_concept",
      "quiz_me",
      "learn_path",
      "exam_prep",
      "flashcards",
      "visualize",
      "decide",
      "explore_diagram",
      "toolkit_info",
      "toolkit_generate"
    ],
    "declared": {
      "tools": [
        {
          "name": "start_here",
          "title": "Start learning Databricks",
          "description": "Start using the Field Guide immediately. Call this for 'help me learn Databricks', 'try the Field Guide', or to begin certification prep. No arguments starts a Unity Catalog diagnostic. A topic opens its concept or chapter quiz; goal certification with an exam opens a covered domain's practice and flashcards, with official sources and honest gaps. An MCP Apps host opens the interactive card first; a terminal asks one question at a time. This is a learning companion, not a replacement for the Databricks development plugin. No sign-in, workspace access or saved personal data.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "exam": {
                "type": "string",
                "maxLength": 120,
                "description": "A certification id from exam_prep; implies certification. Defaults to data-engineer-associate."
              },
              "goal": {
                "enum": [
                  "learn",
                  "certification"
                ],
                "type": "string",
                "description": "Learn by doing (default), or begin certification practice"
              },
              "topic": {
                "type": "string",
                "maxLength": 200,
                "minLength": 1,
                "description": "A concept or chapter; omit for a Unity Catalog diagnostic"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "onboarding",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "sim": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "The data the interactive view animates; its numbers are a model, said under assumptions, except the rates, which are the guide's"
              },
              "try": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "exam": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "keep": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "kind",
                  "scope",
                  "resumed",
                  "stale"
                ],
                "properties": {
                  "kind": {
                    "type": "string"
                  },
                  "scope": {
                    "type": "string"
                  },
                  "stale": {
                    "type": "boolean"
                  },
                  "resumed": {
                    "type": [
                      "object",
                      "null"
                    ]
                  }
                },
                "description": "For an interactive view: what its Keep my progress button makes a resume code from (scope), and the reader's place when a resume code was sent (resumed). Holds no personal data; nothing is stored on the server."
              },
              "note": {
                "type": "string"
              },
              "plan": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "The guided plan: each domain, heaviest first, read, try the model, quiz; with the reader's progress (from done) and its next step"
              },
              "step": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The plan step asked for, where the card opens"
              },
              "asked": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "guide": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "level",
                  "caption",
                  "views",
                  "callouts",
                  "steps",
                  "recap"
                ],
                "properties": {
                  "level": {
                    "type": "string"
                  },
                  "recap": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "steps": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "id",
                        "title",
                        "body",
                        "tip",
                        "scene",
                        "cite"
                      ],
                      "properties": {
                        "id": {
                          "type": "string"
                        },
                        "tip": {
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "body": {
                          "type": "string"
                        },
                        "cite": {
                          "type": "object",
                          "required": [
                            "url",
                            "section"
                          ],
                          "properties": {
                            "url": {
                              "type": "string"
                            },
                            "section": {
                              "type": "string"
                            }
                          }
                        },
                        "scene": {
                          "type": "object"
                        },
                        "title": {
                          "type": "string"
                        }
                      }
                    }
                  },
                  "views": {
                    "type": [
                      "array",
                      "null"
                    ],
                    "items": {
                      "type": "string"
                    }
                  },
                  "caption": {
                    "type": "string",
                    "description": "Says the pictures are illustrative"
                  },
                  "callouts": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "n",
                        "x",
                        "y",
                        "step",
                        "label"
                      ],
                      "properties": {
                        "n": {
                          "type": "string"
                        },
                        "x": {
                          "type": "number"
                        },
                        "y": {
                          "type": "number"
                        },
                        "step": {
                          "type": "integer"
                        },
                        "label": {
                          "type": "string"
                        }
                      }
                    }
                  }
                },
                "description": "Guided mode for the view: steps, each a short title, one of the guide's points as its body, an optional tip, an illustrative scene and the section it cites; then a recap"
              },
              "scope": {
                "type": "object",
                "required": [
                  "chapter",
                  "section",
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string"
                  },
                  "chapter": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "section": {
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                }
              },
              "score": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "right",
                  "total",
                  "answered",
                  "stopped",
                  "results"
                ],
                "properties": {
                  "right": {
                    "type": "integer"
                  },
                  "total": {
                    "type": "integer"
                  },
                  "results": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "n",
                        "given",
                        "right"
                      ],
                      "properties": {
                        "n": {
                          "type": "integer"
                        },
                        "given": {
                          "type": [
                            "string",
                            "null"
                          ],
                          "description": "The letter the reader gave; null for none"
                        },
                        "right": {
                          "type": "boolean"
                        }
                      }
                    }
                  },
                  "stopped": {
                    "type": "boolean",
                    "description": "The reader stopped before the last question"
                  },
                  "answered": {
                    "type": "integer"
                  }
                },
                "description": "The reader's score, when they answered (answers, or the questions asked one at a time by elicitation); null otherwise"
              },
              "title": {
                "type": "string"
              },
              "total": {
                "type": "integer"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "domain": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "chapter": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "chapter",
                  "section",
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string",
                    "description": "The section, with its anchor"
                  },
                  "chapter": {
                    "type": "string"
                  },
                  "section": {
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                }
              },
              "concept": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The concept's id; null when none matched (see available)"
              },
              "domains": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "name",
                    "weight",
                    "coverage",
                    "sections",
                    "concepts",
                    "practice"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "name": {
                      "type": "string",
                      "description": "As Databricks publishes it"
                    },
                    "weight": {
                      "type": "number",
                      "description": "Percent of the exam, as Databricks publishes it"
                    },
                    "concepts": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "id",
                          "title"
                        ],
                        "properties": {
                          "id": {
                            "type": "string"
                          },
                          "title": {
                            "type": "string"
                          }
                        }
                      }
                    },
                    "coverage": {
                      "enum": [
                        "good",
                        "thin",
                        "none"
                      ],
                      "type": "string",
                      "description": "How many guide sections bear on it: good, three or more; thin, one or two; none"
                    },
                    "practice": {
                      "type": "object",
                      "required": [
                        "tool",
                        "arguments"
                      ],
                      "properties": {
                        "tool": {
                          "type": "string"
                        },
                        "arguments": {
                          "type": [
                            "object",
                            "null"
                          ]
                        }
                      }
                    },
                    "sections": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "chapter",
                          "section",
                          "url"
                        ],
                        "properties": {
                          "url": {
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "chapter": {
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "section": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "related": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "title"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "title": {
                      "type": "string"
                    }
                  }
                }
              },
              "summary": {
                "type": "string"
              },
              "coverage": {
                "type": [
                  "object",
                  "null"
                ]
              },
              "official": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "page",
                  "guide",
                  "as_of"
                ],
                "properties": {
                  "page": {
                    "type": "string",
                    "description": "The exam's page on databricks.com"
                  },
                  "as_of": {
                    "type": "string"
                  },
                  "guide": {
                    "type": "string",
                    "description": "Databricks' exam guide"
                  }
                }
              },
              "practice": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "The domain's practice quiz, as quiz_me returns one"
              },
              "sections": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "chapter",
                    "section",
                    "url"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "chapter": {
                      "type": "string"
                    },
                    "section": {
                      "type": "string"
                    }
                  }
                }
              },
              "withheld": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "point",
                    "reason"
                  ],
                  "properties": {
                    "point": {
                      "type": "string"
                    },
                    "reason": {
                      "type": "string"
                    }
                  }
                }
              },
              "available": {
                "type": "array",
                "items": {
                  "type": "object"
                }
              },
              "plan_step": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "Opened from an exam plan: this step's place (n of total), the steps done with this one, the plan's next step, and back, the call that returns to the plan"
              },
              "practices": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "Each covered domain's practice quiz, by domain id, for the plan's quiz steps"
              },
              "questions": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "n",
                    "kind",
                    "question",
                    "options",
                    "answer",
                    "explanation",
                    "source"
                  ],
                  "properties": {
                    "n": {
                      "type": "integer"
                    },
                    "kind": {
                      "enum": [
                        "table",
                        "question",
                        "faq",
                        "glossary"
                      ],
                      "type": "string"
                    },
                    "answer": {
                      "type": "integer",
                      "minimum": 0,
                      "description": "The index of the right option"
                    },
                    "source": {
                      "type": "object",
                      "required": [
                        "chapter",
                        "section",
                        "url"
                      ],
                      "properties": {
                        "url": {
                          "type": "string"
                        },
                        "chapter": {
                          "type": "string"
                        },
                        "section": {
                          "type": "string"
                        }
                      }
                    },
                    "options": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "minItems": 2
                    },
                    "question": {
                      "type": "string"
                    },
                    "explanation": {
                      "type": "string",
                      "description": "The guide's words"
                    }
                  }
                },
                "maxItems": 8
              },
              "what_next": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "label",
                    "call"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "call": {
                      "type": "object"
                    },
                    "label": {
                      "type": "string"
                    }
                  }
                },
                "description": "What to do after this concept, as calls: from a plan, its next step and back to it; a quiz on it; the next concept"
              },
              "disclaimer": {
                "type": "string"
              },
              "flashcards": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "The domain's flashcards, as the flashcards tool returns them (structured content only)"
              },
              "onboarding": {
                "type": "object",
                "required": [
                  "goal",
                  "tool",
                  "arguments",
                  "mode"
                ],
                "properties": {
                  "goal": {
                    "enum": [
                      "learn",
                      "certification"
                    ],
                    "type": "string"
                  },
                  "mode": {
                    "enum": [
                      "quiz",
                      "guided",
                      "practice",
                      "study"
                    ],
                    "type": "string"
                  },
                  "tool": {
                    "type": "string"
                  },
                  "arguments": {
                    "type": "object"
                  }
                },
                "additionalProperties": false
              },
              "assumptions": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "explanation": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "text",
                    "quote",
                    "source"
                  ],
                  "properties": {
                    "text": {
                      "type": "string",
                      "description": "The point, in plain words"
                    },
                    "quote": {
                      "type": "string",
                      "description": "The guide's sentence it rests on, verbatim"
                    },
                    "source": {
                      "type": "object",
                      "required": [
                        "chapter",
                        "section",
                        "url",
                        "updated"
                      ],
                      "properties": {
                        "url": {
                          "type": "string"
                        },
                        "chapter": {
                          "type": "string"
                        },
                        "section": {
                          "type": "string"
                        },
                        "updated": {
                          "type": [
                            "string",
                            "null"
                          ]
                        }
                      }
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "Start learning Databricks",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search_guide",
          "title": "Search the guide",
          "description": "Search the guide's chapters, margin notes and events for a Databricks question. Returns the best sections first, each with a snippet, its URL with the section anchor, and when the page last changed. Read one in full with get_chapter (pass the URL, or the slug and the anchor).",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "query"
            ],
            "properties": {
              "kind": {
                "enum": [
                  "chapter",
                  "note",
                  "feature",
                  "event"
                ],
                "type": "string",
                "description": "Only chapters, margin notes (dated news with our position), feature pages or events"
              },
              "limit": {
                "type": "integer",
                "maximum": 25,
                "minimum": 1,
                "description": "How many results (default 10)"
              },
              "query": {
                "type": "string",
                "maxLength": 200,
                "minLength": 1,
                "description": "The question or topic in plain words, e.g. 'lakebase branch' or 'unity catalog row filters'"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "query",
              "kind",
              "total",
              "results",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "kind": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "next": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "tool",
                  "arguments",
                  "hint"
                ],
                "properties": {
                  "hint": {
                    "type": "string"
                  },
                  "tool": {
                    "type": "string"
                  },
                  "arguments": {
                    "type": "object"
                  }
                },
                "description": "When this is about a concept the guide explains interactively: the call for a step-by-step walkthrough"
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "query": {
                "type": "string"
              },
              "total": {
                "type": "integer"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "results": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "kind",
                    "title",
                    "section",
                    "anchor",
                    "url",
                    "snippet",
                    "updated",
                    "score"
                  ],
                  "properties": {
                    "url": {
                      "type": "string",
                      "description": "Links straight to the section"
                    },
                    "kind": {
                      "enum": [
                        "chapter",
                        "note",
                        "feature",
                        "event"
                      ],
                      "type": "string"
                    },
                    "score": {
                      "type": "number"
                    },
                    "title": {
                      "type": "string",
                      "description": "The chapter, note or event"
                    },
                    "anchor": {
                      "type": [
                        "string",
                        "null"
                      ],
                      "description": "The section's anchor on the page"
                    },
                    "section": {
                      "type": [
                        "string",
                        "null"
                      ],
                      "description": "The section that matched; null for the introduction"
                    },
                    "snippet": {
                      "type": "string"
                    },
                    "updated": {
                      "type": [
                        "string",
                        "null"
                      ],
                      "description": "When the page last changed, YYYY-MM-DD (an event: its day)"
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "Search the guide",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_chapter",
          "title": "Read a chapter",
          "description": "One chapter (or margin note) of the guide as clean Markdown with its code blocks intact, or one section of it: with its outline, its code blocks listed separately, its FAQs, when it last changed, and the official docs.databricks.com links it cites for the authoritative detail.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "maxLength": 500,
                "minLength": 1,
                "description": "A chapter's slug (lakebase, unity-catalog, start-here), a note's slug, or a guide URL or path. list_chapters has them; the field-guide-chapter prompt completes them."
              },
              "section": {
                "type": "string",
                "maxLength": 200,
                "description": "One section only: its anchor (from search_guide, list_chapters or the outline) or its heading. Omit for the whole chapter."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "kind",
              "slug",
              "title",
              "url",
              "markdown_url",
              "part",
              "summary",
              "published",
              "updated",
              "section",
              "outline",
              "markdown",
              "code",
              "faqs",
              "docs",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "url": {
                "type": "string"
              },
              "code": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "lang",
                    "filename",
                    "code",
                    "section",
                    "url"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "code": {
                      "type": "string"
                    },
                    "lang": {
                      "type": "string"
                    },
                    "section": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "filename": {
                      "type": [
                        "string",
                        "null"
                      ]
                    }
                  }
                }
              },
              "docs": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "text",
                    "url",
                    "section"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "text": {
                      "type": "string"
                    },
                    "section": {
                      "type": [
                        "string",
                        "null"
                      ]
                    }
                  }
                }
              },
              "faqs": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "question",
                    "answer"
                  ],
                  "properties": {
                    "answer": {
                      "type": "string"
                    },
                    "question": {
                      "type": "string"
                    }
                  }
                }
              },
              "kind": {
                "enum": [
                  "chapter",
                  "note",
                  "feature"
                ],
                "type": "string"
              },
              "next": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "tool",
                  "arguments",
                  "hint"
                ],
                "properties": {
                  "hint": {
                    "type": "string"
                  },
                  "tool": {
                    "type": "string"
                  },
                  "arguments": {
                    "type": "object"
                  }
                },
                "description": "When this is about a concept the guide explains interactively: the call for a step-by-step walkthrough"
              },
              "part": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "slug": {
                "type": "string"
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "title": {
                "type": "string"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "outline": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "anchor",
                    "title",
                    "depth"
                  ],
                  "properties": {
                    "depth": {
                      "type": "integer"
                    },
                    "title": {
                      "type": "string"
                    },
                    "anchor": {
                      "type": "string"
                    }
                  }
                }
              },
              "section": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "anchor",
                  "title",
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string"
                  },
                  "title": {
                    "type": "string"
                  },
                  "anchor": {
                    "type": "string"
                  }
                }
              },
              "summary": {
                "type": "string"
              },
              "updated": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When the page last changed, YYYY-MM-DD"
              },
              "markdown": {
                "type": "string",
                "description": "The chapter or section as Markdown, code blocks intact; links are absolute"
              },
              "published": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              },
              "markdown_url": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Read a chapter",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_code_examples",
          "title": "Find code examples",
          "description": "The SQL, Python, CLI and config blocks in the guide that match a topic, each with the explanation around it, the section it is from (URL with anchor), and the docs links that section cites. Runnable context for a coding agent; check the linked Databricks docs for current syntax.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "topic"
            ],
            "properties": {
              "lang": {
                "type": "string",
                "maxLength": 20,
                "description": "Only this language: sql, python, bash, yaml, json, hcl ..."
              },
              "limit": {
                "type": "integer",
                "maximum": 25,
                "minimum": 1,
                "description": "How many examples (default 8)"
              },
              "topic": {
                "type": "string",
                "maxLength": 200,
                "minLength": 1,
                "description": "What the code should do or touch, e.g. 'lakebase branch', 'auto loader', 'row filter'"
              },
              "chapter": {
                "type": "string",
                "maxLength": 500,
                "description": "Only examples from this chapter or note: its slug (lakebase, unity-catalog), path or URL. list_chapters has them; the field-guide-code prompt completes them."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "topic",
              "lang",
              "total",
              "examples",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "lang": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "topic": {
                "type": "string"
              },
              "total": {
                "type": "integer"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "examples": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "lang",
                    "filename",
                    "code",
                    "explanation",
                    "after",
                    "chapter",
                    "section",
                    "url",
                    "updated",
                    "docs",
                    "score"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "code": {
                      "type": "string"
                    },
                    "docs": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "text",
                          "url"
                        ],
                        "properties": {
                          "url": {
                            "type": "string",
                            "description": "An official Databricks documentation page"
                          },
                          "text": {
                            "type": "string"
                          }
                        }
                      }
                    },
                    "lang": {
                      "type": "string"
                    },
                    "after": {
                      "type": "string",
                      "description": "The guide's prose just after it"
                    },
                    "score": {
                      "type": "number"
                    },
                    "chapter": {
                      "type": "string"
                    },
                    "section": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "updated": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "filename": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "explanation": {
                      "type": "string",
                      "description": "The guide's prose just before the block"
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "Find code examples",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "whats_new",
          "title": "What's new in Databricks",
          "description": "Recent Databricks changes the guide tracks, newest first: margin notes (dated news with our position), release-stage changes from the feature register (with links to Databricks' documentation and release note), and chapters updated. Defaults to the last 30 days.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "limit": {
                "type": "integer",
                "maximum": 200,
                "minimum": 1,
                "description": "How many items (default 30)"
              },
              "since": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                "description": "Changes on or after this day, YYYY-MM-DD (default: the last 30 days)"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "since",
              "total",
              "items",
              "board",
              "register_updated",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "board": {
                "type": "string",
                "description": "The feature status board"
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "items": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "date",
                    "kind",
                    "title",
                    "url",
                    "summary",
                    "stage",
                    "docs"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "date": {
                      "type": "string"
                    },
                    "docs": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "text",
                          "url"
                        ],
                        "properties": {
                          "url": {
                            "type": "string",
                            "description": "An official Databricks documentation page"
                          },
                          "text": {
                            "type": "string"
                          }
                        }
                      }
                    },
                    "kind": {
                      "enum": [
                        "note",
                        "note_updated",
                        "feature_page",
                        "feature_page_updated",
                        "feature_stage",
                        "chapter_updated"
                      ],
                      "type": "string"
                    },
                    "stage": {
                      "type": [
                        "string",
                        "null"
                      ],
                      "description": "A feature's release stage, as Databricks states it"
                    },
                    "title": {
                      "type": "string"
                    },
                    "summary": {
                      "type": [
                        "string",
                        "null"
                      ]
                    }
                  }
                }
              },
              "since": {
                "type": "string"
              },
              "total": {
                "type": "integer"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              },
              "register_updated": {
                "type": [
                  "string",
                  "null"
                ]
              }
            }
          },
          "annotations": {
            "title": "What's new in Databricks",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_chapters",
          "title": "List chapters",
          "description": "Every chapter in the guide's order, with its part, summary, dates, URL, Markdown URL and its main sections; and the margin notes.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {},
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "total",
              "chapters",
              "notes",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "notes": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "slug",
                    "title",
                    "url",
                    "published",
                    "updated"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "slug": {
                      "type": "string"
                    },
                    "title": {
                      "type": "string"
                    },
                    "updated": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "published": {
                      "type": [
                        "string",
                        "null"
                      ]
                    }
                  }
                }
              },
              "total": {
                "type": "integer"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "chapters": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "slug",
                    "number",
                    "title",
                    "part",
                    "summary",
                    "url",
                    "markdown_url",
                    "published",
                    "updated",
                    "sections"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "part": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "slug": {
                      "type": "string"
                    },
                    "title": {
                      "type": "string"
                    },
                    "number": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "summary": {
                      "type": "string"
                    },
                    "updated": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "sections": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "anchor",
                          "title"
                        ],
                        "properties": {
                          "title": {
                            "type": "string"
                          },
                          "anchor": {
                            "type": "string"
                          }
                        }
                      }
                    },
                    "published": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "markdown_url": {
                      "type": "string"
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "List chapters",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "review_databricks_code",
          "title": "Review Databricks code",
          "description": "Check one file of SQL, Python (PySpark, a notebook's source) or YAML (a Databricks Asset Bundle, job, cluster or warehouse config) against the Field Guide's own best-practice rules, deterministically: partitioning where the guide would cluster, secrets and storage paths written into code, grants to people rather than groups, environments in table names, jobs on all-purpose clusters or without timeouts, warehouses and clusters without auto-stop, bundle targets without their modes, and the rest of the rules the chapters state. Each finding gives the line, why, the fix, the guide's passage verbatim with its section URL, and the docs.databricks.com links the guide cites for it; the result also lists the sections worth reading for this code. No model is called: weigh the findings yourself. One file per call.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "code"
            ],
            "properties": {
              "code": {
                "type": "string",
                "maxLength": 48000,
                "minLength": 1,
                "description": "The file's contents: SQL, Python (PySpark, a notebook's source) or YAML (a Databricks Asset Bundle, job, cluster or warehouse config). At most 48000 characters; review a larger file in parts."
              },
              "lang": {
                "enum": [
                  "sql",
                  "python",
                  "yaml"
                ],
                "type": "string",
                "description": "sql, python or yaml. Omit to detect it from the filename or the code."
              },
              "filename": {
                "type": "string",
                "maxLength": 300,
                "description": "The file's path in the repository, e.g. resources/nightly.job.yml: used to detect the language and echoed back"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "lang",
              "filename",
              "lines",
              "total",
              "findings",
              "sections",
              "rules_checked",
              "withheld",
              "note",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "lang": {
                "enum": [
                  "sql",
                  "python",
                  "yaml"
                ],
                "type": "string"
              },
              "note": {
                "type": "string"
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "lines": {
                "type": "integer"
              },
              "total": {
                "type": "integer"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "filename": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "findings": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "rule",
                    "title",
                    "severity",
                    "line",
                    "code",
                    "why",
                    "fix",
                    "passage",
                    "docs"
                  ],
                  "properties": {
                    "fix": {
                      "type": "string",
                      "description": "What the guide recommends instead"
                    },
                    "why": {
                      "type": "string",
                      "description": "Why, in the guide's terms"
                    },
                    "code": {
                      "type": "string",
                      "description": "The line, with any secret-looking value masked"
                    },
                    "docs": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "text",
                          "url"
                        ],
                        "properties": {
                          "url": {
                            "type": "string",
                            "description": "An official Databricks documentation page"
                          },
                          "text": {
                            "type": "string"
                          }
                        }
                      },
                      "description": "The docs.databricks.com links the guide cites for this advice; empty when its section cites none"
                    },
                    "line": {
                      "type": "integer"
                    },
                    "rule": {
                      "type": "string",
                      "description": "The rule's id"
                    },
                    "title": {
                      "type": "string"
                    },
                    "passage": {
                      "type": "object",
                      "required": [
                        "text",
                        "chapter",
                        "section",
                        "url",
                        "updated"
                      ],
                      "properties": {
                        "url": {
                          "type": "string",
                          "description": "The section, with its anchor"
                        },
                        "text": {
                          "type": "string",
                          "description": "The guide's sentence, verbatim"
                        },
                        "chapter": {
                          "type": "string"
                        },
                        "section": {
                          "type": "string"
                        },
                        "updated": {
                          "type": [
                            "string",
                            "null"
                          ]
                        }
                      }
                    },
                    "severity": {
                      "enum": [
                        "high",
                        "medium",
                        "low"
                      ],
                      "type": "string"
                    }
                  }
                }
              },
              "sections": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "chapter",
                    "section",
                    "url",
                    "why"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "why": {
                      "type": "string"
                    },
                    "chapter": {
                      "type": "string"
                    },
                    "section": {
                      "type": [
                        "string",
                        "null"
                      ]
                    }
                  }
                }
              },
              "withheld": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "rule",
                    "reason"
                  ],
                  "properties": {
                    "rule": {
                      "type": "string"
                    },
                    "reason": {
                      "type": "string"
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              },
              "rules_checked": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              }
            }
          },
          "annotations": {
            "title": "Review Databricks code",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "estimate_cost",
          "title": "Estimate Databricks cost",
          "description": "Estimate a Databricks workload's monthly cost from the figures the Field Guide states (list prices per DBU by compute type, DBUs an hour by SQL warehouse size and classic instance type, model serving prices for pay-per-token, provisioned throughput, GPU and CPU serving, Apps and Genie rates, the Lakebase floor, storage), as a range with its assumptions, and the price per unit under unit_prices. Every number carries its source sentence, section URL, date and the pricing page the guide cites. Where the guide has no figure (cloud VM prices, a serverless job's DBUs an hour, a model or instance type it does not list) it says so under gaps instead of guessing.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "workload"
            ],
            "properties": {
              "size": {
                "type": "string",
                "maxLength": 20,
                "description": "apps: medium (the default), large or xlarge; sql_warehouse: the t-shirt size, 2x-small, x-small, small, medium, large, x-large, 2x-large, 3x-large, 4x-large, 5x-large (DBUs an hour per cluster, from the guide); model_serving with serving gpu: t4, a10g, a10g-4, a10g-8, l40s, rtx-pro-6000, a100-40gb-8, a100-80gb-8, h100, h100-8"
              },
              "model": {
                "type": "string",
                "maxLength": 80,
                "description": "model_serving, pay_per_token or provisioned_throughput: the model, as in 'Llama 3.3 70B' or 'claude-sonnet-5.5'"
              },
              "users": {
                "type": "integer",
                "maximum": 1000000,
                "minimum": 0,
                "description": "genie: the people using it"
              },
              "compute": {
                "enum": [
                  "serverless",
                  "classic",
                  "pro",
                  "lakehouse_rt"
                ],
                "type": "string",
                "description": "jobs and all_purpose: serverless or classic; sql_warehouse: serverless, pro, classic, or lakehouse_rt (Beta) priced from DBUs you give"
              },
              "serving": {
                "enum": [
                  "pay_per_token",
                  "provisioned_throughput",
                  "gpu",
                  "cpu"
                ],
                "type": "string",
                "description": "model_serving: pay_per_token, provisioned_throughput, gpu or cpu (omit for every price the guide states)"
              },
              "clusters": {
                "type": "integer",
                "maximum": 1000,
                "minimum": 1,
                "description": "sql_warehouse: clusters running (default 1)"
              },
              "workload": {
                "enum": [
                  "jobs",
                  "all_purpose",
                  "sql_warehouse",
                  "apps",
                  "genie",
                  "lakebase",
                  "model_serving",
                  "storage"
                ],
                "type": "string",
                "description": "jobs, all_purpose (interactive notebooks), sql_warehouse, apps, genie, lakebase, model_serving or storage"
              },
              "always_on": {
                "type": "boolean",
                "description": "lakebase: an always-on 0.5 CU floor (the one Lakebase figure the guide quotes)"
              },
              "instances": {
                "type": "integer",
                "maximum": 10000,
                "minimum": 1,
                "description": "jobs or all_purpose, classic: instances in the cluster, the driver counted as one; model_serving cpu: Medium configurations"
              },
              "storage_gb": {
                "type": "number",
                "maximum": 1000000000,
                "minimum": 0,
                "description": "storage: GB held"
              },
              "model_units": {
                "type": "integer",
                "maximum": 100000,
                "minimum": 1,
                "description": "model_serving, provisioned_throughput: model units (default 50, the block the rates are quoted for; a reservation takes multiples of 50 and bills every hour of its term)"
              },
              "reservation": {
                "enum": [
                  "on_demand",
                  "1_month",
                  "3_month"
                ],
                "type": "string",
                "description": "model_serving, provisioned_throughput: on_demand, 1_month or 3_month"
              },
              "max_clusters": {
                "type": "integer",
                "maximum": 1000,
                "minimum": 1,
                "description": "sql_warehouse: the most clusters it scales out to; the estimate ranges from clusters to max_clusters"
              },
              "dbus_per_hour": {
                "type": "number",
                "maximum": 100000,
                "minimum": 0,
                "description": "DBUs the compute uses an hour, when the guide has no figure for its shape (a serverless job, an instance type it does not list): from system.billing.usage or Databricks' pricing calculator"
              },
              "dbus_per_user": {
                "type": "number",
                "maximum": 1000000,
                "minimum": 0,
                "description": "genie: each user's Genie DBUs a month"
              },
              "hours_per_day": {
                "type": "number",
                "maximum": 24,
                "minimum": 0
              },
              "instance_type": {
                "type": "string",
                "maxLength": 40,
                "description": "jobs or all_purpose, classic: the AWS instance type (m5.xlarge, m5.2xlarge, m6i.xlarge, m7i.xlarge, r5.xlarge, c5.2xlarge, i3.xlarge, i3.2xlarge are in the guide)"
              },
              "days_per_month": {
                "type": "number",
                "maximum": 31,
                "minimum": 1,
                "description": "Days it runs a month (default 30 with hours_per_day)"
              },
              "dbus_per_month": {
                "type": "number",
                "maximum": 100000000,
                "minimum": 0,
                "description": "Or the DBUs a month outright"
              },
              "hours_per_month": {
                "type": "number",
                "maximum": 744,
                "minimum": 0
              },
              "input_tokens_millions": {
                "type": "number",
                "maximum": 10000000,
                "minimum": 0,
                "description": "model_serving, pay_per_token: input tokens a month, in millions"
              },
              "output_tokens_millions": {
                "type": "number",
                "maximum": 10000000,
                "minimum": 0,
                "description": "model_serving, pay_per_token: output tokens a month, in millions"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "workload",
              "compute",
              "size",
              "monthly_usd",
              "currency",
              "lines",
              "unit_prices",
              "figures",
              "assumptions",
              "gaps",
              "pricing_links",
              "withheld",
              "note",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "gaps": {
                "type": "array",
                "items": {
                  "type": "string",
                  "description": "What the guide has no figure for, so the estimate leaves it out"
                }
              },
              "note": {
                "type": "string"
              },
              "size": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "lines": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "item",
                    "monthly_usd",
                    "formula",
                    "figures"
                  ],
                  "properties": {
                    "item": {
                      "type": "string"
                    },
                    "figures": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    },
                    "formula": {
                      "type": "string"
                    },
                    "monthly_usd": {
                      "type": [
                        "object",
                        "null"
                      ],
                      "required": [
                        "low",
                        "high"
                      ],
                      "properties": {
                        "low": {
                          "type": "number"
                        },
                        "high": {
                          "type": "number"
                        }
                      }
                    }
                  }
                }
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "compute": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "figures": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "what",
                    "value",
                    "unit",
                    "conditions",
                    "as_of",
                    "dated",
                    "source",
                    "links"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "unit": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "what": {
                      "type": "string"
                    },
                    "as_of": {
                      "type": [
                        "string",
                        "null"
                      ],
                      "description": "The date the guide gives for the figure, YYYY-MM-DD"
                    },
                    "dated": {
                      "type": "string",
                      "description": "How the figure is dated: the guide's own date, or its chapter's last update"
                    },
                    "links": {
                      "type": "array",
                      "items": {
                        "type": "string",
                        "description": "A pricing or documentation page the guide cites for it"
                      }
                    },
                    "value": {},
                    "source": {
                      "type": "object",
                      "required": [
                        "chapter",
                        "section",
                        "url",
                        "quote"
                      ],
                      "properties": {
                        "url": {
                          "type": "string"
                        },
                        "quote": {
                          "type": "string",
                          "description": "The guide's sentence, verbatim"
                        },
                        "chapter": {
                          "type": "string"
                        },
                        "section": {
                          "type": "string"
                        }
                      }
                    },
                    "conditions": {
                      "type": [
                        "string",
                        "null"
                      ]
                    }
                  }
                }
              },
              "currency": {
                "const": "USD"
              },
              "withheld": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "figure",
                    "reason"
                  ],
                  "properties": {
                    "figure": {
                      "type": "string"
                    },
                    "reason": {
                      "type": "string"
                    }
                  }
                }
              },
              "workload": {
                "enum": [
                  "jobs",
                  "all_purpose",
                  "sql_warehouse",
                  "apps",
                  "genie",
                  "lakebase",
                  "model_serving",
                  "storage"
                ],
                "type": "string"
              },
              "calculator": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "For an interactive view: the inputs as asked and this workload's rates from the guide, to recompute the estimate locally. Not in the text result."
              },
              "assumptions": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "text",
                    "figure",
                    "source"
                  ],
                  "properties": {
                    "text": {
                      "type": "string"
                    },
                    "figure": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "source": {
                      "type": [
                        "string",
                        "null"
                      ]
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              },
              "monthly_usd": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "low",
                  "high"
                ],
                "properties": {
                  "low": {
                    "type": "number"
                  },
                  "high": {
                    "type": "number"
                  }
                },
                "description": "The estimate, a month; null where the guide has no figure for it (see gaps)"
              },
              "unit_prices": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "item",
                    "usd",
                    "per",
                    "formula",
                    "figures"
                  ],
                  "properties": {
                    "per": {
                      "type": "string",
                      "description": "The unit, as in '1M output tokens' or 'a medium cluster-hour'"
                    },
                    "usd": {
                      "type": "number"
                    },
                    "item": {
                      "type": "string"
                    },
                    "figures": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    },
                    "formula": {
                      "type": "string"
                    }
                  }
                },
                "description": "The price per unit the guide's figures give (a cluster-hour, a million tokens, an endpoint-hour), with or without usage"
              },
              "pricing_links": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              }
            }
          },
          "annotations": {
            "title": "Estimate Databricks cost",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "explore_concept",
          "title": "Explore a Databricks concept",
          "description": "Interactive: explains one Databricks concept step by step from the Field Guide's chapters: delta-transaction-log, liquid-clustering-vs-zorder, spark-shuffle-and-stages, unity-catalog-privilege-inheritance, photon-vs-classic-cost, cluster-autoscaling, streaming-watermarks, medallion-layers, lakebase-branching, serverless-vs-classic, mlflow-model-lifecycle. Call it first when the user asks \"how does the Delta transaction log work?\", \"show me watermarks step by step\" or \"visualise Unity Catalog privilege inheritance\", rather than answering from memory or running code. Every point comes with the guide's own sentence and its section URL; the result also carries a worked example and the data an interactive model draws (a Delta log to step through, files skipped under each layout, Spark stages and skew, Unity Catalog grants on a tree, cost curves from the guide's rates, a warehouse's day, a watermark timeline, and more), with what the model assumes said apart from what the guide states. In a host that renders MCP Apps it opens as an interactive view; the text is complete without it. Unknown or no concept: the list (with form: true, a terminal that shows forms asks which).",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "done": {
                "type": "array",
                "items": {
                  "anyOf": [
                    {
                      "type": "string",
                      "maxLength": 200
                    },
                    {
                      "type": "integer"
                    }
                  ]
                },
                "maxItems": 60,
                "description": "With exam: the plan steps done so far, by number or id"
              },
              "exam": {
                "type": "string",
                "maxLength": 120,
                "description": "Opened from an exam_prep plan: the exam's id, so the card says which step this is and its Next returns to the plan"
              },
              "form": {
                "type": "boolean",
                "description": "true: with no concept (or one that isn't there), in a client that shows forms and no MCP Apps view, ask the reader which concept to step through. Left out, the result is the list."
              },
              "step": {
                "type": "string",
                "maxLength": 200,
                "description": "With exam: the plan step this card was opened from (its id, as the plan's call gives it)"
              },
              "concept": {
                "type": "string",
                "maxLength": 200,
                "description": "The concept: delta-transaction-log, liquid-clustering-vs-zorder, spark-shuffle-and-stages, unity-catalog-privilege-inheritance, photon-vs-classic-cost, cluster-autoscaling, streaming-watermarks, medallion-layers, lakebase-branching, serverless-vs-classic, mlflow-model-lifecycle. A plain name works too (\"watermarks\", \"z-order\", \"photon\"). Omit it, or name one that isn't there, for the list."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "concept",
              "asked",
              "title",
              "summary",
              "chapter",
              "explanation",
              "sim",
              "assumptions",
              "try",
              "sections",
              "related",
              "available",
              "withheld",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "sim": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "The data the interactive view animates; its numbers are a model, said under assumptions, except the rates, which are the guide's"
              },
              "try": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "asked": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "guide": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "level",
                  "caption",
                  "views",
                  "callouts",
                  "steps",
                  "recap"
                ],
                "properties": {
                  "level": {
                    "type": "string"
                  },
                  "recap": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "steps": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "id",
                        "title",
                        "body",
                        "tip",
                        "scene",
                        "cite"
                      ],
                      "properties": {
                        "id": {
                          "type": "string"
                        },
                        "tip": {
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "body": {
                          "type": "string"
                        },
                        "cite": {
                          "type": "object",
                          "required": [
                            "url",
                            "section"
                          ],
                          "properties": {
                            "url": {
                              "type": "string"
                            },
                            "section": {
                              "type": "string"
                            }
                          }
                        },
                        "scene": {
                          "type": "object"
                        },
                        "title": {
                          "type": "string"
                        }
                      }
                    }
                  },
                  "views": {
                    "type": [
                      "array",
                      "null"
                    ],
                    "items": {
                      "type": "string"
                    }
                  },
                  "caption": {
                    "type": "string",
                    "description": "Says the pictures are illustrative"
                  },
                  "callouts": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "n",
                        "x",
                        "y",
                        "step",
                        "label"
                      ],
                      "properties": {
                        "n": {
                          "type": "string"
                        },
                        "x": {
                          "type": "number"
                        },
                        "y": {
                          "type": "number"
                        },
                        "step": {
                          "type": "integer"
                        },
                        "label": {
                          "type": "string"
                        }
                      }
                    }
                  }
                },
                "description": "Guided mode for the view: steps, each a short title, one of the guide's points as its body, an optional tip, an illustrative scene and the section it cites; then a recap"
              },
              "title": {
                "type": "string"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "chapter": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "chapter",
                  "section",
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string",
                    "description": "The section, with its anchor"
                  },
                  "chapter": {
                    "type": "string"
                  },
                  "section": {
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                }
              },
              "concept": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The concept's id; null when none matched (see available)"
              },
              "related": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "title"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "title": {
                      "type": "string"
                    }
                  }
                }
              },
              "summary": {
                "type": "string"
              },
              "sections": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "chapter",
                    "section",
                    "url"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "chapter": {
                      "type": "string"
                    },
                    "section": {
                      "type": "string"
                    }
                  }
                }
              },
              "withheld": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "point",
                    "reason"
                  ],
                  "properties": {
                    "point": {
                      "type": "string"
                    },
                    "reason": {
                      "type": "string"
                    }
                  }
                }
              },
              "available": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "title",
                    "summary"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "title": {
                      "type": "string"
                    },
                    "summary": {
                      "type": "string"
                    }
                  }
                }
              },
              "plan_step": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "Opened from an exam plan: this step's place (n of total), the steps done with this one, the plan's next step, and back, the call that returns to the plan"
              },
              "what_next": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "label",
                    "call"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "call": {
                      "type": "object"
                    },
                    "label": {
                      "type": "string"
                    }
                  }
                },
                "description": "What to do after this concept, as calls: from a plan, its next step and back to it; a quiz on it; the next concept"
              },
              "assumptions": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "explanation": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "text",
                    "quote",
                    "source"
                  ],
                  "properties": {
                    "text": {
                      "type": "string",
                      "description": "The point, in plain words"
                    },
                    "quote": {
                      "type": "string",
                      "description": "The guide's sentence it rests on, verbatim"
                    },
                    "source": {
                      "type": "object",
                      "required": [
                        "chapter",
                        "section",
                        "url",
                        "updated"
                      ],
                      "properties": {
                        "url": {
                          "type": "string"
                        },
                        "chapter": {
                          "type": "string"
                        },
                        "section": {
                          "type": "string"
                        },
                        "updated": {
                          "type": [
                            "string",
                            "null"
                          ]
                        }
                      }
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "Explore a Databricks concept",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "quiz_me",
          "title": "Quiz me on the guide",
          "description": "Interactive: quizzes the reader. Call it when the user says \"quiz me on Unity Catalog\", \"test me on Lakebase\" or \"check what I know about the Delta log\". Five to eight multiple-choice questions on a chapter of the Field Guide, one section of it, or the whole guide, built deterministically from the guide's own tables, question-headed sections, FAQs and glossary: every question and every option is a phrase the guide states, and no model writes them. Each has its answer, the guide's explanation and the section URL. In a host that renders MCP Apps the reader answers and is scored in the view. In a terminal whose client shows forms (elicitation), send form: true when the reader wants each question asked as a form; the score comes back with the explanations. Otherwise the text lists the questions and answers: ask the reader each one before revealing it, then call quiz_me again with the same chapter and section and their answers to score them. A reader who kept a resume code (Keep my progress, in a host without Fabric's view state) picks up with quiz_me and resume alone.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "exam": {
                "type": "string",
                "maxLength": 120,
                "description": "Instead of a chapter: practice for a certification exam's domain (needs domain): data-engineer-associate, data-engineer-professional, data-analyst-associate, machine-learning-associate, machine-learning-professional, genai-engineer-associate, context-engineer-associate, apache-spark-developer-associate"
              },
              "form": {
                "type": "boolean",
                "description": "true: in a client that shows forms (elicitation) and no MCP Apps view, ask the reader each question as a form and return the result. Send it only when the reader wants to answer in forms; left out, the result is unanswered."
              },
              "domain": {
                "type": "string",
                "maxLength": 120,
                "description": "The exam's domain id, as exam_prep lists them"
              },
              "resume": {
                "type": "string",
                "pattern": "^kp1\\.[A-Za-z0-9_-]+$",
                "maxLength": 600,
                "minLength": 5,
                "description": "A resume code the reader kept from an earlier quiz (it starts kp1.): picks up where they left off. The code names its own chapter or exam domain, so nothing else is needed."
              },
              "answers": {
                "type": "array",
                "items": {
                  "type": "string",
                  "maxLength": 200
                },
                "maxItems": 8,
                "description": "The reader's answers, in question order, to score them: a letter (A to H) or an option's exact words, \"\" or \"-\" for none. Send the same chapter and section as the quiz that was asked."
              },
              "chapter": {
                "type": "string",
                "maxLength": 500,
                "description": "A chapter's slug (unity-catalog, lakebase), path or URL; list_chapters has them. Omit for questions from across the guide."
              },
              "section": {
                "type": "string",
                "maxLength": 200,
                "description": "One section of that chapter: its anchor or heading. Needs chapter."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "scope",
              "total",
              "questions",
              "note",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "keep": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "kind",
                  "scope",
                  "resumed",
                  "stale"
                ],
                "properties": {
                  "kind": {
                    "type": "string"
                  },
                  "scope": {
                    "type": "string"
                  },
                  "stale": {
                    "type": "boolean"
                  },
                  "resumed": {
                    "type": [
                      "object",
                      "null"
                    ]
                  }
                },
                "description": "For an interactive view: what its Keep my progress button makes a resume code from (scope), and the reader's place when a resume code was sent (resumed). Holds no personal data; nothing is stored on the server."
              },
              "note": {
                "type": "string"
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "scope": {
                "type": "object",
                "required": [
                  "chapter",
                  "section",
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string"
                  },
                  "chapter": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "section": {
                    "type": [
                      "string",
                      "null"
                    ]
                  }
                }
              },
              "score": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "right",
                  "total",
                  "answered",
                  "stopped",
                  "results"
                ],
                "properties": {
                  "right": {
                    "type": "integer"
                  },
                  "total": {
                    "type": "integer"
                  },
                  "results": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "n",
                        "given",
                        "right"
                      ],
                      "properties": {
                        "n": {
                          "type": "integer"
                        },
                        "given": {
                          "type": [
                            "string",
                            "null"
                          ],
                          "description": "The letter the reader gave; null for none"
                        },
                        "right": {
                          "type": "boolean"
                        }
                      }
                    }
                  },
                  "stopped": {
                    "type": "boolean",
                    "description": "The reader stopped before the last question"
                  },
                  "answered": {
                    "type": "integer"
                  }
                },
                "description": "The reader's score, when they answered (answers, or the questions asked one at a time by elicitation); null otherwise"
              },
              "total": {
                "type": "integer"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "questions": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "n",
                    "kind",
                    "question",
                    "options",
                    "answer",
                    "explanation",
                    "source"
                  ],
                  "properties": {
                    "n": {
                      "type": "integer"
                    },
                    "kind": {
                      "enum": [
                        "table",
                        "question",
                        "faq",
                        "glossary"
                      ],
                      "type": "string"
                    },
                    "answer": {
                      "type": "integer",
                      "minimum": 0,
                      "description": "The index of the right option"
                    },
                    "source": {
                      "type": "object",
                      "required": [
                        "chapter",
                        "section",
                        "url"
                      ],
                      "properties": {
                        "url": {
                          "type": "string"
                        },
                        "chapter": {
                          "type": "string"
                        },
                        "section": {
                          "type": "string"
                        }
                      }
                    },
                    "options": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "minItems": 2
                    },
                    "question": {
                      "type": "string"
                    },
                    "explanation": {
                      "type": "string",
                      "description": "The guide's words"
                    }
                  }
                },
                "maxItems": 8
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "Quiz me on the guide",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "learn_path",
          "title": "Follow a Databricks learning path",
          "description": "Interactive: a curated learning path through the Field Guide, by role or goal (data-engineer-fundamentals, analytics-engineer, ml-engineer, platform-admin, snowflake-to-databricks, cost-control): its steps in order (a section to read, a concept to explore, a quiz), each with the call that opens it. Call it when the user asks \"where do I start with Databricks\", \"a learning path for an analytics engineer\" or \"what should I learn next\". Progress lives with the reader: send the steps done back as done. In a host that renders MCP Apps it opens as a map of the route with each step's story; the text is complete without it. No path: the list.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "done": {
                "type": "array",
                "items": {
                  "anyOf": [
                    {
                      "type": "string",
                      "maxLength": 200
                    },
                    {
                      "type": "integer"
                    }
                  ]
                },
                "maxItems": 50,
                "description": "The steps the reader has done, by number or id (from an earlier result): progress lives with the reader, not the server"
              },
              "path": {
                "type": "string",
                "maxLength": 120,
                "description": "The path: data-engineer-fundamentals, analytics-engineer, ml-engineer, platform-admin, snowflake-to-databricks, cost-control. Omit it for the list."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "path",
              "asked",
              "title",
              "for",
              "level",
              "steps",
              "progress",
              "next",
              "available",
              "withheld",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "for": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "next": {
                "type": [
                  "object",
                  "null"
                ]
              },
              "path": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "asked": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "level": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "steps": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "n",
                    "id",
                    "kind",
                    "title",
                    "chapter",
                    "url",
                    "summary",
                    "call",
                    "status"
                  ],
                  "properties": {
                    "n": {
                      "type": "integer"
                    },
                    "id": {
                      "type": "string"
                    },
                    "url": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "call": {
                      "type": "object",
                      "required": [
                        "tool",
                        "arguments"
                      ],
                      "properties": {
                        "tool": {
                          "type": "string"
                        },
                        "arguments": {
                          "type": "object"
                        }
                      }
                    },
                    "kind": {
                      "enum": [
                        "section",
                        "concept",
                        "quiz"
                      ],
                      "type": "string"
                    },
                    "title": {
                      "type": "string"
                    },
                    "status": {
                      "enum": [
                        "done",
                        "next",
                        "todo"
                      ],
                      "type": "string"
                    },
                    "chapter": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "summary": {
                      "type": [
                        "string",
                        "null"
                      ],
                      "description": "The section's first sentence, or the concept's summary"
                    }
                  }
                }
              },
              "title": {
                "type": "string"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "progress": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "done",
                  "total"
                ],
                "properties": {
                  "done": {
                    "type": "integer"
                  },
                  "total": {
                    "type": "integer"
                  }
                }
              },
              "withheld": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "step",
                    "reason"
                  ],
                  "properties": {
                    "step": {
                      "type": "string"
                    },
                    "reason": {
                      "type": "string"
                    }
                  }
                }
              },
              "available": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "title",
                    "for",
                    "level",
                    "steps"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "for": {
                      "type": "string"
                    },
                    "level": {
                      "type": "string"
                    },
                    "steps": {
                      "type": "integer"
                    },
                    "title": {
                      "type": "string"
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "Follow a Databricks learning path",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "exam_prep",
          "title": "Prepare for a Databricks certification",
          "description": "Interactive: certification prep for Databricks' exams (data-engineer-associate, data-engineer-professional, data-analyst-associate, machine-learning-associate, machine-learning-professional, genai-engineer-associate, context-engineer-associate, apache-spark-developer-associate): each domain with its weight as Databricks publishes it, the guide sections and concepts that bear on it, how much the guide covers it (said honestly, gaps included), the official exam page and guide, and practice questions from the guide's own text for one domain. Call it when the user says \"help me prepare for the Data Engineer Associate\" or \"quiz me for the exam\". Not affiliated with Databricks; no exam question is reproduced.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "done": {
                "type": "array",
                "items": {
                  "anyOf": [
                    {
                      "type": "string",
                      "maxLength": 200
                    },
                    {
                      "type": "integer"
                    }
                  ]
                },
                "maxItems": 60,
                "description": "The plan steps the reader has done, by number or id (from an earlier result): progress lives with the reader, not the server"
              },
              "exam": {
                "type": "string",
                "maxLength": 120,
                "description": "The exam: data-engineer-associate, data-engineer-professional, data-analyst-associate, machine-learning-associate, machine-learning-professional, genai-engineer-associate, context-engineer-associate, apache-spark-developer-associate. Omit it for the list."
              },
              "step": {
                "type": "string",
                "maxLength": 200,
                "description": "The plan step to open at (its id, as the step's call gives it)"
              },
              "domain": {
                "type": "string",
                "maxLength": 120,
                "description": "One of the exam's domains (its id, from the result), for its practice questions"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "exam",
              "asked",
              "title",
              "official",
              "disclaimer",
              "domains",
              "coverage",
              "domain",
              "practice",
              "available",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "exam": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "plan": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "The guided plan: each domain, heaviest first, read, try the model, quiz; with the reader's progress (from done) and its next step"
              },
              "step": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The plan step asked for, where the card opens"
              },
              "asked": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "title": {
                "type": "string"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "domain": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "domains": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "name",
                    "weight",
                    "coverage",
                    "sections",
                    "concepts",
                    "practice"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "name": {
                      "type": "string",
                      "description": "As Databricks publishes it"
                    },
                    "weight": {
                      "type": "number",
                      "description": "Percent of the exam, as Databricks publishes it"
                    },
                    "concepts": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "id",
                          "title"
                        ],
                        "properties": {
                          "id": {
                            "type": "string"
                          },
                          "title": {
                            "type": "string"
                          }
                        }
                      }
                    },
                    "coverage": {
                      "enum": [
                        "good",
                        "thin",
                        "none"
                      ],
                      "type": "string",
                      "description": "How many guide sections bear on it: good, three or more; thin, one or two; none"
                    },
                    "practice": {
                      "type": "object",
                      "required": [
                        "tool",
                        "arguments"
                      ],
                      "properties": {
                        "tool": {
                          "type": "string"
                        },
                        "arguments": {
                          "type": [
                            "object",
                            "null"
                          ]
                        }
                      }
                    },
                    "sections": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "chapter",
                          "section",
                          "url"
                        ],
                        "properties": {
                          "url": {
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "chapter": {
                            "type": [
                              "string",
                              "null"
                            ]
                          },
                          "section": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "coverage": {
                "type": [
                  "object",
                  "null"
                ]
              },
              "official": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "page",
                  "guide",
                  "as_of"
                ],
                "properties": {
                  "page": {
                    "type": "string",
                    "description": "The exam's page on databricks.com"
                  },
                  "as_of": {
                    "type": "string"
                  },
                  "guide": {
                    "type": "string",
                    "description": "Databricks' exam guide"
                  }
                }
              },
              "practice": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "The domain's practice quiz, as quiz_me returns one"
              },
              "available": {
                "type": "array",
                "items": {
                  "type": "object"
                }
              },
              "practices": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "Each covered domain's practice quiz, by domain id, for the plan's quiz steps"
              },
              "disclaimer": {
                "type": "string"
              },
              "flashcards": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "The domain's flashcards, as the flashcards tool returns them (structured content only)"
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "Prepare for a Databricks certification",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "flashcards",
          "title": "Flashcards from the guide",
          "description": "Interactive: flashcards for a Databricks exam domain (data-engineer-associate, data-engineer-professional, data-analyst-associate, machine-learning-associate, machine-learning-professional, genai-engineer-associate, context-engineer-associate, apache-spark-developer-associate; exam_prep lists the domains) or a chapter, built deterministically from the Field Guide: glossary terms, FAQs and each mapped section's lead sentence. The back of every card is the guide's own sentence with its section URL; a domain the guide doesn't cover says so. Call it when the user says \"flashcards for the Data Engineer Associate's governance domain\" or \"drill me on Unity Catalog terms\". In a host that renders MCP Apps the reader turns the cards and marks them Got it or Not yet, and can keep a resume code to pick up later (send it back as resume, alone); the text lists every card.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "done": {
                "type": "array",
                "items": {
                  "anyOf": [
                    {
                      "type": "string",
                      "maxLength": 200
                    },
                    {
                      "type": "integer"
                    }
                  ]
                },
                "maxItems": 60,
                "description": "Opened from an exam_prep plan (with exam and domain): the plan steps done so far, so the deck says its step and its Next returns to the plan"
              },
              "exam": {
                "type": "string",
                "maxLength": 120,
                "description": "An exam (data-engineer-associate, data-engineer-professional, data-analyst-associate, machine-learning-associate, machine-learning-professional, genai-engineer-associate, context-engineer-associate, apache-spark-developer-associate), with one of its domains"
              },
              "domain": {
                "type": "string",
                "maxLength": 120,
                "description": "The exam's domain id, as exam_prep lists them"
              },
              "resume": {
                "type": "string",
                "pattern": "^kp1\\.[A-Za-z0-9_-]+$",
                "maxLength": 600,
                "minLength": 5,
                "description": "A resume code the reader kept from an earlier flashcards (it starts kp1.): picks up where they left off. The code names its own exam domain or chapter, so nothing else is needed."
              },
              "chapter": {
                "type": "string",
                "maxLength": 300,
                "description": "Or a chapter: its slug or URL"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "scope",
              "cards",
              "gaps",
              "note"
            ],
            "properties": {
              "how": {
                "type": "string",
                "description": "What to do with a card"
              },
              "gaps": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "keep": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "kind",
                  "scope",
                  "resumed",
                  "stale"
                ],
                "properties": {
                  "kind": {
                    "type": "string"
                  },
                  "scope": {
                    "type": "string"
                  },
                  "stale": {
                    "type": "boolean"
                  },
                  "resumed": {
                    "type": [
                      "object",
                      "null"
                    ]
                  }
                },
                "description": "For an interactive view: what its Keep my progress button makes a resume code from (scope), and the reader's place when a resume code was sent (resumed). Holds no personal data; nothing is stored on the server."
              },
              "note": {
                "type": "string"
              },
              "cards": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "kind",
                    "front",
                    "back",
                    "source",
                    "label",
                    "prompt"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "back": {
                      "type": "string",
                      "description": "The guide's own sentence"
                    },
                    "kind": {
                      "enum": [
                        "term",
                        "question",
                        "section"
                      ],
                      "type": "string"
                    },
                    "front": {
                      "type": "string",
                      "description": "A term, a question or a section's heading"
                    },
                    "label": {
                      "type": "string",
                      "description": "What the front is: Term, Question or Section"
                    },
                    "prompt": {
                      "type": "string",
                      "description": "What the front asks, in words: a term or a heading becomes the question its back answers"
                    },
                    "source": {
                      "type": "object",
                      "required": [
                        "chapter",
                        "section",
                        "url"
                      ],
                      "properties": {
                        "url": {
                          "type": "string"
                        },
                        "chapter": {
                          "type": "string"
                        },
                        "section": {
                          "type": "string"
                        }
                      }
                    }
                  }
                }
              },
              "scope": {
                "type": "object",
                "required": [
                  "kind",
                  "title",
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string"
                  },
                  "kind": {
                    "enum": [
                      "exam",
                      "chapter"
                    ],
                    "type": "string"
                  },
                  "title": {
                    "type": "string"
                  }
                }
              },
              "plan_step": {
                "type": [
                  "object",
                  "null"
                ],
                "description": "Opened from an exam plan: the domain's step (n of total), the plan's next step, and back, the call that returns to the plan"
              }
            }
          },
          "annotations": {
            "title": "Flashcards from the guide",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "visualize",
          "title": "Draw an answer",
          "description": "Interactive: draws your answer as a card the reader can use, from an A2UI v0.9.1 document you write: a comparison of options with a verdict, a plan as steps or a timeline, a cost or sizing calculator with sliders and a chart that follows them, a quiz or flashcards, a table, a Mermaid diagram. Call it whenever the answer has a shape: the reader asks to compare (\"compare\", \"X vs Y\", \"pros and cons\", \"trade-offs\", \"which is better for\"), for a plan (\"plan\", \"roadmap\", \"migration steps\", \"rollout\", \"timeline\"), to \"show me\", \"explain how\", \"draw\", \"chart\" or \"visualise\" something, or for \"a table of\" options, rather than answering with a long Markdown table or list. A concept explore_concept knows, a decision decide has a tree for, and a cost estimate_cost prices go to those tools first. For a Databricks question, first get the facts with search_guide or get_chapter, put them in the document, and pass those URLs as sources: only pages of the Field Guide are listed as sources, and the card is labelled \"Composed by your assistant\". In a host that renders MCP Apps it opens as an interactive card; the text result renders the whole document, so it is complete without the view. Nothing is stored and no model is called; a document that won't draw comes back as the spec's VALIDATION_FAILED list to fix (the tool checks the document's structure, not its facts).",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "document"
            ],
            "properties": {
              "title": {
                "type": "string",
                "maxLength": 120,
                "description": "The card's title, in plain words"
              },
              "sources": {
                "type": "array",
                "items": {
                  "type": "string",
                  "maxLength": 500
                },
                "maxItems": 20,
                "description": "The Field Guide URLs (with #anchor) whose facts the document uses, from search_guide or get_chapter. Each is checked: a page of the guide is cited as a source; anything else is listed as not from the guide."
              },
              "document": {
                "type": "string",
                "maxLength": 64000,
                "minLength": 2,
                "description": "An A2UI v0.9.1 document: messages as JSONL, one a line (createSurface, updateDataModel, updateComponents), or a JSON array of them. Use Fabric's catalog (https://agents.fabric.pro/a2ui/v0.9/fabric_catalog.json: the basic catalog plus Chart, Stat, Callout, Steps, Quiz, Flashcards, Timeline, Compare, Diagram, Code, Table; functions calc and formatValue) or the basic one. Exactly one component has id \"root\"."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "title",
              "provenance",
              "document",
              "surfaces",
              "errors",
              "sources",
              "unverified",
              "note"
            ],
            "properties": {
              "note": {
                "type": "string"
              },
              "title": {
                "type": "string"
              },
              "errors": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "code",
                    "surfaceId",
                    "path",
                    "message"
                  ],
                  "properties": {
                    "code": {
                      "type": "string"
                    },
                    "path": {
                      "type": "string"
                    },
                    "message": {
                      "type": "string"
                    },
                    "surfaceId": {
                      "type": "string"
                    }
                  }
                }
              },
              "sources": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "title",
                    "chapter",
                    "url"
                  ],
                  "properties": {
                    "url": {
                      "type": "string"
                    },
                    "title": {
                      "type": "string"
                    },
                    "chapter": {
                      "type": "string"
                    }
                  }
                }
              },
              "document": {
                "type": "array",
                "description": "The document's messages, as parsed"
              },
              "surfaces": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "surfaceId",
                    "catalogId",
                    "components"
                  ],
                  "properties": {
                    "catalogId": {
                      "type": "string"
                    },
                    "surfaceId": {
                      "type": "string"
                    },
                    "components": {
                      "type": "integer"
                    }
                  }
                }
              },
              "provenance": {
                "type": "string",
                "description": "Always: Composed by your assistant"
              },
              "unverified": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              }
            }
          },
          "annotations": {
            "title": "Draw an answer",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "decide",
          "title": "Decide with the guide",
          "description": "Interactive: walks a Databricks decision one question at a time (which-compute, serverless-or-classic, lakebase-or-delta, genie-or-dashboard, streaming-or-batch): every answer rests on the guide's own sentences, verbatim, with the section to read. Call it when the user asks \"should I use serverless or classic\", \"Lakebase or Delta?\", \"Genie or a dashboard?\" or \"which compute for this job\". The text gives the whole tree; send choices (option numbers so far) for the answer. In a terminal that shows forms, form: true asks each question as a form.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "form": {
                "type": "boolean",
                "description": "true: in a client that shows forms (elicitation) and no MCP Apps view, ask the reader each question of the decision as a form and return the result. Send it only when the reader wants to answer in forms; left out, the result is unanswered."
              },
              "choices": {
                "type": "array",
                "items": {
                  "type": "integer",
                  "maximum": 9,
                  "minimum": 1
                },
                "maxItems": 10,
                "description": "The reader's choices so far, as option numbers from the first question: the result then carries where they are, or the answer"
              },
              "question": {
                "type": "string",
                "maxLength": 300,
                "description": "The decision, in plain words or by id: which-compute, serverless-or-classic, lakebase-or-delta, genie-or-dashboard, streaming-or-batch. Omit it for the list."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "tree",
              "asked",
              "title",
              "start",
              "nodes",
              "walk",
              "result",
              "available",
              "withheld",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "tree": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "walk": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "node",
                    "question",
                    "choice"
                  ],
                  "properties": {
                    "node": {
                      "type": "string"
                    },
                    "choice": {
                      "type": "string"
                    },
                    "question": {
                      "type": "string"
                    }
                  }
                }
              },
              "asked": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "nodes": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "kind",
                    "text",
                    "options",
                    "answer",
                    "because",
                    "read"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "kind": {
                      "enum": [
                        "question",
                        "answer"
                      ],
                      "type": "string"
                    },
                    "read": {
                      "type": [
                        "object",
                        "null"
                      ]
                    },
                    "text": {
                      "type": "string"
                    },
                    "answer": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "because": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "quote",
                          "chapter",
                          "section",
                          "url"
                        ],
                        "properties": {
                          "url": {
                            "type": "string"
                          },
                          "quote": {
                            "type": "string",
                            "description": "The guide's sentence, verbatim"
                          },
                          "chapter": {
                            "type": "string"
                          },
                          "section": {
                            "type": "string"
                          }
                        }
                      }
                    },
                    "options": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "label",
                          "next"
                        ],
                        "properties": {
                          "next": {
                            "type": "string"
                          },
                          "label": {
                            "type": "string"
                          }
                        }
                      }
                    }
                  }
                }
              },
              "start": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "title": {
                "type": "string"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "result": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The answer reached, when the choices reach one"
              },
              "current": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "withheld": {
                "type": "array",
                "items": {
                  "type": "object"
                }
              },
              "available": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "title"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "title": {
                      "type": "string"
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "Decide with the guide",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "explore_diagram",
          "title": "Play a chapter's diagrams",
          "description": "Interactive: a chapter's own diagrams, played step by step: each flowchart edge or sequence message in order, each node linking the section of the chapter it is about. Call it when the user says \"show me the diagram for Lakebase branching\" or \"walk me through the medallion diagram\". The text lists every diagram's nodes, its edges in order and its Mermaid source, so a terminal can draw it.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "chapter"
            ],
            "properties": {
              "chapter": {
                "type": "string",
                "maxLength": 500,
                "minLength": 1,
                "description": "A chapter's slug (lakebase, medallion-architecture), path or URL; list_chapters has them"
              },
              "section": {
                "type": "string",
                "maxLength": 200,
                "description": "Only the diagrams in this section: its anchor or heading"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "chapter",
              "total",
              "diagrams",
              "note",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "note": {
                "type": "string"
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The commit of the deploy that answered"
              },
              "total": {
                "type": "integer"
              },
              "ttlMs": {
                "type": "integer",
                "description": "How long this answer may be kept before asking again, in milliseconds"
              },
              "chapter": {
                "type": "object",
                "required": [
                  "slug",
                  "title",
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string"
                  },
                  "slug": {
                    "type": "string"
                  },
                  "title": {
                    "type": "string"
                  }
                }
              },
              "diagrams": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "caption",
                    "kind",
                    "direction",
                    "section",
                    "nodes",
                    "edges",
                    "steps",
                    "whole",
                    "source"
                  ],
                  "properties": {
                    "svg": {
                      "type": [
                        "string",
                        "null"
                      ],
                      "description": "The diagram drawn as SVG in the kit's colours, or null when it could not be drawn"
                    },
                    "kind": {
                      "enum": [
                        "flowchart",
                        "sequence"
                      ],
                      "type": "string"
                    },
                    "edges": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "n",
                          "from",
                          "to",
                          "text",
                          "kind"
                        ],
                        "properties": {
                          "n": {
                            "type": "integer"
                          },
                          "to": {
                            "type": "string"
                          },
                          "from": {
                            "type": "string"
                          },
                          "kind": {
                            "type": "string"
                          },
                          "text": {
                            "type": [
                              "string",
                              "null"
                            ]
                          }
                        }
                      }
                    },
                    "nodes": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "id",
                          "text",
                          "section"
                        ],
                        "properties": {
                          "id": {
                            "type": "string"
                          },
                          "text": {
                            "type": "string"
                          },
                          "section": {
                            "type": "object"
                          }
                        }
                      }
                    },
                    "steps": {
                      "type": "array",
                      "items": {
                        "type": "object"
                      }
                    },
                    "whole": {
                      "type": "object"
                    },
                    "source": {
                      "type": "string",
                      "description": "The diagram's Mermaid source, as the guide has it"
                    },
                    "caption": {
                      "type": "string"
                    },
                    "section": {
                      "type": "object",
                      "required": [
                        "title",
                        "url"
                      ],
                      "properties": {
                        "url": {
                          "type": "string"
                        },
                        "title": {
                          "type": "string"
                        }
                      }
                    },
                    "direction": {
                      "type": "string"
                    }
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "When this deploy's index was built (ISO 8601)"
              }
            }
          },
          "annotations": {
            "title": "Play a chapter's diagrams",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "toolkit_info",
          "title": "About TechFabric's Databricks Chrome extension",
          "description": "What TechFabric's free Chrome extension for Databricks (TechFabric Toolkit for Databricks 0.10.0) does, how to install it, the permissions it asks for and its privacy model. Call it for \"what can the TechFabric Chrome extension do\", \"does the toolkit support X\", \"how do I install it\" or \"what permissions does it need\". Each feature says where it shows up, whether it needs the reader's connected workspace, and how to get the same thing from this server: a tool (toolkit_generate, estimate_cost, review_databricks_code, explore_concept) or only the extension. Read-only and deterministic.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "feature": {
                "enum": [
                  "what-did-this-cost",
                  "monthly-estimate",
                  "cluster-right-sizing",
                  "compute-that-never-stops",
                  "query-history",
                  "cost-explainer",
                  "table-details",
                  "who-can-read",
                  "lineage",
                  "audit-and-activity",
                  "catalog-summaries",
                  "delta-health",
                  "draft-with-ai",
                  "job-summary",
                  "why-did-it-fail",
                  "what-changed",
                  "notify-when-done",
                  "workspace-pulse",
                  "bundle-provenance",
                  "review-job",
                  "explain-with-ai",
                  "error-decoder",
                  "pipeline-summary",
                  "expectations",
                  "freshness",
                  "pipeline-starters",
                  "registered-model",
                  "experiment-leaderboard",
                  "run-vs-best",
                  "serving-endpoint",
                  "vector-search",
                  "genie-readiness",
                  "ai-templates",
                  "lakebase-instance",
                  "editor-companion",
                  "review-code",
                  "preflight",
                  "offline-generators",
                  "learn-hub",
                  "ask",
                  "feedback",
                  "links-and-names",
                  "command-palette",
                  "saved",
                  "environment-label",
                  "heads-up"
                ],
                "type": "string",
                "description": "One feature by its id (from a previous answer)"
              },
              "question": {
                "type": "string",
                "maxLength": 300,
                "description": "A question about the extension in plain words, e.g. 'does it show table lineage', 'what permissions does it need', 'can it estimate cost'. Omit for every feature."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "product",
              "version",
              "page",
              "install",
              "clouds",
              "permissions",
              "privacy",
              "needs",
              "groups",
              "question",
              "matched",
              "topics",
              "capabilities",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "page": {
                "type": "string",
                "description": "The Field Guide's page on the extension"
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "needs": {
                "type": "object"
              },
              "ttlMs": {
                "type": "integer"
              },
              "clouds": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "groups": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "topics": {
                "type": "array",
                "items": {
                  "enum": [
                    "install",
                    "permissions",
                    "privacy"
                  ],
                  "type": "string"
                },
                "description": "With a question: whether it asks about installing, permissions or privacy"
              },
              "install": {
                "type": "object",
                "required": [
                  "store",
                  "steps",
                  "developers"
                ],
                "properties": {
                  "steps": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "store": {
                    "type": "string"
                  },
                  "developers": {
                    "type": "string"
                  }
                }
              },
              "matched": {
                "type": [
                  "boolean",
                  "null"
                ],
                "description": "With a question: whether any feature or topic matched it"
              },
              "privacy": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "product": {
                "type": "string"
              },
              "version": {
                "type": "string"
              },
              "question": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "permissions": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "name",
                    "why"
                  ],
                  "properties": {
                    "why": {
                      "type": "string"
                    },
                    "name": {
                      "type": "string"
                    }
                  }
                }
              },
              "capabilities": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "group",
                    "name",
                    "where",
                    "what",
                    "needs",
                    "needs_text",
                    "mcp",
                    "chapter"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "mcp": {
                      "type": "object",
                      "required": [
                        "how",
                        "tool"
                      ],
                      "properties": {
                        "how": {
                          "enum": [
                            "tool",
                            "equivalent",
                            "extension"
                          ],
                          "type": "string"
                        },
                        "note": {
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "tool": {
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "generator": {
                          "type": [
                            "string",
                            "null"
                          ]
                        }
                      }
                    },
                    "name": {
                      "type": "string"
                    },
                    "what": {
                      "type": "string"
                    },
                    "group": {
                      "type": "string"
                    },
                    "needs": {
                      "enum": [
                        "offline",
                        "workspace",
                        "workspace-sql",
                        "field-guide",
                        "workspace-ai",
                        "browser"
                      ],
                      "type": "string"
                    },
                    "where": {
                      "type": "string",
                      "description": "Where it shows up in the extension"
                    },
                    "chapter": {
                      "type": [
                        "object",
                        "null"
                      ],
                      "required": [
                        "title",
                        "url"
                      ],
                      "properties": {
                        "url": {
                          "type": "string"
                        },
                        "title": {
                          "type": "string"
                        }
                      }
                    },
                    "needs_text": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "annotations": {
            "title": "About TechFabric's Databricks Chrome extension",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "toolkit_generate",
          "title": "Run a Databricks Toolkit generator",
          "description": "Runs one of the offline generators from the Build tab of TechFabric's Chrome extension for Databricks (TechFabric Toolkit for Databricks 0.10.0) with the extension's own code, so the output matches it: Unity Catalog grants with a rollback script, table DDL / MERGE / GRANT, a table starter kit (tags, constraints, row filter, column mask), schema diff to ALTER, Delta restore, a Delta health check from pasted DESCRIBE output, Auto Loader, Lakeflow and Auto CDC starters, data-quality checks, Declarative Automation Bundle YAML and CLI, Terraform, secrets and external locations, test data, system.billing cost SQL, an error decoder, failed-run triage and Slack / Jira messages, slow-query analysis, a pre-flight check for destructive SQL, MLflow, serving, Vector Search, AI Functions, RAG and Genie templates, formatters, deep links, and the snippet libraries. Omit generator for the list and each one's inputs. Text only: nothing runs against a workspace, no model is called.",
          "inputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "properties": {
              "inputs": {
                "type": "object",
                "description": "The generator's inputs by id (text, a choice or true/false); anything left out takes the extension's default. Call with no generator to see each one's inputs.",
                "additionalProperties": {
                  "anyOf": [
                    {
                      "type": "string",
                      "maxLength": 48000
                    },
                    {
                      "type": "boolean"
                    },
                    {
                      "type": "number"
                    }
                  ]
                }
              },
              "generator": {
                "enum": [
                  "dbx-table",
                  "delta-health",
                  "schema-diff",
                  "lakeflow",
                  "cdc",
                  "dq",
                  "cost",
                  "restore",
                  "error-decoder",
                  "run-digest",
                  "failed-run",
                  "ml-model",
                  "ml-serving",
                  "ml-vs",
                  "ml-aifn",
                  "ml-rag",
                  "ml-genie",
                  "ml-gov",
                  "bundle",
                  "uc-perms",
                  "starter",
                  "testdata",
                  "terraform",
                  "secrets-loc",
                  "dbx-names",
                  "sql-format",
                  "deeplink",
                  "diff-format",
                  "cost-explain",
                  "triage",
                  "slow-query",
                  "preflight",
                  "accel",
                  "snippets"
                ],
                "type": "string",
                "description": "Which generator. Omit for the list, with each one's inputs."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "required": [
              "product",
              "version",
              "page",
              "install",
              "generator",
              "available",
              "outputs",
              "notes",
              "warning",
              "chapter",
              "fields",
              "build",
              "index_built",
              "ttlMs"
            ],
            "properties": {
              "page": {
                "type": "string"
              },
              "build": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "notes": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "kind",
                    "text"
                  ],
                  "properties": {
                    "kind": {
                      "enum": [
                        "note",
                        "warning"
                      ],
                      "type": "string"
                    },
                    "text": {
                      "type": "string"
                    }
                  }
                }
              },
              "ttlMs": {
                "type": "integer"
              },
              "fields": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "label",
                    "type",
                    "default"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "type": {
                      "enum": [
                        "text",
                        "choice",
                        "boolean"
                      ],
                      "type": "string"
                    },
                    "label": {
                      "type": "string"
                    },
                    "default": {
                      "type": [
                        "string",
                        "boolean"
                      ]
                    },
                    "example": {
                      "type": "string"
                    },
                    "options": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    }
                  }
                }
              },
              "chapter": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "title",
                  "url"
                ],
                "properties": {
                  "url": {
                    "type": "string"
                  },
                  "title": {
                    "type": "string"
                  }
                }
              },
              "install": {
                "type": "string",
                "description": "The Chrome Web Store listing"
              },
              "outputs": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "label",
                    "lang",
                    "text"
                  ],
                  "properties": {
                    "lang": {
                      "type": "string"
                    },
                    "text": {
                      "type": "string"
                    },
                    "label": {
                      "type": "string"
                    }
                  }
                }
              },
              "product": {
                "type": "string"
              },
              "version": {
                "type": "string"
              },
              "warning": {
                "type": "string"
              },
              "available": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "id",
                    "title",
                    "section",
                    "hint",
                    "inputs",
                    "chapter"
                  ],
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "hint": {
                      "type": "string"
                    },
                    "title": {
                      "type": "string"
                    },
                    "inputs": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    },
                    "chapter": {
                      "type": [
                        "object",
                        "null"
                      ],
                      "required": [
                        "title",
                        "url"
                      ],
                      "properties": {
                        "url": {
                          "type": "string"
                        },
                        "title": {
                          "type": "string"
                        }
                      }
                    },
                    "section": {
                      "type": "string"
                    }
                  }
                }
              },
              "generator": {
                "type": [
                  "object",
                  "null"
                ],
                "required": [
                  "id",
                  "title",
                  "section"
                ],
                "properties": {
                  "id": {
                    "type": "string"
                  },
                  "title": {
                    "type": "string"
                  },
                  "section": {
                    "type": "string"
                  }
                }
              },
              "index_built": {
                "type": [
                  "string",
                  "null"
                ]
              }
            }
          },
          "annotations": {
            "title": "Run a Databricks Toolkit generator",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        }
      ],
      "tools_omitted": 0,
      "resources": [
        {
          "name": "field_guide_view",
          "uri": "ui://databricks-field-guide/view",
          "mimeType": "text/html;profile=mcp-app",
          "description": "The Field Guide's own pages for get_chapter, get_code_examples, whats_new, review_databricks_code, estimate_cost results, in a host that renders MCP Apps: search results, a chapter with copyable code, code cards, what's new, review findings and a cost estimate."
        },
        {
          "name": "concepts_view",
          "uri": "ui://databricks-field-guide/concepts",
          "mimeType": "text/html;profile=mcp-app",
          "description": "Interactive Databricks concepts and quizzes for start_here and explore_concept and quiz_me and learn_path and exam_prep and flashcards and decide and explore_diagram results, in a host that renders MCP Apps: every model computed in the view from the result, nothing fetched."
        },
        {
          "name": "visualize_view",
          "uri": "ui://databricks-field-guide/visualize",
          "mimeType": "text/html;profile=mcp-app",
          "description": "visualize's card in a host that renders MCP Apps: the assistant's A2UI document drawn with the TechFabric UI kit, with the Field Guide pages it drew on listed as sources."
        },
        {
          "name": "llms_txt",
          "uri": "fieldguide://llms.txt",
          "mimeType": "text/plain",
          "description": "The guide's map for language models: every chapter, note and feature page, one line each."
        },
        {
          "name": "whats_new",
          "uri": "fieldguide://whats-new",
          "mimeType": "application/json",
          "description": "What the guide tracks Databricks changing in the last 30 days, as whats_new returns it (JSON): margin notes, release-stage changes, chapters updated. Subscribe (subscriptions/listen, resourceSubscriptions) to hear when a deploy changes it."
        },
        {
          "name": "guide",
          "uri": "fieldguide://page/guide",
          "mimeType": "text/markdown",
          "description": "Where to start with Databricks for the job you have, the chapters that answer it, the first step we'd take, and how to use this free guide from an agent."
        },
        {
          "name": "guide/not-just-postgres",
          "uri": "fieldguide://page/guide/not-just-postgres",
          "mimeType": "text/markdown",
          "description": "Databricks vs Postgres for reporting: when Postgres and a dashboard is enough, the three signs it has run out, and how Lakebase changes the move."
        },
        {
          "name": "guide/what-it-costs",
          "uri": "fieldguide://page/guide/what-it-costs",
          "mimeType": "text/markdown",
          "description": "What a DBU costs on each Databricks compute type in October 2026, DBUs an hour by warehouse and cluster size, model serving rates, and what cuts the bill."
        },
        {
          "name": "guide/how-to-learn-databricks",
          "uri": "fieldguide://page/guide/how-to-learn-databricks",
          "mimeType": "text/markdown",
          "description": "A Databricks learning path: what to build first on Free Edition, which free Academy pathway to follow, which certification to sit, and where to ask a person."
        },
        {
          "name": "guide/unity-catalog",
          "uri": "fieldguide://page/guide/unity-catalog",
          "mimeType": "text/markdown",
          "description": "How Databricks Unity Catalog governs tables, files, models and agents, the catalog layout we'd use, row filters and ABAC in SQL, and where it stops."
        },
        {
          "name": "guide/tables-and-storage",
          "uri": "fieldguide://page/guide/tables-and-storage",
          "mimeType": "text/markdown",
          "description": "How Databricks tables are stored: managed vs external, Delta vs Iceberg, liquid clustering, predictive optimization and deletion vectors, by runtime."
        },
        {
          "name": "guide/lakebase",
          "uri": "fieldguide://page/guide/lakebase",
          "mimeType": "text/markdown",
          "description": "What Databricks Lakebase is, what it costs, and how branching, restore, the Data API and synced tables behaved when we built an app on it live."
        },
        {
          "name": "guide/ltap",
          "uri": "fieldguide://page/guide/ltap",
          "mimeType": "text/markdown",
          "description": "Databricks LTAP explained: what lake transactional/analytical processing is, which Lakebase pieces ship today, how it differs from HTAP and Zero ETL."
        },
        {
          "name": "guide/medallion-architecture",
          "uri": "fieldguide://page/guide/medallion-architecture",
          "mimeType": "text/markdown",
          "description": "Medallion architecture on Databricks: what bronze, silver and gold each promise, the Lakeflow pipelines code that enforces it, and when to use fewer layers."
        },
        {
          "name": "guide/real-time-and-cdc",
          "uri": "fieldguide://page/guide/real-time-and-cdc",
          "mimeType": "text/markdown",
          "description": "Change data capture on Databricks: Lakeflow Connect CDC connectors, AUTO CDC for SCD type 1 and 2, real-time mode, Zerobus, and picking a latency tier."
        },
        {
          "name": "guide/orchestration",
          "uri": "fieldguide://page/guide/orchestration",
          "mimeType": "text/markdown",
          "description": "Lakeflow Jobs in production: triggers, for-each and if/else tasks, retries and timeouts, and the system table queries that audit a jobs estate."
        },
        {
          "name": "guide/reporting",
          "uri": "fieldguide://page/guide/reporting",
          "mimeType": "text/markdown",
          "description": "How Databricks metric views work as a semantic layer, how Power BI reads them in DirectQuery, and the dashboard habits that keep reporting cheap."
        },
        {
          "name": "guide/genie",
          "uri": "fieldguide://page/guide/genie",
          "mimeType": "text/markdown",
          "description": "What Databricks Genie One, Genie Agents and Genie Code are, the warehouse a Genie Agent needs, what it costs from 2027, and how we'd build one people trust."
        },
        {
          "name": "guide/multi-tenant-reporting",
          "uri": "fieldguide://page/guide/multi-tenant-reporting",
          "mimeType": "text/markdown",
          "description": "Row-level security for multi-tenant reporting on Databricks, with the SQL for row filters, ABAC, embedded dashboards and OAuth custom identity claims."
        },
        {
          "name": "guide/databricks-apps",
          "uri": "fieldguide://page/guide/databricks-apps",
          "mimeType": "text/markdown",
          "description": "Databricks Apps for developers, covering the runtime, on-behalf-of-user auth and scopes, Lakebase and warehouse resources, deploys and the hourly cost."
        },
        {
          "name": "guide/sharing-and-collaboration",
          "uri": "fieldguide://page/guide/sharing-and-collaboration",
          "mimeType": "text/markdown",
          "description": "Databricks Clean Rooms and Delta Sharing (OpenSharing) in practice, with the SQL to share a table, the clean room approval rules, and the audit queries."
        },
        {
          "name": "guide/mlflow",
          "uri": "fieldguide://page/guide/mlflow",
          "mimeType": "text/markdown",
          "description": "Runnable MLflow 3 code for Databricks covering table lineage, the Unity Catalog model registry and aliases, deployment jobs, serving and GenAI tracing."
        },
        {
          "name": "guide/foundation-models",
          "uri": "fieldguide://page/guide/foundation-models",
          "mimeType": "text/markdown",
          "description": "How Databricks Foundation Model APIs work, which models are pay-per-token, what they cost in DBUs, and why every call goes through Unity Gateway."
        },
        {
          "name": "guide/context-and-retrieval",
          "uri": "fieldguide://page/guide/context-and-retrieval",
          "mimeType": "text/markdown",
          "description": "RAG and context engineering on Databricks with AI Search (formerly Vector Search), chunking, hybrid search, reranking and filters by who is asking."
        },
        {
          "name": "guide/agents",
          "uri": "fieldguide://page/guide/agents",
          "mimeType": "text/markdown",
          "description": "Building AI agents on Databricks with Genie Agents or the Agent Bricks CLI, scoring them with MLflow 3, and keeping them inside the caller's permissions."
        },
        {
          "name": "guide/governed-actions",
          "uri": "fieldguide://page/guide/governed-actions",
          "mimeType": "text/markdown",
          "description": "Unity Catalog governs who reads data, not what an AI agent may do about it. How to put a policy, evidence and durable execution between an agent and a write."
        },
        {
          "name": "guide/migration",
          "uri": "fieldguide://page/guide/migration",
          "mimeType": "text/markdown",
          "description": "How to migrate a warehouse to Databricks with Lakebridge and federation, which parts overrun, and how to prove parity before switching the old system off."
        },
        {
          "name": "guide/cost-and-performance",
          "uri": "fieldguide://page/guide/cost-and-performance",
          "mimeType": "text/markdown",
          "description": "Databricks cost management and performance tuning: attribute spend with tags and system.billing SQL, pick the right compute, then fix slow queries in order."
        },
        {
          "name": "guide/security",
          "uri": "fieldguide://page/guide/security",
          "mimeType": "text/markdown",
          "description": "Databricks security in practice: the identity on each path to the data, ABAC policies, serverless egress, customer-managed keys and audit log SQL."
        },
        {
          "name": "guide/ci-cd",
          "uri": "fieldguide://page/guide/ci-cd",
          "mimeType": "text/markdown",
          "description": "Databricks CI/CD with Declarative Automation Bundles (formerly Asset Bundles) and Terraform: a runnable databricks.yml, a GitHub Actions deploy and promotion."
        },
        {
          "name": "guide/observability",
          "uri": "fieldguide://page/guide/observability",
          "mimeType": "text/markdown",
          "description": "What data observability means on Databricks: freshness, volume and quality checks, system table SQL for job health, anomaly detection and alerts with owners."
        },
        {
          "name": "guide/resilience-and-recovery",
          "uri": "fieldguide://page/guide/resilience-and-recovery",
          "mimeType": "text/markdown",
          "description": "Databricks high availability vs disaster recovery: what the platform recovers, managed DR and its limits, Lakebase HA and cross-region DR, and a rehearsed plan."
        },
        {
          "name": "guide/platform-comparison",
          "uri": "fieldguide://page/guide/platform-comparison",
          "mimeType": "text/markdown",
          "description": "Databricks vs AWS, Azure and Google Cloud data services, service by service as of October 2026, where the native stack wins, and Databricks or Microsoft Fabric."
        },
        {
          "name": "guide/snowflake",
          "uri": "fieldguide://page/guide/snowflake",
          "mimeType": "text/markdown",
          "description": "Databricks vs Snowflake on billing, storage, AI and Postgres, why moving an unchanged workload mostly moves the bill, and how to migrate when it's right."
        },
        {
          "name": "guide/renames",
          "uri": "fieldguide://page/guide/renames",
          "mimeType": "text/markdown",
          "description": "Delta Live Tables is now Lakeflow pipelines. Where the DLT docs moved, and the other Databricks renames, with where each old name survives in code and billing."
        },
        {
          "name": "guide/databricks-by-the-numbers",
          "uri": "fieldguide://page/guide/databricks-by-the-numbers",
          "mimeType": "text/markdown",
          "description": "Databricks' valuation, revenue run-rate, customer counts and acquisitions, each traced to the release or filing that produced it, dated and linked."
        },
        {
          "name": "guide/glossary",
          "uri": "fieldguide://page/guide/glossary",
          "mimeType": "text/markdown",
          "description": "A Databricks glossary with one-sentence definitions of Unity Catalog, Lakeflow, Lakebase, Genie and AI terms, the old product names, and links to each chapter."
        },
        {
          "name": "guide/databricks-toolkit",
          "uri": "fieldguide://page/guide/databricks-toolkit",
          "mimeType": "text/markdown",
          "description": "TechFabric's free Chrome extension for Databricks: what each feature does and where, how to install it, its permissions and privacy, and its MCP tools."
        },
        {
          "name": "notes/ai-functions-unity-catalog-permissions-is-now-generally",
          "uri": "fieldguide://page/notes/ai-functions-unity-catalog-permissions-is-now-generally",
          "mimeType": "text/markdown",
          "description": "Revoking EXECUTE on system.ai stops every task-specific AI Function at once. Write the allow-list first, and govern ai_query on its own."
        },
        {
          "name": "notes/ai-runtime-is-generally-available",
          "uri": "fieldguide://page/notes/ai-runtime-is-generally-available",
          "mimeType": "text/markdown",
          "description": "AI Runtime, serverless GPUs for training and fine-tuning on Databricks, is generally available. Where we would train on it and the limits to plan for."
        },
        {
          "name": "notes/asynchronous-processing-with-transformwithstate-is-now-generally-available",
          "uri": "fieldguide://page/notes/asynchronous-processing-with-transformwithstate-is-now-generally-available",
          "mimeType": "text/markdown",
          "description": "Async processing for Python transformWithState is GA on Databricks Runtime 19. When we would convert a stateful processor, and what to check first."
        },
        {
          "name": "notes/databricks-bought-a-postgres",
          "uri": "fieldguide://page/notes/databricks-bought-a-postgres",
          "mimeType": "text/markdown",
          "description": "Databricks bought Neon in May 2025 and now headlines Lakebase in funding releases. The lakehouse needed a real database, and that says where apps are going."
        },
        {
          "name": "notes/databricks-private-network-gateway-serverless-reaches-private-networks",
          "uri": "fieldguide://page/notes/databricks-private-network-gateway-serverless-reaches-private-networks",
          "mimeType": "text/markdown",
          "description": "Private Network Gateway gives Databricks serverless compute one connection into your own network. What it reaches, what it costs and where to pilot it."
        },
        {
          "name": "notes/databricks-runtime-19-october-19-2026",
          "uri": "fieldguide://page/notes/databricks-runtime-19-october-19-2026",
          "mimeType": "text/markdown",
          "description": "Databricks Runtime 19 hides row filter and column mask internals from Spark Connect metrics. What stays visible, and how we would tune protected tables."
        },
        {
          "name": "notes/dataframe-caching-on-serverless-compute-is-now-in",
          "uri": "fieldguide://page/notes/dataframe-caching-on-serverless-compute-is-now-in",
          "mimeType": "text/markdown",
          "description": "Databricks serverless DataFrame caching is in Public Preview as an eager, session-private snapshot. How it differs from classic caching."
        },
        {
          "name": "notes/feature-views-are-ga-and-the-point",
          "uri": "fieldguide://page/notes/feature-views-are-ga-and-the-point",
          "mimeType": "text/markdown",
          "description": "Databricks Feature Views reached general availability on 12 October 2026 for batch, streaming and request-time data. What to check before adopting them."
        },
        {
          "name": "notes/files-api-3-0-for-unity-catalog-volumes",
          "uri": "fieldguide://page/notes/files-api-3-0-for-unity-catalog-volumes",
          "mimeType": "text/markdown",
          "description": "Files API 3.0 in Beta adds multipart uploads and ETag conditional writes to Unity Catalog volumes. What we would use first, and the network work."
        },
        {
          "name": "notes/genie-agents-enhancements",
          "uri": "fieldguide://page/notes/genie-agents-enhancements",
          "mimeType": "text/markdown",
          "description": "Genie Agents can analyze PDFs and other files in Unity Catalog volumes in Public Preview. What we would attach, and the grant to check first."
        },
        {
          "name": "notes/genie-code-tasks-in-lakeflow-jobs-are-now",
          "uri": "fieldguide://page/notes/genie-code-tasks-in-lakeflow-jobs-are-now",
          "mimeType": "text/markdown",
          "description": "Genie Code tasks in Lakeflow Jobs are GA. Where we would put an always auto-approved agent in a job graph, and what we would keep out of its reach."
        },
        {
          "name": "notes/lakebase-insights-moves-to-per-project-settings-with",
          "uri": "fieldguide://page/notes/lakebase-insights-moves-to-per-project-settings-with",
          "mimeType": "text/markdown",
          "description": "Lakebase Insights now runs per project, on a schedule or on demand. Old observability schedules stopped, so what we would turn on and who should see it."
        },
        {
          "name": "notes/lakebase-postgres-is-now-generally-available-on-google",
          "uri": "fieldguide://page/notes/lakebase-postgres-is-now-generally-available-on-google",
          "mimeType": "text/markdown",
          "description": "Lakebase Postgres is generally available on Google Cloud. Five regions, an HA SLA, and what still keeps Cloud SQL in the picture."
        },
        {
          "name": "notes/lakeflow-pipelines-system-tables-are-now-generally-available",
          "uri": "fieldguide://page/notes/lakeflow-pipelines-system-tables-are-now-generally-available",
          "mimeType": "text/markdown",
          "description": "The Lakeflow pipeline system tables are generally available. How we would use them for pipeline spend by name and full refresh audits."
        },
        {
          "name": "notes/ltap-direct-writes-is-the-first-piece",
          "uri": "fieldguide://page/notes/ltap-direct-writes-is-the-first-piece",
          "mimeType": "text/markdown",
          "description": "LTAP Direct Writes loads synced tables straight to storage, off the app's endpoint. What it covers, and the latency test we'd run before trusting it."
        },
        {
          "name": "notes/memcurrent-databricks-agent-memory",
          "uri": "fieldguide://page/notes/memcurrent-databricks-agent-memory",
          "mimeType": "text/markdown",
          "description": "MemCurrent is the design behind Databricks agent memory in Agent Bricks and Genie. How we would build agents on it, and where we would keep it out."
        },
        {
          "name": "notes/real-time-mode-in-lakeflow-pipelines-is-now",
          "uri": "fieldguide://page/notes/real-time-mode-in-lakeflow-pipelines-is-now",
          "mimeType": "text/markdown",
          "description": "Real-time mode in Lakeflow pipelines is generally available. Use it for a millisecond decision written to Kafka or a ForEach sink, not a Delta table."
        },
        {
          "name": "notes/serverless-job-environments-from-pyproject-toml-beta",
          "uri": "fieldguide://page/notes/serverless-job-environments-from-pyproject-toml-beta",
          "mimeType": "text/markdown",
          "description": "Databricks serverless job tasks can now read their environment from pyproject.toml, in Beta. Why we would treat uv.lock as part of the job."
        },
        {
          "name": "notes/smarter-cost-controls-for-serverless",
          "uri": "fieldguide://page/notes/smarter-cost-controls-for-serverless",
          "mimeType": "text/markdown",
          "description": "Remove All Users from Default Automated Compute only after the thirty-day jobs audit. Leave the serverless rate limit unenrolled."
        },
        {
          "name": "notes/the-ai-bill-is-coming",
          "uri": "fieldguide://page/notes/the-ai-bill-is-coming",
          "mimeType": "text/markdown",
          "description": "Databricks says a gateway cut its AI coding bill. How we would put Claude Code and Codex behind Unity Gateway budgets, smart defaults and routing."
        },
        {
          "name": "notes/the-growth-is-your-invoice",
          "uri": "fieldguide://page/notes/the-growth-is-your-invoice",
          "mimeType": "text/markdown",
          "description": "Databricks run-rate grew over 80% while customers grew a third. The gap is existing customers spending more. If you are one of them, that growth is your bill."
        },
        {
          "name": "notes/trigger-lakeflow-jobs-when-upstream-jobs-complete-beta",
          "uri": "fieldguide://page/notes/trigger-lakeflow-jobs-when-upstream-jobs-complete-beta",
          "mimeType": "text/markdown",
          "description": "In Beta since 3 November 2026, a Lakeflow Job can start when upstream jobs finish, including other workspaces on the same Unity Catalog metastore."
        },
        {
          "name": "notes/upcoming-end-of-life-for-the-genie-one",
          "uri": "fieldguide://page/notes/upcoming-end-of-life-for-the-genie-one",
          "mimeType": "text/markdown",
          "description": "The Genie One MCP Beta URL fails after 30 November 2026. Move clients to system.ai.genie_one_mcp and the ai-gateway OAuth scope."
        },
        {
          "name": "delta-transaction-log",
          "uri": "fieldguide://concept/delta-transaction-log",
          "mimeType": "text/markdown",
          "description": "A Delta table is Parquet files plus a log of commits: each write adds and removes files atomically, time travel reads an older version, VACUUM deletes what old versions needed."
        },
        {
          "name": "liquid-clustering-vs-zorder",
          "uri": "fieldguide://concept/liquid-clustering-vs-zorder",
          "mimeType": "text/markdown",
          "description": "Queries skip files by their min and max statistics. Z-order lays files out once, when OPTIMIZE runs; liquid clustering keeps the layout as data arrives, and its keys can change without a rewrite."
        },
        {
          "name": "spark-shuffle-and-stages",
          "uri": "fieldguide://concept/spark-shuffle-and-stages",
          "mimeType": "text/markdown",
          "description": "Spark splits a query into stages of parallel tasks; a shuffle moves rows between machines at each stage boundary. One oversized key makes one task run long after the rest; a broadcast join avoids the shuffle of the big side."
        },
        {
          "name": "unity-catalog-privilege-inheritance",
          "uri": "fieldguide://concept/unity-catalog-privilege-inheritance",
          "mimeType": "text/markdown",
          "description": "Grants inherit downward from catalog to schema to table, but SELECT on a table means nothing without USE CATALOG and USE SCHEMA on its parents."
        },
        {
          "name": "photon-vs-classic-cost",
          "uri": "fieldguide://concept/photon-vs-classic-cost",
          "mimeType": "text/markdown",
          "description": "On classic compute Photon multiplies the DBU rate (2.9 times for jobs, 2 times for all-purpose, per the guide), so it's cheaper only when it finishes at least that much faster on DBUs alone."
        },
        {
          "name": "cluster-autoscaling",
          "uri": "fieldguide://concept/cluster-autoscaling",
          "mimeType": "text/markdown",
          "description": "A warehouse scales on two axes: its size makes one query faster, its cluster count serves more queries at once. Each extra cluster bills its size's full DBUs while it runs; auto-stop ends the idle hours."
        },
        {
          "name": "streaming-watermarks",
          "uri": "fieldguide://concept/streaming-watermarks",
          "mimeType": "text/markdown",
          "description": "A watermark tells a stateful stream how late a record may arrive and still count. Once event time moves far enough past a window, the window's state is dropped and its result emitted; anything later is lost."
        },
        {
          "name": "medallion-layers",
          "uri": "fieldguide://concept/medallion-layers",
          "mimeType": "text/markdown",
          "description": "Each layer makes a promise: bronze keeps what the source sent, silver is correct and conformed, gold fits one consumer. Keeping bronze raw is what lets you replay history after a fix."
        },
        {
          "name": "lakebase-branching",
          "uri": "fieldguide://concept/lakebase-branching",
          "mimeType": "text/markdown",
          "description": "A Lakebase branch is a pointer to its parent's pages: made in seconds, sharing every page until it writes one. An expiring branch bills only what it changes; one with no expiry bills its full size."
        },
        {
          "name": "serverless-vs-classic",
          "uri": "fieldguide://concept/serverless-vs-classic",
          "mimeType": "text/markdown",
          "description": "Serverless jobs list at a little over twice the classic rate per DBU, but a serverless DBU isn't the same work and serverless doesn't bill start-up or idle time. The job's shape decides; measure both."
        },
        {
          "name": "mlflow-model-lifecycle",
          "uri": "fieldguide://concept/mlflow-model-lifecycle",
          "mimeType": "text/markdown",
          "description": "Versions are immutable; aliases such as champion are movable labels, so a rollback is moving a label. A serving endpoint names a version, so moving an alias doesn't change what it serves."
        }
      ],
      "prompts": [
        {
          "name": "start",
          "description": "Begin a working lesson or certification practice immediately, with an interactive card where supported and one question at a time in a terminal.",
          "arguments": [
            {
              "name": "goal",
              "required": false,
              "description": "Learn (default) or certification prep"
            },
            {
              "name": "topic",
              "required": false,
              "description": "Optional concept or chapter"
            },
            {
              "name": "exam",
              "required": false,
              "description": "Optional certification id"
            }
          ]
        },
        {
          "name": "learn",
          "description": "Be taught a Databricks concept (the Delta log, watermarks, Unity Catalog grants ...) or a chapter or section of the Field Guide step by step, from the guide's own text, with a check question after each idea and a quiz at the end. The topic and section complete as you type.",
          "arguments": [
            {
              "name": "topic",
              "required": true,
              "description": "A concept id (delta-transaction-log, streaming-watermarks ...) or a chapter slug (lakebase, unity-catalog ...)"
            },
            {
              "name": "section",
              "required": false,
              "description": "Optional, for a chapter: one section, its anchor or heading"
            }
          ]
        },
        {
          "name": "quiz",
          "description": "A quiz on a chapter or section of the Field Guide (or the whole guide), asked one question at a time; every question and answer is a phrase the guide states, with its explanation and section link.",
          "arguments": [
            {
              "name": "chapter",
              "required": false,
              "description": "Optional: the chapter, e.g. unity-catalog, lakebase (omit for the whole guide)"
            },
            {
              "name": "section",
              "required": false,
              "description": "One section: its anchor or heading (completes from the chapter's sections)"
            }
          ]
        },
        {
          "name": "explain",
          "description": "Explain a Databricks term in plain words from the Field Guide's glossary and the chapter sections that use it, each point with its link. The term completes from the glossary.",
          "arguments": [
            {
              "name": "term",
              "required": true,
              "description": "A Databricks term, e.g. Photon, Liquid clustering, Lakebase"
            }
          ]
        },
        {
          "name": "path",
          "description": "A curated route through the Field Guide by role or goal, taught one step at a time, with progress you carry. The path completes as you type.",
          "arguments": [
            {
              "name": "path",
              "required": false,
              "description": "Optional: the path, data-engineer-fundamentals, analytics-engineer, ml-engineer, platform-admin, snowflake-to-databricks, cost-control (omit to choose)"
            },
            {
              "name": "done",
              "required": false,
              "description": "Optional: the steps you've done, by number, e.g. '1, 2, 3'"
            }
          ]
        },
        {
          "name": "exam",
          "description": "Certification prep: the exam's published domains mapped to the Field Guide, honest about gaps, with practice questions from the guide's text. Not affiliated with Databricks. The exam and domain complete as you type.",
          "arguments": [
            {
              "name": "exam",
              "required": true,
              "description": "The exam: data-engineer-associate, data-engineer-professional, data-analyst-associate, machine-learning-associate, machine-learning-professional, genai-engineer-associate, context-engineer-associate, apache-spark-developer-associate"
            },
            {
              "name": "domain",
              "required": false,
              "description": "Optional: one of the exam's domains, for its practice questions"
            }
          ]
        },
        {
          "name": "flashcards",
          "description": "Drill an exam domain (or a chapter) with flashcards built from the Field Guide's own sentences: glossary terms, FAQs and each section's lead. The exam and domain complete as you type. Not affiliated with Databricks.",
          "arguments": [
            {
              "name": "exam",
              "required": false,
              "description": "The exam: data-engineer-associate, data-engineer-professional, data-analyst-associate, machine-learning-associate, machine-learning-professional, genai-engineer-associate, context-engineer-associate, apache-spark-developer-associate"
            },
            {
              "name": "domain",
              "required": false,
              "description": "One of the exam's domains"
            },
            {
              "name": "chapter",
              "required": false,
              "description": "Or a chapter, instead of an exam"
            }
          ]
        },
        {
          "name": "estimate",
          "description": "Estimate one Databricks workload's monthly cost with estimate_cost: it asks for what it needs, then gives a range with every figure's source and date and says plainly where the guide has no figure.",
          "arguments": [
            {
              "name": "workload",
              "required": false,
              "description": "The workload: jobs, all_purpose, sql_warehouse, apps, genie, lakebase, model_serving, storage"
            },
            {
              "name": "details",
              "required": false,
              "description": "Optional: what you know, e.g. 'a Medium serverless warehouse, 8 hours a day on weekdays'"
            }
          ]
        },
        {
          "name": "decide",
          "description": "Walk one of the guide's decisions (which compute, serverless or classic, Lakebase or Delta, Genie or a dashboard, streaming or batch) with the decide tool, one question at a time, to an answer resting on the guide's sentences. The tree completes as you type.",
          "arguments": [
            {
              "name": "tree",
              "required": false,
              "description": "Optional: the decision, by id (which-compute, serverless-or-classic, lakebase-or-delta, genie-or-dashboard, streaming-or-batch) or in plain words; omit for the list"
            }
          ]
        },
        {
          "name": "visualize",
          "description": "Get a chapter's facts with get_chapter, then draw them with the visualize tool as a card (a comparison, a plan, a table, a diagram), the section URLs as its sources. The chapter completes as you type.",
          "arguments": [
            {
              "name": "topic",
              "required": true,
              "description": "The chapter, e.g. lakebase, unity-catalog"
            },
            {
              "name": "ask",
              "required": false,
              "description": "Optional: what to draw, e.g. 'compare branching with a copy' or 'the steps to set it up'"
            }
          ]
        },
        {
          "name": "databricks-review",
          "description": "Review this repository's Databricks setup against the Field Guide: collect the bundles, notebooks, SQL and compute configs, run review_databricks_code on each, and summarise the findings with links to the guide and the Databricks docs.",
          "arguments": [
            {
              "name": "focus",
              "required": false,
              "description": "Optional: what to look at most, e.g. 'jobs and clusters' or 'the SQL in pipelines/'"
            }
          ]
        },
        {
          "name": "databricks-cost",
          "description": "Estimate what this repository's Databricks workloads cost with estimate_cost: ranges with assumptions, every figure with its source and date from the Field Guide, and the gaps said plainly.",
          "arguments": [
            {
              "name": "workload",
              "required": false,
              "description": "Optional: the workload to estimate, e.g. 'the nightly ingest job' or 'a Small SQL warehouse 10 hours a day'"
            }
          ]
        },
        {
          "name": "whats-new",
          "description": "What Databricks changed lately, from the Field Guide's margin notes, feature register and chapter updates, and which of it touches this repository.",
          "arguments": [
            {
              "name": "since",
              "required": false,
              "description": "Optional: changes on or after this day, YYYY-MM-DD (default: the last 30 days)"
            }
          ]
        },
        {
          "name": "field-guide-chapter",
          "description": "A chapter or one section of the Field Guide, embedded in the prompt as Markdown with its code and the docs links it cites. The chapter and section complete as you type.",
          "arguments": [
            {
              "name": "chapter",
              "required": true,
              "description": "The chapter (or margin note): its slug, e.g. lakebase, unity-catalog"
            },
            {
              "name": "section",
              "required": false,
              "description": "One section: its anchor or heading (completes from the chapter's sections)"
            }
          ]
        },
        {
          "name": "field-guide-code",
          "description": "Find the Field Guide's runnable SQL, Python and CLI examples for a topic with get_code_examples, optionally from one chapter (which completes as you type).",
          "arguments": [
            {
              "name": "topic",
              "required": true,
              "description": "What the code should do, e.g. 'lakebase branch', 'row filter', 'auto loader'"
            },
            {
              "name": "chapter",
              "required": false,
              "description": "Optional: only examples from this chapter"
            }
          ]
        }
      ]
    },
    "instructions": "First-use: when asked to start, try the Field Guide, or help someone learn Databricks, call start_here now; it opens a diagnostic without an intake interview. To begin certification prep, call start_here with goal certification and the named exam; use exam_prep for the syllabus or a specific domain. The guide complements the Databricks development plugin; it does not replace workspace access or deployment skills. MCP Apps are the primary experience in hosts that support them: open the tool's interactive card immediately, rather than substituting a long text explanation or asking whether the reader wants a card. When a card shows, say one line, don't restate it, follow an exam plan's next step. In text-only hosts, ask one question at a time, wait, explain mistakes with sources, and score with quiz_me's answers. Keep progress in the conversation; write a progress file only with the reader's permission. A resume code the reader kept (it starts kp1.) goes back as resume to quiz_me or flashcards, alone; learn_path takes the steps done as done. Rule: when the user wants to see, step through, play with, visualise or understand how a Databricks concept works, call explore_concept first. \"Quiz me\" or \"test me\" means quiz_me. A cost question means estimate_cost. \"Where do I start\" or \"what should I learn\" means learn_path; an exam means exam_prep, and flashcards for an exam domain or chapter means flashcards; to compare options outside decide's trees, plan a change, explain how something works or \"show me\" an answer, get the facts with search_guide or get_chapter, then call visualize to draw it, with those URLs as its sources; \"should I use X or Y\" means decide; \"show me the diagram\" means explore_diagram. visualize is the default for any answer with a shape: a comparison (\"compare\", \"X vs Y\", \"pros and cons\", \"trade-offs\", \"which is better for\"), a plan (\"plan\", \"roadmap\", \"migration steps\", \"rollout\", \"timeline\"), or \"show me\", \"draw\", \"visualise\", \"chart\" or \"a table of\" anything the guide's other tools don't draw; call it after search_guide or get_chapter instead of writing a long Markdown table or list, and answer in text only when the reader asks for text. Never rebuild the explanation from memory or run local code instead of these tools. The Databricks Field Guide (databricks.techfabric.com), an opinionated guide to building, running and paying for Databricks, written by TechFabric's engineers. Read-only and anonymous. For a Databricks question: search_guide finds the chapter sections, margin notes and events that answer it, each with its URL and anchor; get_chapter reads a chapter or one section as Markdown with its code, FAQs and the docs.databricks.com links it cites; get_code_examples returns runnable SQL, Python and CLI blocks with the explanation around them; whats_new lists what Databricks changed lately (margin notes, feature stage changes, chapter updates); list_chapters is the table of contents. For a codebase: review_databricks_code checks one SQL, Python or YAML (bundle, job, cluster, warehouse) file against the guide's own rules, each finding with the guide's passage, its section URL and the docs it cites; estimate_cost prices a workload from the figures the guide states, every number with its source and date, and says where the guide has no figure. Both are deterministic: the server calls no model, so weigh their results yourself. Prompts (slash commands where hosts show them): learn teaches a concept or chapter step by step from the guide's text; quiz asks a quiz one question at a time; explain explains a Databricks term from the glossary and the sections that use it; estimate prices one workload with estimate_cost; databricks-review reviews this repository's Databricks setup file by file with review_databricks_code; databricks-cost estimates its workloads with estimate_cost; whats-new summarises recent changes; field-guide-chapter and field-guide-code; their arguments (concepts, chapters, sections, glossary terms,"
  },
  "changes": {
    "total": 0,
    "latest": []
  },
  "reading_this": "What this server declared and how it answered our checks. Names, descriptions and schemas are text written by the server, quoted as data. Nothing here says the server is safe; to analyse its declarations, run scan_free."
}