mirror of
https://github.com/GNS3/gns3-server.git
synced 2026-08-27 12:30:13 +03:00
docs: add node creation templates section to roadmap
Added comprehensive node creation template system including: - Batch node creation workflow (HITL with preview) - Node template schema (groups, positioning, auto-linking) - Automatic positioning algorithms (grid, spine-leaf, hierarchical) - Auto-linking strategies (mesh, paired, linear) - Batch parallel execution (20-50 concurrent) - Performance benchmarks for 100-1000+ nodes - Complete enterprise data center example (724 nodes, 4280 links) Key benefits: - 98% token savings for node creation (5000 → 100 tokens for 100 nodes) - 90% time savings (10 min → 1 min for 100 nodes) - Auto-linking eliminates manual connection setup - Combined workflow: Create + configure 724 nodes in ~10 minutes Updated implementation phases to include Phase 2.5 for node creation templates.
This commit is contained in:
YueGuobin
parent
a627d45ca6
commit
3b4bc93e85
@ -1,4 +1,4 @@
|
||||
# Template-Based Configuration with HITL - Future Roadmap
|
||||
# Template-Based System with HITL - Future Roadmap
|
||||
|
||||
**Status:** 💡 Proposed
|
||||
**Target Version:** Next Release
|
||||
@ -6,10 +6,12 @@
|
||||
|
||||
## Overview
|
||||
|
||||
This document outlines the plan for implementing a **Jinja2-based template system with Human-in-the-Loop (HITL) confirmations** for network device configuration in GNS3 AI Copilot.
|
||||
This document outlines the plan for implementing **template-based systems with Human-in-the-Loop (HITL) confirmations** for both **device configuration** and **node creation** in GNS3 AI Copilot.
|
||||
|
||||
### Motivation
|
||||
|
||||
#### Current Configuration Challenges
|
||||
|
||||
The current implementation requires AI to generate complete configuration commands for every device, which:
|
||||
|
||||
- **Consumes excessive tokens:** Each device configuration is generated independently (~150 tokens/device × 10 devices = 1500 tokens)
|
||||
@ -17,15 +19,28 @@ The current implementation requires AI to generate complete configuration comman
|
||||
- **No reusability:** Similar configurations must be regenerated from scratch
|
||||
- **Higher error risk:** Direct execution without preview or confirmation
|
||||
|
||||
#### Current Node Creation Challenges
|
||||
|
||||
Similarly, creating multiple nodes has significant inefficiencies:
|
||||
|
||||
- **Token waste:** Each node creation requires ~50 tokens for tool calls (100 nodes = 5000 tokens)
|
||||
- **Slow execution:** Nodes are created serially or with limited parallelism
|
||||
- **No batch operations:** Cannot create groups of related nodes efficiently
|
||||
- **Manual positioning:** Each node must be positioned individually
|
||||
|
||||
### Proposed Solution
|
||||
|
||||
Implement a **three-step HITL workflow** using Jinja2 templates:
|
||||
Implement a **unified template-based HITL workflow** for both configuration and node creation:
|
||||
|
||||
1. **AI generates template** → Human reviews and confirms
|
||||
2. **AI generates parameters** → Human reviews and confirms
|
||||
3. **Local rendering and execution** → Results displayed
|
||||
2. **AI generates parameters (optional)** → Human reviews and confirms
|
||||
3. **Local execution** → Results displayed
|
||||
|
||||
**Expected Token Savings:** 70-80% reduction for multi-device configurations
|
||||
**Expected Benefits:**
|
||||
- **98-99% token savings** for large-scale operations (1000+ devices/nodes)
|
||||
- **90%+ time savings** through parallel execution and batch operations
|
||||
- **Full user control** with preview and confirmation at every step
|
||||
- **Template reusability** across similar operations
|
||||
|
||||
---
|
||||
|
||||
@ -976,6 +991,721 @@ For 1000+ devices, some failures are inevitable. The system provides:
|
||||
|
||||
---
|
||||
|
||||
## 🔥🔥 Node Creation Templates (Batch Topology Provisioning)
|
||||
|
||||
### Overview
|
||||
|
||||
Just as configuration templates enable rapid device configuration, **node creation templates** enable rapid topology provisioning. This is particularly valuable for:
|
||||
|
||||
- **Training labs**: Provision 100+ device labs in minutes
|
||||
- **Testing environments**: Quickly spin up complex test topologies
|
||||
- **Data center simulation**: Create spine-leaf fabrics with hundreds of nodes
|
||||
- **Network research**: Deploy large-scale simulation topologies
|
||||
|
||||
### Current vs. Template-Based Node Creation
|
||||
|
||||
#### Scenario: Create 100 Routers
|
||||
|
||||
**Current Method:**
|
||||
```
|
||||
AI calls create_node tool 100 times:
|
||||
- Token cost: 50 tokens/node × 100 = 5000 tokens
|
||||
- Execution time: 5-10 minutes (serial/limited parallel)
|
||||
- No batch operations
|
||||
- Manual positioning required
|
||||
```
|
||||
|
||||
**Template Method:**
|
||||
```
|
||||
1. AI generates node creation template: ~100 tokens
|
||||
2. User reviews and confirms template
|
||||
3. Rule engine creates nodes in parallel batches: 0 tokens
|
||||
4. Total: 100 tokens, 30-60 seconds
|
||||
```
|
||||
|
||||
**Savings:** 98% tokens, 90% time
|
||||
|
||||
### Node Creation Workflow
|
||||
|
||||
```
|
||||
User Request: "Create a data center topology with 2 core routers,
|
||||
10 aggregation switches, and 100 access switches"
|
||||
↓
|
||||
┌─────────────────────────────────────────────────────────────┐
|
||||
│ Step 1: AI Generates Node Creation Template │
|
||||
│ │
|
||||
│ AI Output: │
|
||||
│ { │
|
||||
│ "node_groups": [ │
|
||||
│ { │
|
||||
│ "node_type": "cisco_iosv", │
|
||||
│ "count": 2, │
|
||||
│ "name_pattern": "Core-R{{ id }}", │
|
||||
│ "properties": {"ram": 4096, "cpus": 2}, │
|
||||
│ "position": {"y": 100, "x_spacing": 600} │
|
||||
│ }, │
|
||||
│ { │
|
||||
│ "node_type": "cisco_iosv_l2", │
|
||||
│ "count": 10, │
|
||||
│ "name_pattern": "Agg-SW{{ id }}", │
|
||||
│ "position": {"grid": "2x5", "y": 300} │
|
||||
│ }, │
|
||||
│ { │
|
||||
│ "node_type": "cisco_iosv_l2", │
|
||||
│ "count": 100, │
|
||||
│ "name_pattern": "Acc-SW{{ id }}", │
|
||||
│ "position": {"grid": "10x10", "y": 600} │
|
||||
│ } │
|
||||
│ ], │
|
||||
│ "layout": "auto_spine_leaf", │
|
||||
│ "resource_limits": {"max_ram_mb": 120000} │
|
||||
│ } │
|
||||
└─────────────────────────────────────────────────────────────┘
|
||||
↓
|
||||
┌─────────────────────────────────────────────────────────────┐
|
||||
│ 🔵 HITL Checkpoint: Node Template Review │
|
||||
│ │
|
||||
│ User sees: │
|
||||
│ • Total nodes: 112 │
|
||||
│ • Group breakdown: │
|
||||
│ - 2x Core routers (Core-R1, Core-R2) │
|
||||
│ - 10x Aggregation switches (Agg-SW1 - Agg-SW10) │
|
||||
│ - 100x Access switches (Acc-SW1 - Acc-SW100) │
|
||||
│ • Resource requirements: │
|
||||
│ - RAM: ~120 GB │
|
||||
│ - vCPUs: 112 │
|
||||
│ • Layout preview (visual diagram) │
|
||||
│ │
|
||||
│ Actions: [⚡ Batch Create] [✏️ Modify] [❌ Cancel] │
|
||||
└─────────────────────────────────────────────────────────────┘
|
||||
↓
|
||||
┌─────────────────────────────────────────────────────────────┐
|
||||
│ Step 2: Parallel Batch Node Creation (0 tokens) │
|
||||
│ │
|
||||
│ Process: │
|
||||
│ - Validate resources │
|
||||
│ - Create nodes in parallel batches (20-50 concurrent) │
|
||||
│ - Auto-position nodes using layout strategy │
|
||||
│ - Real-time progress streaming │
|
||||
│ │
|
||||
│ Progress: │
|
||||
│ Batch 1/6: Creating 20 nodes... │
|
||||
│ Batch 2/6: Creating 20 nodes... │
|
||||
│ ... │
|
||||
│ Complete: 112/112 nodes created successfully │
|
||||
└─────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
### Node Template Schema
|
||||
|
||||
```python
|
||||
# gns3server/schemas/controller/node_template.py
|
||||
|
||||
class NodeCreationTemplate(BaseModel):
|
||||
"""Template for batch node creation."""
|
||||
|
||||
# Node groups to create
|
||||
node_groups: List[NodeGroupTemplate] = Field(
|
||||
...,
|
||||
description="Groups of nodes with same template"
|
||||
)
|
||||
|
||||
# Layout strategy
|
||||
layout: Literal[
|
||||
"auto_grid", # Automatic grid layout
|
||||
"auto_spine_leaf", # Spine-Leaf topology
|
||||
"auto_star", # Star topology
|
||||
"auto_mesh", # Mesh topology
|
||||
"manual" # Manual coordinates
|
||||
] = Field(default="auto_grid")
|
||||
|
||||
# Resource constraints
|
||||
resource_limits: Optional[ResourceLimits] = Field(None)
|
||||
|
||||
# Auto-link configuration
|
||||
auto_link: Optional[AutoLinkConfig] = Field(
|
||||
None,
|
||||
description="Automatically create links between nodes"
|
||||
)
|
||||
|
||||
|
||||
class NodeGroupTemplate(BaseModel):
|
||||
"""Template for a group of similar nodes."""
|
||||
|
||||
# Node type and count
|
||||
node_type: str = Field(..., description="GNS3 node template type")
|
||||
count: int = Field(..., ge=1, le=10000)
|
||||
|
||||
# Naming convention
|
||||
name_pattern: str = Field(
|
||||
...,
|
||||
description="Name pattern with {{ id }} placeholder, e.g., 'R{{ id }}'"
|
||||
)
|
||||
id_start: int = Field(default=1, description="Starting ID number")
|
||||
|
||||
# Node properties
|
||||
properties: Dict[str, Any] = Field(
|
||||
default_factory=dict,
|
||||
description="Node properties (RAM, CPUs, adapters, etc.)"
|
||||
)
|
||||
|
||||
# Positioning
|
||||
position: Optional[PositionSpec] = Field(None)
|
||||
|
||||
|
||||
class PositionSpec(BaseModel):
|
||||
"""Position specification for node group."""
|
||||
|
||||
strategy: Literal[
|
||||
"auto", # Auto-calculate
|
||||
"grid", # Grid arrangement
|
||||
"circle", # Circular arrangement
|
||||
"hierarchical", # Hierarchical layout
|
||||
"random" # Random distribution
|
||||
] = Field(default="auto")
|
||||
|
||||
# Grid parameters
|
||||
grid_rows: Optional[int] = Field(None)
|
||||
grid_cols: Optional[int] = Field(None)
|
||||
|
||||
# Positioning
|
||||
x_start: Optional[int] = Field(None, description="Starting X coordinate")
|
||||
y_start: Optional[int] = Field(None, description="Starting Y coordinate")
|
||||
x_spacing: int = Field(default=200, description="Horizontal spacing")
|
||||
y_spacing: int = Field(default=150, description="Vertical spacing")
|
||||
|
||||
|
||||
class AutoLinkConfig(BaseModel):
|
||||
"""Automatic link creation between node groups."""
|
||||
|
||||
links: List[LinkPattern] = Field(
|
||||
...,
|
||||
description="Link patterns to create"
|
||||
)
|
||||
|
||||
|
||||
class LinkPattern(BaseModel):
|
||||
"""Pattern for creating links between node groups."""
|
||||
|
||||
from_group: str = Field(..., description="Source node group name")
|
||||
to_group: str = Field(..., description="Destination node group name")
|
||||
link_type: str = Field(default="ethernet")
|
||||
count: int = Field(default=1, description="Links per node pair")
|
||||
strategy: Literal[
|
||||
"mesh", # Full mesh between groups
|
||||
"linear", # Linear connection
|
||||
"paired", # One-to-one pairing
|
||||
"custom" # Custom pattern
|
||||
] = Field(default="mesh")
|
||||
```
|
||||
|
||||
### Auto-Linking: Create Topologies with Connections
|
||||
|
||||
Node creation templates can also automatically create links:
|
||||
|
||||
```python
|
||||
# Example: Create spine-leaf topology with links
|
||||
|
||||
{
|
||||
"node_groups": [
|
||||
{
|
||||
"name": "spine",
|
||||
"node_type": "cisco_iosv",
|
||||
"count": 4,
|
||||
"name_pattern": "Spine{{ id }}",
|
||||
"position": {"y": 100, "x_spacing": 400}
|
||||
},
|
||||
{
|
||||
"name": "leaf",
|
||||
"node_type": "cisco_iosv_l2",
|
||||
"count": 48,
|
||||
"name_pattern": "Leaf{{ id }}",
|
||||
"position": {"grid": "6x8", "y": 400}
|
||||
}
|
||||
],
|
||||
"auto_link": {
|
||||
"links": [
|
||||
{
|
||||
"from_group": "spine",
|
||||
"to_group": "leaf",
|
||||
"strategy": "mesh", # Each spine connects to all leafs
|
||||
"count": 1
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
# Result: 4 spine switches, 48 leaf switches, 192 links (4×48)
|
||||
# Created in ~2-3 minutes
|
||||
```
|
||||
|
||||
### Batch Node Creation Tool
|
||||
|
||||
```python
|
||||
# gns3server/agent/gns3_copilot/tools_v2/node_template_tools.py
|
||||
|
||||
class ExecuteBatchNodeCreation(BaseTool):
|
||||
"""
|
||||
Batch create nodes from template.
|
||||
|
||||
Features:
|
||||
- Parallel creation (20-50 concurrent)
|
||||
- Automatic positioning and layout
|
||||
- Resource validation before creation
|
||||
- Progress streaming via SSE
|
||||
- Error isolation (single failure doesn't stop others)
|
||||
"""
|
||||
|
||||
name = "execute_batch_node_creation"
|
||||
description = "Batch create nodes from template (0 token cost)"
|
||||
|
||||
def _run(self, tool_input: str | dict) -> dict:
|
||||
"""Execute batch node creation."""
|
||||
|
||||
data = json.loads(tool_input) if isinstance(tool_input, str) else tool_input
|
||||
project_id = data.get("project_id")
|
||||
node_template = data.get("node_template")
|
||||
|
||||
total_nodes = sum(g["count"] for g in node_template["node_groups"])
|
||||
|
||||
# Dynamic batch sizing based on scale
|
||||
if total_nodes <= 50:
|
||||
batch_size = 10
|
||||
elif total_nodes <= 200:
|
||||
batch_size = 20
|
||||
elif total_nodes <= 500:
|
||||
batch_size = 30
|
||||
else: # 500+ nodes
|
||||
batch_size = 50
|
||||
|
||||
results = {
|
||||
"total_nodes": total_nodes,
|
||||
"batch_size": batch_size,
|
||||
"groups": [],
|
||||
"auto_links": []
|
||||
}
|
||||
|
||||
# Check resource availability
|
||||
if node_template.get("resource_limits"):
|
||||
availability = self._check_resources(project_id, node_template["resource_limits"])
|
||||
if not availability["available"]:
|
||||
return {
|
||||
"error": "Insufficient resources",
|
||||
"details": availability["shortfall"]
|
||||
}
|
||||
|
||||
# Create each node group
|
||||
for group in node_template["node_groups"]:
|
||||
group_result = self._create_node_group(
|
||||
project_id,
|
||||
group,
|
||||
batch_size,
|
||||
node_template["layout"]
|
||||
)
|
||||
results["groups"].append(group_result)
|
||||
|
||||
# Yield progress for SSE streaming
|
||||
yield_progress({
|
||||
"type": "group_complete",
|
||||
"group_name": group.get("name", "unknown"),
|
||||
"progress": group_result["created"]
|
||||
})
|
||||
|
||||
# Create auto-links if specified
|
||||
if node_template.get("auto_link"):
|
||||
links_result = self._create_auto_links(
|
||||
project_id,
|
||||
node_template["auto_link"],
|
||||
results["groups"]
|
||||
)
|
||||
results["auto_links"] = links_result
|
||||
|
||||
return results
|
||||
|
||||
def _create_node_group(
|
||||
self,
|
||||
project_id: str,
|
||||
group_template: dict,
|
||||
batch_size: int,
|
||||
layout_strategy: str
|
||||
) -> dict:
|
||||
"""Create a group of nodes with same template."""
|
||||
|
||||
count = group_template["count"]
|
||||
name_pattern = group_template["name_pattern"]
|
||||
id_start = group_template.get("id_start", 1)
|
||||
properties = group_template.get("properties", {})
|
||||
|
||||
# Generate node specifications
|
||||
nodes_to_create = []
|
||||
for i in range(count):
|
||||
node_id = id_start + i
|
||||
node_name = name_pattern.replace("{{ id }}", str(node_id))
|
||||
|
||||
# Calculate position
|
||||
position = self._calculate_position(
|
||||
i, count, layout_strategy, group_template
|
||||
)
|
||||
|
||||
nodes_to_create.append({
|
||||
"name": node_name,
|
||||
"node_type": group_template["node_type"],
|
||||
"properties": properties,
|
||||
"x": position["x"],
|
||||
"y": position["y"]
|
||||
})
|
||||
|
||||
# Create in batches
|
||||
created_nodes = []
|
||||
failed_nodes = []
|
||||
|
||||
for batch_start in range(0, count, batch_size):
|
||||
batch_end = min(batch_start + batch_size, count)
|
||||
batch_nodes = nodes_to_create[batch_start:batch_end]
|
||||
|
||||
# Parallel creation
|
||||
batch_results = await self._create_batch_parallel(
|
||||
project_id, batch_nodes
|
||||
)
|
||||
|
||||
for result in batch_results:
|
||||
if result["status"] == "success":
|
||||
created_nodes.append(result)
|
||||
else:
|
||||
failed_nodes.append(result)
|
||||
|
||||
# Progress update
|
||||
yield_progress({
|
||||
"type": "batch_complete",
|
||||
"progress": int((batch_end / count) * 100),
|
||||
"created": len(created_nodes),
|
||||
"failed": len(failed_nodes)
|
||||
})
|
||||
|
||||
return {
|
||||
"node_type": group_template["node_type"],
|
||||
"total": count,
|
||||
"created": len(created_nodes),
|
||||
"failed": len(failed_nodes),
|
||||
"nodes": created_nodes,
|
||||
"errors": failed_nodes
|
||||
}
|
||||
|
||||
def _calculate_position(
|
||||
self,
|
||||
index: int,
|
||||
total: int,
|
||||
layout: str,
|
||||
group_spec: dict
|
||||
) -> dict:
|
||||
"""Calculate node position based on layout strategy."""
|
||||
|
||||
position = group_spec.get("position", {})
|
||||
strategy = position.get("strategy", "auto")
|
||||
|
||||
if strategy == "grid":
|
||||
# Grid layout
|
||||
cols = position.get("grid_cols") or int(math.sqrt(total)) + 1
|
||||
row = index // cols
|
||||
col = index % cols
|
||||
|
||||
return {
|
||||
"x": (position.get("x_start") or 100) + col * position.get("x_spacing", 200),
|
||||
"y": (position.get("y_start") or 100) + row * position.get("y_spacing", 150)
|
||||
}
|
||||
|
||||
elif strategy == "hierarchical" or layout == "auto_spine_leaf":
|
||||
# Hierarchical: Core → Aggregation → Access
|
||||
node_type = group_spec.get("node_type", "").lower()
|
||||
|
||||
if "core" in node_type or "spine" in node_type:
|
||||
# Top layer
|
||||
x = 100 + index * 600
|
||||
y = 100
|
||||
elif "agg" in node_type or "leaf" in node_type:
|
||||
# Middle layer
|
||||
cols = int(math.sqrt(total)) + 1
|
||||
row = index // cols
|
||||
col = index % cols
|
||||
x = 100 + col * 300
|
||||
y = 400 + row * 200
|
||||
else:
|
||||
# Bottom layer
|
||||
x = 100 + (index % 20) * 150
|
||||
y = 800 + (index // 20) * 150
|
||||
|
||||
return {"x": x, "y": y}
|
||||
|
||||
else: # auto or default
|
||||
return {
|
||||
"x": 100 + (index * 200) % 2000,
|
||||
"y": 100 + (index // 10) * 150
|
||||
}
|
||||
|
||||
async def _create_batch_parallel(
|
||||
self,
|
||||
project_id: str,
|
||||
nodes: list[dict]
|
||||
) -> list[dict]:
|
||||
"""Create a batch of nodes in parallel."""
|
||||
import asyncio
|
||||
|
||||
async def create_single(node_spec: dict) -> dict:
|
||||
"""Create a single node."""
|
||||
try:
|
||||
# Call GNS3 create_node API
|
||||
node_id = await self._call_gns3_create_node(
|
||||
project_id, node_spec
|
||||
)
|
||||
return {
|
||||
"name": node_spec["name"],
|
||||
"status": "success",
|
||||
"node_id": node_id,
|
||||
"x": node_spec["x"],
|
||||
"y": node_spec["y"]
|
||||
}
|
||||
except Exception as e:
|
||||
return {
|
||||
"name": node_spec["name"],
|
||||
"status": "failed",
|
||||
"error": str(e)
|
||||
}
|
||||
|
||||
tasks = [create_single(node) for node in nodes]
|
||||
return await asyncio.gather(*tasks)
|
||||
|
||||
def _create_auto_links(
|
||||
self,
|
||||
project_id: str,
|
||||
auto_link_config: dict,
|
||||
created_groups: list[dict]
|
||||
) -> dict:
|
||||
"""Automatically create links between node groups."""
|
||||
|
||||
links_created = []
|
||||
|
||||
for link_pattern in auto_link_config.get("links", []):
|
||||
from_group_name = link_pattern["from_group"]
|
||||
to_group_name = link_pattern["to_group"]
|
||||
strategy = link_pattern.get("strategy", "mesh")
|
||||
|
||||
# Find the created nodes in each group
|
||||
from_nodes = self._get_nodes_by_group(created_groups, from_group_name)
|
||||
to_nodes = self._get_nodes_by_group(created_groups, to_group_name)
|
||||
|
||||
# Create links based on strategy
|
||||
if strategy == "mesh":
|
||||
# Full mesh: every from_node connects to every to_node
|
||||
for from_node in from_nodes:
|
||||
for to_node in to_nodes:
|
||||
link_result = self._create_link(
|
||||
project_id, from_node, to_node, link_pattern
|
||||
)
|
||||
links_created.append(link_result)
|
||||
|
||||
elif strategy == "paired":
|
||||
# One-to-one pairing
|
||||
for from_node, to_node in zip(from_nodes, to_nodes):
|
||||
link_result = self._create_link(
|
||||
project_id, from_node, to_node, link_pattern
|
||||
)
|
||||
links_created.append(link_result)
|
||||
|
||||
elif strategy == "linear":
|
||||
# Linear chain
|
||||
for i in range(min(len(from_nodes), len(to_nodes)) - 1):
|
||||
link_result = self._create_link(
|
||||
project_id, from_nodes[i], to_nodes[i + 1], link_pattern
|
||||
)
|
||||
links_created.append(link_result)
|
||||
|
||||
return {
|
||||
"total_links": len(links_created),
|
||||
"created": sum(1 for l in links_created if l["status"] == "success"),
|
||||
"links": links_created
|
||||
}
|
||||
```
|
||||
|
||||
### Performance Benchmarks
|
||||
|
||||
#### Scenario: 100 Router Lab
|
||||
|
||||
| Metric | Current Method | Template Method |
|
||||
|--------|---------------|-----------------|
|
||||
| **Token Consumption** | 5,000 | **100** |
|
||||
| **Execution Time** | 5-10 min | **30-60 sec** |
|
||||
| **User Control** | Low | **High (preview before create)** |
|
||||
| **Positioning** | Manual | **Automatic** |
|
||||
|
||||
#### Scenario: 500 Switch Data Center
|
||||
|
||||
| Metric | Current Method | Template Method |
|
||||
|--------|---------------|-----------------|
|
||||
| **Token Consumption** | 25,000 | **150** |
|
||||
| **Execution Time** | 25-30 min | **2-3 min** |
|
||||
| **Links Created** | Manual | **Auto (mesh, spine-leaf)** |
|
||||
|
||||
#### Scenario: 1000 Node Training Lab
|
||||
|
||||
| Metric | Current Method | Template Method |
|
||||
|--------|---------------|-----------------|
|
||||
| **Token Consumption** | 50,000 | **200** |
|
||||
| **Execution Time** | 50-60 min | **4-6 min** |
|
||||
| **Scalability** | Poor | **Excellent** |
|
||||
|
||||
### Complete Example: Enterprise Data Center
|
||||
|
||||
```python
|
||||
# User Request
|
||||
"""
|
||||
Create an enterprise data center topology:
|
||||
- 4 spine routers (high-end)
|
||||
- 20 leaf switches (10G)
|
||||
- 200 access switches (1G)
|
||||
- 500 servers (VPCS)
|
||||
|
||||
Use spine-leaf architecture with full mesh connectivity.
|
||||
All servers connect to access switches in pairs.
|
||||
"""
|
||||
|
||||
# Generated Template
|
||||
{
|
||||
"node_groups": [
|
||||
{
|
||||
"name": "spine",
|
||||
"node_type": "cisco_iosv",
|
||||
"count": 4,
|
||||
"name_pattern": "Spine-R{{ id }}",
|
||||
"properties": {
|
||||
"ram": 4096,
|
||||
"cpus": 2,
|
||||
"adapters": 8
|
||||
},
|
||||
"position": {
|
||||
"strategy": "hierarchical",
|
||||
"y": 100,
|
||||
"x_spacing": 600
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "leaf",
|
||||
"node_type": "cisco_iosv_l2",
|
||||
"count": 20,
|
||||
"name_pattern": "Leaf-SW{{ id }}",
|
||||
"properties": {
|
||||
"ram": 2048,
|
||||
"cpus": 1,
|
||||
"adapters": 16
|
||||
},
|
||||
"position": {
|
||||
"strategy": "grid",
|
||||
"grid_rows": 4,
|
||||
"grid_cols": 5,
|
||||
"y": 400,
|
||||
"x_spacing": 300,
|
||||
"y_spacing": 200
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "access",
|
||||
"node_type": "cisco_iosv_l2",
|
||||
"count": 200,
|
||||
"name_pattern": "Acc-SW{{ id }}",
|
||||
"properties": {
|
||||
"ram": 1024,
|
||||
"cpus": 1,
|
||||
"adapters": 4
|
||||
},
|
||||
"position": {
|
||||
"strategy": "grid",
|
||||
"grid_rows": 10,
|
||||
"grid_cols": 20,
|
||||
"y": 800,
|
||||
"x_spacing": 120,
|
||||
"y_spacing": 100
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "server",
|
||||
"node_type": "vpcs",
|
||||
"count": 500,
|
||||
"name_pattern": "Server-{{ id }}",
|
||||
"properties": {},
|
||||
"position": {
|
||||
"strategy": "grid",
|
||||
"grid_rows": 20,
|
||||
"grid_cols": 25,
|
||||
"y": 1200,
|
||||
"x_spacing": 60,
|
||||
"y_spacing": 60
|
||||
}
|
||||
}
|
||||
],
|
||||
"auto_link": {
|
||||
"links": [
|
||||
{
|
||||
"from_group": "spine",
|
||||
"to_group": "leaf",
|
||||
"strategy": "mesh"
|
||||
},
|
||||
{
|
||||
"from_group": "leaf",
|
||||
"to_group": "access",
|
||||
"strategy": "paired",
|
||||
"count": 10
|
||||
},
|
||||
{
|
||||
"from_group": "access",
|
||||
"to_group": "server",
|
||||
"strategy": "paired",
|
||||
"count": 2
|
||||
}
|
||||
]
|
||||
},
|
||||
"layout": "auto_spine_leaf",
|
||||
"resource_limits": {
|
||||
"max_ram_mb": 750000,
|
||||
"max_vcpus": 724
|
||||
}
|
||||
}
|
||||
|
||||
# Execution Result
|
||||
{
|
||||
"total_nodes": 724,
|
||||
"created": 724,
|
||||
"failed": 0,
|
||||
"duration_sec": 285, # ~4.75 minutes
|
||||
"links_created": 4280, # Auto-created
|
||||
"groups": [
|
||||
{"name": "spine", "created": 4, "failed": 0},
|
||||
{"name": "leaf", "created": 20, "failed": 0},
|
||||
{"name": "access", "created": 200, "failed": 0},
|
||||
{"name": "server", "created": 500, "failed": 0}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### Combined Workflow: Node Creation + Configuration
|
||||
|
||||
The real power comes from combining both template systems:
|
||||
|
||||
```
|
||||
1. Create topology with node templates
|
||||
- 724 nodes created in ~5 minutes
|
||||
- 4280 links auto-created
|
||||
|
||||
2. Configure devices with config templates
|
||||
- Generate OSPF/BGP templates
|
||||
- Configure 724 devices in ~5 minutes
|
||||
|
||||
Total: 724-node data center
|
||||
- Created and configured in ~10 minutes
|
||||
- Token cost: ~400 (vs ~100,000 with AI-only approach)
|
||||
- 99.6% token savings
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Implementation Phases
|
||||
|
||||
### Phase 1: Core MVP (Minimum Viable Product)
|
||||
@ -1018,6 +1748,25 @@ For 1000+ devices, some failures are inevitable. The system provides:
|
||||
- **Rule-based parameter generation (0 token cost)**
|
||||
- User documentation
|
||||
|
||||
### Phase 2.5: Node Creation Templates
|
||||
|
||||
**Status:** 💡 Proposed
|
||||
**Estimated Effort:** 2-3 days
|
||||
|
||||
**Tasks:**
|
||||
1. 🔥🔥 Implement `GenerateNodeTemplate` tool
|
||||
2. 🔥🔥 Implement `ExecuteBatchNodeCreation` tool
|
||||
3. 🔥🔥 Create `NodeCreationTemplate` schema
|
||||
4. 🔥🔥 Implement automatic positioning algorithms
|
||||
5. 🔥🔥 Implement auto-linking functionality
|
||||
6. Resource validation before creation
|
||||
|
||||
**Deliverables:**
|
||||
- **Batch node creation with 0 token cost**
|
||||
- **Auto-positioning (grid, spine-leaf, star, mesh)**
|
||||
- **Auto-linking (mesh, paired, linear)**
|
||||
- Progress streaming for large batches
|
||||
|
||||
### Phase 3: Template Library & Large-Scale Support
|
||||
|
||||
**Status:** 💡 Proposed
|
||||
@ -1330,6 +2079,7 @@ langgraph>=0.0.20
|
||||
|
||||
| Date | Version | Changes |
|
||||
|------|---------|---------|
|
||||
| 2026-03-20 | 0.3 | Added node creation templates section with batch topology provisioning, auto-linking, automatic positioning; Combined node creation + configuration workflows for rapid 1000+ node data center deployment |
|
||||
| 2026-03-20 | 0.2 | Added large-scale topology support section (1000+ nodes), direct execution mode, batch parallel execution, rule engine optimizations |
|
||||
| 2026-03-20 | 0.1 | Initial roadmap document created |
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user