LabOps Agent 🔬

Slack Agent for Good — Slack Agent Builder Challenge 2026 (Salesforce/Devpost)

Predict. Alert. Act. All from Slack.

LabOps Agent is a Slack-native AI agent that predicts reagent stockouts in clinical laboratories before they happen, based on historical demand patterns by test type — and enables lab staff to act directly from Slack without switching to external LIMS systems.

The Problem

Clinical laboratories run on reagents. When a critical reagent runs out mid-operation, testing stops. Current solutions (Quartzy, Scispot) only send passive threshold alerts after stock is already low. No product today predicts stockouts based on test-type demand patterns.

Example: TSH demand spikes every autumn in Argentina (Mar–May, 2.5x ratio). A lab with 680 units, at a projected demand of ~147 units/day, runs out in ~6 days — inside the 7-day reorder window. Without prediction, they find out when the analyzer throws an error.

Related MCP server: MCP Slack Python

What LabOps Agent Does

1. Predicts stockouts using Prophet, calibrated with patterns derived from anonymized demand analysis in Argentine clinical labs

2. Alerts lab staff in #labops-alerts with interactive Block Kit messages — before the stockout happens

3. Acts — staff orders reagents, assigns tasks, and updates inventory without leaving Slack

Why LabOps Agent is Different

No existing product (Quartzy, Scispot, Benchling) combines:

• Prediction by test type — TSH spikes in autumn (Mar–May), Hemograma is stable; each reagent gets its own Prophet model

• Native Slack agent — not a webhook or Zapier bridge; Bolt Python with Socket Mode, interactive Block Kit buttons, and modals

• Domain expertise — built by someone with 4 years of B2B KAM experience in clinical diagnostics (Argentina), not a generic inventory template

Technologies Used

Design decision note: search.messages (Slack Search API) was evaluated but replaced by conversations_replies (Channel History API) for thread history retrieval. search.messages requires a workspace user token (xoxp-) which is not available in standard bot-token deployments; the bot token returns empty results. Thread-scoped history via conversations_replies provides the relevant alert context without requiring a user token.

MCP Server

LabOps Agent exposes a real MCP Server using the official Anthropic MCP Python SDK:

# Run MCP Server (stdio transport)
cd backend
python mcp_server.py

Tools available:

• get_inventory — Query current reagent stock

• get_forecast — Prophet demand forecast

• create_order — Create reagent order

• update_canvas — Update inventory Canvas

Architecture

┌─────────────────────────────────────────────────────┐
│                  SLACK WORKSPACE                     │
│   #labops-alerts  │  Canvas Inventario  │  App Home  │
└──────────────────┬──────────────────────────────────┘
                   │ Bolt Python (Socket Mode)
┌──────────────────▼──────────────────────────────────┐
│                FASTAPI BACKEND                       │
│  ┌─────────────────┐   ┌──────────────────────────┐ │
│  │   MCP SERVER    │   │   PREDICTION ENGINE      │ │
│  │ get_inventory   │   │   Prophet + seasonality  │ │
│  │ get_forecast    │   │   params from 414K B2B   │ │
│  │ create_order    │   │   CV MAPE 8-11% (synth)  │ │
│  │ update_canvas   │   └──────────────────────────┘ │
│  └─────────────────┘                                 │
└─────────────────────────────────┬───────────────────┘
                                  │
┌─────────────────────────────────▼───────────────────┐
│                    SUPABASE                          │
│  inventory │ demand_history │ orders │ alerts_log    │
└─────────────────────────────────────────────────────┘
                                  │
┌─────────────────────────────────▼───────────────────┐
│                  CLAUDE API                          │
│  Natural language explanations of predictions        │
└─────────────────────────────────────────────────────┘

Demo Flow (3 minutes)

0:00–0:45 — Agent detects TSH will run out in ~6 days (demand forecast exceeds stock)

0:45–1:30 — Alert fires in #labops-alerts with Block Kit buttons:

• 📊 Ver proyección

• 🛒 Ordenar reactivo

• 👤 Asignar al equipo

1:30–2:15 — User clicks "Ordenar reactivo" → modal opens → one click confirms → Canvas auto-updates

2:15–3:00 — Agent explains WHY TSH is at risk (seasonal demand pattern) → Claude API summarizes past incidents

Try it Live

Demo video (≤3 min): Watch on YouTube — full demo with voiceover narration. Live deploy: https://labops-agent.onrender.com (Render persistent host — Socket Mode + FastAPI co-hosted) Sandbox workspace: https://labopsespacio.slack.com (invite-only sandbox).

