Skip to main content
Glama
semlayer MCP server

semlayer MCP server

semlayer

๐Ÿ‘‰ Try it live in your browser, with nothing to install: try.semlayer.dev

The semantic layer that infers itself โ€” skip the quarter of hand-writing dbt YAML. Fair Source (FSL-1.1-ALv2); the format and its schemas are Apache-2.0.

Listed on mcpservers.org

Point it at your warehouse. It profiles every column, discovers the foreign keys nobody declared, decodes the status columns, finds the business rules hiding in your aggregate tables, and writes the whole thing down as a portable semantic layer in an openly licensed format โ€” with confidence, provenance, and lifecycle on every single claim โ€” ready for any AI agent to consume over MCP.

pip install "semlayer[warehouses]"
semlayer init snowflake            # generates the minimal-grant setup script
# `snowflake` reads the environment; `snowflake:<connection>` reads
# ~/.snowflake/connections.toml; `snowflake://user@account/db?role=..` is a URL
semlayer infer snowflake -o layer.yaml \
  --context ./docs/ --context ./etl-repo/CLAUDE.md   # optional: your wikis/dictionaries as priors
semlayer review layer.yaml         # accept/reject what the engine inferred
semlayer mcp layer.yaml            # serve it to Claude, Cursor, or any MCP client
semlayer lint layer.yaml query.sql  # check any SQL (yours or an agent's) against the layer
semlayer drift layer.yaml snowflake  # catch schema changes (cron- and CI-friendly)

Or start from an agent instead of a terminal: add the MCP server to Claude Desktop, Claude Code or Cursor and ask it what it can see โ€” it discovers the warehouses configured on your machine and says what to do next, with no layer built yet. See docs/mcp.md.

For Claude Desktop there is a one-click bundle. Every release attaches a semlayer-<version>.mcpb file. Download it and double-click, and Claude Desktop installs the server. The bundle is about 12 KB; it installs semlayer from PyPI on first run, so you need neither Python nor uv beforehand.

Or have the agent install it. Point any coding agent at this repository and ask it to install the semlayer MCP server: everything it needs is in llms-install.md, written for an agent rather than a person, and it needs nothing else. semlayer is also in the official MCP registry as dev.semlayer/mcp, so a registry-aware client can find and install it without being told where to look.

In VS Code and Cursor, the same layer underlines the fan-out joins and missing required filters as you type. Install the extension from the Visual Studio Marketplace or Open VSX โ€” docs/vscode.md.

In CI, the same findings land on the pull request diff:

- uses: semlayer-dev/semlayer@v0.7.0-beta.8
  with:
    mode: lint            # or: drift, to fail when the warehouse moved
    layer: layer.yaml

docs/ci.md.

From a checkout (to develop on semlayer itself): pip install -e ".[warehouses]".

What to ask it

Once the MCP server is connected, you talk to your agent as usual. These are things worth trying, with what semlayer does behind each one. The table and column names come from messy_mart, the sample retail warehouse the benchmark uses; yours will differ.

Before a layer exists

  • "What data can you see?" The agent lists the warehouses configured on this machine and says which ones semlayer can open. No credential is read and no connection is opened.

  • "Build a semantic layer for it." The agent asks you first, because inference reads your warehouse and spends your own LLM budget. A DuckDB file finishes in the same turn; a real warehouse takes minutes.

Asking a question

  • "What was total order revenue by quarter?" The agent pulls the tables, joins and required filters that bear on the question, writes the SQL, checks it against the layer, runs it read-only, and answers. Under the answer it lists the assumptions nobody has confirmed yet.

  • "Which table should I use for order revenue, and which should I avoid?" use ord_hdr; avoid ord_hdr_legacy (superseded), with the summary tables offered only where their grain covers the question.

Checking SQL you already have

Paste a statement and ask "Check this before I run it." Three from the sample warehouse, each of which runs without error and returns a wrong number:

SQL

What the check says

SELECT SUM(tot_amt) FROM ord_hdr

missing_required_filter: amounts over ord_hdr must exclude cancelled orders (sts_cd <> 'X')

SELECT SUM(o.tot_amt) FROM ord_hdr o JOIN ord_ln l ON l.ord_id = o.ord_id WHERE o.sts_cd <> 'X'

fanout_aggregate: the join to ord_ln multiplies each order's total

SELECT SUM(amount) FROM ord_hdr_legacy

deprecated_table: use ord_hdr instead

