albugent-webmcp

Albugent WebMCP brings browser-native data governance—combining deterministic WASM calculation with human-approved AI remediation.

Comment

Name Origin Notice

Albugent is derived from Albumin — the vital, invisible plasma protein produced by the liver that maintains osmotic pressure and safely transports nutrients throughout the human body. Much like Albumin, true data governance works silently in the background: maintaining structural pressure, ensuring compliance, and safely regulating data flow without disrupting operational pipelines. (100% human-conceived project name, not AI-generated).

Inspiration

Data governance tools are traditionally split into two disconnected worlds: a human scanning visual dashboards for anomalies, and an AI agent asked by a data engineer to "check if anything looks off."

In conventional setups, the agent operates blindly — screen-scraping UI elements, guessing what buttons do, or attempting complex calculations inline. When autonomous LLM agents chain dozens of unguided tool calls and perform mathematical profiling, context drift leads to hallucinated metrics and broken schemas.

We built Albugent to prove a different paradigm: What if the dashboard and the AI agent shared one single, typed computation layer?

WebMCP (document.modelContext.registerTool) provides the exact browser-native primitive for this pattern. Instead of the agent guessing what the UI sees, Albugent exposes a single in-browser governance engine twice:

  1. As a reactive pixel-rendered dashboard for human operators.
  2. As deterministic WebMCP tools for the LLM agent.

Both read from the exact same client-side SQLite WASM databases. The core design rule: The engine computes and executes; the agent decides and explains.

What it does

Albugent WebMCP is a 100% browser-native data governance engine auditing 17 datasets across three enterprise domains (healthcare, fiction-retail, nyc-taxi pipelines) loaded entirely client-side via SQLite WASM. Zero server backend; zero data leaves the browser.

For the Human Operator:

  • Live Governance Dashboard: Real-time health status (Healthy / Warning / Critical) across all 17 datasets, driven by a unified risk-scoring formula (0–100).
  • Independent Compliance Badges: Always-visible PII exposure and NULL-density warning icons next to every dataset, preventing critical compliance flags (like 5 PII columns scoring 25/100) from being hidden inside an averaged numeric risk score.
  • Interactive KPI Drill-Downs: Zero-dependency visual charts for system-wide compliance metrics.
  • Dataset Detail & Lineage Views: Column-level NULL profiling, detected PII severity, and inferred pipeline relationships (raw_ → staging_ → mart_).

For the AI Agent (via WebMCP):

A floating chat widget powered by Groq connects directly to 7 registered WebMCP tools (document.modelContext). Tool calls are collapsed into expandable audit traces under each message.

Human-in-the-Loop Remediation Loop (The Core Workflow):

  1. Contextual Action: Clicking "Propose masking fix" next to a flagged table pre-fills a chat prompt with the exact dataset URN.
  2. Deterministic Evaluation: The agent invokes propose_remediation. The engine re-evaluates the real risk score. If risk is low, the tool refuses action with exact metrics unless explicit force=true is requested.
  3. Inline Approval: When a proposal is generated, Approve / Reject controls render directly inside the chat bubble.
  4. WASM SQL Execution: Approving executes a dynamic UPDATE statement against the in-memory SQLite database, instantly masking PII columns.
  5. Live State Sync: The entire UI (KPI cards, dataset badges, compliance icons) refreshes live without reloading the page.

How we built it

  • Frontend & UI: Vite, React, TypeScript, Tailwind CSS v4.
  • Computation Engine: Web Worker running @sqlite.org/sqlite-wasm with sqlite3_deserialize for zero-latency, client-side SQL execution.
  • Agent Integration: Groq API (OpenAI-compatible) executing a strict single-tool-call loop.
  • WebMCP Integration: toolRegistry.ts registers 7 tools on document.modelContext, passing readOnlyHint: true on query tools per Chrome security guidelines.
  • Decoupled State Bridge: proposalStore.ts provides a pub/sub event bus bridging WebMCP tool calls registered at application boot (main.tsx) with React UI state (App.tsx).

Challenges we ran into

