Chat & agents over your data · Verified · Runs in your infrastructure

Answers your AI can actually trust — from every database you run.

Ask your data in plain language and get answers that are permission-checked, audited, and traced to the exact source rows — across SQL and NoSQL alike. Nothing is copied out; your data and credentials never leave your systems.

30+ databases · SQL, NoSQL & vector
No ETL, no replication
Zero data leaves your firewall
Why did revenue drop last quarter?
SELECT segment, SUM(total_amount) AS revenue FROM orders WHERE created_at >= '2026-01-01' GROUP BY segment ORDER BY revenue DESC;
every number traced to its source rows — or Datalic abstains
~98%
Query accuracy with a governed semantic layer (vs ~30% raw)
30+
Databases spoken natively — SQL, NoSQL & vector
0
Fabricated numbers reach the user
Never
Credentials or raw data leave your systems
Why Datalic

Putting AI on your data breaks in three predictable ways.

Every team wiring an LLM to their databases hits the same walls. Datalic is built to remove all of them at once.

Wrong

It makes up numbers

On real schemas, LLMs return a plausible-but-wrong answer more often than not — and serve it confidently. One bad figure in front of a decision-maker and trust in the whole tool is gone.

Narrow

It only speaks SQL

Your business doesn't run on SQL alone. MongoDB, Elasticsearch, Neo4j, Redis, DynamoDB — most tools can't even connect, let alone answer across them.

Unsafe

It's a security risk

Handing an agent a raw database connection means over-privileged access, prompt-injection exposure, and no record of who asked what. Security teams block it.

How it works

We write the query. Your infrastructure runs it.

The intelligence runs in Datalic's cloud. Every query executes inside your own environment, right next to your database — so your data and credentials never leave your walls. One secure, outbound channel connects the two.

Datalic Cloud — the brain

Understands the question, writes the query

  • Maps plain language to your business terms and each database's schema
  • Generates the right native query per dialect — one governed step at a time
  • Never holds a credential and never connects to your database — by construction
Your environment — the runtime

Executes, governs, and verifies

  • Runs inside your firewall; credentials stay local, in memory, next to the DB
  • Enforces your access policy — mask, deny, row-scope — before anything is shared
  • Verifies every number, then returns a governed attestation — not your raw rows

Only the question, the governed result summaries, and the verified answer cross the wire. Nothing is replicated, nothing is stale, and there's no second copy of your data to secure.

The moat — verification

Every number is bound to the row it came from.

Datalic recomputes derived figures against the real cells and traces each one to its source. If a number can't be traced, it isn't shown — Datalic abstains instead of guessing. It's the one thing text-to-SQL tools can't attest.

Answer
Paid revenue is $4,402.25 — 79% of the $5,590.75 total.
──── traced to ───▶
✓ Source rows · orders
statusrevenue
paid4,402.25
refunded739.50
pending449.00

Abstentions are free. The verified answer is your audit trail, your billing meter, and the reason a security team finally says yes.

Security & governance

Governed by construction — safe enough for a security team to approve.

One access policy and one audit trail across every database. The brain can't reach your data even if it wanted to; the runtime enforces every rule locally, and fails closed.

RO

Read-only by default

The agent reads; it can't write, drop, or run a runaway query. Writes are an explicit, reversible, confirm-gated exception.

AP

Per-object access policy

Grant read/write/none per table, mask sensitive columns, and row-scope to the caller — enforced in your runtime, fail-closed. A token can only ever narrow access, never widen it.

AU

Full audit trail

Every request records who asked, in which role, and the exact native query that ran — one governed record across your whole database fleet.

MT

Multi-tenant isolation

One connection serves many of your end-users, each row-scoped to only their own data — the subject is stamped from a verified token, never from model output.

# the same policy the runtime enforces, before any result is shared customers → read · mask email, phone · rows where tenant_id = :subject orders → read · rows where tenant_id = :subject audit_log → deny # invisible to this role salaries → deny
Semantic Studio

Teach it your business — then let it draft the rest.

Datalic profiles each database and drafts a semantic contract: your entities, metrics, joins, time grains, and rules. In Semantic Studio, a human approves, edits, or rejects each AI suggestion — approved definitions are pinned and survive re-profiling. That's the jump from ~30% raw text-to-SQL to ~98% governed accuracy.

  • AI-drafted, human-approved. Every metric and join comes with a confidence score and a reason. You stay in control of what "revenue" means.
  • One contract, everywhere. The definitions you approve are what the brain generates against and the runtime enforces — meaning and security in one place.
  • A verified example library. Approved question↔query pairs teach the system your patterns — the retrieval layer that keeps accuracy climbing.
