Alephgrid

dev.alephgridPublished by alephgrid.devv0.1.0Updated Nov 1, 2026

Read-only MCP access to Alephgrid workbooks: schema cards, reads, SQL, saved queries, receipts.

VerifiedStreamable HTTPWeb executableDatabasesData & Analytics

Overview

AI-generated overview

Read-only MCP access to Alephgrid workbooks, letting an assistant inspect schemas, read tables and sheets, run read-only SQL and saved queries.

What you can do
  • Inspect workbook structure through schema cards and catalog search
  • Read rows from tables and sheets, including filtered views
  • Run read-only SQL against the workbook's own tables
  • Run saved queries and analyses, with content-hashed receipts for each result
  • Track activity per agent connection
When to use it
Useful when an assistant needs to explore or query large Alephgrid workbooks (CSV, Parquet, JSON or XLSX data) without editing them, for example to answer questions over big tables or reuse saved queries and analyses.
Requirements
A remote Alephgrid server reachable over Streamable HTTP at the /mcp endpoint, plus a bearer token created in Alephgrid under a space or workbook, sent in the Authorization header. The token is shown once and prefixed agc_.
Before you install
The connection token is a secret; anyone holding it can read the workbook data it grants access to. Access is read-only, but data leaves the Alephgrid server toward the assistant, so check what the space or workbook exposes. The product is pre-release.

Installation

In SourceWeft

  1. Open Alephgrid in the dashboard and add it to a workspace.
  2. Connect Authorization token credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Other MCP clients

Follow the launch instructions in the repository.

README

[Alephgrid]

An open-source spreadsheet for data that doesn't fit in a spreadsheet.
Hundreds of millions of rows, real spreadsheet formulas, SQL when you want it.
Runs on your laptop or your own server. Your data never leaves it.

[Website: alephgrid.dev] [License: Apache-2.0] [Status: pre-release] [Built with Rust and TypeScript]

[A sheet totalling a 20,000-row orders table with SUMIFS, formatted as currency and percentages, with a column chart of revenue by region and a selection showing the fill handle]

Open a CSV or Parquet file with hundreds of millions of rows, then scroll, sort, filter, edit and add calculated columns in your browser. Next to those big tables, build ordinary sheets with formatting, charts and Excel formulas such as XLOOKUP and SUMIFS, and point those formulas straight at the big tables. Everything runs on a DuckDB file on your machine. There are no seats, tiers or paywalls: export, sign-in, teams and every other feature are free.

