AlchemyLake for Databricks

Install a governed creative surface directly inside your Databricks workspace. AlchemyLake turns the data your lakehouse already trusts into finished deliverables Genie doesn't make: board-ready PowerPoint decks with a read-aloud script and Q&A prep under every slide, enterprise PDF dossiers with a statistical appendix and an Excel evidence workbook, deep-research dossiers (a planned multi-step investigation — Genie sources get governed SQL follow-ups in one continuing conversation), designed infographics, animated video briefings with narration (six formats), two-host data podcasts (five formats), and sonified scores (six genres) whose tempo follows your growth.

Get started free — no card required

1. Sign up — 50 free credits land in your account immediately, nothing to enter but an email.
2. Grab a developer key — sign in at app.alchemylake.com → Studio → Developer · MCP & keys → Forge a new key (starts with alk_…).
3. Clone this repo and deploy it into your Databricks workspace:

   git clone https://github.com/zorost/alchemylake-databricks.git
   cd alchemylake-databricks
   # edit the workspace host in databricks.yml (see Path 1 below), then:
   databricks bundle deploy -t prod
   databricks bundle run alchemylake_app -t prod
   

   Tracking main gets you the latest build; git checkout v0.4.0 first pins the deploy to a tagged release instead, if you'd rather not move with main.
4. Open the App URL the CLI prints, paste your key, then Load governed sources → pick one → Transmute.

That's a governed PDF, deck, infographic, or video briefing — sealed to your own data, running inside your own workspace — for free, in about five minutes. No Databricks Apps on your workspace? Skip straight to Path 2 — register one URL and Genie, Claude, or Cursor get the same 50 free credits to work with, no bundle required.

Every lane binds to a governed source, and the numbers discipline holds throughout: the platform computes an analyst-grade statistical dossier from the bound rows by code — trend with fit quality, outliers, correlations, segment shares, concentration, pivots — the model never authors a figure, a verifier checks every claim after generation, and the result is sealed (source · row count · data sha256 · verification score) with the seal embedded in the file itself. Genie answers bind as sources too, and one-click recipes ship a board deck or a whole campaign pack from one table. Every credit accounted.

Where Genie stops, AlchemyLake starts. Genie answers questions about your data inside the workspace — tables and charts. AlchemyLake takes the same governed rows the last mile: "Ask Genie for Q2 revenue by region, then render an 8-slide deck titled Q2 Momentum" leaves the workspace as a .pptx the CFO can present cold — every figure verified against the rows, provenance sealed into the file.

This repository is a self-contained Databricks Asset Bundle. One command deploys a Databricks App (SSO-authenticated, running on your workspace) that calls the AlchemyLake platform over MCP. Nothing bypasses governance: the same credit ledger, provenance seals, and role checks that protect the web app protect every call made from inside Databricks. Your data never leaves the lakehouse except as the exact rows you choose to bind.

.
├── databricks.yml        # the Asset Bundle (App resource + targets)
├── app/
│   ├── app.py            # the Streamlit App (thin MCP client)
│   ├── app.yaml          # App runtime config (command + env)
│   └── requirements.txt
└── sql/
    └── ai_render.sql     # optional UC function: call AlchemyLake from SQL/Genie

Three ways to use AlchemyLake with Databricks

What agents can ship from a table (things a Genie answer alone cannot):

• render_deep_research — a planned multi-step investigation: the brief is decomposed into sub-questions, each answered with real evidence (Genie sources get governed SQL follow-ups in one continuing conversation), then synthesized into a sealed PDF dossier + Excel evidence workbook.
• render_presentation — a .pptx board deck, 5–20 slides, speaker script + Q&A in every notes pane, AI cover art, real charts from the rows.
• render_report — an enterprise PDF dossier (KPI band, chart sections, statistical appendix, citations, methodology) plus an Excel evidence workbook: raw rows, facts, statistics, pivot, correlations.
• render_infographic — a designed KPI poster with the exact figures rendered in-image and a branded provenance strip.
• render_video_briefing — an animated video briefing: platform-drawn charts, spoken narration, motion and crossfades. Six formats (style param): consultant walkthrough, newsroom segment, executive stand-up, documentary deep-dive, field report, social recap.
• render_podcast — a two-host audio briefing with a sealed transcript. Five formats: two-host interview, skeptic's debate, executive stand-up, narrative deep-dive, plain-language walkthrough.
• render_music — a sonified score (tempo ↔ momentum, mode ↔ trend) plus the literal data-motif WAV of the rows. Six genres: cinematic score, corporate uplift, ambient data fields, electronic pulse, orchestral arc, lo-fi data study.

Prefer plain REST? The same keys work on the public API: https://app.alchemylake.com/api/public/v1 (OpenAPI at /api/public/v1/openapi.json). Prefer a terminal? npx alchemylake is a zero-dependency CLI over that API:

export ALCHEMYLAKE_API_KEY=alk_YOUR_KEY
npx alchemylake upload ./q3-actuals.xlsx       # CSV/Excel/PDF/Word/text → governed source
npx alchemylake render report --prompt "Board brief" --source up.1a2b3c
npx alchemylake render deep_research --prompt "Why did Q3 dip?" --source genie:dbx1

How it fits together

AlchemyLake never runs inside this bundle — the App is a thin, SSO'd client that calls the governed platform over HTTPS/MCP. Your tables stay in your lakehouse; only the exact rows you bind for a given render ever leave the workspace, and only to produce that one sealed deliverable.

flowchart LR
    subgraph WS["Your Databricks workspace"]
        UC[("Unity Catalog<br/>tables & volumes")]
        Genie["Genie space"]
        CSV["Uploaded CSV / Excel"]
        App["AlchemyLake App<br/>(this bundle · Streamlit · SSO'd)"]
        Agents["Genie / Agent Bricks<br/>Claude · Cursor"]
    end

    AL(["AlchemyLake<br/>governed render platform"])

    UC -- "bind rows" --> App
    Genie -- "bind an answer<br/>(conversation continues)" --> App
    CSV -- "bind (BYO-data)" --> App
    App <-- "MCP: render, verify, seal" --> AL
    Agents <-- "13 MCP tools, same contract" --> AL
    AL -. "no-egress text tier" .-> FM["Your Databricks<br/>Foundation Model endpoint"]

    AL --> Out(["Sealed deliverable<br/>PDF · PPTX · image · video · audio"])

Every render — from the App, from an agent, or from ai_render() in SQL — goes through the same discipline before it comes back:

flowchart LR
    A["Bind<br/><sub>pick a governed source</sub>"] --> B["Analyze<br/><sub>compute the facts</sub>"]
    B --> C["Design<br/><sub>plan the deliverable</sub>"]
    C --> D["Transmute<br/><sub>generate</sub>"]
    D --> E["Verify<br/><sub>check every claim</sub>"]
    E --> F["Seal<br/><sub>embed provenance</sub>"]

The model is never the source of a number — every figure is computed from your rows first, and whatever the render says is checked against those figures afterward. The seal (source · row count · data hash · verification score) rides embedded in the file itself, in every format, so it survives being forwarded, downloaded, or printed.

Beyond a Genie answer