Semantic Studio · Suggestions◆ AI-drafted
Metric
Net Revenue
SUM(orders.total_amount) − SUM(refunds.amount)
confidence 0.94refunds join inferred
Join
orders → customers
orders.customer_id = customers.id · many-to-one
confidence 0.99
Capable, not just safe

Far more than "ask a question, get a chart."

Datalic runs the full analytical loop — governed and verified at every step.

Ask

Natural-language answers

Questions across one database or many, returned as a number, a table, or a chart — every figure verified.

Analyze

Deep, multi-step analysis

Cohorts, retention, forecasting, anomaly investigation — the brain plans the hypotheses, your runtime executes them.

Join

Cross-database answers

Combine Postgres orders, Mongo events, and Elasticsearch tickets in one question — pooled locally, never a raw-row export.

Prepare

Clean & transform data

Audit quality, propose a reversible cleanup recipe, preview the diff, and apply on confirmation — with an undo token.

Report

Professional reports

Full multi-section reports as Markdown, HTML, or Word — with professional charts, rendered locally from the governed result.

Localize

Speaks your language

Ask in any language; Datalic answers in the same one. Verified numbers stay identical — a fast path to every market.

For developers

Embed a verified data layer in a few lines.

A stateless SDK runs inside your firewall and dials out to the brain — in Python, JavaScript/TypeScript, Java, Go, or C#. Install one package, add your client credentials, ask. Also available as an MCP server and a browser embed.

  1. Install the SDK with the driver for your database.

    Every database is its own extra — pull only what you use.

  2. Authenticate with client credentials from the console.

    Exchanged for a short-lived token; no raw key ever crosses the wire.

  3. Ask — the brain plans, your runtime executes.

    One governed step at a time, enforced and verified locally.

  4. Render the verified answer as a report.

    Markdown, HTML, or Word — charts and tables, drawn from the governed result.

# pip install "datalic-sdk[postgresql]"
from datalic_sdk import Runtime, BrainStepClient, ClientCredentials, ConsoleClient
from datalic_sdk.report import save_report

creds = ClientCredentials(client_id, client_secret, console_url)

# runs inside your firewall — credentials stay local, in memory
runtime = await Runtime.from_env(
    connections=["postgresql-shop", "mongodb-events"],
    console=ConsoleClient(creds),
)

client = BrainStepClient("https://api.datalic.ai", creds)
final  = await client.run(
    "Why did revenue drop last quarter?",
    connections=["postgresql-shop", "mongodb-events"],
    executor=runtime.executor,
)

# a verified report — every figure traced to its source
save_report(final["envelope"], "report.html")
// npm install @datalic/sdk
import { Runtime, BrainStepClient, ClientCredentials, ConsoleClient } from "@datalic/sdk";
import { saveReport } from "@datalic/sdk/report";

const creds = new ClientCredentials(clientId, clientSecret, consoleUrl);

// runs inside your firewall — credentials stay local, in memory
const runtime = await Runtime.fromEnv({
  connections: ["postgresql-shop", "mongodb-events"],
  console: new ConsoleClient(creds),
});

const client = new BrainStepClient("https://api.datalic.ai", creds);
const final = await client.run("Why did revenue drop last quarter?", {
  connections: ["postgresql-shop", "mongodb-events"],
  executor: runtime.executor,
});

// a verified report — every figure traced to its source
saveReport(final.envelope, "report.html");
// implementation "ai.datalic:datalic-sdk:1.0.0"
ClientCredentials creds = new ClientCredentials(clientId, clientSecret, consoleUrl);

// runs inside your firewall — credentials stay local, in memory
Runtime runtime = Runtime.fromEnv(
    List.of("postgresql-shop", "mongodb-events"),
    new ConsoleClient(creds));

BrainStepClient client = new BrainStepClient("https://api.datalic.ai", creds);
TurnResult result = client.run(
    "Why did revenue drop last quarter?",
    List.of("postgresql-shop", "mongodb-events"),
    runtime.executor());

// a verified report — every figure traced to its source
Report.save(result.envelope(), "report.html");
// go get github.com/datalic-ai/datalic-sdk-go
creds := datalic.NewClientCredentials(clientID, clientSecret, consoleURL)

// runs inside your firewall — credentials stay local, in memory
runtime, _ := datalic.RuntimeFromEnv(ctx,
    []string{"postgresql-shop", "mongodb-events"},
    datalic.NewConsoleClient(creds))

client := datalic.NewBrainStepClient("https://api.datalic.ai", creds)
final, _ := client.Run(ctx,
    "Why did revenue drop last quarter?",
    []string{"postgresql-shop", "mongodb-events"},
    runtime.Executor())

