Full-Stack Ecosystem Demo¶

New in v1.2.1. The cross-subsystem walkthrough that wires four FCC subsystems — Web Frontend (WebSocket bridge), Distiller Bridge, Sky-Parlour Visualization Bridge, and Open Science FAIR audit — into a single end-to-end story.

This is the demo to run when you want to convince yourself (or someone else) that FCC's pieces actually work together. Every other demo exercises one subsystem in isolation; the full_stack demo wires them into a coherent flow that mirrors what a production deployment looks like.

What the demo does (in plain English)¶

A Research Crafter persona (RC) publishes a SCENARIO_STARTED event to the EventBus. This is the kickoff signal — in production it would come from the FCC simulation engine, a Streamlit app, or the React frontend.
The Distiller Bridge fabricates a small synthetic dataset representing the personas RC will collaborate with. In production this would be a real NanoCube query against your Distiller backend; in the demo it runs in mock mode and returns deterministic data.
The Sky-Parlour Visualization Bridge transforms the event + the fabricated data into a D3 force-graph payload. RC sits at the center; the synthetic personas radiate outward; edge weights come from the fabricated efficacy scores.
The WebSocket bridge captures the payload from the EventBus subscriber and queues it for broadcast. In production this is where a connected React frontend (or any other WebSocket client) receives the JSON message and updates its visualization.
The Open Science registry collects the resulting artifact bundle (persona ID, fabricated dataset, D3 payload, broadcast manifest) and runs the FAIR mandatory gates against it.
A compliance report is rendered showing the per-principle FAIR scores and any failed gates. The demo prints it; production would ship it to a dashboard or persist it to Mnemosyne for retrieval in the next session.
(Optional) The VocabularyMappingLoader is asked to verify the sister-project vocabulary contracts. If fcc-athenium-plugin and/or fcc-mnemosyne-plugin are installed, this step confirms the cross-project entity resolution path is healthy.

Why this demo matters¶

Before v1.2.1, every subsystem had its own demo and its own Streamlit app, but none of them ran together. Adopters would learn to use the WS bridge, then the Distiller, then Sky-Parlour, then Open Science as four separate skills with no narrative connecting them. The full-stack demo collapses that gap: it's the canonical example of "this is what a real FCC deployment does in 30 seconds of wall time."

It's also the demo we run during release verification to make sure none of the subsystems silently broke a downstream consumer.

Running the demo¶

Option A: Run the notebook¶

jupyter nbconvert --execute notebooks/32_full_stack_ecosystem_demo.ipynb

The notebook is the executable form. It walks through all 9 steps interactively and prints the result of each.

Option B: Use the demo registry¶

from fcc.demos.registry import DemoRegistry

registry = DemoRegistry.from_builtin()
demo = registry.get("full_stack")
print(demo.name)
print(f"Steps: {len(demo.steps)}")
for step in demo.steps:
    print(f"  [{step.step_id}] {step.title}")

The registered demo is a DemoScenario with 10 documented steps. It doesn't auto-execute — it's a description of the flow. The notebook is the executable runner.

Option C: CLI¶

fcc demo run full_stack

(Per the standard demo CLI pattern.)

Prerequisites¶

pip install -e .[full] — the full extras group ships websockets, streamlit, and the protocol bridges
(Optional) pip install -e plugins/fcc-athenium-plugin -e plugins/fcc-mnemosyne-plugin for vocabulary contract verification
(Optional) pip install -e ../l2_athenium ../l2_mnemosyne for the full sister-project ecosystem

Verification¶

The demo is part of the v1.2.1 release-gate suite. Run it via:

pytest tests/test_demo_cli.py::TestDemoRegistryFromBuiltin::test_from_builtin_has_full_stack_demo -v
jupyter nbconvert --execute notebooks/32_full_stack_ecosystem_demo.ipynb --output /tmp/_smoke.ipynb

Both must exit cleanly. The notebook is short enough that the nbconvert --execute round-trip takes <30 seconds.