Canner/WrenAI: GenBI (Generative BI) for AI agents, an open-source, governed text-to-SQL through an open context layer that turns natural-language questions into trusted dashboards, charts, and SQL across 20+ data sources, such as BigQuery, Snowflake, PostgreSQL, ClickHouse, Amazon Redshift, Databricks and more. · GitHub

Open-source GenBI for AI agents

Your agents generate governed SQL, deploy dashboards, and keep business definitions in Git, across 22+ data sources.

Get started in 3 commands ↓  ·  Read the docs →  ·  Join Discord →

WrenAI is the open-source generative BI (GenBI) engine. It gives the AI agents you already use (Claude Code, Cursor, MCP clients, LangChain) a governed semantic layer and an AI context layer, so they turn business questions into correct SQL, ship the answer as a shareable dashboard, and stay inside your guardrails.

Schemas tell an agent where data lives. Wren tells it what the data means: approved metric definitions, enums, units, joins, worked examples, and the tribal knowledge buried in docs and chat threads. All of it lives as reviewable YAML and Markdown in a repo you own.

Three commands, then your agent does the rest. Works with Claude Code, Cursor, Cline, Codex, and 50+ other agents.

1. Install the CLI

pip install wrenai

Add connector extras as you need them, for example pip install "wrenai[postgres,memory]".

2. Teach your agent about Wren

npx skills add Canner/WrenAI

This installs a ~50-line discovery stub. Your agent fetches full workflow guides from the CLI on demand, so instructions always match the installed version.

3. Open your agent in a project folder and ask

"Use Wren to set up my Postgres database."

The agent checks your environment, creates a connection profile, scaffolds the project, and runs a first query.

No database handy? Say "Use Wren with the bundled jaffle_shop sample" and run the same flow against a real sample warehouse.

pip install wrenai -i https://pypi.tuna.tsinghua.edu.cn/simple

If HuggingFace model downloads time out, run export HF_ENDPOINT=https://hf-mirror.com before using the CLI.

Once you're connected, these three prompts cover the whole GenBI loop:

• Answers and dashboards, not just SQL. Generate a governed answer, deploy it as a dashboard, share the URL. One agent-driven loop, end to end.
• Correct instead of confidently wrong. Schema-aware retrieval, MDL planning, dry-plan validation, row limits, value profiling, and structured errors with hints keep agent SQL inside guardrails.
• Business meaning lives in Git. Metric definitions, enums, approved joins, and proven examples are versioned files. Review them in a pull request. Diff them. Take them with you.
• Works through the agents you already run. Claude Code, Cursor, Cline, Codex, MCP clients, LangChain. Wren is a layer, not another chat UI to adopt.
• Sits on your existing stack. Warehouse, transformation pipelines, existing semantic models. 22+ sources on one Apache DataFusion engine.
• Open by default. Core engine, SDK, and skills under Apache-2.0. It runs without us.

• You want AI agents to produce trustworthy BI, answers and dashboards, not just plausible SQL.
• Your business logic (definitions, enums, units, approved joins) lives outside the database and your agents keep getting it wrong.
• You want a context layer that is open, reviewable, and version-controlled, usable by every agent and every person, not gated behind one vendor's UI.

Skip Wren if you only need a one-off chart from a single CSV, or you're happy letting an agent guess at SQL with no governance.

Everything Wren writes on your laptop is plain YAML and Markdown in a repo you own. Git Sync turns that same repo into a governed, team-wide GenBI deployment in Wren Cloud or a self-hosted installation, including air-gapped. Nothing to export, nothing to re-model.

• No new CLI to learn. Bind a directory once with wren cloud create or wren cloud link. After that, git push and git pull are the entire interface.
• Metrics reviewed like code. A change to net_revenue shows up as a readable diff in a pull request on GitHub, GitLab, Bitbucket, or your own remote. Run CI on it. Promote staging to production like application code.
• You keep the repo, always. Clone it, back it up, feed it to another tool, or leave with it, any time.
• No reusable credential on disk. Every push authenticates with a fresh token that expires in 600 seconds. The durable key stays in ~/.wren/cloud.yml (mode 0600) and is never handed to git.

$ git push
To cloud.getwren.ai/acme/wren-analytics.git
   9f2c1a4..b71e0d3  main -> main
✔ deploy queued · model queryable in Wren Cloud

The engine in this repo (MDL semantic layer, governed text-to-SQL, MCP server, CLI, 22+ connectors) is Apache-2.0, free forever, and self-hostable. The following are commercial, delivered as Wren AI Cloud or self-hosted Enterprise Plus:

• Row- and column-level security and access control with users and groups
• GenBI UI, dashboards, embedded and APIs
• Scenario AI harnesses: GenBI Apps, Agentic Mode, AI-assisted context preparation
• Advanced security and audit, support and SLAs, plus cloud, VPC, and air-gapped deployment

Same engine underneath. Your MDL stays in your Git either way. Read the published boundary →

Wren is a governed semantic layer, expressed in the Modeling Definition Language (MDL): a Git-friendly definition of what your data means, not just where it lives. Every answer and dashboard is planned against it.

• Models, columns, relationships, views: the shape of your data, decoupled from any one warehouse.
• Cubes and metrics: approved, reusable definitions so "revenue" means the same thing everywhere.
• Context beyond the schema: enums, units, approved joins, and definitions in instructions.md and queries.yml.

• Engine: Apache DataFusion based. BigQuery, Snowflake, PostgreSQL, ClickHouse, Amazon Redshift, Databricks, DuckDB, and more. Connect a database →
• GenBI dashboards: agent-built, browser-side apps powered by wren-core-wasm, deployable to Vercel or Cloudflare Pages
• Knowledge and memory: version-controlled instructions.md and queries.yml, plus a local LanceDB memory index with hybrid retrieval
• Agent SDKs: wren-langchain (LangChain / LangGraph), wren-pydantic, and a reference Python integration for other stacks. SDK overview →
• Governed execution primitives: functions, dry-plan validation, row limits, structured errors

wren skills get onboarding         # workflow guide: set up project + first query
wren skills get enrich-context     # workflow guide: add business context
wren skills get genbi              # workflow guide: build & deploy a dashboard

wren query --sql '...'             # query through the MDL semantic layer
wren ask "<question>" --guided     # wrap a question for a weaker agent
wren ask "<question>" --direct     # wrap a question for a stronger agent

Full reference: CLI · MDL · Architecture

• End-to-end correctness primitives: value profiling, rich retrieval, structured errors, golden eval runner
• Agent-native distribution: first-class SDKs across major agent frameworks

Vote on what ships next in GitHub Discussions →

Business intelligence produced by AI agents. Instead of a person building charts by hand, an agent generates governed SQL, deploys a dashboard, and shares it, grounded in an AI context layer so the output is trustworthy rather than merely plausible. Wren AI is the open-source GenBI engine.

Yes, and governed: questions become SQL planned against your semantic layer (MDL) and dry-plan validated before execution. Wren then goes further, deploying dashboards and managing the context that keeps answers correct.

Yes. Wren is a governed semantic layer expressed in MDL (models, metrics, relationships), paired with an AI context layer (memory, examples, unstructured knowledge) and a governed execution engine that runs those definitions across 22+ sources.

The reviewable, version-controlled knowledge agents need but schemas don't provide: business semantics, approved definitions, examples, memory, and governance. Read the vision: The missing context layer for AI agents over business data.

On 2026-05-07 Wren Engine merged into this repo under core/, and the previous Canner/wren-engine repo was archived. The earlier chat-first BI product is now Wren GenBI Classic, preserved on the legacy/v1 branch (tag v1-final) with no new features or security fixes. For a maintained, hosted version of that experience, see Wren AI Commercial. Read the announcement →

• Quickstart: from skill install to first answer
• Build & deploy a GenBI app: generate a dashboard and ship it
• Concepts: what context is, what MDL is, how memory works
• Connect a database: Postgres, BigQuery, Snowflake, DuckDB, and more
• Agent SDKs: what's shipping today, what's next
• Git Sync: git push your open-source project to governed, team-wide GenBI

• 💬 Discord: get unstuck fast, chat with the team and other builders
• 🐙 GitHub Discussions: design conversations, RFCs, roadmap votes
• 🐦 Twitter / X: release notes and short updates
• 🗞 Blog: vision, post-mortems, deep dives

We build in the open. Issues, PRs, connectors, SDK integrations, and docs fixes are all welcome.

• New here? Pick up a good first issue.
• Contributor guide: setup, conventions, and the contribution bar
• Architecture map: find the right place to land your change

core/
  wren-core/         Rust semantic engine (Apache DataFusion)
  wren-core-base/    Shared manifest types + MDL builder
  wren-core-py/      Python bindings (PyPI: wren-core)
  wren-core-wasm/    WebAssembly build (npm: wren-core-wasm)
  wren/              Python SDK and CLI (PyPI: wrenai)
  wren-mdl/          MDL JSON schema
sdk/
  wren-langchain/    LangChain / LangGraph integration
  wren-pydantic/     Pydantic AI integration
skills/              Agent skills for context authoring
docs/                Module documentation
examples/            Example projects

Apache 2.0. See LICENSE.