// a verified report — every figure traced to its source
datalic.SaveReport(final.Envelope, "report.html")
// dotnet add package Datalic.Sdk
var creds = new ClientCredentials(clientId, clientSecret, consoleUrl);

// runs inside your firewall — credentials stay local, in memory
var runtime = await Runtime.FromEnvAsync(
    new[] { "postgresql-shop", "mongodb-events" },
    new ConsoleClient(creds));

var client = new BrainStepClient("https://api.datalic.ai", creds);
var final = await client.RunAsync(
    "Why did revenue drop last quarter?",
    new[] { "postgresql-shop", "mongodb-events" },
    runtime.Executor);

// a verified report — every figure traced to its source
Report.Save(final.Envelope, "report.html");
SDK · Python · JavaScript · Java · Go · C#  |  @datalic/embed · browser  |  MCP server · Claude, GPT & Gemini query your data through the same governed door
Ship it two ways

Turn your product into chat — and agents — over your data.

The same governed, verified core, delivered two ways: embedded in your app for your users, or over MCP for any AI agent. Every answer permission-checked and traced to its source.

Embed in your product

Chat with your data. Agentic with your data.

Drop a verified chat-and-agent experience over your customers' data into your app in a few lines. Ask mode for instant answers; agent mode for multi-step analysis, cross-database joins, data prep, and full reports. Your UI, your brand, unlimited end-users — every number verified.

// a verified chat + agent widget, in your app <DatalicChat subject={user.id} mode="agent" /> // or call it directly const a = await dc.ask("Top 5 products by revenue", { subject, verify: "strict" });
<DatalicChat> · ask & agent mode · report renderers · @datalic/embed
Connect any AI agent · MCP

Let Claude, GPT, or your own agent query your data — safely.

Expose your databases as governed MCP tools. One tools/call → Datalic writes the native query, enforces your access policy, verifies every number, and returns the answer. The agent plans; your runtime executes; it never sees a credential or a raw row.

// any MCP host — Claude Desktop, Cursor, your agent { "datalic": { "command": "datalic-mcp", "env": { "DATALIC_API_KEY": "dlc_live_…" } } } // tools: ask · exec · describe · prep …
Claude · Cursor · GPT · Gemini · your own agent
Native execution

One question, answered where your data lives.

No ETL, no warehouse to feed, no copy into our cloud. Datalic speaks each database's own query language — including the NoSQL and vector stores SQL-only tools can't reach.

PostgreSQLMongoDBElasticsearchNeo4jRedisMySQLSQL ServerOracleSnowflakeBigQueryRedshiftDatabricksClickHouseTrinoDuckDBSQLiteDynamoDBOpenSearchInfluxDBPineconeQdrantWeaviateAthenaMariaDBCockroachDB
SQL family · Warehouses · Document & search · Graph · Key-value · Vector · Time-series
Deploy your way

Cloud-managed, hybrid, or fully self-hosted.

Cloud-managed

We host the brain; your runtime lives in your app. Fastest to start, nothing to operate.

✓ data still never leaves you
Hybrid

Our cloud brain, your execution — the default. Intelligence managed, data local.

✓ the standard deployment
Self-hosted / air-gapped

Run the whole stack in your VPC or on-prem with a Helm chart. Bring your own model.

✓ highest margin · zero egress
Pricing

A platform fee, plus verified answers.

Never raw tokens. A credit is one verified answer — and abstentions are free. Bring your own model key to drop the usage cost to near zero.

Embedded SDK
$500/mo · per tenant
Ship "ask your data" inside your product. Unlimited end-users.
  • Per-tenant connections, unlimited viewers
  • BYOK by default — heavy usage never eats margin
  • Access policy, masking, row-scope per tenant
  • The <DatalicChat> embed + renderers
Start free
Agent Data Layer
$2,500/mo + credits
The governed door for your AI agents and MCP hosts.
  • ~25k verified answers/mo included
  • Managed credits (~2× cost) or BYOK
  • MCP server + cross-database answers
  • Full audit trail + usage dashboard
Get a demo
Enterprise · self-host
Annual license
Run the whole stack in your own cloud or air-gapped.
  • BYOK / local model — COGS near zero
  • Unlimited answers, SSO, support + SLA
  • Helm chart, VPC / on-prem deploy
  • Security review + design partnership
Talk to us
✓ You pay only for answers Datalic verified — abstentions are free.
Get started

See Datalic catch a wrong number — live.

Bring a real schema. We'll wire two databases and show you a verified, cross-database answer — with every figure traced to its source, and the audit log of exactly what ran — in about ten minutes.