Reviewing what was inferred

  • "What in this layer has nobody reviewed?" The open claims, as questions you can answer, each with what the engine saw.

  • "Yes, cancelled orders are excluded from revenue. Record that." The verdict is written to the layer with your name on it. The agent asks for your name once and never signs for you.

  • "Save the layer to semantic/layer.yaml." It is written into your project, where a teammate can read and review it.

More in docs/mcp.md.

Related MCP server: autokg

Why

AI agents fail on real warehouses: frontier models solved just 21.3% of Spider 2.0's enterprise-warehouse tasks at publication (vs ~91% on the earlier academic Spider 1.0) โ€” and even today's best agentic scaffolds only reach ~30%. The fix is a semantic layer โ€” but every existing tool (dbt, LookML, Cube, Snowflake semantic views) makes humans write it by hand, and it goes stale the day someone runs an ALTER TABLE.

On our messy-warehouse benchmark (cryptic names, zero declared constraints, hidden business rules), an agent using the inferred layer answers 82% of business questions correctly vs 42% from the raw schema (+95% relative), with or without the layer's SQL linter โ€” and the errors it fixes are the silent kind: raw-schema "total revenue" happily sums cancelled orders; a fan-out join quietly triples a total. Full benchmark, methodology changes included, and where we DON'T help โ†’

What gets inferred

Examples from the test suite

Semantic types + roles

sts_cd โ†’ status code; tot_amt โ†’ monetary measure with sum/avg aggregations; PII flagged recall-first

Keys & joins

104/104 undeclared FKs on TPC-DS-style naming, F1 = 1.0 on our messy fixture โ€” with zero of the seeded false-FK traps accepted (statistics alone never auto-include; naming + LLM must corroborate)

Enum decodes

C=Completed, X=Cancelled โ€” joined from the decode dimension the engine itself discovered

Business rules

"these aggregate tables reconcile only when sts_cd <> 'X'" โ€” found by hypothesis-testing, scoped to revenue metrics (scope: measures), never to counts; inherited by a child fact only when its line amounts provably sum to the parent's total

Grain, SCD2, ratios

"one row per ord_id"; cust_mstr is SCD2 with eff_start_dt/eff_end_dt/is_curr_flg and an as-of join rule; avg_tot_amt_per_order = revenue / orders

SQL linting

check_sql (MCP) / semlayer lint (CLI): deterministic checks of any SQL against the layer โ€” missing required filters, fan-out sums, deprecated tables, SCD2 without a validity window, hallucinated columns, vacuous correlated subqueries โ€” each with a fix hint

Metrics, routing, deprecation

revenue/count metrics with contract-legal filters; "use ord_hdr, avoid ord_hdr_legacy (superseded)"

Descriptions

every table + column, LLM-written from evidence via join-graph context propagation, judged 0.82โ€“0.89 correct+useful by an independent model

Your docs as priors

--context ingests data dictionaries, wiki exports, CLAUDE.md files โ€” and tells you where they're wrong: doc-vs-data contradictions go to review, never silent override (guide)

Everything lands with confidence (calibrated, with the misses published), provenance (which signals produced it), and lifecycle (inferred โ†’ reviewed โ†’ certified, plus deprecated/orphaned), governed by a normative consumer contract that makes silent misuse โ€” summing across a fan-out, joining SCD2 at current-row, filtering on guessed decodes โ€” non-conforming, not merely unwise.

Cost & privacy

  • ~$0.70 per 100 tables end-to-end on the cheap model tier, with your own API key (measured cost model). LLM calls are escalation-only; ~80% of columns resolve from statistics alone.

  • Several teams, one surface: each team infers its own schema into its own file; an analyst's hub lists them as members and holds the cross-document relationships, semlayer stitch infers those through the analyst's own connection, and every command takes the hub (docs/sets.md).

  • Tiers: every table carries a tier (core, staging, raw, scratch) inferred from its name and ETL columns; raw and scratch tables are modeling: inventory_only -- listed with their shape, never joined, described, metricised or queued for review column by column. On a 2,000-table synthetic estate that is 62% of tables set aside, the review queue cut 4.4x and foreign-key precision 0.31 โ†’ 0.94 (measured).

  • --no-llm: fully deterministic mode, zero API calls, still useful (0.780 typing / 0.834 role across 7 fixtures, against 0.809 / 0.838 with the model) โ€” for orgs where LLM access needs procurement.

  • --no-sample-egress: no value read from a warehouse cell is sent to the LLM, at no net accuracy cost across our 7 fixtures (0.809 typing / 0.842 role, versus 0.809 / 0.838 with samples). Per warehouse it trades rather than being uniformly free โ€” up to a point better or worse. Re-measured 2026-10-03; see docs/cost-model.md.

  • Two knobs for speed, output identical at any value: --llm-workers N (default 4) runs that many model calls at once (typing escalation, foreign-key validation, both Describe passes; bounded by your API rate limit, measured 7.2x at 8) and --query-workers N runs that many foreign-key queries at once in your warehouse (default 4 on a network warehouse, since it spends your compute: measured 3.3x at 4 and 6.7x at 8 on BigQuery; every core on an in-process DuckDB file). --no-llm builds still use --query-workers. (measured)

  • Read-only, minimal-grant: semlayer init generates the grant script; the reader persona is proved unable to write โ€” on PostgreSQL by a test that runs in ordinary CI against a real server (tests/test_postgres.py, no credentials needed), and on Snowflake by a live suite runnable against your own account (tests/test_snowflake_live.py).

  • Model-response cache, on your disk and nowhere else: each model response is cached in semlayer/cassettes under your platform cache directory ($XDG_CACHE_HOME or ~/.cache, ~/Library/Caches on macOS, %LOCALAPPDATA% on Windows), so an interrupted whole-warehouse run resumes without paying for the same prompts twice. The files hold what the model wrote about your schema โ€” descriptions, inferred types, and the enum decodes it returned, which do quote the coded values it was shown (X=Cancelled). No credentials, no result sets, and nothing is sent to us. Switch it off with --no-llm-cache or SEMLAYER_LLM_CACHE=off, move it with SEMLAYER_LLM_CACHE=<dir>, or keep cell values out of the prompts entirely with --no-sample-egress.

  • Telemetry: anonymous usage statistics โ€” command, duration, outcome, warehouse type, bucketed table/column counts, version, OS, whether an infer was started from the CLI or from an agent, and for semlayer mcp which MCP client connected and which of our tools it called (one of seven fixed words for the client, never its own name; tool names only, never their arguments). Never names, SQL, or data. See exactly what is sent with semlayer telemetry --show; opt out with semlayer telemetry --off, or per-shell with SEMLAYER_TELEMETRY=off. (what and why)

Honest scope (beta)

  • Best on messy warehouses. On clean, well-named schemas our benchmark shows raw DDL is already sufficient โ€” we publish that negative result rather than hide it. If your warehouse is tidy TPC-DS, you may not need us.

  • ETL input: dbt (--manifest target/manifest.json) -- reads the model DAG to settle join targets statistics cannot. Catalog comments and --context docs are read as priors on every run.

  • Verify it yourself, free: ANTHROPIC_API_KEY= pytest -q replays recorded model responses, so every accuracy floor and benchmark number above is checkable with no API key and no spend โ€” including from a fork, where CI has no secrets (what those recordings are, and what is still untidy about them). The warehouses behind the numbers, with sources, pinned versions and licences, are listed in docs/warehouses.md.

  • Scale: measured to 50,000 tables, as one file or as one layer per team stitched into a hub; the largest real warehouse run so far is about 2,000. Data VOLUME is not the limit -- 4TB and 45TB are the same architecture. The ladder, and how to make it fast.

  • Warehouses: Snowflake, BigQuery, PostgreSQL, DuckDB (+ Iceberg on S3 via the DuckDB bridge). PostgreSQL also reaches Redshift and other Postgres-protocol engines, whose catalogs differ in places and are untested. Exporter: dbt (losses reported, never silent). LLM: Anthropic API (Bedrock/Vertex routing is next).

  • Not included: hosted service, ontology enrichment (it failed our own ablation gate โ€” receipts), LookML/RDF exporters.

  • The eval harness ships in this repo โ€” fixtures, gold layers, competency questions, benchmark runner. Run our numbers yourself: python fixtures/build.py && pytest tests/ -q.

Beta feedback

Running the beta? File the Beta feedback form. GitHub issues are public and permanent, so the form asks only for numbers you are happy to say out loud โ€” don't paste schema names, role names or the *.report.json the CLI writes next to your output. That file stays on your machine; it records which tables and schemas you scoped the run to, so it is yours, not ours. If you want us to see it, email hello@semlayer.dev โ€” same address for anything else sensitive.

Layout

