# semlayer (pypi · semlayer)

Infers a semantic layer from your data warehouse and serves it to agents over MCP.

- Trust score: 84/100 (high trust)
- Change this week: +18
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- pypi · `semlayer`: 84/100 (this document), [markdown](https://verifymcp.io/servers/dev-semlayer-mcp/semlayer.md), [page](https://verifymcp.io/servers/dev-semlayer-mcp/semlayer)

## Channel facts

- Registry: `pypi`
- Package: `semlayer`
- Version: `0.7.0b8`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - 2 of 41 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 87/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to semlayer-dev/semlayer).
  - License check failed: the license (FSL-1.1-ALv2) isn't a recognized OSI-approved license.
  - Actively maintained (last published 1 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 74/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 2886 tokens (~137/item across 21 items; 21 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 53/100
  - Stability observed for 16 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 21 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 22 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the semlayer MCP server?

semlayer runs locally as a PyPI package, launched with uvx --with 'semlayer[warehouses]' semlayer mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 3 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add dev-semlayer-mcp -- uvx --with 'semlayer[warehouses]' semlayer mcp
```

### Cursor

```json
{
  "mcpServers": {
    "dev-semlayer-mcp": {
      "command": "uvx",
      "args": [
        "--with",
        "semlayer[warehouses]",
        "semlayer",
        "mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "dev-semlayer-mcp": {
      "command": "uvx",
      "args": [
        "--with",
        "semlayer[warehouses]",
        "semlayer",
        "mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add dev-semlayer-mcp -- uvx --with 'semlayer[warehouses]' semlayer mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "dev-semlayer-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "--with",
        "semlayer[warehouses]",
        "semlayer",
        "mcp"
      ],
      "enabled": true
    }
  }
}
```

### Hermes

```yaml
mcp_servers:
  dev-semlayer-mcp:
    command: "uvx"
    args: ["--with", "semlayer[warehouses]", "semlayer", "mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "dev-semlayer-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "--with",
        "semlayer[warehouses]",
        "semlayer",
        "mcp"
      ]
    }
  }
}
```

### Other

```json
{
  "mcpServers": {
    "dev-semlayer-mcp": {
      "command": "uvx",
      "args": [
        "--with",
        "semlayer[warehouses]",
        "semlayer",
        "mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 84, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-20 (score 68, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-19 (score 83, +16)

- [security improvement] Malware scan: unverified → pass
- [functional] Package version: 0.7.0b7 → 0.7.0b8

### 2026-11-17 (score 67, 0)

- [security improvement] Malware scan: unverified → pass
- [functional] Package version: 0.7.0b6 → 0.7.0b7

### 2026-11-16 (score 67, −14)

- [security regression] Malware scan: pass → unverified

### 2026-11-15 (score 81, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-14 (score 66, +1)

- [security improvement] Malware scan: unverified → pass
- [functional] Package version: 0.7.0b3 → 0.7.0b6
- [functional] Package version: 0.7.0b3 → 0.7.0b5

### 2026-11-13 (score 65, −15)

- [security regression] Malware scan: pass → unverified
- [functional] Package version: 0.7.0b2 → 0.7.0b3

## MCP tools (21)

### `status` (~104 tokens)

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.

Output parameters:

- `result` (string)

### `discover_connections` (~213 tokens)

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.

Input parameters:

- `requested` (string)

Output parameters:

- `result` (string)

### `load_layer` (~89 tokens)

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.

Input parameters:

- `ref` (string, required)

Output parameters:

- `result` (string)

### `infer` (~329 tokens)

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.

Input parameters:

- `connection` (string)
- `question` (string)
- `scope` (string)
- `use_llm` (boolean)
- `wait_seconds` (integer)

Output parameters:

- `result` (string)

### `cancel_infer` (~23 tokens)

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

Output parameters:

- `result` (string)

### `context_for_question` (~176 tokens)

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.

Input parameters:

- `question` (string, required)

Output parameters:

- `result` (string)

### `run_sql` (~216 tokens)

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.

Input parameters:

- `sql` (string, required)

Output parameters:

- `result` (string)

### `review_questions` (~103 tokens)

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.

Input parameters:

- `limit` (integer)
- `tables` (string)

Output parameters:

- `result` (string)

### `review_question` (~29 tokens)

One question in full: every object it covers, and the evidence.

Input parameters:

- `key` (string, required)

Output parameters:

- `result` (string)

### `review_answer` (~293 tokens)

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

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.

Input parameters:

- `by` (string)
- `decided_by` (string, required)
- `exclude` (string)
- `key` (string, required)
- `note` (string)
- `verdict` (string, required)

Output parameters:

- `result` (string)

### `review_decisions` (~44 tokens)

Every verdict in this layer and who stands behind each one.

Read `signal`: `agent` means nobody has confirmed it. Say so when an
answer rests on one.

Output parameters:

- `result` (string)

### `save_layer` (~99 tokens)

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.

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.

Input parameters:

- `path` (string, required)

Output parameters:

- `result` (string)

### `export_layer` (~86 tokens)

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

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.

Input parameters:

- `path` (string, required)
- `target` (string, required)

Output parameters:

- `result` (string)

### `semantic_search` (~29 tokens)

Search tables, columns, and metrics by keywords. The starting point.

Input parameters:

- `query` (string, required)

Output parameters:

- `result` (string)

### `get_domains` (~19 tokens)

List warehouse domains (table groupings) for navigation.

Output parameters:

- `result` (string)

### `get_tables` (~24 tokens)

List table summaries, optionally within a domain.

Input parameters:

- `domain` (string)

Output parameters:

- `result` (string)

### `table_detail` (~31 tokens)

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

Input parameters:

- `name` (string, required)

Output parameters:

- `result` (string)

### `get_metrics` (~20 tokens)

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

Output parameters:

- `result` (string)

### `route_intent` (~29 tokens)

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

Input parameters:

- `intent` (string, required)

Output parameters:

- `result` (string)

### `check_sql` (~144 tokens)

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.

Input parameters:

- `dialect` (string)
- `sql` (string, required)

Output parameters:

- `result` (string)

### `compile_metric` (~181 tokens)

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.

Input parameters:

- `calendar` (string)
- `dialect` (string)
- `filter` (string)
- `group_by` (string)
- `name` (string, required)
- `scd` (string)
- `time_end` (string)
- `time_grain` (string)
- `time_start` (string)

Output parameters:

- `result` (string)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/dev-semlayer-mcp/semlayer#diagnostics

## Score history

- 2026-11-21: 84
- 2026-11-20: 68
- 2026-11-19: 83
- 2026-11-18: 67
- 2026-11-17: 67
- 2026-11-16: 67
- 2026-11-15: 81
- 2026-11-14: 66
- 2026-11-13: 65
- 2026-11-12: 80
- 2026-11-11: 64
- 2026-11-10: 79
- 2026-11-09: 78
- 2026-11-08: 78
- 2026-11-07: 78
- 2026-11-06: 77
- 2026-11-05: 62

## Common questions

### What is the semlayer MCP server?

semlayer is an MCP server listed in the public MCP registry as dev.semlayer/mcp. Infers a semantic layer from your data warehouse and serves it to agents over MCP. This page covers its PyPI package (semlayer).

### Is the semlayer MCP server safe to use?

semlayer scores 84 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the semlayer MCP server expose?

semlayer exposes 21 tools: status, discover_connections, load_layer, infer, cancel_infer, and 16 more. Their descriptions and schemas cost roughly 2,281 tokens of context every time the server is loaded.

### Is the semlayer MCP server still maintained?

semlayer is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the semlayer MCP server under?

semlayer declares the FSL-1.1-ALv2 licence, which is not on the OSI-approved list. Read the terms before using it at work, and note this covers the source only, not the cost of any service it calls.

### What did VerifyMCP test on the semlayer MCP server?

VerifyMCP ran 16 checks on semlayer, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/semlayer/
- Socket report: https://socket.dev/pypi/package/semlayer
- Repository: https://github.com/semlayer-dev/semlayer
- Website: https://semlayer.dev/
- Changelog RSS feed: https://verifymcp.io/servers/dev-semlayer-mcp/semlayer.xml
- Changelog JSON feed: https://verifymcp.io/servers/dev-semlayer-mcp/semlayer/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/dev-semlayer-mcp/semlayer.json
- HTML version of this page: https://verifymcp.io/servers/dev-semlayer-mcp/semlayer