Reproduce the live deploy (judge-reachable, chart renders)

Slack fetches forecast-chart images from its own servers, so the backend must be reachable over public HTTPS. Socket Mode also needs a persistent host, so this deploys to Render/Railway/Fly — not Vercel serverless (see Deployment).

1. Join the Slack Developer Program and create a Developer Sandbox workspace.

2. Create a new app from slack-manifest.json, install it, and copy the Bot + App tokens.

3. Deploy with the included render.yaml blueprint (one persistent web service hosts both the chart endpoint and the Socket Mode websocket).

4. After the first deploy, set BACKEND_URL=https://labops-agent.onrender.com (or your service URL) and redeploy so the forecast chart renders in Slack.

Local + tunnel (for recording the demo on your machine):

docker-compose up --build                 # backend + slack client + DB
cloudflared tunnel --url http://localhost:8000   # public HTTPS for the chart
# set BACKEND_URL=https://<random>.trycloudflare.com in .env, restart slack_client

Without a public BACKEND_URL, the forecast still shows as native Block Kit fields — the chart image is simply omitted, never broken.

Setup Instructions

Prerequisites

• Python 3.11+

• Supabase account

• Slack Developer Sandbox (via Slack Developer Program)

• Anthropic API key

1. Clone and install

git clone https://github.com/Marianooss/labops-agent
cd labops-agent
pip install -r requirements.txt

2. Configure environment

cp .env.example .env
# Fill in your keys:
# SUPABASE_URL, SUPABASE_KEY
# SLACK_BOT_TOKEN, SLACK_APP_TOKEN, SLACK_SIGNING_SECRET
# SLACK_USER_TOKEN (optional — only for Slack Search API, not used in current implementation)
# ANTHROPIC_API_KEY
# LABOPS_ALERTS_CHANNEL=#labops-alerts

3. Set up Supabase

# Run in Supabase SQL Editor:
# 1. data/create_tables.sql
# 2. data/seed_data.sql

4. Create Slack App (from manifest)

1. Go to api.slack.com/apps → Create New App

2. Select From an app manifest

3. Choose your Developer Sandbox workspace

4. Paste the contents of slack-manifest.json

5. Click Create

6. Go to OAuth & Permissions → Install to Workspace

7. Copy the Bot User OAuth Token and App-Level Token into your .env

Manifest includes all required scopes: chat:write, channels:read, channels:history, groups:read, groups:history, im:write, users:read, app_mentions:read, canvases:read, canvases:write.

5. One-Click Docker Setup (recommended for judges)

# Clone and start everything (PostgreSQL + backend + slack client + auto-seed)
git clone https://github.com/Marianooss/labops-agent
cd labops-agent
docker-compose up --build

# Wait ~30s for DB init, then test:
curl "http://localhost:8000/alert/trigger?reagent_name=TSH"

This runs the full stack locally without needing a cloud Supabase account:

• db — PostgreSQL with auto-created schema and seed data

• backend — FastAPI on http://localhost:8000

• slack_client — Bolt Python Socket Mode (waits gracefully if Slack tokens are missing)

To enable Slack integration, copy .env.example to .env and fill in SLACK_BOT_TOKEN, SLACK_APP_TOKEN, and SLACK_SIGNING_SECRET before running docker-compose up.

6. Local Setup without Docker (one-script)

# Single command — starts backend + Slack client + seeds DB
python scripts/start_local.py

Or manually in separate terminals:

# Terminal 1: FastAPI backend
cd backend && uvicorn main:app --reload --port 8000

# Terminal 2: Slack agent
cd backend && python slack_client.py

Note: Backend commands must be run from the backend/ directory because modules use relative imports.

Deployment (Render / Railway / Fly)

Why not Vercel? The agent uses Slack Socket Mode, which holds a persistent websocket. Vercel serverless functions are short-lived and cannot keep that connection open. (If you must use Vercel, you would have to switch to HTTP Events mode and expose /slack/events — a different integration path this repo does not use.) Instead, deploy to a persistent host.

The included render.yaml provisions one web service that hosts both:

1. the FastAPI HTTP app (serves the public /chart/forecast/{reagent} PNG that Slack image blocks fetch — needs public HTTPS), and

2. the Socket Mode websocket, started in a background thread via RUN_SOCKET_MODE=1 (see backend/main.py startup).

