# Inform Growth — Beacon Software demo MCP

A standalone MCP server that demonstrates Inform Growth's Camber Core platform
using a fictional B2B SaaS company (Beacon Software, ~$15M ARR, ~80 employees).
All data is synthetic; all tool shapes are real.

## What it does

Connect any MCP-capable AI client. The server exposes ~20 tools across five
categories — `crm_*`, `marketing_*`, `billing_*`, `support_*`, `ops_*` — plus
three orchestration tools for a guided 5-step walkthrough.

A prospect plays the CEO of Beacon Software, runs a few prompts against their
agent, and experiences the cross-system rollups, anomaly detection, and
workflow capture they'd get from a real Camber Core deployment.

## Connect from an AI client

After the server is live (e.g. on Railway), point your client at the URL.

### Claude Desktop

Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "inform-demo": {
      "url": "https://<your-railway-host>/mcp"
    }
  }
}
```

### Claude Code (CLI)

```bash
claude mcp add inform-demo --transport http https://<your-railway-host>/mcp
```

### One-line bootstrap prompt

> Connect to the Inform Growth demo MCP at `<URL>`. Read the `welcome://demo`
> resource, then call `start_demo()` and walk me through the 5 steps as the
> CEO of Beacon Software.

## Run locally

```bash
pip install ".[dev]"

# stdio (Claude Code / Inspector)
python server.py

# HTTP
MCP_TRANSPORT=streamable-http python server.py
# server on http://localhost:8000/mcp
```

## Regenerate synthetic data

```bash
python scripts/generate_beacon.py
# writes data/beacon.json (deterministic — seed=42)
```

Seeded patterns the walkthrough depends on:

- Companies 7, 23, 41 → expansion-risk (high MRR growth + tickets + low CSAT)
- Deals 102, 118 → stalling (no activity 60+ days)
- Campaign 14 → surprising attribution win
- Project 23 → at-risk, blocking revenue recognition

## Internal analytics

Every meaningful event emits a JSON line to stdout. Railway aggregates these in
the service log view. To get a funnel out of them:

```bash
railway logs --service demo-mcp \
  | grep '"event":' \
  | jq -s 'group_by(.event) | map({event: .[0].event, count: length})'
```

Event types:

| event | when |
|---|---|
| `server_started` | server boot |
| `session_started` | a prospect calls `start_demo` |
| `step_reached` | `next_step` advances the walkthrough (step in payload) |
| `workflow_saved` | a prospect calls `save_workflow` |
| `session_ended` | walkthrough completes (step 5) |

## Deploy to Railway

1. **Create a new Railway service** pointed at this repo (`Inform-Growth/inform-demo-mcp`, `main` branch)
2. **Railway auto-detects the Dockerfile** at the repo root. No further config needed.
3. **Optional env overrides:**
   - `MCP_TRANSPORT` (default `streamable-http`)
   - `MCP_SERVER_NAME` (default `inform-demo-mcp`)
   - `PORT` (Railway injects this; the server binds to it automatically)
   - `ALLOWED_HOSTS` — comma-separated hostnames that pass DNS-rebinding protection. Supports `host:*` for any port. **Default: unset, which disables the check** (appropriate for a public demo). Set to the Railway hostname (e.g. `inform-demo-mcp.up.railway.app`) to lock it down.
4. **Public networking** — toggle on in Railway so prospects can connect

After deploy, the URL is `https://<service>.up.railway.app/mcp`.

## File tree

```
.
├── README.md                 # this file
├── Dockerfile                # Railway image
├── pyproject.toml            # mcp[cli] + uvicorn; faker only in dev
├── server.py                 # FastMCP entry point
├── beacon/
│   ├── __init__.py
│   ├── data.py               # beacon.json loader + helpers
│   ├── crm.py                # 5 tools (deals, companies, contacts, activities)
│   ├── marketing.py          # 3 tools (campaigns, attribution)
│   ├── billing.py            # 3 tools (subscriptions, MRR metrics)
│   ├── support.py            # 3 tools (tickets, support metrics)
│   ├── ops.py                # 3 tools (projects, at-risk rollup)
│   └── orchestration.py      # start_demo, next_step, save_workflow + welcome text
├── analytics/
│   ├── __init__.py
│   └── events.py             # log_event — JSON line to stdout
├── scripts/
│   └── generate_beacon.py    # faker(seed=42) generator
└── data/
    └── beacon.json           # ~720KB committed synthetic data
```

## Design notes

- **No auth, no init gate** — public by design. Locked in `inform-notes/notes/track-a2-v0-scope.md` D5.
- **Per-connection session state** — `start_demo` returns a `session_id`; client passes it to `next_step` / `save_workflow`. State is in-memory and lost on reconnect (D6).
- **save_workflow** persists only for the duration of the connection. Honest about the demo nature (D4).
- **20 tools, 5 categories** — generic prefixes so prospects don't anchor on "we use a different tool" (D1).
- **Deterministic data** — `Faker.seed(42)` plus surgical pattern injection. Anyone who regenerates gets identical output (D2).
- **Hosting** — Railway, deployed from this repo's `main` branch. D7's Calendly placeholder lives in `beacon/orchestration.py`.

For the full design rationale see `Inform-Growth/inform-notes/notes/track-a2-v0-scope.md`.