debba/tabularis: Open-Source Desktop SQL Workspace with MCP Server

debba/tabularis: Open-Source Desktop SQL Workspace with MCP Server

Managing databases across multiple engines while keeping AI agents in sync is a growing pain for developers. Most desktop SQL clients either lock advanced features behind paywalls, lack modern AI integration, or force you to context-switch between your editor and database tool. debba/tabularis addresses this directly: it's an open-source desktop SQL workspace that combines native database support for PostgreSQL^{↗ Bright Coding Blog}, MySQL/MariaDB, SQLite and 13+ additional engines with built-in MCP server capabilities for Claude, Cursor, and Devin—plus SQL notebooks and visual EXPLAIN analysis.

What is debba/tabularis?

debba/tabularis (also referenced as TabularisDB/tabularis) is an Apache 2.0-licensed desktop application built with React 19, TypeScript, Tailwind CSS^{↗ Bright Coding Blog} v4 on the frontend and Rust with Tauri v2 and SQLx on the backend. As of July 2026, the project has accumulated 3,726 GitHub stars and 247 forks, with active development continuing through regular releases.

The project originated as an experiment in AI-assisted development—building a working tool from scratch with heavy AI involvement. That experiment evolved into an actively maintained project with a plugin ecosystem, multi-language UI support (English, Italian, Spanish, Chinese Simplified, French, German, Japanese, Russian, Tagalog, and Korean), and distribution across Windows, macOS, and Linux via WinGet, Homebrew, Snap, Flatpak, AUR, and direct installers.

What distinguishes tabularis in the current landscape is its native MCP (Model Context Protocol) server integration. Rather than bolting on AI features through cloud APIs alone, the application exposes database schema and query execution capabilities directly to AI agents running in Claude Desktop, Cursor, or Windsurf/Devin. This means your AI coding assistant can read table structures, suggest optimizations, and execute validated SQL without leaving your editor workflow.

The project maintains a public [INTERNAL_LINK: plugin registry] and bounty board for community-driven database driver expansion, with shipped plugins for DuckDB, ClickHouse, Redis, Firestore, Google Sheets, IBM Db2, and others.

Key Features

Multi-Database Native Support: PostgreSQL, MySQL/MariaDB, and SQLite ship built-in. Everything else extends through a plugin architecture covering ClickHouse, Cloudflare D1, Dameng, DuckDB, Firestore, IBM Db2, IBM Informix, Redis, CSV folders, Google Sheets, HackerNews, and more—with BigQuery, LibSQL/Turso, MongoDB, Oracle, SQL Server, and others in various stages of development.

Built-in MCP Server: The standout differentiator. Running tabularis --mcp exposes five tools to connected AI agents: list_connections, list_databases, list_tables, describe_table (full schema with columns, indexes, foreign keys), and run_query. One-click configuration for Claude Desktop, Cursor, and Windsurf eliminates manual JSON editing.

SQL Notebooks: Multi-cell documents combining SQL and Markdown^{↗ Smart Converter} with cross-cell variable references ({{cellName.columnName}}), global parameters ({{$paramName}}), inline bar/line/pie charts, and export to HTML, CSV, or JSON. Auto-saved as .tabularis-notebook files with sequential execution and stop-on-error options.

Visual EXPLAIN: Interactive execution plan graphs for PostgreSQL, MySQL/MariaDB, and SQLite—rendering query optimizer decisions as navigable node graphs rather than raw text output. Includes table metrics, raw database output, and optional AI-assisted analysis views.

Plugin System (Any Language): Plugins are standalone executables communicating via JSON-RPC 2.0 over stdin/stdout. This means drivers can be written in Python^{↗ Bright Coding Blog}, Go, Rust, or any language—not locked to Java/Eclipse (DBeaver) or JavaScript^{↗ Bright Coding Blog} (TablePlus) plugin ecosystems. No restart required for installation.

AI Text-to-SQL (Optional, Privacy-Focused): Supports OpenAI, Anthropic, MiniMax, OpenRouter, and any OpenAI-compatible API (Groq, Perplexity, Azure OpenAI, LocalAI). Critically, Ollama local models run without API keys or data leaving your machine.

Use Cases

AI-Assisted Schema Exploration: A developer onboarding to a legacy PostgreSQL database connects tabularis, enables the MCP server, and asks Claude in Cursor: "Show me all tables in the production connection and describe the orders table." The agent lists connections, selects the right one, and returns structured schema information without the developer writing a single query or switching applications.

Reproducible Analytical Workflows: Data analysts use SQL notebooks to document multi-step investigations—combining Markdown context, parameterized queries referencing earlier cell results, and embedded charts. The .tabularis-notebook format preserves the full analytical narrative for team sharing, unlike ad-hoc query tabs that lose context.

Query Performance Optimization: A backend engineer notices slow MySQL queries in production. Using visual EXPLAIN, they identify a missing index through the interactive plan graph, verify the fix with the AI-assisted analysis view, and document the before/after in a notebook for the team's knowledge base.

Cross-Database Development with Consistent Tooling: Teams maintaining services across PostgreSQL (primary store), Redis (caching layer), and DuckDB (analytical exports) use tabularis with plugins rather than learning three separate client interfaces. Connection appearance customization (Lucide icons, emoji, custom images, accent colors) helps distinguish environments visually.

Local-First AI Without Cloud Dependencies: Security-conscious organizations or developers in air-gapped environments run Ollama locally for text-to-SQL and query explanation, keeping all database metadata and queries on-premises while still gaining AI assistance.

Installation & Setup

Windows (WinGet — Recommended)

winget install Debba.Tabularis

WinGet handles dependencies, updates, and PATH configuration automatically. For manual installation, download tabularis_x.x.x_x64-setup.exe from the Releases page.

macOS (Homebrew — Recommended)

brew tap TabularisDB/tabularis
brew install --cask tabularis

Builds from v0.13.1 onward are signed and notarized by Apple. For older releases, you may need to run xattr -c /Applications/tabularis.app after installation and grant accessibility access in Privacy & Security settings.

Linux (Multiple Methods)

Snap (auto-updating):

sudo snap install tabularis

Flatpak:

flatpak remote-add --if-not-exists flatpark https://dl.flatpark.org/flatpark.flatpakrepo
flatpak install flatpark dev.tabularis.Tabularis

AppImage (portable, no install required):

chmod +x tabularis_x.x.x_amd64.AppImage
./tabularis_x.x.x_amd64.AppImage

Arch Linux (AUR):

yay -S tabularis-bin

The application checks for updates automatically on startup. Configuration stores in standard locations: ~/.config/tabularis/ (Linux), ~/Library/Application Support/tabularis/ (macOS), or %APPDATA%\tabularis\ (Windows).

Real Code Examples

Enabling the MCP Server

The MCP server starts with a single flag:

tabularis --mcp

This exposes the JSON-RPC endpoint that Claude Desktop, Cursor, or Windsurf connect to. Once configured (via Settings → MCP Server Integration → Install Config), AI agents gain structured access to your database environment without manual credential management or query formatting.

Cross-Cell Variable Reference in Notebooks

Notebooks enable dynamic, multi-step analyses where later cells reference earlier results:

-- Cell named 'top_customers'
SELECT customer_id, SUM(total) as lifetime_value
FROM orders
GROUP BY customer_id
ORDER BY lifetime_value DESC
LIMIT 10;

-- Subsequent cell references the result
SELECT * FROM customers
WHERE id IN ({{top_customers.customer_id}});

The {{cellName.columnName}} syntax injects values from previous cell results. Global parameters use {{$paramName}} for user-defined inputs across the notebook.

Plugin Development Skeleton

The JSON-RPC over stdio protocol enables drivers in any language. From the plugin guide, a minimal driver implements standard methods over stdin/stdout:

// Example JSON-RPC 2.0 request from tabularis to plugin
{"jsonrpc":"2.0","id":1,"method":"connect","params":{"host":"localhost","port":5432}}

// Expected response
{"jsonrpc":"2.0","id":1,"result":{"connected":true,"version":"15.4"}}

Plugins register in plugins/registry.json for discoverability. The architecture deliberately avoids language lock-in—contrast with DBeaver's Java/Eclipse requirement or TablePlus's JavaScript-only extension model.

Advanced Usage & Best Practices

Connection Organization at Scale: Use per-connection appearance overrides (custom icons, accent colors) to visually distinguish production, staging, and development environments. This reduces the risk of accidental schema modifications in the wrong database—particularly valuable when the MCP server gives AI agents write access via run_query.

Notebook Version Control: While .tabularis-notebook files auto-save locally, consider committing them to git for analytical workflow documentation. The JSON-based format diffs reasonably well for tracking query evolution, though large result sets may bloat file size—export final results separately.

Local AI for Sensitive Schemas: For databases containing PII or proprietary schema designs, configure Ollama integration (Settings → AI Assistant) rather than cloud providers. This keeps all metadata, generated queries, and AI interactions on your machine. Model lists cache locally after first fetch.

SSH Tunnel Pre-Configuration: When connecting to cloud-managed databases with IP restrictions, set up SSH tunneling in the connection profile rather than maintaining separate terminal sessions. Tabularis detects tunnel readiness automatically, eliminating race conditions in scripted workflows.

Plugin Isolation for Stability: The external plugin process model (JSON-RPC over stdio) means a crashing third-party driver won't bring down the main application. However, monitor plugin resource usage—poorly implemented drivers can consume excessive memory or leak connections.

Comparison with Alternatives

Trade-offs to consider: DBeaver remains the choice for breadth—100+ native drivers versus tabularis's focused 16 shipped plugins. TablePlus offers a polished commercial experience with broader database coverage but lacks notebook workflows and MCP integration. Beekeeper Studio's simpler interface suits occasional use but misses advanced features entirely. Tabularis prioritizes depth in modern workflows (AI integration, notebooks, visual analysis) over universal database coverage.

FAQ

Is debba/tabularis free for commercial use? Yes, Apache License 2.0 permits commercial use, modification, and distribution without cost.

Which AI clients work with the MCP server? Claude Desktop, Cursor, and Windsurf/Devin have one-click setup. Other MCP-compatible clients can be configured manually.

Can I run AI features without sending data to the cloud? Yes, Ollama integration uses local models with no API key or external data transmission.

Does the plugin system require TypeScript or Rust knowledge? No—plugins use JSON-RPC over stdio and can be written in any language.

How are connection passwords stored? Optionally in the system Keychain; otherwise, configuration stores in standard OS-specific directories.

Is macOS Apple Silicon supported natively? Yes, separate aarch64 and x64 builds are provided. Apple Silicon builds are signed and notarized from v0.13.1.

What happens if a plugin crashes? The external process model isolates failures—tabularis continues running and reports the plugin error without application restart.

Conclusion

debba/tabularis occupies a specific and increasingly relevant niche: developers who want desktop SQL tooling that integrates natively with modern AI workflows rather than treating AI as an afterthought. The built-in MCP server, SQL notebooks with cross-cell referencing, and visual EXPLAIN analysis address concrete productivity gaps that established alternatives haven't prioritized.

It's best suited for: teams using Claude/Cursor/Devin who want database context in their editor; analysts needing reproducible, documented SQL workflows; and developers preferring open-source tools with local AI options for sensitive environments.

The project is actively maintained with regular releases, a growing plugin ecosystem, and clear contribution pathways—including open bounties for database drivers. If your current SQL client forces context-switching between database exploration and AI-assisted coding, tabularis warrants direct evaluation.

Get started: https://github.com/debba/tabularis