Render → New → Blueprint → select this repo → fill the secret env vars
→ after first deploy, set `BACKEND_URL=https://labops-agent.onrender.com` → redeploy

Railway and Fly.io work identically with the same Dockerfile (it honors the host-injected $PORT).

Project Structure

labops-agent/
├── backend/
│   ├── main.py           # FastAPI entry point
│   ├── mcp_server.py     # MCP tools (4 lab tools)
│   ├── prediction.py     # Prophet demand forecasting
│   ├── slack_client.py   # Bolt Python + event handlers
│   ├── database.py       # Dual backend: Supabase or PostgreSQL
│   ├── claude_client.py  # Claude API wrapper
│   └── blocks_loader.py  # Block Kit / Canvas template loader
├── blocks/
│   ├── alert.json        # Stockout alert Block Kit template
│   ├── modal_order.json  # Order reagent modal template
│   └── canvas.json       # Inventory canvas template
├── data/
│   ├── create_tables.sql # Database schema
│   └── seed_data.sql     # Demo data (DEMO badge)
├── docs/
│   ├── architecture.md   # Technical architecture
│   ├── impact.md         # Impact metrics
│   └── demo_script.md    # 3-minute demo script
├── scripts/
│   ├── init_db.py        # Auto-seed PostgreSQL on Docker startup
│   ├── start_local.py    # One-script local startup (backend + slack + seed)
│   ├── holdout_backtest.py   # Monthly hold-out backtest (illustrative)
│   └── cross_validation.py   # Rolling-origin CV (headline accuracy metric)
├── notebooks/
│   ├── cv_metrics.json       # Rolling-origin CV results (real, reproducible)
│   ├── holdout_metrics.json  # Monthly hold-out results (caveated)
│   └── prophet_metrics.json  # Consolidated metrics summary
├── tests/
│   ├── test_mcp.py       # MCP tool unit tests
│   ├── test_prediction.py # Prophet engine tests
│   └── test_integration.py # Bolt handler integration tests
├── models/               # Prophet serialized models (.pkl)
├── render.yaml           # Render Blueprint (persistent host + Socket Mode)
├── docker-compose.yml    # One-click local stack
├── Dockerfile            # Backend container
├── LICENSE               # MIT License
├── AGENTS.md             # Development operating system
├── BIBLE.md              # Immutable declarations
└── CLAUDE.md             # Claude Code instructions

UiPath Components Used

None — this project uses Slack platform APIs (Channel History API, Canvas API) for messaging and surfaces, Anthropic MCP Server for tool exposure, and Claude API for natural language generation.

Demo Screenshots

Extracted from the final demo video (YouTube).

Block Kit Alert

Real-time Block Kit alert fired when Prophet predicts a stockout within the reorder lead time window.

Order Modal

Pre-filled order modal with model-suggested quantity and supplier dropdown — one click creates the order in Supabase.

Demand Forecast Chart

Prophet-generated forecast chart with 80% confidence interval, rendered live and embedded in the Slack thread.

Canvas Update

Inventory Canvas updates in real time after an order is confirmed.

Verified numbers from live deploy:

• TSH demand: ~144 u/día (hábil), ~79 u/día (fin de semana) — Prophet forecast, output real /alert/trigger, out-of-peak (Jul-Sep)

• Stockout projection: 6 días con 680 u stock (projected_stockout_date: 2026-07-08)

• Forecast chart: renders from https://labops-agent.onrender.com/chart/forecast/TSH

• Canvas: persists via lab_config table in Supabase

Data & Privacy

All data in this project is synthetic and clearly labeled with DEMO badges. No real patient data, no PHI. The prediction model's seasonal parameters (peak months, peak/trough ratios per test type) were derived from analysis of 414,289 real B2B demand records (Labmedicina, 2025-2026, anonymized — raw data not included, see data/DATASET_PROVENANCE.md); Prophet trains on a synthetic daily series encoding those parameters. Reported CV metrics (MAPE ~8-11%) are a synthetic-benchmark validation of the pipeline, not a real-consumption accuracy claim — see docs/architecture.md.

License

MIT License — see LICENSE

Builder

Mariano Adrian Oss · DevelopOss · Buenos Aires, Argentina

B2B KAM in clinical diagnostics (4 years) + AI Builder. This project applies real insider knowledge of clinical laboratory operations to a problem that existing software hasn't solved: uninterrupted diagnostic access for vulnerable patients inside the tools labs already use daily.

LabOps Agent · Slack Agent Builder Challenge 2026 · Track: Slack Agent for Good