Updated readme and cli

Author: BtXin

Dockerfile

@@ -4,6 +4,7 @@ FROM rust:1.94.0-slim AS builder
 RUN apt-get update && apt-get install -y \
     pkg-config \
     libssl-dev \
+    libsqlite3-dev \
     cmake \
     protobuf-compiler \
     g++ \
@@ -19,6 +20,7 @@ FROM debian:trixie-slim
 
 RUN apt-get update && apt-get install -y \
     libssl3t64 \
+    libsqlite3-0 \
     zlib1g \
     ca-certificates \
     && rm -rf /var/lib/apt/lists/*

README.md

@@ -28,7 +28,7 @@ Skardi lets AI agents and applications query files, databases, data lakes, and v
 - **CLI for local agents & queries** — Run SQL against local files, remote object stores (S3, GCS, Azure), databases, and datalake formats — ideal for local AI agents like [OpenClaw](https://github.com/openclaw/openclaw)
 - **Declarative pipelines** — Define SQL queries in YAML, get REST APIs automatically
 - **Automatic parameter inference** — Request parameters, types, and response schemas are inferred from your SQL
-- **Multi-source federation** — JOIN across CSV, Parquet, PostgreSQL, MySQL, MongoDB, Iceberg, and Lance in a single query
+- **Multi-source federation** — JOIN across CSV, Parquet, PostgreSQL, MySQL, SQLite, MongoDB, Iceberg, and Lance in a single query
 - **Full CRUD** — SELECT, INSERT, UPDATE, and DELETE operations on supported databases
 - **Vector search** — Native KNN similarity search via Lance integration
 - **S3 support** — Read CSV, Parquet, and Lance files directly from S3
@@ -52,6 +52,7 @@ Skardi lets AI agents and applications query files, databases, data lakes, and v
   - [Parquet](#parquet)
   - [PostgreSQL](#postgresql)
   - [MySQL](#mysql)
+  - [SQLite](#sqlite)
   - [MongoDB](#mongodb)
   - [Apache Iceberg](#apache-iceberg)
   - [Lance (Vector Search)](#lance-vector-search)
@@ -132,7 +133,7 @@ skardi query --ctx ./ctx.yaml --schema -t products
 | Local files | CSV, Parquet, JSON/NDJSON, Lance |
 | Remote stores | S3, GCS, Azure Blob, HTTP/HTTPS, OSS, COS |
 | Datalake formats | Lance, Iceberg |
-| Databases | PostgreSQL, MySQL, MongoDB |
+| Databases | PostgreSQL, MySQL, SQLite, MongoDB |
 
 **Context file resolution** (when `--ctx` is omitted): checks `SKARDICONFIG` env var, then `~/.skardi/config/ctx.yaml`. If no context file is found, the query runs without pre-registered tables (you can still query files directly by path).
 
@@ -205,7 +206,7 @@ data_sources:
 
 ### Access Mode
 
-By default, all data sources are **read-only** — only `SELECT` queries are allowed. To enable write operations (`INSERT`, `UPDATE`, `DELETE`), set `access_mode: read_write` on the data source. Only `postgres` and `mysql` sources support `read_write` mode; setting it on other types will produce an error at startup.
+By default, all data sources are **read-only** — only `SELECT` queries are allowed. To enable write operations (`INSERT`, `UPDATE`, `DELETE`), set `access_mode: read_write` on the data source. Only `postgres`, `mysql`, and `sqlite` sources support `read_write` mode; setting it on other types will produce an error at startup.
 
 ```yaml
 data_sources:
@@ -366,6 +367,28 @@ export MYSQL_PASSWORD="mypassword"
 
 For detailed setup, CRUD examples, and federated queries, see [demo/mysql/MYSQL_DEMO.md](demo/mysql/MYSQL_DEMO.md).
 
+### SQLite
+
+Full CRUD support (SELECT, INSERT, UPDATE, DELETE) with no external server required — just a local `.db` file.
+
+```yaml
+- name: "users"
+  type: "sqlite"
+  path: "data/my_database.db"
+  options:
+    table: "users"
+    busy_timeout_ms: "5000"     # Optional, default: 5000
+```
+
+SQLite requires no credentials — just the path to the database file.
+
+**CLI direct path query** (no context file needed):
+```bash
+skardi query --sql "SELECT * FROM './data/my_database.db.users'"
+```
+
+For detailed setup, CRUD examples, and federated queries, see [demo/sqlite/SQLITE_DEMO.md](demo/sqlite/SQLITE_DEMO.md).
+
 ### MongoDB
 
 Full CRUD support with point lookups, full scans, and federated queries.
@@ -587,6 +610,7 @@ The [demo/](demo/) directory contains complete working examples:
 | [demo/README.md](demo/README.md) | Product search demo (CSV/Parquet) |
 | [demo/postgres/](demo/postgres/) | PostgreSQL CRUD and federated query examples |
 | [demo/mysql/](demo/mysql/) | MySQL CRUD and federated query examples |
+| [demo/sqlite/](demo/sqlite/) | SQLite CRUD and federated query examples |
 | [demo/mongo/](demo/mongo/) | MongoDB CRUD and federated query examples |
 | [demo/iceberg/](demo/iceberg/) | Apache Iceberg integration examples |
 | [demo/lance/](demo/lance/) | Lance vector search examples |

crates/cli/README.md

@@ -29,7 +29,7 @@ Execute a SQL query or show table schema(s). Data sources can come from:
 - **Local files** — CSV, Parquet, JSON/NDJSON (directly by path in SQL or via context file)
 - **Remote files** — S3, GCS, Azure Blob, HTTP/HTTPS, OSS, COS (directly by URL in SQL or via context file)
 - **Datalake formats** — Lance (directly by path in SQL or via context file), Iceberg (via context file)
-- **Databases** — PostgreSQL, MySQL, MongoDB (via context file)
+- **Databases** — PostgreSQL, MySQL, SQLite, MongoDB (via context file or direct path for SQLite)
 
 #### Query files directly (no context file needed)
 
@@ -44,6 +44,10 @@ skardi query --sql "SELECT * FROM './data/logs.json'"
 # Lance datasets
 skardi query --sql "SELECT * FROM './embeddings.lance' LIMIT 5"
 
+# SQLite tables (pattern: path/to/file.db.table_name)
+skardi query --sql "SELECT * FROM './data/my_database.db.users'"
+skardi query --sql "SELECT * FROM './data/app.sqlite.customers'"
+
 # Remote files (S3, GCS, Azure)
 skardi query --sql "SELECT * FROM 's3://mybucket/data/events.parquet'"
 skardi query --sql "SELECT * FROM 'gs://mybucket/data.csv'"
@@ -153,6 +157,14 @@ data_sources:
       user_env: MYSQL_USER
       pass_env: MYSQL_PASS
 
+  # SQLite
+  - name: users
+    type: sqlite
+    path: data/my_database.db
+    options:
+      table: users
+      busy_timeout_ms: "5000"   # Optional
+
   # MongoDB
   - name: profiles
     type: mongo
@@ -174,6 +186,7 @@ data_sources:
 | `iceberg` | Apache Iceberg tables | Warehouse path (local or S3) |
 | `postgres` | PostgreSQL tables | `postgresql://host:port/db` |
 | `mysql` | MySQL tables | `mysql://host:port/db` |
+| `sqlite` | SQLite tables | Local file path (e.g. `data/my.db`) |
 | `mongo` | MongoDB collections | `mongodb://host:port` |
 
 **Path resolution:** Relative paths in the context file are resolved relative to your **current working directory**.
@@ -258,6 +271,9 @@ skardi query --sql "SELECT * FROM 's3://mybucket/events.parquet' LIMIT 10"
 # Query a Lance dataset
 skardi query --sql "SELECT * FROM './embeddings.lance' LIMIT 5"
 
+# Query a SQLite table directly
+skardi query --sql "SELECT * FROM './data/app.db.users' LIMIT 10"
+
 # With context file
 cargo run -p skardi-cli -- query --ctx ./demo/ctx.yaml --sql "SELECT * FROM products LIMIT 5"
 

crates/cli/src/main.rs

@@ -19,7 +19,8 @@ use serde::Deserialize;
 use source::lance::knn_table_function::register_lance_knn_udtf;
 use source::providers::{
     iceberg::register_iceberg_table, lance::register_lance_table, mongo::register_mongo_tables,
-    mysql::register_mysql_tables, sqlx::postgres::register_postgres_tables,
+    mysql::register_mysql_tables, sqlite::register_sqlite_tables,
+    sqlx::postgres::register_postgres_tables,
 };
 use std::collections::HashMap;
 use std::fmt;
@@ -244,6 +245,25 @@ impl UrlTableFactory for SkardiUrlTableFactory {
         &self,
         url: &str,
     ) -> datafusion::error::Result<Option<Arc<dyn TableProvider>>> {
+        // Handle SQLite databases: detect patterns like "path/to/file.db.table_name"
+        let sqlite_extensions = [".db.", ".sqlite.", ".sqlite3."];
+        if let Some(ext) = sqlite_extensions.iter().find(|ext| url.contains(*ext)) {
+            let pos = url.find(ext).unwrap();
+            let db_path = &url[..pos + ext.len() - 1]; // include .db but not trailing dot
+            let table_name = &url[pos + ext.len()..];
+
+            if !table_name.is_empty() {
+                let provider =
+                    source::providers::sqlite::create_sqlite_table_provider(db_path, table_name)
+                        .await
+                        .map_err(|e| {
+                            datafusion::error::DataFusionError::Execution(e.to_string())
+                        })?;
+
+                return Ok(Some(provider));
+            }
+        }
+
         // Handle Lance datasets by path suffix
         if url.ends_with(".lance") || url.contains(".lance/") {
             let dataset = Dataset::open(url)
@@ -530,6 +550,23 @@ async fn register_source(
                 .await
                 .with_context(|| format!("Failed to register Lance '{}'", source.name))?;
         }
+        "sqlite" => {
+            let path_str = source
+                .path
+                .as_deref()
+                .ok_or_else(|| anyhow::anyhow!("SQLite source '{}': path required", source.name))?;
+            let resolved = resolve_path(path_str)?;
+
+            register_sqlite_tables(
+                session_ctx,
+                &source.name,
+                &resolved,
+                source.options.as_ref(),
+                false,
+            )
+            .await
+            .with_context(|| format!("Failed to register SQLite '{}'", source.name))?;
+        }
         "iceberg" => {
             let path_str = source.path.as_deref().ok_or_else(|| {
                 anyhow::anyhow!(

crates/source/src/providers/sqlite.rs

@@ -30,6 +30,29 @@ use std::sync::Arc;
 use std::time::Duration;
 use tokio_rusqlite::Connection;
 
+/// Create a read-only SQLite table provider for a single table.
+pub async fn create_sqlite_table_provider(
+    db_path: &str,
+    table_name: &str,
+) -> Result<Arc<dyn TableProvider>> {
+    let pool = Arc::new(
+        SqliteConnectionPoolFactory::new(db_path, Mode::File, Duration::from_millis(5000))
+            .build()
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to create SQLite connection pool: {}", e))?,
+    );
+
+    let factory = SqliteTableFactory::new(Arc::clone(&pool));
+    let table_ref = TableReference::bare(table_name);
+
+    let provider = factory
+        .table_provider(table_ref)
+        .await
+        .map_err(|e| anyhow::anyhow!("Failed to create SQLite table provider: {}", e))?;
+
+    Ok(provider)
+}
+
 /// Register SQLite tables into DataFusion SessionContext
 ///
 /// # Arguments