bash
alephgrid flights.parquet          # opens http://127.0.0.1:7878 with the file loadedalephgrid --demo-rows 100000000    # or try it on 100M generated rows
[The Functions side panel beside a sheet: a MARGIN function's code, its passing test result and the Publish version button][Dark theme: a 200,000-row flights table with the SQL workspace docked under the grid, showing a GROUP BY query and its results]
Your own functions in a side panel: code, tests, docs and versionsSQL when you want it, docked under the grid (dark theme)
[The hub: search, three recently opened workbooks and the workbook list with contents, size and compute state]
The hub: every workbook, its size and whether its compute is running

Status: pre-release. The first release (v0.1.0) is being prepared. Build from source or with Docker today; published binaries and images come with the release. See what is shipped and what is not.

Why Alephgrid

  • Big tables stay fast. Opening a workbook reads nothing into memory. The grid asks only for the rows on screen, so scrolling to row 900,000,000 is a range read. Sorts build a permutation, not a copy; calculated columns are computed only for the rows you look at.
  • A real spreadsheet next to them. Sheets use Excel syntax and an Excel-compatible engine (IronCalc), with formatting, merged cells, frozen panes, charts, colour rules, comments and XLSX import and export.
  • Spreadsheet formulas over big tables. =XLOOKUP(A2, customers[id], customers[region]) and =SUMIFS(orders[amount], orders[region], A2) in a sheet cell run as one query over the whole table, not one lookup per row. See table formulas.
  • No SQL required, SQL available. Filters, pivots, joins and charts work without writing SQL; the SQL workspace stays closed until you open it, and a server can turn it off.
  • Yours to run. One binary with the UI embedded, data in a plain directory, Apache-2.0. Teams get spaces, roles, single sign-on, audit, quotas and backups in the same binary.
  • Agents through MCP. Give an AI agent read access to a workbook's tables, sheets and saved queries over the Model Context Protocol, with a receipt for every result.

Features

ImportCSV/TSV (auto-detected), Parquet, JSON/JSONL, gzip as tables; XLSX as editable sheets. Drag and drop or CLI. Streamed, reviewed in a side pane with column types and samples
TablesVirtual canvas grid for any number of rows; typed edits, insert and delete rows; add, rename and delete columns; calculated columns (=[fare_usd] / [distance_mi]); multi-column sort and filters over the whole table; header value filters with counts; saved views
SheetsExcel formulas, cross-sheet references, named ranges, dynamic arrays, LET / LAMBDA; formula autocomplete and argument help; undo/redo
EditingKeyboard first: arrows, Shift and Mod selection, F2, Mod+A (the filled block, then the sheet), copy, cut, paste with formulas translated, paste special (values, formulas, formats, transpose), fill down and right, and a fill handle that continues series (1, 2 → 3, 4; Week 1 → Week 2) or repeats patterns. See keyboard
Formatting and layoutBold, italic, underline, strikethrough, sizes, colours, borders, alignment, wrap, number formats, merged cells; frozen rows and columns, sizes, hide and unhide, zoom 50–200%; kept through XLSX
Sheet dataFind and replace (one sheet or all), sort and filter a range, colour rules and scales, allowed-value lists, charts (column, bar, line, area, scatter, pie) previewed before they are saved, comments with replies
AnalysisLive sum, average and count of the selection; the Analyze pane for summaries, pivots, joins, charts and column profiles without SQL; deduplicate, split, trim and convert types with previews
SQLSchema browser, autocomplete, $parameters, cancellable previews, saved and live queries with versions, tables from queries, complete exports; reads the workbook's own tables only
FunctionsDefine reusable functions as sheet formulas, SQL expressions or sandboxed Python; test them, publish versions, pin and roll back. See functions
ExportCSV, Parquet or JSON lines for any table or filtered view; XLSX for sheets, with a report of anything XLSX cannot hold
CollaborationSeveral people on one workbook see each other's edits live; history and revision restore
TeamsOrganizations, spaces, owner/editor/viewer roles (also from identity-provider groups), invitations, service tokens, password or OpenID Connect sign-in, quotas, audit log, backups and an administration screen. See teams
ComputeEach open workbook gets its own share of memory and threads, sleeps when idle and wakes when opened; larger sizes (--profile) for heavy workbooks. See compute
Agents (MCP)Read-only agent connections per space or workbook over Streamable HTTP (/mcp) or stdio (alephgrid mcp): schema cards, catalog search, reads, read-only SQL, saved queries and analyses, content-hashed receipts, activity per connection

The full inventory, including what is partial or not planned, is in docs/SPREADSHEET_FEATURES.md.

Quick start

Install a release

From v0.1.0 (being prepared; see releasing):

bash
npx alephgrid flights.parquet                         # npm, or: pnpm dlx / yarn dlx / bunx alephgriddocker run -p 7878:7878 -v alephgrid-data:/data ghcr.io/alephgrid/alephgrid

or download alephgrid-VERSION-TARGET.tar.gz for Linux (x86_64, arm64) or macOS (Apple silicon, Intel) from GitHub Releases and check it against SHA256SUMS. On Windows, use Docker or WSL.

From source

Requires Rust 1.88+ and Node 20+.

bash
git clone https://github.com/alephgrid/alephgrid && cd alephgrid(cd web && npm install && npm run build)       # build the UI (embedded into the binary)cargo build --release./target/release/alephgrid --demo-rows 10000000

The first build compiles DuckDB from source, which takes several minutes.

Docker (for a team)

bash
docker compose up -ddocker compose logs alephgrid | grep "setup code"   # the one-time code that creates the adminopen http://localhost:7878/setup

With --auth accounts, people sign in with a password or single sign-on (OpenID Connect), and spaces grant them roles; see docs/TEAMS.md. Without it (the default on your own machine), there is no sign-in and the server only listens on 127.0.0.1. Running it for others, backups, upgrades and restores are covered in docs/OPERATIONS.md.

Options

FlagEnvDefault
--data-dirALEPHGRID_DATA_DIR./alephgrid-data
--host / --portALEPHGRID_HOST / ALEPHGRID_PORT127.0.0.1 / 7878
--auth local|accountsALEPHGRID_AUTHlocal: no sign-in, loopback only
--public-urlALEPHGRID_PUBLIC_URLhow people reach the server (needed for SSO; https makes cookies Secure)
--oidc-issuer, --oidc-client-idALEPHGRID_OIDC_* (secret: ALEPHGRID_OIDC_CLIENT_SECRET)no single sign-on
--session-hoursALEPHGRID_SESSION_HOURS12
--space-storage, --space-workbooks, --space-jobs, --space-open-workbooksALEPHGRID_SPACE_*no limits (admins can set them per space)
--memory-limitALEPHGRID_MEMORY_LIMITDuckDB default (80% of RAM, spills to disk)
--threadsALEPHGRID_THREADSall cores
--disk-reserveALEPHGRID_DISK_RESERVE32MiB kept back so the server can still restart when the disk fills (operations)
--idle-timeoutseconds without activity before a workbook's compute sleeps
--profile name=MEM:THREADS[:dedicated]extra compute sizes admins can grant to spaces
--disable-sqlALEPHGRID_DISABLE_SQLSQL allowed; when set, every operation that runs user-written SQL is refused
--demo-rows Ngenerate a demo workbook
alephgrid mcp --url URL --token agc_…ALEPHGRID_URL, ALEPHGRID_AGENT_TOKENconnect an MCP client over stdio to a running server (docs/MCP.md)

alephgrid --help lists every option.

Formulas

In sheets, formulas use Excel syntax: =SUM(B2:B9), =XLOOKUP(...), =Budget!B4*2. A sheet formula can read a whole table by name:

=SUMIFS(orders[amount], orders[region], $A2, orders[month], $B$1)=XLOOKUP(A2, customers[id], customers[region], "none")

Fill or drag it like any formula; each copy reads its own row. The formula catalog lists supported functions with tested examples, and known gaps are documented with reproducible inputs.

In tables, calculated columns refer to columns by name, and the leading = is optional:

=[fare_usd] / [distance_mi]=CASE WHEN [dep_delay_min] > 15 THEN 'late' ELSE 'on time' END=[origin] || '→' || [dest]

Typical flow: summarise 100M rows with Analyze or SQL, choose Open in sheet, then model on top of the result.

How it is built

  • DuckDB underneath. Every workbook is one DuckDB file: columnar, compressed and parallel across cores. Imports use DuckDB's own CSV, Parquet and JSON readers.
  • IronCalc for sheets, stored in the same workbook file.
  • Rust server (axum, HTTP and WebSocket) with the UI embedded; TypeScript client with a canvas grid, no framework. Wire types are generated from Rust, and a test fails when they drift.

See docs/ARCHITECTURE.md.

Measured (20M-row table, 9 columns, debug build, 8-core / 8 GB laptop)

OperationTime
Reopen the workbook after a restart3 ms (no rehydrate)
Fetch 100 rows at row 0 / 10M / 19.99M3–11 ms
Filter carrier = DL AND origin = SEA (125k matches)34 ms
Sort 20M rows by a float column0.95 s
Sum/avg/min/max of a column over all 20M rows28 ms
GROUP BY carrier via SQL39–57 ms
Edit 1 cell / paste 1,000 cells3 ms / 43 ms

Reproduce with alephgrid --demo-rows 20000000 and docs/bench.mjs. Release-build benchmarks over varied data shapes will be published with v0.1.0.

Documentation

Start at docs/README.md. The most used pages:

ForRead
Spreadsheet usersFeatures · Keyboard · Table formulas · Functions · Analysis
Running a serverOperations · Teams · Compute · Security · MCP
ContributorsContributing · Architecture · Protocol · Test strategy

Development

bash
cargo run -p alephgrid-server -- --demo-rows 1000000   # API on :7878cd web && npm run dev                                  # UI with hot reload on :5173 (proxies to :7878)cargo test --workspace
crates/alephgrid-core     DuckDB tables, views, formulas, IronCalc sheets (pure Rust library)crates/alephgrid-server   axum HTTP + WebSocket server, CLI, MCP, embedded UIweb/                      TypeScript client (canvas grid, row cache, UI) and browser testsdocs/                     user, operator and contributor documentation

README screenshots are generated from the running product by web/scripts/readme-screenshots.mjs.

Roadmap

Next after v0.1.0: S3 and Parquet data read in place, then multi-machine deployments on Kubernetes. See docs/ROADMAP.md and the implementation checklist.

Community

  • Questions and ideas: GitHub Discussions.
  • Bugs: open an issue with steps to reproduce.
  • Security problems: please report privately; see SECURITY.md.
  • Contributing: CONTRIBUTING.md. Everyone taking part follows the code of conduct.

License

Apache-2.0. Use it, host it and build on it, commercially or not.

Source: README.md at commit 067b9b4

Tools

0
This server asks for a credential such as an API key, so SourceWeft could not read its tools without one and has not indexed them.

Version history

1
  1. v0.1.0LatestNov 1, 2026

Score

60% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts