semlayer MCP server
Use this MCP server to infer, inspect, query against, review, and persist a semantic layer for your warehouse, with SQL safety checks and metric compilation.
Check server/layer status and discover reachable warehouses by name without opening connections or reading credentials.
Load a specific layer from the status list, a connection name, or a layer file.
Infer/build a semantic layer from a warehouse, optionally scoped to schemas, with or without LLM use; ask the user first because it reads the warehouse and may cost money.
Cancel an in-progress inference.
Get question-specific context: relevant tables, columns, keys, required filters, metrics, routing knowledge, and unresolved assumptions.
Search and navigate the layer by keyword, domains, tables, table details, metrics, and intent routing to use/avoid tables.
Lint SQL before running it anywhere: unknown tables/columns, deprecated tables, missing required filters, fan-out aggregates, SCD2 validity issues, and more.
Run one read-only SELECT against the session warehouse, with check_sql first, row/time limits, and returned assumptions.
Review inferred claims: list and fetch open questions, record accept/reject/set verdicts with attribution, and list decisions.
Save the layer into the user's project and export a snapshot to another format, currently dbt (lossy).
Compile metrics to correct SQL with filters, group-by, time grains, date ranges, SCD current/as-of handling, and fiscal/calendar choice.
Enables export of the inferred semantic layer to dbt YAML format for integration into dbt projects.
Allows the server to connect to DuckDB warehouses (including Iceberg on S3) for schema inference and semantic layer generation.
Allows the server to connect to Snowflake warehouses, infer schema, foreign keys, business rules, and generate a semantic layer.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@semlayer MCP server What was our revenue last month, excluding cancelled orders?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.
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.yamlFrom 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 |
|
|
|
|
|
|
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 |
|
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 |
|
Business rules | "these aggregate tables reconcile only when |
Grain, SCD2, ratios | "one row per ord_id"; |
SQL linting |
|
Metrics, routing, deprecation | revenue/count metrics with contract-legal filters; "use |
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 |
|
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
membersand holds the cross-document relationships,semlayer stitchinfers 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 aremodeling: 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 Nruns 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-llmbuilds still use--query-workers. (measured)Read-only, minimal-grant:
semlayer initgenerates 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/cassettesunder your platform cache directory ($XDG_CACHE_HOMEor~/.cache,~/Library/Cacheson 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-cacheorSEMLAYER_LLM_CACHE=off, move it withSEMLAYER_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
inferwas started from the CLI or from an agent, and forsemlayer mcpwhich 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 withsemlayer telemetry --show; opt out withsemlayer telemetry --off, or per-shell withSEMLAYER_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--contextdocs are read as priors on every run.Verify it yourself, free:
ANTHROPIC_API_KEY= pytest -qreplays 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 toolscancel_inferAIdempotent
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_sqlARead-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_metricARead-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_questionARead-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_connectionsARead-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_layerADestructiveIdempotent
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_domainsARead-onlyIdempotent
List warehouse domains (table groupings) for navigation.
Inputs: no named parameters. Returns: result
get_metricsBRead-onlyIdempotent
List defined metrics (name, measure, aggregation, filter).
Inputs: no named parameters. Returns: result
get_tablesARead-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_layerAIdempotent
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_answerAIdempotent
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_decisionsARead-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_questionARead-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_questionsARead-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_intentCRead-onlyIdempotent
Which tables to use (and avoid) for an analytical intent.
Inputs: intent (required). Returns: result
run_sqlARead-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_layerADestructiveIdempotent
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
semantic_searchBRead-onlyIdempotent
Search tables, columns, and metrics by keywords. The starting point.
Inputs: query (required). Returns: result
statusARead-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_detailARead-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
Scored across 21 tools
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.
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.
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.
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
Related MCP Connectors
Query your warehouse or a CSV with Claude/ChatGPT over MCP, governed by table-level ACL + audit.
The AI that understands raw data: Schema over your tables and databases, as MCP tools.
Query your org's data in natural language โ read-only MCP access to SQL, NoSQL, files & warehouses.
Build a semantic layer of reusable metrics and query it in plain words. Share models with your team.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables 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
- AlicenseNot gradedqualityDmaintenanceTurns 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

Atlas MCPofficial
AlicenseNot gradedqualityAmaintenanceEnables natural language querying of SQL databases and REST APIs through the MCP protocol, grounded in a semantic layer.1AGPL 3.0- FlicenseNot gradedqualityBmaintenanceEnables 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-