1. WASM & Worker Asset Resolution

In production, Vite's SPA fallback initially served index.html for mistyped worker or database paths, producing misleading non-JavaScript MIME type and SQLITE_NOTADB errors. We resolved this by building strict URL maps and wrapping all SQLite operations in a shared WASM initialization promise (ensureSqliteInitialized) to eliminate race conditions during initial load.

2. Guardrail Enforcement Beyond tool_choice: 'none'

We discovered that passing tool_choice: 'none' on follow-up turns did not reliably prevent models from attempting tool calls, causing API rejections. The solution was structural: finalizing completion requests are sent with the tools array completely omitted from the payload, removing the schema shape entirely.

3. Agent Architecture Fabrications

During testing, when asked why it executed a remediation, the LLM fabricated a plausible-sounding "automatic risk engine threshold" that did not exist in the code. We resolved this by enforcing strict engine-level risk re-checks in propose_remediation (returning real numerical proof) and updating system prompts to forbid ungrounded operational claims.

4. Blended Risk Scores vs. Strict Compliance Requirements

Initially, computeRiskScore assigned a categorical +25 score for MEDIUM-PII presence. For datasets like mart_demographics (containing 5 PII columns but low NULL density), this resulted in a score of 25/100, visually signaling "Healthy/Low Risk." In enterprise data governance, the presence of PII is an absolute compliance event, not an averaged metric. We corrected this architecture by decoupling compliance indicators from the numeric score, adding independent dataset-level warning icons that ignite strictly on anomaly presence regardless of the blended score.

Accomplishments that we're proud of

  • True Shared Truth: The dashboard and the LLM agent receive identical JSON outputs computed by the exact same TypeScript worker logic.
  • Real In-Browser Remediation: MASK_PII generates and runs dynamic SQL queries directly inside SQLite WASM, updating reactive UI state end-to-end.
  • Strict Guardrails: The agent never computes math or hallucinates risk scores — it relies 100% on deterministic profiling.
  • First Full-Stack Reactive UI: Designed and built my first full web interface from scratch, successfully orchestrating client-side React state, SQLite WASM worker event loops, and live WebMCP tool execution into a single reactive dashboard.
  • Compliance-First UX Architecture: Successfully separated strict binary compliance flags (PII presence) from aggregated numerical risk scores, ensuring critical compliance issues are never hidden from human operators.

What we learned

  1. API Guardrails Must Be Structural: Relying on soft parameters like tool_choice: 'none' is insufficient. True reliability requires physically altering the schema payload passed to the model.
  2. LLM Fluency Is Not Correctness: An agent that confidently invents explanations for its behavior is more dangerous than one emitting obvious errors. Grounding every action in deterministic worker output is mandatory for enterprise tools.
  3. Full-Stack Execution & Team Specialization: Building a custom reactive UI for the first time and bridging complex front-end state with the SQLite WASM engine consumed a massive amount of development time, leaving less bandwidth for UI polish. The primary personal insight: building complex agentic systems as a solo developer highlights the critical need for a balanced team — allowing focus to be directed entirely toward core engine architecture, logic, and data governance, where my true strengths lie.

What's next for Albugent WebMCP

  • Governance Tool SDK: Build a standard, extensible SDK allowing developers to wrap arbitrary SQL databases into WebMCP tools with zero custom UI coding.
  • Full Remediation Execution: Implement dynamic SQL generators for REMEDIATE_NULLS and CIRCUIT_BREAK proposal types.
  • FK-Based Lineage Engine: Upgrade naming-convention heuristics to full foreign-key graph parsing.
  • Agent Evals & Resilient Tooling: Implement structured error recovery guidance and automated evaluation suites for WebMCP tool consistency.

Built With

  • chatgpt
  • claude
  • compatible
  • css
  • cursor
  • document.modelcontext
  • googlechromecanary
  • groq-ai-(openai
  • networkx
  • readonlyhint:
  • sqlite-wasm
  • tailwindcss
  • typescript
  • vercel
  • vite
  • webmcp
Share this project:

Updates