Skip to content

Commit af329cf

Browse files
temirofftemiroff
committed
Add presentation checklist
1 parent 666da13 commit af329cf

2 files changed

Lines changed: 334 additions & 0 deletions

File tree

‎README.md‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -72,6 +72,7 @@ See [Blacknode and NVIDIA AI-Q](docs/aiq-integration.md) and
7272
| Guide | Use it for |
7373
|---|---|
7474
| [Beginner Walkthrough](docs/walkthrough.md) | Step-by-step setup, editor use, CLI checks, NVIDIA workflows, MCP, Docker, and troubleshooting. |
75+
| [Presentation Checklist](docs/presentation-checklist.md) | Fast demo order with actions, expected proof, and feature checkpoints. |
7576
| [MCP Quickstart](docs/quickstart-mcp.md) | Connecting Blacknode to an MCP client. |
7677
| [MCP Test Prompts](docs/mcp-test-prompts.md) | Copy-paste prompts for proving agent workflow control. |
7778

‎docs/presentation-checklist.md‎

Lines changed: 333 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,333 @@
1+
# Blacknode Presentation Checklist
2+
3+
Use this as the fast live-demo order. It keeps the flow focused on proof:
4+
local runtime, visual editor, run replay, NVIDIA workflows, MCP agent control,
5+
and self-hosted deployment.
6+
7+
## Opening Position
8+
9+
Blacknode is the visual workflow editor for agent stacks. Agents are strong at
10+
intent and reasoning; workflow construction needs typed structure, validation,
11+
visible state, run history, and exportable artifacts.
12+
13+
Core identity:
14+
15+
```text
16+
Blacknode turns agent intent into typed, visible, runnable workflows.
17+
```
18+
19+
NVIDIA identity:
20+
21+
```text
22+
Blacknode is the visual workflow editor for the NVIDIA agent stack.
23+
```
24+
25+
## Quick Demo Order
26+
27+
| Step | Action | Proof |
28+
|---:|---|---|
29+
| 1 | Open README | Short intro, 2x2 image grid, playable demos, walkthrough link. |
30+
| 2 | Run `blacknode doctor` | Colored `[OK]`, `[WARN]`, `[NOT OK]` environment status. |
31+
| 3 | Run `blacknode demo` | Local runtime returns `Hello World`. |
32+
| 4 | Start `start.bat` or `./start.sh` | Editor opens at `http://localhost:3000`. |
33+
| 5 | Open **Templates** -> **Text Pipeline** -> **Cook** | Visible graph returns `Hello World`. |
34+
| 6 | Build Text -> Text -> Concat -> Output by hand | Typed handles connect and validate visually. |
35+
| 7 | Open **Runs** after cooking | Run history, event timeline, replay, result, errors. |
36+
| 8 | Save in **Workflows** | Workflow becomes a reusable JSON artifact. |
37+
| 9 | Open **NVIDIA AI Mission Control** | No-key NVIDIA workflow plan and readiness surface. |
38+
| 10 | Open **NVIDIA Local NIM Launch** | Docker command and local endpoint wiring. |
39+
| 11 | Open **NVIDIA NIM** with `NVIDIA_API_KEY` | Hosted NIM model result and model-call run events. |
40+
| 12 | Open **NVIDIA NIM Benchmark** | Text, latency, metrics, and raw samples. |
41+
| 13 | Run `blacknode mcp` | Agent can list nodes, inspect schemas, build, validate, run, export. |
42+
| 14 | Run streamable HTTP MCP | AI-Q, NeMo Agent Toolkit, and HTTP MCP clients can connect. |
43+
| 15 | Run Docker Compose | Self-hosted editor, backend, run store, and HTTP MCP endpoint. |
44+
45+
## Terminal Checks
46+
47+
### Local Runtime
48+
49+
```powershell
50+
blacknode doctor
51+
blacknode demo
52+
```
53+
54+
Expected:
55+
56+
- Doctor prints colored status labels.
57+
- Demo prints `Blacknode demo OK`.
58+
- Demo result is `Hello World`.
59+
60+
### Validate, Run, Export
61+
62+
Windows:
63+
64+
```powershell
65+
blacknode validate templates\text-pipeline.json
66+
blacknode run templates\text-pipeline.json
67+
blacknode export-python templates\text-pipeline.json --output workflow.py
68+
python workflow.py
69+
```
70+
71+
macOS/Linux:
72+
73+
```bash
74+
blacknode validate templates/text-pipeline.json
75+
blacknode run templates/text-pipeline.json
76+
blacknode export-python templates/text-pipeline.json --output workflow.py
77+
python workflow.py
78+
```
79+
80+
Expected:
81+
82+
- Validation returns `"ok": true`.
83+
- Run returns `"value": "Hello World"`.
84+
- Exported Python prints `Hello World`.
85+
86+
## Editor Checks
87+
88+
### Template Run
89+
90+
1. Start the editor.
91+
2. Open **Templates**.
92+
3. Click **Text Pipeline**.
93+
4. Click the Output node.
94+
5. Click **Cook**.
95+
96+
Expected:
97+
98+
- Output node shows `Hello World`.
99+
- Runs tab records the execution.
100+
- Results on unrelated nodes stay visible until those nodes cook again.
101+
102+
### Manual Graph Build
103+
104+
1. Click **Clear**.
105+
2. Add **Text**, **Text**, **Concat**, **Output**.
106+
3. Set Text values to `Hello` and ` World`.
107+
4. Connect Text `value` -> Concat `a`.
108+
5. Connect Text `value` -> Concat `b`.
109+
6. Connect Concat `value` -> Output `value`.
110+
7. Click **Organize**.
111+
8. Click **Cook** on Output.
112+
113+
Expected:
114+
115+
- Graph lays out cleanly.
116+
- Typed handles match by color/type.
117+
- Output shows `Hello World`.
118+
119+
### Workflow Save
120+
121+
1. Open **Workflows**.
122+
2. Name the workflow.
123+
3. Click **Save**.
124+
4. Reopen it from the saved workflow list.
125+
5. Right-click the row for **Insert**, **Rename**, **Duplicate**, **Delete**.
126+
127+
Expected:
128+
129+
- Saved workflow appears under `workflows/*.json`.
130+
- Workflow can be reopened or inserted.
131+
132+
### Run Replay
133+
134+
1. Cook any workflow.
135+
2. Open **Runs**.
136+
3. Open the newest run.
137+
4. Use step/play/scrub controls.
138+
5. Use **Open workflow** when a run snapshot is available.
139+
140+
Expected:
141+
142+
- Node highlights follow the execution timeline.
143+
- Model calls and tool calls are counted.
144+
- Result or error is visible in the run record.
145+
146+
## NVIDIA Checks
147+
148+
### No-Key Planning
149+
150+
Windows:
151+
152+
```powershell
153+
blacknode run templates\nvidia-ai-mission-control.json
154+
blacknode run templates\nvidia-local-nim-launch.json
155+
```
156+
157+
macOS/Linux:
158+
159+
```bash
160+
blacknode run templates/nvidia-ai-mission-control.json
161+
blacknode run templates/nvidia-local-nim-launch.json
162+
```
163+
164+
Expected:
165+
166+
- Mission Control returns an NVIDIA stack plan.
167+
- Local NIM Launch returns Docker command text and endpoint output.
168+
169+
### Hosted NIM
170+
171+
Windows:
172+
173+
```powershell
174+
$env:NVIDIA_API_KEY="your-key"
175+
start.bat
176+
```
177+
178+
macOS/Linux:
179+
180+
```bash
181+
export NVIDIA_API_KEY="your-key"
182+
./start.sh
183+
```
184+
185+
Editor path:
186+
187+
1. Open **Templates**.
188+
2. Click **NVIDIA NIM** or **NVIDIA NIM MCP Demo**.
189+
3. Confirm the **Model** node uses a `nim:` model.
190+
4. Click **Cook** on Output.
191+
5. Open **Runs** and inspect model-call timing.
192+
193+
Expected:
194+
195+
- Output shows the NIM model response.
196+
- Runs panel records model-call events.
197+
198+
### Local NIM
199+
200+
1. Open **Templates**.
201+
2. Click **NVIDIA Local NIM Launch**.
202+
3. Click **Cook**.
203+
4. Copy the generated Docker command.
204+
5. Start the NIM container in a separate terminal.
205+
6. Point `NIMHealthCheck`, `NIMAgent`, or `NIMBenchmark` at the local endpoint.
206+
207+
Expected:
208+
209+
- Local command and endpoint are generated in the graph.
210+
- Same workflow surface can route to hosted or local NIM.
211+
212+
## MCP Checks
213+
214+
### Stdio MCP
215+
216+
```powershell
217+
blacknode mcp
218+
```
219+
220+
Agent prompt:
221+
222+
```text
223+
Using the blacknode MCP tools, list the available node types, show the schema
224+
for Text, Concat, and Output, then create a workflow that concatenates "Hello"
225+
and " World", validates it, runs it, and exports it as Python.
226+
```
227+
228+
Expected:
229+
230+
- Agent lists node types.
231+
- Agent creates a typed workflow.
232+
- Validation passes.
233+
- Run returns `Hello World`.
234+
- Export returns Python.
235+
236+
### Streamable HTTP MCP
237+
238+
```powershell
239+
blacknode mcp --transport streamable-http --host 127.0.0.1 --port 9901 --path /mcp
240+
```
241+
242+
Endpoint:
243+
244+
```text
245+
http://127.0.0.1:9901/mcp
246+
```
247+
248+
Expected:
249+
250+
- Same Blacknode MCP tool surface over HTTP.
251+
- AI-Q, NeMo Agent Toolkit, or another streamable HTTP MCP client can connect.
252+
253+
## Custom Node Check
254+
255+
1. Open **Script**.
256+
2. Paste:
257+
258+
```python
259+
from blacknode.node import node
260+
261+
@node(inputs=["text:Text", "n:Int"], outputs=["result:Text"])
262+
def FirstNWords(ctx: dict) -> dict:
263+
words = ctx.get("text", "").split()
264+
n = int(ctx.get("n", 10))
265+
return {"result": " ".join(words[:n])}
266+
```
267+
268+
3. Click **Run** or press **Ctrl+Enter**.
269+
4. Add the new Custom node to the canvas.
270+
5. Connect and cook it.
271+
272+
Expected:
273+
274+
- Custom node appears without server restart.
275+
- Typed ports work like built-in nodes.
276+
277+
## Tool Workflow Checks
278+
279+
Templates:
280+
281+
- **Python Tool Agent**
282+
- **Visual Tool Agent**
283+
- **Subnet Tool Call**
284+
- **Subnet Tool Agent**
285+
286+
Expected:
287+
288+
- `PythonFn` exposes Python code as a callable tool.
289+
- `SubnetAsTool` turns a visual subgraph into a tool.
290+
- `ToolBox` collects tools.
291+
- `ToolCall` tests a tool directly.
292+
- `AgentLoop` can call tools through the graph.
293+
294+
## Docker Check
295+
296+
```bash
297+
docker compose up --build
298+
```
299+
300+
Open:
301+
302+
```text
303+
http://127.0.0.1:3000
304+
```
305+
306+
Services:
307+
308+
| Service | Port | Purpose |
309+
|---|---:|---|
310+
| `editor` | `3000` | Browser editor. |
311+
| `editor-server` | `7777` | Backend, workflow store, run store, cook API. |
312+
| `blacknode-mcp` | `9901` | Streamable HTTP MCP server at `/mcp`. |
313+
314+
Expected:
315+
316+
- Self-hosted editor works.
317+
- Run history persists through the backend.
318+
- HTTP MCP endpoint is available at `/mcp`.
319+
320+
## Closing Proof
321+
322+
Blacknode provides one visible workflow surface across:
323+
324+
- local CLI checks
325+
- browser graph editing
326+
- typed validation
327+
- run replay
328+
- model routing
329+
- NVIDIA hosted and local NIM flows
330+
- MCP agent control
331+
- streamable HTTP MCP
332+
- Docker Compose deployment
333+
- Python export

0 commit comments

Comments
 (0)