@gluip/chart-canvas-mcp 0.1.5 → 0.3.0

package/README.md

@@ -16,9 +16,24 @@ Watch the [full demo on YouTube](https://www.youtube.com/watch?v=XVucQstPisc) to
 🎨 **Interactive Dashboard**: Drag-and-drop grid layout with real-time updates  
 🔄 **Live Synchronization**: Changes appear instantly in your browser  
 📊 **Rich Visualizations**: Powered by ECharts and Mermaid  
+💾 **Universal Data Sources**: Query SQLite, CSV, Parquet, JSON, and NDJSON files directly  
+⚡ **Smart Data Flow**: Execute queries server-side - data stays local, never sent to LLM  
+🔒 **Privacy First**: Your data never leaves your machine  
 🚀 **Easy Setup**: One command to get started  
 🌐 **Production Ready**: Built-in production mode with optimized builds
 
+## Supported Data Sources
+
+Chart Canvas can query and visualize data from multiple file formats:
+
+- **SQLite** (`.db`, `.sqlite`, `.sqlite3`) - Relational databases
+- **CSV** (`.csv`) - Comma-separated values
+- **Parquet** (`.parquet`) - Columnar storage format
+- **JSON** (`.json`) - JSON arrays of objects
+- **NDJSON** (`.jsonl`, `.ndjson`) - Newline-delimited JSON
+
+**Privacy & Performance**: All queries execute locally on your machine using DuckDB. Query results are transformed into visualizations server-side - only metadata (chart configuration) is sent to the LLM, never your actual data. This makes it fast, scalable, and private.
+
 ## Quick Start
 
 ### Installation
@@ -68,6 +83,12 @@ Add to your MCP client configuration (e.g., Claude Desktop):
 "Draw a flowchart for the user authentication process"
 
 "Make a table with team member information"
+
+"Show me the database schema for my SQLite database"
+
+"Query the athletes table and show the top 10 with most personal records"
+
+"Create a chart showing sales trends from the database grouped by region"
 ```
 
 ## MCP Tools
@@ -77,6 +98,7 @@ Add to your MCP client configuration (e.g., Claude Desktop):
 Create charts, diagrams, and tables on the canvas.
 
 **Supported Types**:
+
 - `line` - Line charts with multiple series
 - `bar` - Bar charts for comparisons
 - `scatter` - Scatter plots for data distribution
@@ -85,6 +107,7 @@ Create charts, diagrams, and tables on the canvas.
 - `flowchart` - Mermaid diagrams (flowcharts, sequence diagrams, Gantt charts, etc.)
 
 **Example**:
+
 ```typescript
 {
   type: "line",
@@ -109,6 +132,60 @@ Remove all visualizations from the canvas.
 
 Open the dashboard in your default browser.
 
+### getDatabaseSchema
+
+Inspect the structure of a SQLite database to understand available tables and columns before writing queries.
+
+**Parameters**:
+
+- `databasePath` - Path to SQLite database file (e.g., `./data/mydb.sqlite` or absolute path)
+
+**Example**:
+
+```typescript
+{
+  databasePath: "/path/to/database.db";
+}
+```
+
+**Returns**: Formatted schema showing all tables, columns, data types, and constraints.
+
+### queryAndVisualize
+
+Execute a SQL query on a SQLite database and create a visualization from the results. Queries are executed server-side and must be read-only (SELECT only). Maximum 10,000 rows.
+
+**Parameters**:
+
+- `databasePath` - Path to SQLite database file
+- `query` - SQL SELECT query (read-only)
+- `visualizationType` - Type of chart: `line`, `bar`, `scatter`, `pie`, or `table`
+- `columnMapping` (optional for table) - Mapping of columns to chart axes:
+  - `xColumn` - Column for X-axis (required for charts)
+  - `yColumns` - Array of columns for Y-axis (required for charts)
+  - `seriesColumn` - Column to group data into separate series (optional)
+  - `groupByColumn` - Alternative grouping column (optional)
+- `title` - Optional title for visualization
+- `description` - Optional description
+- `useColumnAsXLabel` - If true, use X column values as labels instead of numbers
+
+**Example**:
+
+```typescript
+{
+  databasePath: "./data/sales.db",
+  query: "SELECT region, SUM(revenue) as total FROM sales GROUP BY region",
+  visualizationType: "bar",
+  columnMapping: {
+    xColumn: "region",
+    yColumns: ["total"]
+  },
+  title: "Revenue by Region",
+  useColumnAsXLabel: true
+}
+```
+
+**Security**: Only SELECT and WITH (CTE) queries are allowed. INSERT, UPDATE, DELETE, DROP, and other modifying operations are blocked.
+
 ## Architecture
 
 - **Backend**: Node.js + TypeScript + Express + MCP SDK
@@ -128,7 +205,7 @@ cd chart-canvas
 cd backend
 npm install
 
-# Install frontend dependencies  
+# Install frontend dependencies
 cd ../frontend
 npm install
 

package/dist/database.js

@@ -0,0 +1,224 @@
+import { DuckDBInstance } from "@duckdb/node-api";
+import { existsSync } from "fs";
+import { resolve, extname } from "path";
+const FORBIDDEN_KEYWORDS = [
+    "INSERT",
+    "UPDATE",
+    "DELETE",
+    "DROP",
+    "CREATE",
+    "ALTER",
+    "TRUNCATE",
+    "REPLACE",
+    "ATTACH",
+    "DETACH",
+];
+const MAX_ROWS = 10000;
+const QUERY_TIMEOUT_MS = 5000;
+/**
+ * Validate database/file path - must exist and be a file
+ */
+export function validateDatabasePath(dbPath) {
+    const resolvedPath = resolve(dbPath);
+    if (!existsSync(resolvedPath)) {
+        throw new Error(`File does not exist: ${dbPath}`);
+    }
+    return resolvedPath;
+}
+/**
+ * Detect file type based on extension
+ */
+export function getFileType(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    if (ext === ".db" || ext === ".sqlite" || ext === ".sqlite3") {
+        return "sqlite";
+    }
+    if (ext === ".csv") {
+        return "csv";
+    }
+    if (ext === ".parquet") {
+        return "parquet";
+    }
+    if (ext === ".json") {
+        return "json";
+    }
+    if (ext === ".jsonl" || ext === ".ndjson") {
+        return "ndjson";
+    }
+    return "unknown";
+}
+/**
+ * Validate SQL query - must be read-only (SELECT only)
+ */
+export function validateReadOnlyQuery(sql) {
+    const upperSQL = sql.trim().toUpperCase();
+    // Must start with SELECT or WITH (for CTEs)
+    if (!upperSQL.startsWith("SELECT") && !upperSQL.startsWith("WITH")) {
+        throw new Error("Only SELECT queries are allowed");
+    }
+    // Check for forbidden keywords
+    for (const keyword of FORBIDDEN_KEYWORDS) {
+        const regex = new RegExp(`\\b${keyword}\\b`, "i");
+        if (regex.test(sql)) {
+            throw new Error(`Query contains forbidden keyword: ${keyword}`);
+        }
+    }
+}
+/**
+ * Get the DuckDB read function for a file type
+ */
+function getReadFunction(filePath, fileType) {
+    const escapedPath = filePath.replace(/'/g, "''");
+    switch (fileType) {
+        case "sqlite":
+            // For SQLite, we'll attach the database
+            return `sqlite_scan('${escapedPath}', '')`;
+        case "csv":
+            return `read_csv_auto('${escapedPath}')`;
+        case "parquet":
+            return `read_parquet('${escapedPath}')`;
+        case "json":
+            return `read_json_auto('${escapedPath}')`;
+        case "ndjson":
+            return `read_json_auto('${escapedPath}', format='newline_delimited')`;
+        default:
+            throw new Error(`Unsupported file type. Supported: .db/.sqlite/.sqlite3 (SQLite), .csv, .parquet, .json, .jsonl/.ndjson`);
+    }
+}
+/**
+ * Get table name from file path
+ */
+function getTableName(filePath) {
+    return (filePath
+        .split("/")
+        .pop()
+        ?.replace(/\.(db|sqlite|sqlite3|csv|parquet|json|jsonl|ndjson)$/i, "") ||
+        "data");
+}
+/**
+ * Get database/file schema using DuckDB
+ */
+export async function getDatabaseSchema(dbPath) {
+    const resolvedPath = validateDatabasePath(dbPath);
+    const fileType = getFileType(resolvedPath);
+    if (fileType === "unknown") {
+        throw new Error(`Unsupported file type. Supported: .db/.sqlite/.sqlite3 (SQLite), .csv, .parquet, .json, .jsonl/.ndjson`);
+    }
+    const instance = await DuckDBInstance.create(":memory:");
+    const conn = await instance.connect();
+    try {
+        // For SQLite, we need to install and load the sqlite extension
+        if (fileType === "sqlite") {
+            await conn.run("INSTALL sqlite");
+            await conn.run("LOAD sqlite");
+        }
+        const readFunc = getReadFunction(resolvedPath, fileType);
+        const tableName = getTableName(resolvedPath);
+        // For SQLite, we need to query the sqlite_master table
+        if (fileType === "sqlite") {
+            const escapedPath = resolvedPath.replace(/'/g, "''");
+            // Get table names
+            const tablesReader = await conn.runAndReadAll(`SELECT name FROM sqlite_scan('${escapedPath}', 'sqlite_master') WHERE type='table' AND name NOT LIKE 'sqlite_%'`);
+            const tables = tablesReader.getRowObjects();
+            if (!tables || tables.length === 0) {
+                return { tables: [] };
+            }
+            // Get columns for each table
+            const tableSchemas = [];
+            for (const table of tables) {
+                const columnsReader = await conn.runAndReadAll(`DESCRIBE SELECT * FROM sqlite_scan('${escapedPath}', '${table.name}') LIMIT 0`);
+                const columns = columnsReader.getRowObjects();
+                tableSchemas.push({
+                    name: table.name,
+                    columns: columns.map((col) => ({
+                        name: col.column_name,
+                        type: col.column_type,
+                        notNull: false,
+                        defaultValue: null,
+                        primaryKey: false,
+                    })),
+                });
+            }
+            return { tables: tableSchemas };
+        }
+        else {
+            // For file-based formats (CSV, Parquet, JSON)
+            const reader = await conn.runAndReadAll(`DESCRIBE SELECT * FROM ${readFunc} LIMIT 0`);
+            const columns = reader.getRowObjects();
+            const columnInfos = columns.map((col) => ({
+                name: col.column_name,
+                type: col.column_type,
+                notNull: false,
+                defaultValue: null,
+                primaryKey: false,
+            }));
+            return {
+                tables: [
+                    {
+                        name: tableName,
+                        columns: columnInfos,
+                    },
+                ],
+            };
+        }
+    }
+    finally {
+        conn.closeSync();
+        instance.closeSync();
+    }
+}
+/**
+ * Execute a SQL query using DuckDB
+ */
+export async function executeQuery(dbPath, sql) {
+    const resolvedPath = validateDatabasePath(dbPath);
+    const fileType = getFileType(resolvedPath);
+    validateReadOnlyQuery(sql);
+    if (fileType === "unknown") {
+        throw new Error(`Unsupported file type. Supported: .db/.sqlite/.sqlite3 (SQLite), .csv, .parquet, .json, .jsonl/.ndjson`);
+    }
+    const instance = await DuckDBInstance.create(":memory:");
+    const conn = await instance.connect();
+    try {
+        // For SQLite, install and load the extension first
+        if (fileType === "sqlite") {
+            await conn.run("INSTALL sqlite");
+            await conn.run("LOAD sqlite");
+        }
+        const readFunc = getReadFunction(resolvedPath, fileType);
+        const tableName = getTableName(resolvedPath);
+        // Replace table references with read function calls
+        let modifiedSql = sql;
+        // For SQLite, don't modify - queries reference tables directly via sqlite_scan
+        if (fileType !== "sqlite") {
+            modifiedSql = sql.replace(new RegExp(`\\b${tableName}\\b`, "gi"), readFunc);
+        }
+        const reader = await conn.runAndReadAll(modifiedSql);
+        const rawRows = reader.getRowObjects();
+        if (rawRows.length > MAX_ROWS) {
+            throw new Error(`Query returned ${rawRows.length} rows, exceeding limit of ${MAX_ROWS}`);
+        }
+        // Convert BigInt values to numbers for JSON serialization
+        const rows = rawRows.map((row) => {
+            const converted = {};
+            for (const [key, value] of Object.entries(row)) {
+                if (typeof value === "bigint") {
+                    converted[key] = Number(value);
+                }
+                else {
+                    converted[key] = value;
+                }
+            }
+            return converted;
+        });
+        const columns = reader.columnNames();
+        return {
+            rows,
+            columns,
+        };
+    }
+    finally {
+        conn.closeSync();
+        instance.closeSync();
+    }
+}

package/dist/index.js

@@ -4,6 +4,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { stateManager } from "./state.js";
 import { startApiServer, getServerPort } from "./api.js";
+import { getDatabaseSchema, executeQuery } from "./database.js";
+import { transformToTable, transformToSeries, extractXLabels, } from "./transformers.js";
 import open from "open";
 const server = new Server({
     name: "chart-canvas-server",
@@ -107,6 +109,80 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["id"],
                 },
             },
+            {
+                name: "updateVisualization",
+                description: "Update an existing visualization on the canvas. You can change its data, title, description, or any other property.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "ID of the visualization to update",
+                        },
+                        type: {
+                            type: "string",
+                            enum: ["line", "bar", "scatter", "table", "flowchart", "pie"],
+                            description: "Type of visualization",
+                        },
+                        series: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string" },
+                                    data: {
+                                        type: "array",
+                                        items: {
+                                            type: "array",
+                                            items: { type: "number" },
+                                            minItems: 2,
+                                            maxItems: 2,
+                                        },
+                                    },
+                                },
+                                required: ["name", "data"],
+                            },
+                            description: "Updated data series for charts",
+                        },
+                        table: {
+                            type: "object",
+                            properties: {
+                                headers: {
+                                    type: "array",
+                                    items: { type: "string" },
+                                },
+                                rows: {
+                                    type: "array",
+                                    items: {
+                                        type: "array",
+                                        items: { type: ["string", "number"] },
+                                    },
+                                },
+                            },
+                            required: ["headers", "rows"],
+                            description: "Updated table data",
+                        },
+                        mermaid: {
+                            type: "string",
+                            description: "Updated Mermaid diagram syntax",
+                        },
+                        title: {
+                            type: "string",
+                            description: "Updated title",
+                        },
+                        description: {
+                            type: "string",
+                            description: "Updated description",
+                        },
+                        xLabels: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Updated x-axis labels",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
             {
                 name: "clearCanvas",
                 description: "Remove all visualizations from the canvas",
@@ -123,6 +199,78 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {},
                 },
             },
+            {
+                name: "getDatabaseSchema",
+                description: "Get the schema of a data source (SQLite database, CSV, Parquet, or JSON file) including all tables/columns. Use this to understand the data structure before writing queries.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        databasePath: {
+                            type: "string",
+                            description: "Path to the data file. Supported formats: SQLite (.db, .sqlite, .sqlite3), CSV (.csv), Parquet (.parquet), JSON (.json, .jsonl, .ndjson)",
+                        },
+                    },
+                    required: ["databasePath"],
+                },
+            },
+            {
+                name: "queryAndVisualize",
+                description: "Execute a SQL query on a data source (SQLite, CSV, Parquet, or JSON file) and create a visualization from the results. The query must be read-only (SELECT only). You must specify how to map columns to the visualization.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        databasePath: {
+                            type: "string",
+                            description: "Path to the data file (SQLite, CSV, Parquet, JSON)",
+                        },
+                        query: {
+                            type: "string",
+                            description: "SQL SELECT query to execute (read-only, max 10000 rows)",
+                        },
+                        visualizationType: {
+                            type: "string",
+                            enum: ["line", "bar", "scatter", "table", "pie"],
+                            description: "Type of visualization to create from the query results",
+                        },
+                        columnMapping: {
+                            type: "object",
+                            properties: {
+                                xColumn: {
+                                    type: "string",
+                                    description: "Column to use for X-axis (required for charts, not needed for table)",
+                                },
+                                yColumns: {
+                                    type: "array",
+                                    items: { type: "string" },
+                                    description: "Column(s) to use for Y-axis values (required for charts, not needed for table)",
+                                },
+                                seriesColumn: {
+                                    type: "string",
+                                    description: "Optional: Column to group data into separate series (e.g., 'category', 'product_name')",
+                                },
+                                groupByColumn: {
+                                    type: "string",
+                                    description: "Optional: Column to group by (alternative to seriesColumn)",
+                                },
+                            },
+                            description: "Mapping of query result columns to chart axes. Not required for table type.",
+                        },
+                        title: {
+                            type: "string",
+                            description: "Optional title for the visualization",
+                        },
+                        description: {
+                            type: "string",
+                            description: "Optional description for the visualization",
+                        },
+                        useColumnAsXLabel: {
+                            type: "boolean",
+                            description: "If true, use the xColumn values as labels instead of numeric values (useful for dates/categories)",
+                        },
+                    },
+                    required: ["databasePath", "query", "visualizationType"],
+                },
+            },
         ],
     };
 });
@@ -164,6 +312,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ],
             };
         }
+        case "updateVisualization": {
+            const { id, type, series, table, mermaid, title, description, xLabels } = args;
+            const updates = {};
+            if (type !== undefined)
+                updates.type = type;
+            if (series !== undefined)
+                updates.series = series;
+            if (table !== undefined)
+                updates.table = table;
+            if (mermaid !== undefined)
+                updates.mermaid = mermaid;
+            if (title !== undefined)
+                updates.title = title;
+            if (description !== undefined)
+                updates.description = description;
+            if (xLabels !== undefined)
+                updates.xLabels = xLabels;
+            const updated = stateManager.updateVisualization(id, updates);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: updated
+                            ? `Updated visualization ${id}`
+                            : `Visualization ${id} not found`,
+                    },
+                ],
+            };
+        }
         case "clearCanvas": {
             stateManager.clearCanvas();
             return {
@@ -200,6 +377,115 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
         }
+        case "getDatabaseSchema": {
+            try {
+                const { databasePath } = args;
+                const schema = await getDatabaseSchema(databasePath);
+                // Format schema as readable text
+                let schemaText = `Data source schema for: ${databasePath}\n\n`;
+                for (const table of schema.tables) {
+                    schemaText += `Table: ${table.name}\n`;
+                    schemaText += `Columns:\n`;
+                    for (const col of table.columns) {
+                        const constraints = [];
+                        if (col.primaryKey)
+                            constraints.push("PRIMARY KEY");
+                        if (col.notNull)
+                            constraints.push("NOT NULL");
+                        if (col.defaultValue)
+                            constraints.push(`DEFAULT ${col.defaultValue}`);
+                        const constraintStr = constraints.length > 0 ? ` (${constraints.join(", ")})` : "";
+                        schemaText += `  - ${col.name}: ${col.type}${constraintStr}\n`;
+                    }
+                    schemaText += `\n`;
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: schemaText,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error getting data source schema: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                };
+            }
+        }
+        case "queryAndVisualize": {
+            try {
+                const { databasePath, query, visualizationType, columnMapping, title, description, useColumnAsXLabel, } = args;
+                // Execute query
+                const result = await executeQuery(databasePath, query);
+                if (result.rows.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "Query returned 0 rows. No visualization created.",
+                            },
+                        ],
+                    };
+                }
+                // Create visualization based on type
+                let viz;
+                if (visualizationType === "table") {
+                    // For tables, just transform all columns
+                    const tableData = transformToTable(result.rows, result.columns);
+                    viz = stateManager.addVisualization({
+                        type: "table",
+                        table: tableData,
+                        title,
+                        description,
+                    });
+                }
+                else {
+                    // For charts, need column mapping
+                    if (!columnMapping ||
+                        !columnMapping.xColumn ||
+                        !columnMapping.yColumns) {
+                        throw new Error("columnMapping with xColumn and yColumns is required for chart visualizations");
+                    }
+                    const series = transformToSeries(result.rows, result.columns, columnMapping);
+                    const xLabels = useColumnAsXLabel
+                        ? extractXLabels(result.rows, columnMapping.xColumn)
+                        : undefined;
+                    viz = stateManager.addVisualization({
+                        type: visualizationType,
+                        series,
+                        title,
+                        description,
+                        xLabels,
+                    });
+                }
+                const port = getServerPort() || 3000;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Created ${visualizationType} visualization with ${result.rows.length} rows. ID: ${viz.id}. View at http://localhost:${port}`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error executing query and creating visualization: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                };
+            }
+        }
         default:
             throw new Error(`Unknown tool: ${name}`);
     }

package/dist/state.js

@@ -28,6 +28,17 @@ class StateManager {
         this.state.visualizations = this.state.visualizations.filter((v) => v.id !== id);
         return this.state.visualizations.length < initialLength;
     }
+    updateVisualization(id, updates) {
+        const index = this.state.visualizations.findIndex((v) => v.id === id);
+        if (index === -1) {
+            return null;
+        }
+        this.state.visualizations[index] = {
+            ...this.state.visualizations[index],
+            ...updates,
+        };
+        return this.state.visualizations[index];
+    }
     clearCanvas() {
         this.state.visualizations = [];
     }

package/dist/transformers.js

@@ -0,0 +1,138 @@
+/**
+ * Transform SQL query results to TableData format
+ */
+export function transformToTable(rows, columns) {
+    if (rows.length === 0) {
+        return {
+            headers: columns,
+            rows: [],
+        };
+    }
+    return {
+        headers: columns,
+        rows: rows.map((row) => columns.map((col) => row[col])),
+    };
+}
+/**
+ * Transform SQL query results to SeriesData format for charts
+ */
+export function transformToSeries(rows, columns, mapping) {
+    if (rows.length === 0) {
+        return [];
+    }
+    const { xColumn, yColumns, seriesColumn, groupByColumn } = mapping;
+    // Validate required columns
+    if (!xColumn) {
+        throw new Error("xColumn is required for chart transformation");
+    }
+    if (!yColumns || yColumns.length === 0) {
+        throw new Error("At least one yColumn is required for chart transformation");
+    }
+    // Validate columns exist
+    if (!columns.includes(xColumn)) {
+        throw new Error(`xColumn '${xColumn}' not found in query results`);
+    }
+    for (const yCol of yColumns) {
+        if (!columns.includes(yCol)) {
+            throw new Error(`yColumn '${yCol}' not found in query results`);
+        }
+    }
+    if (seriesColumn && !columns.includes(seriesColumn)) {
+        throw new Error(`seriesColumn '${seriesColumn}' not found in query results`);
+    }
+    if (groupByColumn && !columns.includes(groupByColumn)) {
+        throw new Error(`groupByColumn '${groupByColumn}' not found in query results`);
+    }
+    // If there's a seriesColumn, group data by series
+    if (seriesColumn) {
+        return transformWithSeriesColumn(rows, xColumn, yColumns[0], seriesColumn);
+    }
+    // If there's a groupByColumn, create separate series for each group
+    if (groupByColumn) {
+        return transformWithGroupBy(rows, xColumn, yColumns[0], groupByColumn);
+    }
+    // Otherwise, create one series per yColumn
+    return transformMultipleYColumns(rows, xColumn, yColumns);
+}
+/**
+ * Transform data with a series column (e.g., different product lines)
+ */
+function transformWithSeriesColumn(rows, xColumn, yColumn, seriesColumn) {
+    const seriesMap = new Map();
+    for (const row of rows) {
+        const seriesName = String(row[seriesColumn]);
+        const xValue = parseNumericValue(row[xColumn]);
+        const yValue = parseNumericValue(row[yColumn]);
+        if (!seriesMap.has(seriesName)) {
+            seriesMap.set(seriesName, new Map());
+        }
+        seriesMap.get(seriesName).set(xValue, yValue);
+    }
+    const result = [];
+    for (const [seriesName, dataMap] of seriesMap.entries()) {
+        const data = Array.from(dataMap.entries()).sort((a, b) => a[0] - b[0]);
+        result.push({
+            name: seriesName,
+            data,
+        });
+    }
+    return result;
+}
+/**
+ * Transform data with a group by column
+ */
+function transformWithGroupBy(rows, xColumn, yColumn, groupByColumn) {
+    return transformWithSeriesColumn(rows, xColumn, yColumn, groupByColumn);
+}
+/**
+ * Transform data with multiple Y columns (each becomes a series)
+ */
+function transformMultipleYColumns(rows, xColumn, yColumns) {
+    const result = [];
+    for (const yColumn of yColumns) {
+        const data = rows
+            .map((row) => {
+            const xValue = parseNumericValue(row[xColumn]);
+            const yValue = parseNumericValue(row[yColumn]);
+            return [xValue, yValue];
+        })
+            .sort((a, b) => a[0] - b[0]);
+        result.push({
+            name: yColumn,
+            data,
+        });
+    }
+    return result;
+}
+/**
+ * Parse a value to number, handling various formats
+ */
+function parseNumericValue(value) {
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        // Try to parse as number
+        const parsed = parseFloat(value);
+        if (!isNaN(parsed)) {
+            return parsed;
+        }
+        // Try to parse as date
+        const date = Date.parse(value);
+        if (!isNaN(date)) {
+            return date;
+        }
+    }
+    // For other types, try to convert to number
+    const num = Number(value);
+    if (!isNaN(num)) {
+        return num;
+    }
+    throw new Error(`Cannot convert value to number: ${value}`);
+}
+/**
+ * Extract X labels from query results
+ */
+export function extractXLabels(rows, xColumn) {
+    return rows.map((row) => String(row[xColumn]));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gluip/chart-canvas-mcp",
-  "version": "0.1.5",
-  "description": "MCP server for creating interactive visualizations (charts, diagrams, tables) through AI assistants",
+  "version": "0.3.0",
+  "description": "MCP server for creating interactive visualizations (charts, diagrams, tables) and querying data sources (SQLite, CSV, Parquet, JSON) through AI assistants",
   "author": "Martijn",
   "license": "MIT",
   "type": "module",
@@ -22,7 +22,11 @@
     "echarts",
     "mermaid",
     "ai",
-    "llm"
+    "llm",
+    "sqlite",
+    "database",
+    "sql",
+    "query"
   ],
   "repository": {
     "type": "git",
@@ -39,6 +43,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
+    "@duckdb/node-api": "^1.4.3-r.3",
     "express": "^4.21.2",
     "cors": "^2.8.5",
     "open": "^10.1.0"