LingxiBI

Connect databases. Talk to your data. Let AI build the dashboards.

灵犀 — intuitive understanding between you and your data.

🚀 Live Demo · ⚡ Quick Start · ✨ Features · 🧠 How It Learns · 🏗️ Architecture · 📦 Deploy

⭐ If LingxiBI is useful to you, please star it on GitHub — it really helps!

English · 简体中文

LingxiBI is a self-learning BI platform that turns raw databases into shareable, interactive dashboards — no SQL required, no traditional BI tool needed.

Connect MySQL, PostgreSQL, or Oracle, then:

1. Ask in plain language — the AI writes & executes read-only SQL.
2. Curate a metrics library — grounding the AI in your business definitions.
3. Get smarter over time — every conversation teaches the system your schema's business rules.
4. Generate HTML dashboards — refine them conversationally, with full version history.
5. Stay informed — threshold alerts via email (Excel attached) and/or Feishu interactive cards.

_{▲ AI-generated interactive dashboard with ECharts visualizations}

_{▲ Natural language conversations with your data}

⚠️ Shared public demo — don't enter real credentials or sensitive data. Data may be reset periodically.

Most text-to-SQL tools are stateless — they forget everything between questions. LingxiBI accumulates per-datasource business knowledge and feeds it back into every answer. The more your team uses it, the more accurate it becomes.

flowchart TD
    A(["🧑 You — ask / 👍 like"]) --> B["💬 Conversation\n(WebSocket streaming)"]
    B --> C["⚙️ Background task:\nextract NEW business knowledge"]
    C --> D[("📚 Learned Context\n(per datasource)")]
    D --> E["🎯 Relevance-ranked +\ntoken-budgeted selection"]
    E --> F["✨ Grounded SQL generation\n→ better answers over time"]
    F -.->|"feeds next"| B

    D --- K1["🔗 Knowledge base\nrelations · rules · field meanings"]
    D --- K2["👍 Few-shot examples"]
    D --- K3["⭐ Curated metrics library"]
    D --- K4["📊 Column profiles\nenums · ranges · samples"]

Key mechanisms:

• Auto-extraction — after each turn, the LLM distills only new knowledge (deduplicated, with confidence levels)
• Human feedback — 👍 saves Q&A pairs as few-shot examples for future queries
• Curated metrics — validated SQL with business-meaningful names, reused as trusted definitions
• Smart recall — ranked by keyword relevance × confidence, clamped to a token budget

flowchart TD
    Browser["🌐 Browser"] -->|HTTPS| Nginx["Nginx :9528"]
    
    Nginx -->|"/"| SPA["⚛️ Static SPA\n(client/dist)"]
    Nginx -->|"/api/*"| API["🦀 Rust API\n(Axum :3001)"]
    Nginx -->|"/api/chat"| WS["🔌 WebSocket"]

    API --> MetaDB[("🗄️ MySQL/MariaDB\nMetadata DB")]
    API --> DS["🎯 Data Sources\nMySQL · PG · Oracle"]
    API --> LLM["🤖 LLM Provider\nOpenAI-compatible"]

    MetaDB --> Scheduler["⏰ Background Schedulers"]
    Scheduler --> Snap["📸 Snapshots"]
    Scheduler --> Alerts["🔔 Alerts"]
    Alerts --> SMTP["📧 SMTP\nemail + Excel"]
    Alerts --> Feishu["🪶 Feishu\ninteractive card"]

Design principles:

• Stateless API — only the metadata DB holds state; horizontally scalable
• Atomic scheduling — background jobs claim work atomically; safe for multi-instance
• Multi-channel delivery — each alert rule can target email, Feishu, or both; outcomes are recorded independently
• Security-first — SQL allowlist validator, SSRF guards on webhooks, bcrypt-12, security response headers

docker compose up -d --build

Open http://localhost:9528 → create the first admin account. Done.

docker compose logs -f server     # follow API logs
docker compose down               # stop (preserves data)
docker compose down -v            # stop + wipe all data

🛡️ Production: set strong passwords in .env, set CORS_ALLOWED_ORIGIN to your real domain, and terminate TLS upstream.

# 1. Create metadata database
mysql -e "CREATE DATABASE ai_report CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"

# 2. Start the API server
cd server
cp .env.example .env   # edit DATABASE_URL + JWT_SECRET
cargo run              # migrations auto-run, listening on :3001

# 3. Start the frontend
cd client
npm install && npm run dev   # Vite proxies /api → :3001

Open the printed URL, create admin, add a data source, configure your LLM in Settings.

LLM provider, SMTP, and Feishu webhook are configured in-app at runtime (stored in DB, not env vars).

# One-time server setup (Rust, MySQL, Nginx, TLS):
bash scripts/setup-server.sh [domain]

# Deploy from your machine:
./scripts/deploy.sh user@host [domain]

Rust binary is built on the target host (no glibc mismatch). SPA is built locally and served as static files.

💡 Docker Compose also works for production behind your own TLS proxy.

lingxibi/
├── client/                  React + Vite SPA
│   └── src/
│       ├── pages/           Route-level views
│       ├── components/      Shared UI components
│       ├── stores/          Zustand state management
│       ├── lib/             API client, types
│       └── i18n/            EN / ZH translations
├── server/                  Rust (Axum) API
│   ├── src/
│   │   ├── routes/          HTTP + WebSocket handlers
│   │   ├── llm/             LLM client + prompt engineering
│   │   ├── alert_engine.rs  Alert evaluation + multi-channel delivery
│   │   ├── feishu.rs        Feishu webhook + HMAC signing
│   │   ├── email.rs         SMTP delivery
│   │   └── ...
│   └── migrations/          SQL migrations (auto-run)
├── scripts/                 Deployment automation
├── docker-compose.yml       One-command full stack
└── .env.example             Environment template

📣 Report vulnerabilities privately to macrogroot@outlook.com — not via public issues.

LingxiBI supports multiple users with two roles and a clear split between shared infrastructure and personal work products.

Roles

• Admin — manages shared infrastructure and can see/manage everything: data sources, the AI provider (LLM) config, SMTP/Feishu settings, the knowledge base, and user accounts.
• Member — works only with their own content and the data sources they've been granted.

What's private vs. shared

Datasource-level access Data sources are admin-managed. A member cannot see or query a data source until an admin grants them access. Grants are enforced on the server for every data-touching path — listing, schema/graph reads, ad-hoc SQL, metric & report-dataset creation/refresh, snapshots, and AI chat. Revoking a grant immediately blocks further queries (already-cached data stays until overwritten). Admins implicitly have access to every data source.

First run & adding users

• The first account you register becomes the admin. Registration then closes.
• Add more users at Settings → Users (admin only): create members/admins, reset passwords, toggle roles.
• Grant a member access to a data source at Data Sources → (select one) → Access.

Existing single-admin deployments: after upgrading, all current data is assigned to the first admin, and data sources start with no member grants — grant access as you add members.

• Embedding-based semantic retrieval for knowledge base & examples
• Feishu Bitable (Base) sync
• More notification channels (DingTalk, WeChat Work, Slack)
• Encryption-at-rest for stored credentials
• Multi-arch Docker images (GHCR) on tagged releases
• SECURITY.md + CHANGELOG.md
• More chart types & dashboard templates

Contributions welcome! See CONTRIBUTING.md for workflow and guidelines.

• 📧 macrogroot@outlook.com
• 🐛 Open an issue

MIT License © 2026 Marco