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.
Top Related Projects
Robust Speech Recognition via Large-Scale Weak Supervision
Port of OpenAI's Whisper model in C/C++
WhisperX: Automatic Speech Recognition with Word-level Timestamps (& Diarization)
Faster Whisper transcription with CTranslate2
High-performance GPGPU inference of OpenAI's Whisper automatic speech recognition (ASR) model
Quick Overview
WrenAI is an open-source AI assistant framework designed to help developers create custom AI assistants. It provides a flexible and extensible platform for building conversational AI applications, leveraging large language models and other AI technologies.
Pros
- Highly customizable and extensible architecture
- Supports multiple AI models and integrations
- Easy to deploy and scale
- Active community and ongoing development
Cons
- Limited documentation for advanced features
- Steeper learning curve compared to some simpler chatbot frameworks
- Requires knowledge of AI concepts and language models
- May have higher computational requirements for complex assistants
Code Examples
Here are a few code examples demonstrating basic usage of WrenAI:
- Creating a simple assistant:
from wrenai import Assistant
assistant = Assistant("My Assistant")
assistant.add_skill("greeting", "Say hello to the user")
assistant.add_skill("weather", "Provide weather information")
response = assistant.process("Hello, what's the weather like today?")
print(response)
- Adding a custom skill:
from wrenai import Skill
class WeatherSkill(Skill):
def execute(self, input_text):
# Implement weather fetching logic here
return "It's sunny and 25°C today."
assistant.add_skill(WeatherSkill())
- Using a specific AI model:
from wrenai import Assistant, GPT3Model
model = GPT3Model(api_key="your-api-key")
assistant = Assistant("GPT-3 Assistant", model=model)
response = assistant.process("Explain quantum computing")
print(response)
Getting Started
To get started with WrenAI, follow these steps:
- Install WrenAI:
pip install wrenai
- Create a basic assistant:
from wrenai import Assistant
assistant = Assistant("My First Assistant")
assistant.add_skill("greeting", "Greet the user")
assistant.add_skill("farewell", "Say goodbye to the user")
while True:
user_input = input("You: ")
if user_input.lower() == "exit":
break
response = assistant.process(user_input)
print(f"Assistant: {response}")
- Run your assistant and start interacting with it!
For more advanced usage and customization options, refer to the WrenAI documentation.
Competitor Comparisons
Robust Speech Recognition via Large-Scale Weak Supervision
Pros of Whisper
- Highly accurate speech recognition across multiple languages
- Open-source with extensive documentation and community support
- Robust performance on diverse audio inputs, including noisy environments
Cons of Whisper
- Requires significant computational resources for real-time transcription
- Large model size may be challenging for deployment on resource-constrained devices
- Limited customization options for specific domain adaptations
Code Comparison
WrenAI:
from wren import Wren
wren = Wren()
result = wren.transcribe("audio.wav")
print(result.text)
Whisper:
import whisper
model = whisper.load_model("base")
result = model.transcribe("audio.wav")
print(result["text"])
Key Differences
- WrenAI focuses on lightweight, efficient speech recognition, while Whisper prioritizes accuracy and multilingual support
- WrenAI is designed for edge devices and real-time applications, whereas Whisper is better suited for server-side processing
- Whisper offers more comprehensive language support and advanced features, while WrenAI emphasizes simplicity and ease of integration
Use Cases
- Choose WrenAI for mobile apps, IoT devices, or scenarios requiring low-latency transcription
- Opt for Whisper when accuracy is paramount, dealing with multiple languages, or processing large volumes of audio data
Port of OpenAI's Whisper model in C/C++
Pros of whisper.cpp
- Highly optimized C++ implementation for efficient speech recognition
- Supports various quantization levels for reduced memory usage
- Provides both command-line and library interfaces for flexibility
Cons of whisper.cpp
- Limited to Whisper model, while WrenAI supports multiple models
- Requires more technical expertise to set up and use effectively
- Less focus on user-friendly interfaces compared to WrenAI
Code Comparison
whisper.cpp:
#include "whisper.h"
int main(int argc, char ** argv) {
struct whisper_context * ctx = whisper_init_from_file("ggml-base.en.bin");
whisper_full_default(ctx, wparams, pcmf32.data(), pcmf32.size());
whisper_print_timings(ctx);
whisper_free(ctx);
}
WrenAI:
from wren import Wren
wren = Wren()
result = wren.transcribe("audio.mp3")
print(result.text)
The code comparison showcases the difference in complexity and ease of use between the two libraries. whisper.cpp requires more setup and C++ knowledge, while WrenAI offers a simpler Python interface for quick transcription tasks.
WhisperX: Automatic Speech Recognition with Word-level Timestamps (& Diarization)
Pros of WhisperX
- Offers advanced features like word-level timestamps and speaker diarization
- Supports multiple languages and provides language detection
- Actively maintained with frequent updates and improvements
Cons of WhisperX
- Requires more computational resources due to its advanced features
- May have a steeper learning curve for beginners
- Limited to audio transcription and diarization tasks
Code Comparison
WhisperX:
import whisperx
model = whisperx.load_model("large-v2")
result = model.transcribe("audio.mp3")
print(result["segments"])
WrenAI:
from wren import Wren
wren = Wren()
response = wren.generate("Summarize this text: ...")
print(response)
Key Differences
WhisperX focuses on audio transcription and diarization, while WrenAI is a more general-purpose AI assistant. WhisperX provides detailed audio analysis, including word-level timestamps and speaker identification. WrenAI, on the other hand, offers a broader range of capabilities, including text generation, summarization, and potentially other AI-powered tasks.
The choice between these repositories depends on the specific use case. For audio-related tasks, WhisperX would be more suitable, while WrenAI might be preferable for general AI assistance and text-based tasks.
Faster Whisper transcription with CTranslate2
Pros of faster-whisper
- Optimized for speed, offering faster transcription than standard Whisper models
- Supports multiple languages and can perform translation
- Provides streaming capabilities for real-time transcription
Cons of faster-whisper
- Focused solely on speech-to-text, lacking additional AI capabilities
- May require more computational resources due to its optimization for speed
- Limited customization options compared to more general-purpose AI frameworks
Code Comparison
faster-whisper:
from faster_whisper import WhisperModel
model = WhisperModel("large-v2", device="cuda", compute_type="float16")
segments, info = model.transcribe("audio.mp3", beam_size=5)
for segment in segments:
print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))
WrenAI:
from wren import Wren
wren = Wren()
response = wren.chat("Transcribe the following audio file: audio.mp3")
print(response)
Summary
faster-whisper excels in speech-to-text tasks with its speed-optimized approach and multi-language support. However, it's limited to transcription tasks. WrenAI, while not specifically optimized for transcription, offers a more versatile AI platform that can handle various tasks through natural language interactions. The choice between the two depends on whether you need specialized transcription capabilities or a more general-purpose AI assistant.
High-performance GPGPU inference of OpenAI's Whisper automatic speech recognition (ASR) model
Pros of Whisper
- Optimized for performance with GPU acceleration
- Supports multiple languages for transcription
- Provides a C++ implementation for better integration with native applications
Cons of Whisper
- Limited to speech recognition and transcription tasks
- Requires more setup and configuration compared to WrenAI
- May have a steeper learning curve for non-technical users
Code Comparison
WrenAI:
from wren import Wren
wren = Wren()
result = wren.transcribe("audio.mp3")
print(result.text)
Whisper:
#include "whisper.h"
whisper_context * ctx = whisper_init_from_file("model.bin");
whisper_full_params params = whisper_full_default_params(WHISPER_SAMPLING_GREEDY);
whisper_full(ctx, params, audio_data, audio_len, "en");
Summary
Whisper offers high-performance speech recognition with multi-language support and GPU acceleration, making it suitable for more advanced applications. However, it may require more technical expertise to implement and use effectively. WrenAI, on the other hand, provides a simpler interface for transcription tasks, making it more accessible for quick integration into projects, but may lack some of the advanced features and optimizations found in Whisper.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Open-source GenBI: generative BI for AI agents.
Your agents generate, deploy, and govern dashboards from any database, grounded in a context layer they can actually trust.
Docs · Discord · Vision · Blog
ð£ 2026-05-07: Wren Engine has merged into this repo under
core/. The previousCanner/wren-enginerepo is archived. The previous WrenAI GenBI app (the Docker-based chat-first BI product) is preserved on thelegacy/v1branch (tagv1-final) and is now Wren GenBI Classic; see A note on the "GenBI" name below. Read the announcement â
What WrenAI is
WrenAI is the open-source GenBI engine: it lets AI agents generate, deploy, and govern business intelligence, from a SQL answer to a shareable dashboard, across 22+ data sources.
What makes the output trustworthy is the layer underneath: an open context layer that gives agents what schemas don't. That means business semantics, approved definitions, examples, memory, and governance, plus the unstructured company knowledge that lives in your docs, wikis, and chat threads. Generative BI is only as good as the context it stands on, and Wren is that context, made reviewable and reusable by every agent you already run.
GenBI in three beats: Generate · Deploy · Know
- Generate. Your agent turns a business question into governed SQL and charts. Schema-aware retrieval, MDL planning, dry-plan validation, and structured errors keep it correct instead of confidently wrong.
- Deploy. Turn any answer into a shareable, browser-side dashboard powered by
wren-core-wasmand ship it to your own Vercel or Cloudflare Pages account with one command. - Know. The knowledge that makes all of this correct lives in versionable, evidence-linked files: semantic models (MDL), company definitions (
instructions.md), and a memory of what worked. Reviewable. Git-friendly. Never locked inside someone else's UI.
Why agent builders pick WrenAI
- Generative BI, end to end. Not just text-to-SQL. Generate the answer, deploy the dashboard, share the URL, all driven by the agents you already use.
- Knowledge management built in. Business meaning, approved definitions, and proven examples are captured as reviewable, version-controlled context, not buried in prompts.
- Open by default. Open-sourced core, SDK, and skills under the Apache-2.0 license.
- Correctness as primitives. Rich schema retrieval, dry-plan validation, structured errors with hints, value profiling, eval runner. The agent orchestrates; the trace lives in its reasoning.
- Sits on top of your existing stack. Warehouse, transformation pipelines, your existing semantic layer. Not another tool to maintain.
How Wren compares
| A raw LLM agent | A traditional BI tool | A bare semantic layer | WrenAI | |
|---|---|---|---|---|
| Writes SQL for you | â (often wrong) | â | â | â governed |
| Knows your business definitions | â | partial, in-tool | â (schema only) | â + non-schema knowledge |
| Generates & deploys dashboards | â | â (manual, in-tool) | â | â agent-driven |
| Works through your agents (Claude Code, Cursor, MCPâ¦) | â | â | â | â |
| Open, reviewable, Git-friendly context | â | â | partial | â |
| Governed execution across 22+ sources | â | per-connector | â (definitions only) | â |
Wren is for you ifâ¦
- 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 context that's open, reviewable, and version-controlled, usable by every agent and 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.
Quickstart
WrenAI is agent-driven by design: install the CLI, install a one-file discovery stub for your AI client, then let your AI agent drive the rest. Workflow guides live inside the CLI itself and are served on demand, so content always matches the installed version.
1. Install the CLI
pip install wrenai # core (DuckDB included)
pip install "wrenai[postgres,memory]" # add per-datasource and memory extras as needed
Tip for users in mainland China: If
pip installis slow or fails, use the Tsinghua mirror:pip install wrenai -i https://pypi.tuna.tsinghua.edu.cn/simpleIf HuggingFace model downloads time out, add
export HF_ENDPOINT=https://hf-mirror.combefore running the CLI.
2. Install the discovery stub for your AI client
npx skills add Canner/WrenAI # auto-detects Claude Code, Cursor, Cline, Codex, â¦
The stub is ~50 lines. It teaches your agent to fetch workflow guides via
wren skills get <name> and shaped prompts via
wren ask "<question>" --guided|--direct, and everything else lives in the CLI.
3. Ask your agent to set things up
Open your agent in a project directory and say something like:
"Use Wren to set up my Postgres database."
The agent runs wren skills get onboarding, follows the guide step-by-step,
checks your environment, creates a connection profile, scaffolds the project,
and runs a first query.
4. (Optional) Enrich the project: the Know beat
Once onboarding finishes, ask:
"Enrich my Wren project with the business context in
raw/."
The agent runs wren skills get enrich-context and follows the guide in
grill mode (one question at a time) or auto-pilot mode (agent reads
<project>/raw/ and proposes). Both modes write to MDL, instructions,
queries, and memory, all reviewable, all Git-friendly.
5. Ask questions: the Generate beat
"Who are our top 10 customers by sales this quarter?"
Your agent fetches MDL context, recalls similar past queries, writes
governed SQL, and executes via wren query.
6. Build & deploy a dashboard: the Deploy beat
"Turn that into an interactive dashboard I can filter and share, and deploy it to Vercel."
The agent runs wren skills get genbi, builds a browser-side GenBI app from
your project's context, previews it locally, and ships it to your own Vercel
or Cloudflare Pages account, returning a live, shareable URL. See the
Build & deploy a GenBI app guide.
Want to try it without your own database? Ask your agent to use the
bundled jaffle_shop sample dataset. Same flow, querying a real warehouse
end-to-end in a couple of minutes.
Two beats first, then the third
# Day 1 (agent-driven)
wren skills get onboarding # workflow guide: set up project + first query (Generate)
wren skills get enrich-context # workflow guide: add business context (Know)
wren skills get genbi # workflow guide: build & deploy a dashboard (Deploy)
# Day-to-day
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
Fast at first. Deep when you need it. Always reviewable and Git-friendly.
What's Included
- Modeling Definition Language (MDL): models, columns, relationships, views, cubes, metrics, row-level / column-level access control (RLAC / CLAC)
- Engine: Apache DataFusion based, 22+ data sources
- GenBI dashboards: agent-built, browser-side apps powered by
wren-core-wasm, deployable to Vercel / Cloudflare Pages - Knowledge & memory: business meaning in version-controlled
instructions.mdandqueries.yml, plus a local LanceDB memory index (hybrid retrieval) for recall - Agent SDK:
wren-langchain(LangChain / LangGraph),wren-pydantic; reference Python integration for other stacks - Governed execution primitives: functions, dry-plan, row limits, access control
What's next
- End-to-end correctness primitives: value profiling, rich retrieval, structured errors, golden eval runner
- Agent-native distribution: first-class SDKs across major agent frameworks; see GitHub Discussions for what's prioritized next
- Full governed execution: audit logs, rate limits, approval workflow, data-flow inspector
Full roadmap and design notes: see the introduction.
A note on the "GenBI" name
"GenBI" now refers to this open-source generative-BI capability: agents that
generate governed answers and deploy dashboards on top of Wren's context
layer. The earlier Wren AI GenBI app, the Docker-based chat-first BI
product, is now Wren GenBI Classic, preserved on the
legacy/v1 branch (no new
features or security fixes). For a maintained, hosted version of that classic
experience, see Wren AI Commercial.
Documentation
- 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
Community
- ð¬ Discord: chat with the team and other builders
- ð GitHub Discussions: design conversations, RFCs, longer threads
- ð¦ Twitter / X: release notes and short updates
- ð Blog: vision, post-mortems, deep dives
Contributing
We build in the open. Issues, PRs, connector contributions, SDK integrations, docs fixes are all welcome.
- Contributor guide
- Connector ecosystem program: three-tier ownership (official, community-blessed, community-owned)
- Architecture map: find the right place to land your change
- Looking for somewhere to start? Try the
good first issuelabel.
Project structure (click to expand)
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/ Reference agent SDK integration
skills/ Agent skills for context authoring
docs/ Module documentation
examples/ Example projects
Contributors
License
Apache 2.0. See LICENSE.
Come build open GenBI with us.
If WrenAI helps you, drop a â, it genuinely helps us grow!
Top Related Projects
Robust Speech Recognition via Large-Scale Weak Supervision
Port of OpenAI's Whisper model in C/C++
WhisperX: Automatic Speech Recognition with Word-level Timestamps (& Diarization)
Faster Whisper transcription with CTranslate2
High-performance GPGPU inference of OpenAI's Whisper automatic speech recognition (ASR) model
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot