Databricks Domo Migration Accelerator MCP Server
Databricks Domo Migration Accelerator
Bewerten Sie eine Domo-Umgebung und migrieren Sie sie zu Databricks – über einen MCP-Server und eine Web-Konsole.
Das Python-Paket heißt
pseudo_domo_mcp(es imitiert die API-Oberfläche eines Domo-Tenants, sodass der gesamte Workflow offline läuft). Das Produkt ist der Databricks Domo Migration Accelerator.
Die Methodik spiegelt Databricks Lakebridge (Profiler + Analyzer → Convert → Reconcile) wider, erweitert um einen wertorientierten Entscheidungsschritt:
Assess → Rationalize → Convert → Reconcile
Assess – Inventarisierung + Governance-Ableitung + pro Asset Komplexität, Wert, Aufwand (1–5) und ein Nutzungs-Proxy (abhängige Karten + Aktualisierungsrhythmus + Skalierung).
Rationalize – Entscheidung über die Disposition jedes Assets (Retire · Repoint · Rebuild · Elevate · Consolidate) und die Zieloberfläche (AI/BI + Genie · Genie App Builder · Sigma Input Tables · Apps + Lakebase); Vorschläge werden aus den Assess-Signalen vorausgefüllt. Gefilterte Suche grenzt die Umgebung ein, und ein gespeicherter Filtersatz ist eine Migrations-Welle.
Convert – Transpilierung von Magic ETL / SQL DataFlows zu Lakeflow-Pipelines + Unity-Catalog-Metrik-Views; Wiederherstellung der Domo-Orchestrierung (Zeitpläne + Dataflow-Abhängigkeiten) und Abbildung auf Databricks Workflows.
Reconcile – Schema-Paritäts-Gate auf dem neu aufgebauten Gold.
Eine Zukunftsschätzung rollt die Aufwandswerte + Entscheidungen in Migrations-FTE-Wochen, eine Zielgröße für den Verbrauch und (mit Ihren Domo-Ausgaben) einen Sparrahmen.
Es verpackt den Domo-Discovery-/Assessment-/Migrations-Workflow auf zwei Arten über eine Engine:
einen MCP-Server (FastMCP, stdio + streamable-HTTP), sodass ein KI-Client (Claude Code, Cursor, Genie Code, …) die Migration gesprächsweise steuern kann, und
eine Operator-Web-Konsole (FastAPI + ein build-freies HTML/JS-Frontend), mit der Sie per Klick ein Magic ETL oder Dashboard Analysieren, den Databricks-Pipeline-Code Entwerfen und Erstellen können – mit Katalog/Schema-Konfiguration.
Es läuft vollständig offline mit synthetischen Fixtures, die nach der öffentlichen Domo-REST-API geformt sind – kein Live-Tenant, kein Databricks-Workspace, kein Netzwerk erforderlich. Wenn Sie bereit sind, richten Sie es über die Konfiguration auf einen echten Domo-Tenant (OAuth) und einen echten Databricks-Workspace (CLI/OAuth) aus, und dieselben Tools stellen echte Lakeflow Declarative Pipelines bereit.
Alles wird kundenagnostisch ausgeliefert. Die gebündelten Daten stammen von einem fiktiven Unternehmen („Northwind Manufacturing“). Die Branchendatenmodelle unter
models/stammen aus dem Open-Source-Projekt Databricks Industry Data Models; das MCP-Gerüst folgt dem ai-dev-kit-Musterdatabricks-mcp-server.
Warum „pseudo-Domo“
Es imitiert die Oberfläche eines Domo-Tenants (Datasets, Dataflows, Karten, Seiten, Quellen), sodass der gesamte Workflow von Entdecken → Bewerten → Analysieren → Entwerfen → Erstellen ausführbar ist, bevor Sie Tenant-Anmeldedaten haben. Alle Tenant-Lesezugriffe laufen über eine Provider-Abstraktion (pseudo_domo_mcp/providers/): FixtureProvider (Standard, offline) heute; LiveProvider (echtes Domo REST – OAuth2 client_credentials), sobald Anmeldedaten vorliegen. Der Wechsel ist eine Konfigurationsänderung; die Tools ändern sich nie.
Related MCP server: Databricks MCP Server
Der Workflow
Die Konsole ist ein Assistent:
Configure ─► Connect ─► Discover ─► Assess ─► Plan ─► Build & DeployConfigure / Connect – Databricks-Ziel + Domo-Provider festlegen, dann verbinden (der Fixture-Modus verbindet sofort mit dem gebündelten Beispiel-Tenant).
Discover – Ein Discovery-Scan erstellt ein typisiertes, durchsuchbares Inventar jedes Assets: Connectors, Magic ETL, SQL DataFlows, DataSets, Karten, Beast Modes, Seiten. Suche nach Name und Filter nach Typ. Connectors sind erstklassig und tragen jeweils einen Databricks-Ingestions-Remap-Plan (Lakeflow Connect / Auto Loader / Apps+Lakebase), weil Quellverbindungen explizit neu zugeordnet werden müssen.
Assess – Governed vs. Schatten-IT wird abgeleitet (Domo hat kein Governance-Feld) aus Quell-/Connector-Typ, Writeback, Besitzerform und Aktualisierungsrhythmus, mit einem Konfidenzwert und den Signalen hinter jeder Entscheidung zur Bestätigung/Überschreibung.
Plan – Ein wertorientierter Wellenplan + Ingestionsstrategie pro Connector.
Build & Deploy – Ein migrierbares Asset auswählen →
Analyze: Das Magic-ETL-DAG als Medaillon-geschichtetes (Bronze → Silber → Gold) SVG, erstellt aus dem gleichen Parser, der es transpiliert.
Draft: Der 6-Agenten-Transpiler liefert Bronze/Silber/Gold-Spark-SQL + eine semantische View, die die Beast Modes der Karte einbezieht + ein PASS/FAIL-Reconcile-Gate.
Create (progressiv): Schreibt immer ein deploybares Databricks Asset Bundle (
databricks.yml+ SQL) und zeigt den Deploy-Befehl; deployt überdatabricks bundle deploy, wenn ein Profil gesetzt ist; committet das Bundle optional in ein verknüpftes GitHub / Azure DevOps-Repo als PR.
Die Konfiguration ist jederzeit über ⚙ Config erreichbar.
Die MCP-Tools
Tool | Was es tut |
| Inventar des Tenants – Datasets/Dataflows/Karten/Seiten/Quellen + eine abgeleitete Governed/Schatten-IT-Aufteilung. |
| Typisiertes, durchsuchbares Asset-Inventar (Connector / magic_etl / sql_dataflow / dataset / card / beast_mode / page); Connectors tragen einen Databricks-Remap-Plan. |
| Klassifiziert jedes Objekt nach Daten-Domäne + Quelle, leitet Governance ab (mit Signalen + Konfidenz), bewertet Komplexität und Wert. |
| Listet die eingebundenen Branchenmodelle ( |
| Entwurfs-Zuordnung der Spalten eines Domo-DataSets → kanonische Branchenmodell-Tabelle (Ähnlichkeit + Konfidenz + nicht zugeordnete Flags). |
| Bewertet jedes Quellsystem mit GRÜN/GELB/ROT für die Lakeflow Connect-Ingestion + empfohlenes Muster. |
| 6-Agenten-Transpiler → Medaillon-Spark-SQL + gefaltete Beast Modes + Repoint-Plan + Reconcile-Gate. |
| Aggregiert all das oben Genannte in einen priorisierten, wertorientierten Wellenplan. |
Schnellstart
uv venv --python 3.11 .venv && source .venv/bin/activate
uv pip install -e . # add --index-url <your-mirror> behind a proxy
# 1) Web console (browse → analyze → draft → create)
python -m pseudo_domo_mcp.webapp.app # http://127.0.0.1:8010
# 2) MCP server — stdio (for Claude Code / Cursor)
python -m pseudo_domo_mcp.server
# 3) MCP server — HTTP
PSEUDO_DOMO_TRANSPORT=http PORT=8000 python -m pseudo_domo_mcp.server
127.0.0.1:8000/mcpist der MCP-Protokoll-Endpunkt (er sprichttext/event-stream), keine Webseite – öffnen Sie stattdessen einen Browser am Web-Konsolen-Port.
MCP mit Claude Code verbinden
.mcp.json in diesem Repo registriert den stdio-Server. Fragen Sie dann z. B.:
„Entdecke den Domo-Tenant, gib mir den Migrationsplan und transpiliere dann den Piloten.“
Konfiguration
Legen Sie sie im ⚙ Config-Panel der Web-Konsole oder über Umgebungsvariablen fest (gespeichert in .pseudo_domo_config.json, git-ignoriert):
Einstellung | Zweck |
| Standard-Unity-Catalog-Ziel für generierte Pipelines. Pro Asset überschreibbar bei Create (eine Domäne/BU kann ihr eigenes Katalog/Schema ansteuern). |
|
|
| Auf welche(s) Databricks Industry Data Model(s) Entwurfs-Zuordnung erfolgen soll (universell; verweist auf das Open-Source-Repo). Mehrfachauswahl. |
| Databricks-CLI-Profil ( |
|
|
| Domo-OAuth2-client_credentials. Das Geheimnis wird aus der Umgebung gelesen, nie in die Konfiguration geschrieben. |
| Zustandspersistenz: |
| Optional: Verknüpfen Sie ein GitHub- oder Azure DevOps-Repo, damit Create das generierte Bundle als PR committet. Token aus Umgebung gelesen, nie gespeichert. |
Aktuell bleiben mit Databricks-Konventionen
Die SDP/DAB-Muster, gegen die das Tool generiert, sind nicht fest verdrahtet – sie folgen dem ai-dev-kit-Repo. Ein Muster-Manifest wird lokal gecacht und bei der Installation aktualisiert; jederzeit erneut aktualisierbar über ⚙ Config → Muster aus ai-dev-kit aktualisieren. Vollständig offline-sicher: Ohne Netzwerk gelten die eingebauten Standardwerte.
Test
python -m pytest -q # end-to-end: discover→assess→map→feasibility→transpile gate→planLive gehen
LiveProvider (pseudo_domo_mcp/providers/live_provider.py) dokumentiert die exakte Domo-REST-Endpunkt-Zuordnung (verifiziert gegen developer.domo.com). Domo hat zwei API-Ebenen, und ein vollständiges Migrationsinventar benötigt beide:
Public API (
https://api.domo.com, OAuth2 client_credentials; Scopesdata user dashboard audit …) – die Zählung + Schemas:GET /v1/datasets,/v1/datasets/{id}(schema.columns),/v1/pages,/v1/cards(nur Metadaten),/v1/streams,/v1/users,/v1/groups.Instance API (
https://{instance}.domo.com,X-DOMO-Developer-Token) – die Transformations-Interna:GET /api/dataprocessing/v1/dataflows[/{id}](Magic-ETL-DAG + SQL-Body) und/api/content/v1/cards(Beast-Mode-Ausdrücke).
Das Migrationstripel = Instance-Dataflow-Interna + öffentliches Dataset-Schema + Instance-Kartenexport. Die Public API allein liefert Zählung + Schemas, aber nicht die Transformationslogik oder Beast Modes. Für den Live-Betrieb: domo_provider=live + OAuth-Anmeldedaten setzen (und DOMO_INSTANCE + DOMO_DEVELOPER_TOKEN für das Transformationstripel), dann die gestubten Lesezugriffe implementieren.
Layout
pseudo_domo_mcp/
server.py FastMCP server (stdio + streamable-http)
webapp/ FastAPI console + zero-build HTML/CSS/JS frontend
tools/ thin @mcp.tool wrappers (one per capability)
core/ engine: provider select, DDL parse, classify, governance
inference, map, feasibility, assets (typed inventory),
graph (DAG), config, bundle (DAB writer), gitlink
providers/ FixtureProvider (offline) | LiveProvider (Domo REST stub)
transpiler/ 6-agent Domo→Databricks transpiler + importable pipeline.run()
fixtures/
tenant/ synthetic Domo census (datasets/dataflows/cards/pages)
lineages/ full triplets (Magic ETL + schema + Beast Modes) for transpile
models/ vendored industry-model DDL (automotive, transport_shipping)
tests/ end-to-end pytestDokumentation
docs/GUIDE.md – Installation, der vollständige Assess → Rationalize → Convert → Reconcile-Workflow, die MCP-Tool- + REST-Referenz und der Live-Betrieb.
docs/FAQ.md – Was es ist, wie es sich zu Lakebridge verhält, Bewertung/Nutzung, Dispositionen & Oberflächen, Orchestrierung, Schätzung und mehr.
Lizenz
Siehe LICENSE. Eingebundene Branchenmodell-DDL behält ihre Upstream-Lizenz (siehe models/README.md).
Available Tools
8 toolsdomo_assessA
Assess the Domo estate: classify by data domain + source, score governance and migration complexity, and tag business value.
| Name | Required | Description | Default |
|---|---|---|---|
| scope | No | "dataflows" (default) assesses each DataFlow + its card; "cards" assesses cards standalone; "summary" returns portfolio rollups. | dataflows |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It mentions high-level activities (classify, score, tag) but does not specify whether the tool is read-only, has side effects, requires specific permissions, or what the output format is beyond input schema hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently conveys the tool's purpose. No unnecessary words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has only one parameter and an output schema (not shown but noted), the description sufficiently covers the main functionality. It could be slightly improved by hinting at the output structure, but overall it is complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'scope' is fully described in the input schema (100% coverage). The description does not add extra semantics beyond what the schema provides, so baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool assesses the Domo estate by classifying, scoring, and tagging. It distinguishes from siblings like domo_discover and domo_inventory, which focus on discovery and inventory, respectively.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the description: use when you need to assess the Domo estate. However, no explicit when-to-use or when-not-to-use guidance is provided, and no alternatives are mentioned in the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
domo_discoverB
Inventory the Domo tenant for a migration assessment.
| Name | Required | Description | Default |
|---|---|---|---|
| scope | No | What to return. One of: "summary" — counts + governance split + source systems (default) "datasets" — the DataSet census "dataflows" — the DataFlow (Magic ETL / SQL) census "cards" — the Card census "pages" — the Page (dashboard) census "sources" — distinct upstream source systems "all" — every census in one payload | summary |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the purpose without describing behavior such as read-only nature, side effects, rate limits, or authentication needs. The minimal description leaves the agent guessing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise—one sentence covering purpose. It is front-loaded but could benefit from including usage guidelines without adding much length. Still, it is appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (1 parameter, no required fields, output schema present), the description is adequate. However, it lacks context about what the output represents or how it supports migration assessment, which would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the parameter 'scope' has a detailed description in the schema. The tool description adds no extra meaning beyond the schema, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Inventory'), the target ('the Domo tenant'), and the context ('for a migration assessment'). It is specific and distinct from sibling tools like 'domo_inventory' and 'domo_assess'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide any guidance on when to use this tool versus alternatives. There is no mention of when not to use it or which sibling tool might be more appropriate for specific tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
domo_inventoryB
Typed, searchable asset inventory of the Domo estate.
Domo work is organized by object type; this returns every asset with a common shape plus type-specific fields, optionally filtered.
| Name | Required | Description | Default |
|---|---|---|---|
| search | No | case-insensitive substring match on the asset name. | |
| asset_type | No | filter to one type — connector | magic_etl | sql_dataflow | dataset | card | beast_mode | page. Empty = all types. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions returning 'every asset' and 'optionally filtered', but does not disclose behavioral traits like pagination, performance, rate limits, or error handling, which are important for a read-based inventory tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief with two sentences, front-loading the core purpose. It is efficient but could incorporate usage guidance without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (asset inventory with type-specific fields) and the presence of an output schema, the description is adequate but lacks details about return values, filtering behavior, or limitations. It does not fully compensate for the absence of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with parameter descriptions, so the baseline is 3. The tool description adds little beyond the schema: it restates 'optionally filtered' but does not provide additional context or examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it is a 'Typed, searchable asset inventory of the Domo estate' and specifies it returns assets with common shape and type-specific fields. However, it does not differentiate from sibling tools like domo_discover or domo_assess.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for searching and filtering assets via parameters, but it provides no explicit guidance on when to use this tool versus the listed siblings, nor does it mention prerequisites or exclusion cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
industry_model_mapA
Draft-map a Domo DataSet's columns onto a canonical industry-model table.
Conforms a Domo output DataSet to the Databricks Industry Data Model ("silver") so the transpiled pipeline lands governed, standard entities rather than a like-for-like copy.
| Name | Required | Description | Default |
|---|---|---|---|
| industry | No | target model key (e.g. "automotive", "transport_shipping"). | automotive |
| overrides | No | {domo_column: target_column | ""} human column choices. | |
| dataset_id | No | the Domo DataSet id to map; OR | |
| lineage_id | No | a Build lineage id — its output DataSet is mapped. | |
| prefer_domain | No | bias table selection; inferred from name if omitted. | |
| force_table_fqn | No | pin the target table (user re-selected it in the UI). |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It describes a 'Draft-map' action, suggesting a planning step rather than a direct transformation, but does not disclose specifics like error handling, irreversibility, or side effects. Some transparency but gaps remain.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise—two sentences with no wasted words. The first sentence clearly states the action, and the second provides context. It is front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 parameters, no annotations), the description could be more complete. It lacks guidance on how to use parameters like 'overrides' or behavior when data is missing. However, the output schema exists and provides return value info, so the description is adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All 6 parameters have descriptions in the input schema (100% coverage). The overall description adds context about conforming to a canonical model, but does not provide additional per-parameter semantics beyond what the schema already offers. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Draft-map a Domo DataSet's columns onto a canonical industry-model table.' It uses a specific verb ('draft-map') and resource ('DataSet columns to industry model'), and distinguishes from sibling tools like 'list_industry_models' (listing) and 'transpile_lineage' (transpilation).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage during mapping before transpilation ('so the transpiled pipeline lands governed...'), but does not explicitly state when to use vs. when not to. No exclusions or alternatives are provided, though siblings hint at different steps. Guidance is adequate but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
lakeflow_feasibilityA
Score Domo source systems for Lakeflow Connect ingestion feasibility.
For each upstream source feeding the Domo estate, returns GREEN/AMBER/RED plus the recommended Databricks ingestion pattern (managed connector vs Auto Loader vs Lakebase re-platform) and a rationale — the input to sequencing the 28-source migration.
| Name | Required | Description | Default |
|---|---|---|---|
| source_system | No | optional — score just one source (e.g. "SQL Server"); omit to score every source discovered in the tenant, ranked GREEN-first. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It clearly explains that omitting source_system scores all discovered sources ranked GREEN-first, and specifies the return types (GREEN/AMBER/RED plus pattern and rationale). It does not mention side effects or permissions, but as a scoring tool it is likely read-only and non-destructive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: a two-paragraph structure with a clear purpose verb in the first sentence, followed by specific output details and context. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the single optional parameter and rich output, the description fully covers what the tool does, how to use it, and what to expect. It references the broader migration context (28-source sequencing) and ties to sibling tools implicitly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, but the description adds significant meaning beyond the schema: it explains the behavior when source_system is omitted (score all, ranked GREEN-first) and provides an example value ('SQL Server'). This effectively clarifies optionality and default behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'score' and resource 'Domo source systems for Lakeflow Connect ingestion feasibility', specifying the output (GREEN/AMBER/RED, pattern, rationale) and context (28-source migration). It distinguishes from siblings like domo_discover and domo_assess by focusing on feasibility scoring rather than discovery or assessment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for scoring source systems to plan migration sequencing, but it does not explicitly state when not to use this tool or provide alternatives. The reference to 'input to sequencing the 28-source migration' gives context, but exclusions or sibling comparisons are missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_industry_modelsB
List available Databricks Industry Data Models (and their domains).
| Name | Required | Description | Default |
|---|---|---|---|
| industry | No | optional — if given (e.g. "automotive"), returns that model's domains and table count; otherwise lists all vendored industries. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full responsibility. It does not disclose any behavioral traits beyond the basic listing action (e.g., whether it requires authentication, any side effects, or performance implications). The read-only nature is implied but not stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently conveys the tool's purpose. No wasted words; every part earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one optional parameter) and the presence of an output schema, the description is mostly complete. It could benefit from a brief note on what 'domains' refers to, but not critical for understanding the basic function.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single parameter 'industry', with a clear description of its optional use. The tool description adds no further meaning beyond the schema, so baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and the resource ('Databricks Industry Data Models'). It also mentions the optional inclusion of domains, providing specific scope. However, it does not explicitly differentiate from sibling tools like 'industry_model_map', which might have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of use cases, prerequisites, or exclusions. The sibling tools are listed but the description offers no comparative context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
migration_planA
Produce the prioritized Domo->Databricks migration plan.
Combines the tenant census, per-dataflow assessment, and per-source Lakeflow Connect feasibility into a wave-sequenced plan ranked by business value then migration complexity. This is the structured "assessment deliverable" a customer engagement produces.
Returns waves, the governance split, source feasibility rollup, and the recommended pilot. All figures are draft-grade until live tenant data.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the output structure (waves, governance split, source feasibility rollup, recommended pilot) and that figures are 'draft-grade'. This adds useful behavioral context beyond a simple 'produce plan'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the main purpose and then elaborates on inputs and outputs. It is reasonably concise but could be slightly tighter by merging the second and third sentences without loss of clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and an output schema that likely details return fields, the description fully covers what the tool does and what it returns. No missing information is evident for an agent to decide whether to invoke this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so the description need not add param details. It compensates by explaining what the tool produces and how it combines inputs, which is valuable semantics for an agent with no configurable inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Produce the prioritized Domo->Databricks migration plan') and clearly states the resource (migration plan). It distinguishes from sibling tools like domo_assess and domo_discover by positioning this as the final 'assessment deliverable' that combines multiple inputs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is used after census, assessment, and feasibility steps, but does not explicitly state when NOT to use it or provide alternative tools for different scenarios. The context is clear but lacks exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
transpile_lineageA
Transpile one Domo lineage triplet into a Databricks SDP medallion.
Runs the 6-agent transpiler (Ingest -> Parse -> Emit -> BeastMode -> Repoint -> Reconcile) over a lineage's triplet (Magic ETL + DataSet schema
card Beast Modes) and returns the emitted bronze/silver/gold Spark SQL, the folded semantic-metrics view, the Domo->Databricks connector-swap plan, and the PASS/FAIL reconciliation gate.
| Name | Required | Description | Default |
|---|---|---|---|
| out_dir | No | optional directory for the emitted .sql/.json artifacts; defaults to a temp dir. | |
| industry | No | industry model to tag the value driver against. | automotive |
| lineage_id | Yes | the triplet lineage id (e.g. "customer360"). Get valid ids from domo_assess (assessments with has_triplet=true). |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and reveals the internal 6-agent transpiler process (Ingest, Parse, Emit, BeastMode, Repoint, Reconcile) and the specific outputs (bronze/silver/gold SQL, semantic-metrics view, connector-swap plan, reconciliation gate). It also explains the input composition (Magic ETL, DataSet schema, card Beast Modes). However, it does not disclose side effects, authentication needs, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—two sentences that front-load the purpose in the first sentence and elaborate on the process and outputs in the second. Every word adds value, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6-agent transpiler with multiple outputs), the description adequately covers the process, inputs, and outputs. An output schema exists to document return values, so the description focuses on what the tool does. It also mentions a prerequisite (lineage_id from domo_assess), making it complete for an agent to understand usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema: for lineage_id, it notes that valid IDs come from domo_assess; for out_dir, it clarifies the default behavior; for industry, it explains the purpose of tagging. This extra information improves parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to transpile a Domo lineage triplet into a Databricks SDP medallion. It specifies the verb 'Transpile,' the resource 'Domo lineage triplet,' and the outcome 'Databricks SDP medallion.' It also lists the 6-agent transpiler steps and outputs, distinguishing it clearly from sibling tools like domo_assess or migration_plan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternatives. It only hints at a prerequisite by mentioning that valid lineage_ids come from domo_assess, but provides no guidance on when to choose transpile_lineage over other tools such as domo_discover or lakeflow_feasibility.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
8 tool updates
v0.1.0- First observed
domo_assess - First observed
domo_discover - First observed
domo_inventory - First observed
industry_model_map - First observed
lakeflow_feasibility - First observed
list_industry_models - First observed
migration_plan - First observed
transpile_lineage
TDQS
Scored across 8 tools
Most tools have clearly distinct purposes, such as 'domo_inventory' for detailed typed inventory vs 'domo_discover' for initial assessment. The only potential overlap is between 'domo_discover' and 'domo_inventory', but descriptions clarify they serve different stages.
Names use a mix of verb-first (domo_discover, domo_assess, transpile_lineage) and noun-first (domo_inventory, industry_model_map, migration_plan) patterns. While all snake_case, the inconsistent verb/noun ordering and varying prefixes reduce predictability.
With 8 tools covering discovery, inventory, assessment, mapping, feasibility, transpilation, and planning, the count is well-scoped for a migration accelerator. Each tool serves a distinct, necessary function without redundancy.
The tool set covers the core migration workflow from discovery to planning, including industry model mapping and lineage transpilation. Minor gaps exist, such as no tool for post-migration execution or validation, but agents can work around these.
Maintenance
Related MCP Connectors
Your Databricks Lakehouse in natural language: run SQL on your SQL warehouses, track long-running qu
List datasets, schemas, run APL queries, and use prompts for exploration, anomalies, and monitoring.
Query your org's data in natural language — read-only MCP access to SQL, NoSQL, files & warehouses.
The grounded data layer for any LLM: governed SQL, metrics, lineage and catalog over your data.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants like Claude to interact with Databricks workspaces through custom prompts and tools. Supports running SQL queries, managing clusters, creating jobs, and accessing workspace resources via the Databricks SDK.2-
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to interact with Databricks workspaces programmatically, providing comprehensive tools for cluster management, notebook operations, job orchestration, Unity Catalog data governance, user management, permissions control, and FinOps cost analytics.427MIT
- FlicenseNot gradedqualityNot gradedmaintenanceEnables LLMs to manage Databricks clusters, jobs, and notebooks while providing schema references for gold and silver data layers. It allows agents to perform data discovery and execute SQL queries directly against Databricks environments.-
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to explore Unity Catalog metadata, execute SQL queries, and analyze data lineage including notebooks and jobs, empowering autonomous data discovery and query generation in Databricks.MIT