Skip to main content
Glama
pete-welch-db

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-Muster databricks-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 & Deploy
  • Configure / 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 über databricks 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

domo_discover

Inventar des Tenants – Datasets/Dataflows/Karten/Seiten/Quellen + eine abgeleitete Governed/Schatten-IT-Aufteilung.

domo_inventory

Typisiertes, durchsuchbares Asset-Inventar (Connector / magic_etl / sql_dataflow / dataset / card / beast_mode / page); Connectors tragen einen Databricks-Remap-Plan.

domo_assess

Klassifiziert jedes Objekt nach Daten-Domäne + Quelle, leitet Governance ab (mit Signalen + Konfidenz), bewertet Komplexität und Wert.

list_industry_models

Listet die eingebundenen Branchenmodelle (automotive, transport_shipping) + deren Domänen/Tabellen auf.

industry_model_map

Entwurfs-Zuordnung der Spalten eines Domo-DataSets → kanonische Branchenmodell-Tabelle (Ähnlichkeit + Konfidenz + nicht zugeordnete Flags).

lakeflow_feasibility

Bewertet jedes Quellsystem mit GRÜN/GELB/ROT für die Lakeflow Connect-Ingestion + empfohlenes Muster.

transpile_lineage

6-Agenten-Transpiler → Medaillon-Spark-SQL + gefaltete Beast Modes + Repoint-Plan + Reconcile-Gate.

migration_plan

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/mcp ist der MCP-Protokoll-Endpunkt (er spricht text/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

catalog / schema

Standard-Unity-Catalog-Ziel für generierte Pipelines. Pro Asset überschreibbar bei Create (eine Domäne/BU kann ihr eigenes Katalog/Schema ansteuern).

pipeline_language

sql oder python – die SDP-Quellsprache. Pro Asset überschreibbar.

industry_models

Auf welche(s) Databricks Industry Data Model(s) Entwurfs-Zuordnung erfolgen soll (universell; verweist auf das Open-Source-Repo). Mehrfachauswahl.

databricks_profile

Databricks-CLI-Profil (databricks auth login). Leer = nur Bundle-Dateien schreiben; gesetzt = wirklich deployen. OAuth wird von der CLI übernommen; kein Workspace-Geheimnis gespeichert.

domo_provider

fixture (offline) oder live (Domo REST).

domo_client_id + DOMO_CLIENT_SECRET (env)

Domo-OAuth2-client_credentials. Das Geheimnis wird aus der Umgebung gelesen, nie in die Konfiguration geschrieben.

store_backend + lakebase_instance

Zustandspersistenz: local (JSON-Datei, Standard) oder lakebase (Databricks Postgres) für dauerhafte, gemeinsame Scan-Historie / Migrationsstatus / Bundle-Registry.

git_provider + git_repo + GIT_TOKEN (env)

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→plan

Live 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; Scopes data 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 pytest

Dokumentation

  • 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 tools
domo_assessA

Assess the Domo estate: classify by data domain + source, score governance and migration complexity, and tag business value.

ParametersJSON Schema
NameRequiredDescriptionDefault
scopeNo"dataflows" (default) assesses each DataFlow + its card; "cards" assesses cards standalone; "summary" returns portfolio rollups.dataflows

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.6/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
scopeNoWhat 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 payloadsummary

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.2/5.0
Behavior2/5

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.

Conciseness4/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
searchNocase-insensitive substring match on the asset name.
asset_typeNofilter to one type — connector | magic_etl | sql_dataflow | dataset | card | beast_mode | page. Empty = all types.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.2/5.0
Behavior2/5

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.

Conciseness4/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
industryNotarget model key (e.g. "automotive", "transport_shipping").automotive
overridesNo{domo_column: target_column | ""} human column choices.
dataset_idNothe Domo DataSet id to map; OR
lineage_idNoa Build lineage id — its output DataSet is mapped.
prefer_domainNobias table selection; inferred from name if omitted.
force_table_fqnNopin the target table (user re-selected it in the UI).

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.7/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
source_systemNooptional — score just one source (e.g. "SQL Server"); omit to score every source discovered in the tenant, ranked GREEN-first.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.6/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters5/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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).

ParametersJSON Schema
NameRequiredDescriptionDefault
industryNooptional — if given (e.g. "automotive"), returns that model's domains and table count; otherwise lists all vendored industries.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.2/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness4/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
out_dirNooptional directory for the emitted .sql/.json artifacts; defaults to a temp dir.
industryNoindustry model to tag the value driver against.automotive
lineage_idYesthe triplet lineage id (e.g. "customer360"). Get valid ids from domo_assess (assessments with has_triplet=true).

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.1/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines2/5

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.

  1. 8 tool updatesv0.1.0
    • First observeddomo_assess
    • First observeddomo_discover
    • First observeddomo_inventory
    • First observedindustry_model_map
    • First observedlakeflow_feasibility
    • First observedlist_industry_models
    • First observedmigration_plan
    • First observedtranspile_lineage

TDQS

A3.6/5.0

Scored across 8 tools

Disambiguation4/5

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.

Naming Consistency3/5

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.

Tool Count5/5

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.

Completeness4/5

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

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • F
    license
    Not graded
    quality
    D
    maintenance
    Enables 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
    -
  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables 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.
    427
    MIT
  • F
    license
    Not graded
    quality
    Not graded
    maintenance
    Enables 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.
    -
  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables 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