MCP-delivered · free for individuals
Everyone's context — not someone's catalog.
Stop re-explaining your data to your AI every session. Connect Claude Code, Cursor, or Codex with a context key, or claude.ai over OAuth. Your agent recalls your context before it writes SQL. Mismatches surface as a caveat so you and your agent know what to trust.
Personal context is free and unmetered. No credit card required.
Works inside the coding agents you already use. Claude Code · Cursor · Codex · claude.ai
See it work inside the agent
One command to connect. Then your agent recalls the definition you saved, runs the query with its own warehouse access, and reconcile flags what to treat with care.
saved context · returned by recall
Reenactment of the real loop — the same recall → reconcile → caveat flow the MCP runs today. Your agent keeps its own warehouse access; ClariLayer never holds your warehouse credentials and never runs SQL server-side.
Connect your AI
Start free with Claude Code, Cursor, or Codex using a context key, or add ClariLayer as a custom claude.ai Connector and approve over OAuth. After signup, choose one real rule to save and try it in an agent question. No credit card required.
Ask Claude Code to set it up
Copy this prompt and paste it into Claude Code. Your AI will help you set up the connection and check it. You may need to complete a browser sign-in or restart your AI.
Connection status updates only after ClariLayer receives a successful health check.
Help me connect ClariLayer to Claude Code.
This prompt authorizes connection setup only. Do not upload or bootstrap any context, call write tools, or create or edit project instruction files. Do not claim that copying this prompt or writing configuration means the connection works.
Connection details:
- Server name: `clarilayer`
- Transport: remote MCP over Streamable HTTP
- URL: https://app.clarilayer.com/api/mcp/mcp
Preserve all unrelated client configuration. Inspect through the client's settings or a private local helper that emits only the server-present, transport-matches, and URL-matches booleans. Never read an entire config into chat or emit raw config, CLI output, headers, or token values. If a server named `clarilayer` already exists, do not overwrite, remove, rename, or duplicate it. Compare its transport and URL with the details above, report any difference, and ask me before making a narrowly scoped update through the client's supported settings.
Prefer OAuth when this client exposes a compatible login flow. ClariLayer OAuth has not been verified end to end for every client, so do not promise it will be available. If OAuth is unavailable and this client supports secure bearer-token, API-key, or Authorization-header configuration, tell me to create or copy a ClariLayer context key and enter it directly in that secure client field. Never ask me to paste, send, or repeat the key in this chat, and never place it in chat text, command history, logs, screenshots, or project files.
For Claude Code, inspect the existing MCP entry first. If no `clarilayer` entry exists and you can run the local CLI, add it with `claude mcp add --transport http clarilayer https://app.clarilayer.com/api/mcp/mcp`. Then use Claude Code's `/mcp` flow to authenticate when OAuth is offered. If you cannot operate the local CLI, guide me through the same steps.
After setup, tell me if the client needs a refresh or restart. Verify only with read-only MCP tool discovery and then `clarilayer__health`. Report the connection as working only after the health call succeeds. If you cannot access connector settings or tools from this session, give me the exact UI or CLI steps I must perform and wait for me to report the result.Run in your terminal
claude mcp add --transport http clarilayer https://app.clarilayer.com/api/mcp/mcp --header "Authorization: Bearer cl_YOUR_CONTEXT_KEY"Replace cl_YOUR_CONTEXT_KEY with the context key you mint in ClariLayer. The key is shown once at creation, so paste it straight into the command above. Keep it out of prompts, tickets and screen recordings.
This Claude Code prompt targets only CLAUDE.md. Paste it into that local agent. The agent inspects one file and asks before editing. An already-current or conflict decision, or an approved write, reports installed, already current, or conflict/manual review; declined approval stops without claiming an installation state. Copying it here does not edit your repository.
Install or update ClariLayer's managed instructions for Claude Code.
ClariLayer's browser and remote MCP server have not edited any local file. You are the local agent performing this repository-local inspection. The user's act of pasting this scoped update prompt authorizes a safe create or replacement limited to the recognized ClariLayer managed range or an exact published legacy block in the one target below. Do not ask for redundant approval for that safe case. An ambiguous, malformed, or hand-edited legacy conflict requires an exact one-file diff and explicit confirmation before any change.
1. Call the ClariLayer MCP tool `get_project_stanza` with `mode: "full"`. Use its structured `managed_block`, `managed_block_template`, `managed_instance`, `legacy_stanza`, `legacy_stanzas`, `legacy_managed_blocks`, `append_once_sentinel`, `client_targets`, and `managed_apply_guidance` fields exactly; do not recreate or paraphrase their contents.
2. Select only the `claude-code` descriptor and confirm that it names exactly `CLAUDE.md`. If the descriptor or the pinned metadata below differs, change nothing and report `conflict/manual review`.
3. Inspect exactly `CLAUDE.md`. Do not inspect or modify any other project instruction target.
4. This selected target has no required preamble.
5. No authenticated project report scope was supplied. Use managed_block as target_managed_block and do not invent instance metadata.
6. If the selected target already contains a range byte-identical to target_managed_block, change nothing and report `already current`.
7. If the current target contains one exact published v1/v2/v3 managed range, replace only that range with target_managed_block. Do not remove or rebind an exact scoped current-v4 range without authenticated project report scope; leave it unchanged, report `conflict/manual review`, and guide the user to the signed-in Connect update path. If it contains one exact legacy_stanza or legacy_stanzas item, replace only those exact bytes. A normal new install or these safe replacements are already authorized by this prompt: preserve every byte outside the selected range and do not ask again.
8. If legacy heading text is present but no exact legacy block matches, or a managed range is hand-edited, unknown/newer, malformed, or ambiguous, change nothing. Show the complete exact one-file proposed diff with no elision and ask for confirmation; without confirmation report `conflict/manual review`. Never silently downgrade an unknown/newer range.
9. Translate the canonical guidance's internal `already-current` label to `already current`, and `conflict/manual-review` to `conflict/manual review`. After an authorized create or replacement, report `installed`. Report exactly one terminal state with no alternate spelling: `installed`, `already current`, `conflict/manual review`.
10. Before any write, retain the exact bytes before and after the selected range. After the write, re-read the complete selected target. Report `installed` and submit a local attestation only if the installed range equals target_managed_block, carries the pinned version/hash and no instance metadata, and every surrounding byte is unchanged. If verification fails, report `conflict/manual review` and do not attest installation.
11. No authenticated project report scope was supplied. Do not call sync_instruction_setup or invent project/installation identifiers; report only the local terminal state.
Selected target: CLAUDE.md
Managed protocol version: 4
Managed payload hash: sha256:2a549743ee65b0cc81e8bd57cc30cf437fd30278f1780730616448fd3ac83a0d
Managed begin marker: <!-- BEGIN CLARILAYER MANAGED INSTRUCTIONS -->
Managed end marker: <!-- END CLARILAYER MANAGED INSTRUCTIONS -->
This target has no required preamble. Do not invent one.
Canonical fail-safe guidance:
Select exactly one client target; never touch more than one instruction file. target_managed_block means managed_block_template with only its four typed placeholders filled from the explicit Connect report scope and locally computed refs; without that scope it means the generic managed_block. For Cursor, if the selected target already exists, require its exact required_preamble before any already-current, append, or replacement decision; otherwise return conflict/manual-review and change nothing. If that target contains exactly one well-formed managed range with the published begin marker before the end marker, compare the entire range: when it is byte-identical to target_managed_block return already-current and change nothing. During an explicit scoped Connect update, an exact generic managed_block or an exact current-v4 range carrying only the four recognized typed instance metadata lines may be rebound by replacing only that range with target_managed_block. When it is byte-identical to one legacy_managed_blocks item replace only that marked range. Any other well-formed range, including a hand-edited or unknown/newer version, is conflict/manual-review: show the complete exact one-file replacement diff and require confirmation before replacing it. Duplicate, nested, reversed, or unmatched markers are conflict/manual-review: change nothing. With no managed marker, replace only a byte-identical legacy_stanza or one exact legacy_stanzas item. If append_once_sentinel exists but the full legacy bytes differ, return conflict/manual-review and change nothing. If neither markers nor the legacy sentinel exists, append target_managed_block during an explicit scoped Connect update, otherwise append managed_block, to an existing Claude Code or Codex target, or create the selected target with the same selected block. For Cursor, create the target with its exact required_preamble, a blank line, then that selected block. An unscoped update must not remove or rebind a recognized scoped current-v4 range. Before a write, retain the exact surrounding bytes. After a write, re-read the selected target and require the current managed range, version and hash plus byte-identical surrounding content before reporting installed or attesting the result. Never edit bytes outside the recognized managed range or exact legacy block, never delete unrelated content, and never claim the server or browser edited a file.The browser and remote server did not edit a file.
Use this only for an early ClariLayer section that kept the old heading but was shortened or edited. The standard installer above remains the default and safely sends that state to manual review. Copying this opt-in recovery prompt only hands instructions to your selected local agent; the browser and remote server have not read or edited your repository.
Recover one older shortened ClariLayer section in Claude Code's project instructions.
This is a separate, opt-in guided legacy migration. The normal managed installer must remain fail closed for edited legacy text. ClariLayer's browser and remote MCP server have not read or edited this repository; you are the selected local agent, and only you may inspect or change the one target below after explicit approval.
Follow this algorithm exactly:
1. Call the ClariLayer MCP tool `get_project_stanza`. Use its structured `managed_block`, `managed_version`, `managed_hash`, `managed_markers`, and `client_targets` fields exactly; never recreate, paraphrase, or partially copy `managed_block`. Select only the `claude-code` descriptor. Require its `client` to be `claude-code`, its `target_file` to be `CLAUDE.md`, and its `required_preamble` to be null. Require all returned version, hash, and marker metadata to match the pinned values below, and require `managed_block` to carry those exact markers and metadata. Any mismatch is unsafe.
2. Read the entire byte content of exactly `CLAUDE.md`. Do not inspect or modify any other project instruction target. The browser and remote server have not performed this read or any write.
3. Recovery is eligible only if every condition below is true:
- No managed begin marker or managed end marker occurs anywhere in the file.
- The exact line `## ClariLayer — your data context layer (use it proactively)` occurs exactly once in the whole file, and that sole occurrence is a real Markdown H2 heading outside every backtick or tilde fenced code block. Heading-shaped text inside fenced code is not eligible.
- The candidate section is unambiguously bounded from the first byte of that H2 heading through immediately before the next real Markdown H1 or H2 heading outside fenced code, or through EOF when no later H1/H2 exists.
- Preserve the exact separator at that boundary instead of consuming it. Before a following heading, take the maximal contiguous whitespace-byte suffix immediately preceding that heading, require it to contain at least one complete line ending, and keep that suffix outside the replacement range so the following heading remains at the start of its original line. At EOF, likewise keep any maximal trailing whitespace-byte suffix that contains the file's final line ending outside the replacement range; if there is no final line ending, preserve the no-trailing-newline state. These preserved bytes are not part of `managed_block` and must not be normalized.
4. Fail closed on any unsafe state. A missing or duplicate exact heading, a heading that exists only inside fenced code, an unterminated or ambiguous fence, an ambiguous section boundary or boundary separator, any complete/malformed/partial/duplicate/nested/reversed managed marker, any selected-target or pinned-metadata mismatch, or any other uncertainty means: change nothing, report `conflict/manual review`, and recommend manual review. Never append `managed_block` over the legacy section.
5. Before writing, show the exact full one-file replacement diff for `CLAUDE.md`: the complete bounded candidate replacement range removed and the complete canonical `managed_block` added, while every preserved boundary or trailing suffix byte appears as unchanged context, with no elision, summary, or truncation. Ask for explicit approval of that exact diff. If approval is declined, write nothing and claim no terminal installation state.
6. Immediately before any approved write, re-read the whole file as bytes and require byte-for-byte equality, including line endings, with the bytes used to produce the shown diff. If any byte changed concurrently, stop without writing and report `conflict/manual review`.
7. After approval, replace only the bounded candidate replacement range with the returned canonical `managed_block`. Preserve every byte before and after that range, including the exact boundary/trailing suffix isolated in step 3, unrelated content, whitespace, line endings, and the existing trailing-newline state. Never synthesize a separator by altering `managed_block`; retain the original separator outside it. Do not modify another instruction target.
8. Re-read the whole target after the write. Verify that the inserted managed range is byte-identical to `managed_block`; the pinned begin and end markers each occur exactly once and in that order; the installed version and hash match both the returned and pinned values; the exact old heading is gone; and every byte outside the replaced range is unchanged. Only after every check passes, report the existing terminal state `installed` and a separate supplemental receipt/detail exactly `guided legacy migration`. Do not create a new terminal state. If any verification fails, report it honestly and never call the result `installed`.
Selected recovery client: claude-code
Selected target: CLAUDE.md
Required preamble: null
Exact legacy H2: ## ClariLayer — your data context layer (use it proactively)
Managed protocol version: 4
Managed payload hash: sha256:2a549743ee65b0cc81e8bd57cc30cf437fd30278f1780730616448fd3ac83a0d
Managed begin marker: <!-- BEGIN CLARILAYER MANAGED INSTRUCTIONS -->
Managed end marker: <!-- END CLARILAYER MANAGED INSTRUCTIONS -->The browser and remote server did not edit a file.
Our own evidence
In our internal paired evaluation—three batteries, 38 pre-registered data questions—the agent scored 36/38 with ClariLayer connected and 26/38 without.
These are results from our evaluation, not an independent benchmark or a guarantee for every task.
Anthropic (June 2026) reported analytics-agent accuracy moving from 21% to 95%+ with context and skills.
dbt (April 2026) reported 64.5% for raw text-to-SQL, with semantic-layer approaches reaching 98–100% on covered questions.
Gartner (March 2026) projected that 60% of agentic-analytics projects relying solely on MCP would fail without a consistent semantic layer.
These organizations studied the category. They did not measure ClariLayer.
Product illustration: a saved rule carries its source and trust posture.
Your context layer
Active customer
Definition · you → reconciled
Net revenue (excl. refunds)
Definition · from dbt
orders.region — null before 2023
Schema note · you → reconciled
fct_orders ↔ dim_customers join
Join path · you
Reconciled against your source — not blindly asserted.
FAQ
What ClariLayer can see, what it doesn't touch, what's free, and what “reconciled” actually means.
Create your account, connect your AI, and save one real rule. Personal context is free and unmetered. No credit card required.
Connect your AIWe use privacy-friendly analytics
With your consent we use PostHog and Vercel Analytics to understand how ClariLayer is used so we can improve it. We never sell your data. Errors are always monitored (without analytics) so we can keep the app reliable. You can change your mind anytime.