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.
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.
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.
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.
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.
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.
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
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.
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.
| status | revenue |
|---|---|
| paid | 4,402.25 |
| refunded | 739.50 |
| pending | 449.00 |
✓Abstentions are free. The verified answer is your audit trail, your billing meter, and the reason a security team finally says yes.
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.
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.
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.
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.
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.
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.
Far more than "ask a question, get a chart."
Datalic runs the full analytical loop — governed and verified at every step.
Natural-language answers
Questions across one database or many, returned as a number, a table, or a chart — every figure verified.
Deep, multi-step analysis
Cohorts, retention, forecasting, anomaly investigation — the brain plans the hypotheses, your runtime executes them.
Cross-database answers
Combine Postgres orders, Mongo events, and Elasticsearch tickets in one question — pooled locally, never a raw-row export.
Clean & transform data
Audit quality, propose a reversible cleanup recipe, preview the diff, and apply on confirmation — with an undo token.
Professional reports
Full multi-section reports as Markdown, HTML, or Word — with professional charts, rendered locally from the governed result.
Speaks your language
Ask in any language; Datalic answers in the same one. Verified numbers stay identical — a fast path to every market.
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.
- Install the SDK with the driver for your database.
Every database is its own extra — pull only what you use.
- Authenticate with client credentials from the console.
Exchanged for a short-lived token; no raw key ever crosses the wire.
- Ask — the brain plans, your runtime executes.
One governed step at a time, enforced and verified locally.
- 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");
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.
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.
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.
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.
Cloud-managed, hybrid, or fully self-hosted.
We host the brain; your runtime lives in your app. Fastest to start, nothing to operate.
✓ data still never leaves youOur cloud brain, your execution — the default. Intelligence managed, data local.
✓ the standard deploymentRun the whole stack in your VPC or on-prem with a Helm chart. Bring your own model.
✓ highest margin · zero egressA 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.
- ✓Per-tenant connections, unlimited viewers
- ✓BYOK by default — heavy usage never eats margin
- ✓Access policy, masking, row-scope per tenant
- ✓The
<DatalicChat>embed + renderers
- ✓~25k verified answers/mo included
- ✓Managed credits (~2× cost) or BYOK
- ✓MCP server + cross-database answers
- ✓Full audit trail + usage dashboard
- ✓BYOK / local model — COGS near zero
- ✓Unlimited answers, SSO, support + SLA
- ✓Helm chart, VPC / on-prem deploy
- ✓Security review + design partnership
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.