spec/ format schema + consumer contract ยท src/semlayer/ the engine ยท fixtures/ 9 eval warehouses + golds + CQ suites ยท docs/ benchmark, cost model, spike reports ยท ARCHITECTURE.md how it works

Licence

Fair Source, not open source. The engine and CLI are FSL-1.1-ALv2: free for any internal use, including in production and CI, with no fee or key; the one prohibition is offering semlayer to third parties as a competing product or service. Every release converts to Apache-2.0 two years after it is published.

The format specification, its JSON Schemas and the exporters are Apache-2.0 โ€” a semantic layer nobody else can read is worth nothing.

Releases 0.1.0b1 through 0.4.0b5 were published under Apache-2.0 and remain so permanently. LICENSING.md has the paths table, the conversion dates, and policy text for security teams.

Available Tools

21 tools
cancel_inferA
Idempotent

Stop the inference that is running. Takes effect at the next stage.

    Call it when the user asks to stop a run `infer` started. It returns
    immediately with `cancelling`, because a run cannot be interrupted
    mid-stage; call `status` to see it end. With no run going it changes
    nothing and returns status with an `error` saying so.
    

Inputs: no named parameters. Returns: result

check_sqlA
Read-onlyIdempotent

Lint SQL against the semantic layer BEFORE it runs ANYWHERE.

    Including SQL you intend to execute with a tool that is not
    semlayer's. Deterministic checks: unknown tables/columns, correlated
    references, deprecated tables, missing required filters, fan-out
    aggregates, SCD2 joins without a validity window. These are the
    mistakes that return a NUMBER rather than an error, so an unchecked
    statement can be confidently wrong. Fix every error and warning
    (each finding carries a fix hint), then re-check. Cheap,
    deterministic, and it never touches the warehouse.
    

Inputs: sql (required), dialect. Returns: result

compile_metricA
Read-onlyIdempotent

Compile a metric to correct SQL (joins, filters, time bucketing).

    group_by: comma-separated columns. On refusal the response lists
    legal alternatives โ€” retry with those or ask the user; do NOT
    hand-assemble SQL for a refused request.

    scd: "current" or "asof", required when the join path crosses a
    history table. These are different questions โ€” a customer's segment
    now, or their segment when they ordered โ€” so ask the user which they
    meant rather than guessing.
    

Inputs: name (required), scd, filter, dialect, +5 more. Returns: result

context_for_questionA
Read-onlyIdempotent

START EVERY QUESTION ABOUT THE USER'S DATA HERE.

    Including when you are not sure a layer is loaded: if none is, this
    answers with `status` instead of failing, so there is no reason to
    decide for yourself that there is nothing to query. Deciding that
    without calling anything is how a user with a 36-table layer loaded
    was told the server had no data.

    Returns the part of the layer that bears on this question -- the
    tables it selected, their columns, keys, required filters and
    metrics, the routing knowledge for choosing between them -- plus
    `open_questions`: the claims underneath that nobody has confirmed.

    Write your SQL from this, `check_sql` it, then `run_sql`. Put the
    open questions under your answer as assumptions.
    

Inputs: question (required). Returns: result

discover_connectionsA
Read-onlyIdempotent

Which warehouses are reachable from this machine, by name.

    Reads DuckDB files in the working directory, warehouse environment
    variables, `$SEMLAYER_HOME/.env`, dbt's profiles.yml and Snowflake's
    connections.toml. Names only: no credential is read, no value that
    could be one is reported, and no connection is opened. Each entry says
    whether semlayer can open it (`supported`) and what it would need if
    not (`note`).

    requested: the warehouse the user NAMED, in their words, when it is
    not in the list -- "databricks", "our iceberg tables in s3", "redshift".
    The answer says whether semlayer opens it after all (Redshift is the
    postgres connection), and if not, the nearest route and what to tell
    them. Pass it rather than guessing: a wrong guess here is either a
    promise we cannot keep or a user sent away who did not need to be.
    

Inputs: requested. Returns: result

export_layerA
DestructiveIdempotent

Write a snapshot of the layer in another tool's format.

    path: where the user wants it written.
    target: `dbt` today. On request only, and lossy -- the result says
    what the format could not carry. Nothing keeps it in step with the
    layer afterwards and you must keep answering from the layer, never
    from the export.
    

Inputs: path (required), target (required). Returns: result

get_domainsA
Read-onlyIdempotent

List warehouse domains (table groupings) for navigation.

Inputs: no named parameters. Returns: result

get_metricsB
Read-onlyIdempotent

List defined metrics (name, measure, aggregation, filter).

Inputs: no named parameters. Returns: result

get_tablesA
Read-onlyIdempotent

List table summaries, optionally within a domain.

Inputs: domain. Returns: result

inferA

Build the semantic layer for a warehouse. Ask the user first.

    This READS THEIR WAREHOUSE -- metadata and sample values -- under the
    connection given, and on a real warehouse it takes minutes and uses
    their own LLM key, which costs them money. Ask before calling it, and
    say which warehouse you are about to model.

    connection: a uri from `status.connections`, or one the user gave.
    Omit it to use the session's.
    question: what the user actually asked. Keep it here: when the layer
    is ready, `status` reminds you to answer it, so a run that outlives
    this turn does not lose the point of itself.
    scope: schema names, comma-separated, to model only those. The way to
    make a big warehouse finish quickly.
    wait_seconds: how long to hold this call open (capped at 60). A DuckDB
    file finishes inside it and comes back `ready`, so you can answer in
    the same turn. Anything larger comes back `inferring`.
    use_llm: false for a statistics-only layer -- no descriptions, no
    decode validation, no cost, and much faster.

    While this call is open it streams progress notifications, so a
    client that renders them shows a bar. Nothing will wake you AFTER it
    returns. Tell the user that, and call `status` when they next speak.
    

Inputs: scope, use_llm, question, connection, +1 more. Returns: result

load_layerA
Idempotent

Load one of the layers status listed under layers.

    ref: the `ref` from that list, the connection it is for, or a path to
    a layer file. Returns the new status. Use it when several layers are
    on this machine and the user has said which warehouse they mean --
    and after it, tell them which one you loaded. It replaces the layer
    this session answers from and leaves every file as it was; a ref that
    cannot be loaded comes back as status with an `error`, which still
    lists `layers`.
    

Inputs: ref (required). Returns: result

review_answerA
Idempotent

Record a verdict. Takes effect immediately, and says who decided.

    key: the question's `key`, from `review_questions`.

    verdict: `accept`, `reject`, or `set:<value>` -- `review_question`
    gives the shape `set` takes.

    decided_by: `agent` if this is YOUR call, `person` if the user said
    it. Never guess this. You may accept a claim whose accept changes no
    behaviour; rejecting, setting, and accepting anything that unlocks
    behaviour are the person's, and you will be told which this is.

    by: the name to record. For a person, what they told you -- ask once
    if you do not know, never invent it, and never use your own client's
    name. For yourself, something recognisable like `claude-code/opus`.

    exclude: comma-separated object locations the verdict should skip.
    note: your reasoning, kept on the question whether or not the verdict
    was recorded. This is how you PROPOSE one you may not decide.

    If the layer is a set (a hub with members) this is refused and tells
    the user which terminal command records it, so do not promise them it
    is kept until you have the result.
    

Inputs: key (required), verdict (required), decided_by (required), by, +2 more. Returns: result

review_decisionsA
Read-onlyIdempotent

List every verdict recorded in the loaded layer, and who made it.

    Call it when the user asks what has been decided or by whom, or to
    check what an answer rests on. Each row has the verdict, where it
    applies, the date, the name recorded and a `signal`. Read `signal`:
    `agent` means nobody has confirmed it. Say so when an answer rests
    on one.

    Read-only, and it covers the whole layer the session has loaded. For
    what is still undecided, call `review_questions`.
    

Inputs: no named parameters. Returns: result

review_questionA
Read-onlyIdempotent

Fetch one open review question in full, by its key.

    Call it after `review_questions` and before `review_answer`, or
    before putting a question to the user. It adds what the list leaves
    out: every object the question covers, each with where it is, the
    claim and the evidence; what accepting or rejecting would change;
    the shape a `set:` verdict takes; and who may decide.

    Read-only. A key that is not in the queue returns an `error` and
    what to do next -- an answered question has left the queue, which is
    usually what happened.
    

Inputs: key (required). Returns: result

review_questionsA
Read-onlyIdempotent

List the open review questions in the loaded layer.

    What is uncertain in this layer, as questions you can answer. Pull
    this when the user asks what is unreviewed or unreliable. Do
    NOT walk the user through it after inference: the questions that
    matter are the ones an answer rested on, and `run_sql` hands you
    those as `assumptions`.

    tables: comma-separated, to scope it to what you are looking at.
    limit: the most to return; `truncated` says whether there were more.

    Read-only. Each question carries its `key`, the claim, what the
    engine saw, and who may decide it. `review_question` gives one in
    full, `review_answer` records a verdict, and `review_decisions` lists
    the ones already given.
    

Inputs: limit, tables. Returns: result

route_intentC
Read-onlyIdempotent

Which tables to use (and avoid) for an analytical intent.

Inputs: intent (required). Returns: result

run_sqlA
Read-onlyIdempotent

Run ONE read-only SELECT against the session's warehouse.

    `check_sql` runs first and an error means the SQL is NOT executed --
    a query that sums cancelled orders runs perfectly well, so "it ran"
    was never the standard. Warnings do not block, and come back with the
    rows because they are about whether the number means what the user
    thinks.

    Rows are capped and there is a ten-minute time limit; the cap, the
    limit and whether rows were truncated are all stated in the result,
    so you can tell the user what actually applied. Nothing is written,
    nothing is persisted, and your SQL is never rewritten: a required
    filter is reported, never silently applied.

    Refused while an inference is running -- one connection is not shared
    between the two. Ask again when `status` says `ready`.

    The result carries `assumptions` -- the unconfirmed claims the answer
    rests on. Answer the user in words first, then render those under it.
    

Inputs: sql (required). Returns: result

save_layerA
DestructiveIdempotent

Write the layer into the user's project so their team has it.

    The cache is per-machine; a file in the repository is what a
    colleague reads. From then on this session's verdicts land there.
    Ask where they want it rather than choosing for them. A file already
    at that path is replaced; a path that cannot be written comes back
    as `saved: false` with the reason.

    Refused on a set: a hub and its members are several files the user
    already chose the paths for, and one file cannot hold them.
    

Inputs: path (required). Returns: result

statusA
Read-onlyIdempotent

What this server has, what it can see, and what to do next.

    Call this first -- and always before telling a user you have no data
    about their warehouse. It answers with the loaded layer (its size, age, and
    how many claims nobody has reviewed yet), the warehouse connections
    visible from this machine, and a `next` field saying what to do --
    including when there is no layer at all, which is the state a fresh
    install is in. Read-only: it opens no warehouse connection and
    changes nothing.
    

Inputs: no named parameters. Returns: result

table_detailA
Read-onlyIdempotent

Full detail for one table: columns, keys, relationships, REQUIRED FILTERS.

Inputs: name (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelogโ€ฆ

    TDQS

    B3.4/5.0

    Scored across 21 tools

    Disambiguation3/5

    Most tools have clear distinct roles, but the entry-point tools overlap heavily: context_for_question ('START EVERY QUESTION HERE'), semantic_search ('The starting point'), route_intent, and get_domains/get_tables all compete for the same navigation job with conflicting guidance. An agent could reasonably misselect among them when beginning a question. The review_* family and the inference lifecycle tools (infer/cancel_infer/status) are cleanly separated.

    Naming Consistency4/5

    Nearly everything is consistent snake_case verb_noun (get_domains, load_layer, run_sql, check_sql, review_questions, save_layer). The only deviations are the noun-only 'status' and 'table_detail', which break the verb_noun pattern but remain readable and predictable.

    Tool Count3/5

    21 tools is at the heavy end, and while the server genuinely spans several sub-domains (connection discovery, inference lifecycle, navigation, querying/linting, review workflow, export), the navigation surface could likely be consolidated into fewer entry points. Each tool does something, but the count sits in the borderline 16-25 band.

    Completeness4/5

    Coverage is strong: discovery, inference with cancellation, navigation, SQL execution plus linting, metric compilation, a full review lifecycle (list/fetch/answer/decisions), and save/export. Minor gaps remainโ€”no way to edit or delete individual layer objects or refresh a saved layerโ€”but agents can work around these.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI agents to query live schema, lineage, and query-context across data warehouses, dbt projects, orchestration systems, and BI tools via MCP tools.
      Apache 2.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      Turns warehouse/lakehouse tables into a governed entity-relationship knowledge graph exposed through MCP, enabling AI agents to answer multi-table business questions without hard-coded SQL or large schema prompts.
      Apache 2.0
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables natural language querying of SQL databases and REST APIs through the MCP protocol, grounded in a semantic layer.
      1
      AGPL 3.0
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to query databases correctly by serving governed context over MCP, including canonical metric definitions, relationships, business meaning, and guardrails, so answers come back with resolved definitions, fired filters, freshness, and a trust score instead of guesses.
      3
      -