Upload WorkflowDesigner.py

WorkflowDesigner.py

@@ -0,0 +1,2459 @@
+from dataclasses import asdict, dataclass, field
+import os
+import pickle
+from typing import Dict, List, Optional, Any
+import gradio as gr
+import json
+import tempfile
+import asyncio
+import uuid
+from dataclasses import dataclass, asdict
+from typing import List, Dict, Optional, Any
+from openai import AsyncOpenAI
+import base64
+
+# Complete Hierarchical Component definitions with Implementation Details
+COMPONENT_INFO = {
+    "SYSTEM": {
+        "description": "Top-level system architecture containing all components",
+        "color": "#333333",
+        "icon": "🌐",
+        "shape": "folder",
+        "sub_components": ["AGENT", "USER", "TOOL", "DATA", "PROCESSOR", "ROUTER", "INFRASTRUCTURE", "CONFIG"]
+    },
+
+    # ===================================
+    # AGENT: Autonomous reasoning units
+    # ===================================
+    "AGENT": {
+        "description": "Autonomous reasoning and decision-making units",
+        "color": "#4CAF50",
+        "icon": "🤖",
+        "shape": "rect",
+        "sub_components": ["REASONING_AGENT", "ACTION_AGENT", "PLANNER_AGENT", "REACT_AGENT", "MULTI_AGENT"]
+    },
+    
+    "REASONING_AGENT": {
+        "shape": "rect",
+        "color": "#4CAF50",
+        "icon": "🧠",
+        "description": [
+            "• Performs complex reasoning tasks",
+            "• Uses chain-of-thought or tree-of-thought",
+            "• Can break down complex problems",
+            "• Maintains reasoning traces"
+        ],
+        "implementation": {
+            "python_snippet": """
+class ReasoningAgent:
+    def __init__(self, model, tools=None):
+        self.model = model
+        self.tools = tools or []
+        self.reasoning_history = []
+    
+    async def process(self, query, context=None):
+        # Chain-of-thought reasoning
+        reasoning_steps = await self.generate_reasoning_steps(query, context)
+        self.reasoning_history.extend(reasoning_steps)
+        
+        # Final answer generation
+        answer = await self.synthesize_answer(reasoning_steps)
+        return answer
+    
+    async def generate_reasoning_steps(self, query, context):
+        prompt = f\"\"\"Analyze this problem step by step:
+        Query: {query}
+        Context: {context}
+        
+        Break down your reasoning:\"\"\"
+        return await self.model.generate(prompt)
+            """,
+            "prompt_template": """
+You are a reasoning agent. Analyze the user's query step by step:
+
+Query: {user_input}
+Context: {context}
+
+Please:
+1. Break down the problem into logical steps
+2. Consider different perspectives
+3. Evaluate evidence and constraints
+4. Synthesize a comprehensive answer
+
+Reasoning steps:
+            """,
+            "dependencies": ["openai", "langchain", "pydantic"],
+            "config": {
+                "model": "gpt-4",
+                "temperature": 0.1,
+                "max_tokens": 2000
+            }
+        }
+    },
+    
+    "ACTION_AGENT": {
+        "shape": "rect",
+        "color": "#4CAF50",
+        "icon": "⚡",
+        "description": [
+            "• Executes actions using available tools",
+            "• Monitors action outcomes",
+            "• Handles errors and retries",
+            "• Updates state after actions"
+        ],
+        "implementation": {
+            "python_snippet": """
+class ActionAgent:
+    def __init__(self, tools, model):
+        self.tools = {tool.name: tool for tool in tools}
+        self.model = model
+    
+    async def execute_action(self, action_request):
+        tool_name, parameters = self.parse_action(action_request)
+        if tool_name in self.tools:
+            return await self.tools[tool_name].execute(parameters)
+        else:
+            raise ValueError(f"Unknown tool: {tool_name}")
+    
+    def parse_action(self, action_request):
+        # Parse action from model response
+        return action_request['tool'], action_request['parameters']
+            """,
+            "dependencies": ["pydantic", "asyncio"],
+            "config": {
+                "retry_attempts": 3,
+                "timeout_seconds": 30
+            }
+        }
+    },
+    
+    "PLANNER_AGENT": {
+        "shape": "rect",
+        "color": "#4CAF50",
+        "icon": "📋",
+        "description": [
+            "• Creates multi-step plans to achieve goals",
+            "• Decomposes complex tasks",
+            "• Optimizes execution order",
+            "• Monitors plan progress"
+        ],
+        "implementation": {
+            "python_snippet": """
+class PlannerAgent:
+    def __init__(self, model):
+        self.model = model
+        self.plans = []
+    
+    async def create_plan(self, goal, context):
+        plan_prompt = f\"\"\"Create a step-by-step plan to achieve:
+        Goal: {goal}
+        Context: {context}
+        
+        Return a list of actionable steps:\"\"\"
+        plan_steps = await self.model.generate(plan_prompt)
+        plan = Plan(steps=plan_steps, goal=goal)
+        self.plans.append(plan)
+        return plan
+            """,
+            "dependencies": ["pydantic"],
+            "config": {
+                "max_steps": 20,
+                "planning_temperature": 0.3
+            }
+        }
+    },
+    
+    "REACT_AGENT": {
+        "shape": "rect",
+        "color": "#4CAF50",
+        "icon": "🔄",
+        "description": [
+            "• Implements ReAct (Reason + Act) framework",
+            "• Alternates reasoning and action steps",
+            "• Maintains conversation history",
+            "• Handles tool interactions"
+        ],
+        "implementation": {
+            "python_snippet": """
+class ReActAgent:
+    def __init__(self, model, tools):
+        self.model = model
+        self.tools = tools
+        self.conversation_history = []
+    
+    async def step(self, input_text):
+        # Generate thought
+        thought = await self.generate_thought(input_text)
+        
+        # Decide on action
+        action = await self.decide_action(thought)
+        
+        # Execute action if needed
+        if action:
+            observation = await self.execute_action(action)
+            return {"thought": thought, "action": action, "observation": observation}
+        else:
+            return {"thought": thought, "answer": await self.generate_answer(thought)}
+            """,
+            "dependencies": ["asyncio", "langchain"],
+            "config": {
+                "max_iterations": 10,
+                "react_temperature": 0.7
+            }
+        }
+    },
+    
+    "MULTI_AGENT": {
+        "shape": "rect",
+        "color": "#4CAF50",
+        "icon": "👥",
+        "description": [
+            "• Coordinates multiple specialized agents",
+            "• Manages agent communication",
+            "• Distributes tasks among agents",
+            "• Aggregates results from agents"
+        ],
+        "implementation": {
+            "python_snippet": """
+class MultiAgentSystem:
+    def __init__(self, agents, orchestrator):
+        self.agents = {agent.name: agent for agent in agents}
+        self.orchestrator = orchestrator
+    
+    async def coordinate(self, task):
+        # Assign task to appropriate agents
+        agent_assignments = await self.orchestrator.assign(task)
+        
+        # Execute in parallel
+        results = await asyncio.gather(*[
+            self.agents[agent_name].process(subtask)
+            for agent_name, subtask in agent_assignments.items()
+        ])
+        
+        return self.orchestrator.aggregate(results)
+            """,
+            "dependencies": ["asyncio", "concurrent.futures"],
+            "config": {
+                "max_concurrent_agents": 10,
+                "communication_protocol": "message_queue"
+            }
+        }
+    },
+
+    # ===================================
+    # USER: Interaction interfaces
+    # ===================================
+    "USER": {
+        "description": "User interaction points and interfaces",
+        "color": "#9C27B0",
+        "icon": "👤",
+        "shape": "ellipse",
+        "sub_components": ["USER_INPUT", "USER_OUTPUT", "MULTIMODAL_INTERFACE"]
+    },
+    
+    "USER_INPUT": {
+        "shape": "ellipse",
+        "color": "#9C27B0",
+        "icon": "⌨️",
+        "description": [
+            "• Accepts text, voice, or gesture input",
+            "• Validates and sanitizes input",
+            "• Converts to structured format",
+            "• Handles multiple input channels"
+        ],
+        "implementation": {
+            "python_snippet": """
+class UserInputHandler:
+    def __init__(self):
+        self.input_validators = {
+            'text': self.validate_text,
+            'voice': self.validate_voice,
+            'gesture': self.validate_gesture
+        }
+    
+    async def process_input(self, input_type, raw_input):
+        validator = self.input_validators.get(input_type)
+        if validator:
+            return await validator(raw_input)
+        else:
+            raise ValueError(f"Unsupported input type: {input_type}")
+    
+    async def validate_text(self, text):
+        # Sanitize and structure text input
+        return {"type": "text", "content": text.strip()}
+            """,
+            "dependencies": ["validators", "pydantic"],
+            "config": {
+                "max_input_length": 10000,
+                "allowed_input_types": ["text", "voice", "gesture"]
+            }
+        }
+    },
+    
+    "USER_OUTPUT": {
+        "shape": "ellipse",
+        "color": "#9C27B0",
+        "icon": "🔊",
+        "description": [
+            "• Formats responses for user consumption",
+            "• Supports multiple output formats",
+            "• Handles accessibility features",
+            "• Manages response timing"
+        ],
+        "implementation": {
+            "python_snippet": """
+class UserOutputHandler:
+    def __init__(self):
+        self.formatters = {
+            'text': self.format_text,
+            'audio': self.format_audio,
+            'visual': self.format_visual
+        }
+    
+    async def deliver_response(self, response_data, output_format):
+        formatter = self.formatters.get(output_format)
+        if formatter:
+            formatted_response = await formatter(response_data)
+            return await self.send_to_user(formatted_response)
+    
+    async def format_text(self, data):
+        # Format response as structured text
+        return {"format": "text", "content": data}
+            """,
+            "dependencies": ["jinja2", "markdown"],
+            "config": {
+                "default_format": "text",
+                "max_response_length": 5000
+            }
+        }
+    },
+    
+    "MULTIMODAL_INTERFACE": {
+        "shape": "ellipse",
+        "color": "#9C27B0",
+        "icon": "🖼️",
+        "description": [
+            "• Handles multiple input/output modalities",
+            "• Integrates text, image, audio, video",
+            "• Manages modality conversion",
+            "• Supports rich media responses"
+        ],
+        "implementation": {
+            "python_snippet": """
+class MultimodalInterface:
+    def __init__(self):
+        self.input_processors = {
+            'image': ImageProcessor(),
+            'audio': AudioProcessor(),
+            'text': TextProcessor()
+        }
+        self.output_formatters = {
+            'rich_text': RichTextFormatter(),
+            'multimedia': MultimediaFormatter()
+        }
+    
+    async def process_multimodal_input(self, inputs):
+        processed_inputs = {}
+        for input_type, input_data in inputs.items():
+            processor = self.input_processors.get(input_type)
+            if processor:
+                processed_inputs[input_type] = await processor.process(input_data)
+        return processed_inputs
+            """,
+            "dependencies": ["pillow", "pyaudio", "opencv-python"],
+            "config": {
+                "supported_modalities": ["text", "image", "audio", "video"],
+                "max_file_size_mb": 50
+            }
+        }
+    },
+
+    # ===================================
+    # TOOL: External functions and capabilities
+    # ===================================
+    "TOOL": {
+        "description": "External functions and capabilities",
+        "color": "#795548",
+        "icon": "🔧",
+        "shape": "hexagon",
+        "sub_components": ["MCP_TOOL", "API_TOOL", "LOCAL_TOOL", "AGENT_TOOL", "FUNCTION_TOOL"]
+    },
+    
+    "MCP_TOOL": {
+        "shape": "hexagon",
+        "color": "#795548",
+        "icon": "🔌",
+        "description": [
+            "• Model Context Protocol server",
+            "• Standardized tool interface",
+            "• Dynamic tool discovery",
+            "• Secure resource access"
+        ],
+        "implementation": {
+            "python_snippet": """
+# MCP Server implementation
+from mcp import MCPServer, Tool
+
+class FileSystemTool:
+    @Tool
+    async def read_file(self, path: str) -> str:
+        \"\"\"Read content from a file\"\"\"
+        with open(path, 'r') as f:
+            return f.read()
+    
+    @Tool
+    async def write_file(self, path: str, content: str) -> str:
+        \"\"\"Write content to a file\"\"\"
+        with open(path, 'w') as f:
+            f.write(content)
+        return f"Written to {path}"
+
+# MCP Client usage
+async def use_mcp_tool(agent, tool_name, parameters):
+    result = await agent.use_tool(tool_name, parameters)
+    return result
+            """,
+            "protocol_spec": {
+                "version": "1.0",
+                "transport": ["stdio", "sse"],
+                "authentication": ["none", "bearer"]
+            },
+            "example_tools": ["filesystem", "calculator", "web_search", "database"]
+        }
+    },
+    
+    "API_TOOL": {
+        "shape": "hexagon",
+        "color": "#795548",
+        "icon": "🔗",
+        "description": [
+            "• Wraps external REST/gRPC APIs",
+            "• Handles authentication and rate limits",
+            "• Manages request/response mapping",
+            "• Provides error handling and retries"
+        ],
+        "implementation": {
+            "python_snippet": """
+class APITool:
+    def __init__(self, base_url, auth_token=None, rate_limit=10):
+        self.base_url = base_url
+        self.auth_token = auth_token
+        self.rate_limit = rate_limit
+        self.session = aiohttp.ClientSession()
+    
+    async def call(self, endpoint, method='GET', data=None):
+        headers = {"Authorization": f"Bearer {self.auth_token}"} if self.auth_token else {}
+        url = f"{self.base_url}/{endpoint}"
+        
+        async with self.session.request(method, url, json=data, headers=headers) as response:
+            return await response.json()
+            """,
+            "dependencies": ["aiohttp", "requests"],
+            "config": {
+                "timeout": 30,
+                "max_retries": 3,
+                "retry_delay": 1.0
+            }
+        }
+    },
+    
+    "LOCAL_TOOL": {
+        "shape": "hexagon",
+        "color": "#795548",
+        "icon": "💻",
+        "description": [
+            "• Locally executed utility functions",
+            "• File operations, math calculations",
+            "• System utilities and helpers",
+            "• Fast execution without network calls"
+        ],
+        "implementation": {
+            "python_snippet": """
+class LocalTool:
+    @staticmethod
+    async def file_operations(action, **kwargs):
+        if action == 'read':
+            with open(kwargs['path'], 'r') as f:
+                return f.read()
+        elif action == 'write':
+            with open(kwargs['path'], 'w') as f:
+                f.write(kwargs['content'])
+                return f"File written to {kwargs['path']}"
+    
+    @staticmethod
+    async def math_operations(operation, **kwargs):
+        if operation == 'add':
+            return kwargs['a'] + kwargs['b']
+        elif operation == 'multiply':
+            return kwargs['a'] * kwargs['b']
+            """,
+            "dependencies": ["os", "math"],
+            "config": {
+                "max_execution_time": 5.0,
+                "allowed_operations": ["file", "math", "system"]
+            }
+        }
+    },
+    
+    "AGENT_TOOL": {
+        "shape": "hexagon",
+        "color": "#795548",
+        "icon": "🛠️",
+        "description": [
+            "• Allows one agent to act as a tool for another",
+            "• Wraps agent functionality for external use",
+            "• Handles agent-to-agent communication",
+            "• Manages agent state and context"
+        ],
+        "implementation": {
+            "python_snippet": """
+class AgentTool:
+    def __init__(self, agent):
+        self.agent = agent
+    
+    async def execute(self, query, context=None):
+        # Wrap agent execution as a tool call
+        result = await self.agent.process(query, context)
+        return {
+            "result": result,
+            "agent_name": self.agent.name,
+            "execution_time": time.time()
+        }
+            """,
+            "dependencies": ["asyncio", "time"],
+            "config": {
+                "max_concurrent_calls": 5,
+                "timeout_seconds": 60
+            }
+        }
+    },
+    
+    "FUNCTION_TOOL": {
+        "shape": "hexagon",
+        "color": "#795548",
+        "icon": "🧮",
+        "description": [
+            "• Generic callable function exposed to agents",
+            "• Wraps Python functions for tool use",
+            "• Handles parameter validation",
+            "• Provides type safety and documentation"
+        ],
+        "implementation": {
+            "python_snippet": """
+from pydantic import BaseModel, create_model
+
+class FunctionTool:
+    def __init__(self, func, description, param_schema=None):
+        self.func = func
+        self.description = description
+        self.param_schema = param_schema or self._infer_schema(func)
+    
+    async def execute(self, **kwargs):
+        validated_params = self.param_schema(**kwargs)
+        return await self.func(**validated_params.dict())
+    
+    def _infer_schema(self, func):
+        # Infer schema from function signature
+        sig = inspect.signature(func)
+        fields = {}
+        for name, param in sig.parameters.items():
+            fields[name] = (param.annotation, param.default if param.default != param.empty else ...)
+        return create_model(f"{func.__name__}Params", **fields)
+            """,
+            "dependencies": ["pydantic", "inspect"],
+            "config": {
+                "max_params": 10,
+                "validation_enabled": True
+            }
+        }
+    },
+
+    # ===================================
+    # DATA: Storage and knowledge systems
+    # ===================================
+    "DATA": {
+        "description": "Data sources and storage systems",
+        "color": "#009688",
+        "icon": "💾",
+        "shape": "cylinder",
+        "sub_components": ["KNOWLEDGE_BASE", "VECTOR_DB", "DOCUMENT_STORE", "CACHE", "MEMORY"]
+    },
+    
+    "KNOWLEDGE_BASE": {
+        "shape": "cylinder",
+        "color": "#009688",
+        "icon": "📘",
+        "description": [
+            "• Curated domain-specific facts and rules",
+            "• Structured knowledge representation",
+            "• Supports inference and reasoning",
+            "• Maintains consistency and accuracy"
+        ],
+        "implementation": {
+            "python_snippet": """
+class KnowledgeBase:
+    def __init__(self, storage_backend):
+        self.storage = storage_backend
+        self.index = {}
+    
+    async def query(self, query_text, context=None):
+        # Query knowledge base with optional context
+        results = await self.storage.search(query_text)
+        return self._format_results(results)
+    
+    async def update(self, fact, metadata=None):
+        # Add or update knowledge fact
+        await self.storage.insert(fact, metadata)
+        self._update_index(fact)
+            """,
+            "dependencies": ["sqlite3", "nltk"],
+            "config": {
+                "max_facts": 100000,
+                "update_frequency": "daily"
+            }
+        }
+    },
+    
+    "VECTOR_DB": {
+        "shape": "cylinder",
+        "color": "#009688",
+        "icon": "🔍",
+        "description": [
+            "• Embedding-based database for semantic search",
+            "• Stores vector representations of text",
+            "• Enables similarity-based retrieval",
+            "• Supports semantic understanding"
+        ],
+        "implementation": {
+            "python_snippet": """
+import numpy as np
+from sentence_transformers import SentenceTransformer
+
+class VectorDB:
+    def __init__(self, embedding_model="all-MiniLM-L6-v2"):
+        self.model = SentenceTransformer(embedding_model)
+        self.vectors = {}
+        self.metadata = {}
+    
+    async def add_document(self, doc_id, text, metadata=None):
+        embedding = self.model.encode(text)
+        self.vectors[doc_id] = embedding
+        self.metadata[doc_id] = metadata or {}
+    
+    async def search(self, query, top_k=5):
+        query_embedding = self.model.encode(query)
+        similarities = []
+        for doc_id, vector in self.vectors.items():
+            similarity = np.dot(query_embedding, vector) / (
+                np.linalg.norm(query_embedding) * np.linalg.norm(vector)
+            )
+            similarities.append((doc_id, similarity))
+        
+        return sorted(similarities, key=lambda x: x[1], reverse=True)[:top_k]
+            """,
+            "dependencies": ["sentence-transformers", "numpy"],
+            "config": {
+                "embedding_model": "all-MiniLM-L6-v2",
+                "max_documents": 10000
+            }
+        }
+    },
+    
+    "DOCUMENT_STORE": {
+        "shape": "cylinder",
+        "color": "#009688",
+        "icon": "🗂️",
+        "description": [
+            "• Raw document repository (PDFs, web pages, etc.)",
+            "• Handles various document formats",
+            "• Provides document parsing and extraction",
+            "• Manages document lifecycle and metadata"
+        ],
+        "implementation": {
+            "python_snippet": """
+class DocumentStore:
+    def __init__(self, storage_path):
+        self.storage_path = storage_path
+        self.parsers = {
+            '.pdf': self._parse_pdf,
+            '.txt': self._parse_text,
+            '.docx': self._parse_docx
+        }
+    
+    async def store_document(self, filename, content):
+        # Parse and store document with metadata
+        ext = os.path.splitext(filename)[1].lower()
+        parser = self.parsers.get(ext)
+        if parser:
+            parsed_content = await parser(content)
+            # Store in database with metadata
+            return await self._save_to_db(filename, parsed_content)
+    
+    async def _parse_pdf(self, content):
+        # Extract text from PDF
+        import PyPDF2
+        pdf_reader = PyPDF2.PdfReader(content)
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text()
+        return text
+            """,
+            "dependencies": ["PyPDF2", "python-docx"],
+            "config": {
+                "supported_formats": [".pdf", ".txt", ".docx", ".html"],
+                "max_file_size_mb": 100
+            }
+        }
+    },
+    
+    "CACHE": {
+        "shape": "cylinder",
+        "color": "#009688",
+        "icon": "⏱️",
+        "description": [
+            "• Temporary fast-access storage for responses or embeddings",
+            "• Implements LRU or TTL eviction policies",
+            "• Reduces computation and API costs",
+            "• Improves response times"
+        ],
+        "implementation": {
+            "python_snippet": """
+import time
+from collections import OrderedDict
+
+class Cache:
+    def __init__(self, max_size=1000, ttl_seconds=3600):
+        self.cache = OrderedDict()
+        self.max_size = max_size
+        self.ttl = ttl_seconds
+    
+    async def get(self, key):
+        if key in self.cache:
+            value, timestamp = self.cache[key]
+            if time.time() - timestamp < self.ttl:
+                return value
+            else:
+                del self.cache[key]
+        return None
+    
+    async def set(self, key, value):
+        if len(self.cache) >= self.max_size:
+            self.cache.popitem(last=False)
+        self.cache[key] = (value, time.time())
+            """,
+            "dependencies": ["time", "collections"],
+            "config": {
+                "max_size": 1000,
+                "ttl_seconds": 3600,
+                "eviction_policy": "lru"
+            }
+        }
+    },
+    
+    "MEMORY": {
+        "shape": "cylinder",
+        "color": "#009688",
+        "icon": "🧠",
+        "description": [
+            "• Short-term context memory (conversation history, scratchpad)",
+            "• Maintains session state and context",
+            "• Supports conversation continuity",
+            "• Manages memory lifecycle"
+        ],
+        "implementation": {
+            "python_snippet": """
+class Memory:
+    def __init__(self, max_context_length=2000):
+        self.conversation_history = []
+        self.scratchpad = {}
+        self.max_context_length = max_context_length
+    
+    async def add_interaction(self, user_input, agent_response):
+        interaction = {
+            "timestamp": time.time(),
+            "user": user_input,
+            "agent": agent_response
+        }
+        self.conversation_history.append(interaction)
+        self._trim_history()
+    
+    def _trim_history(self):
+        # Trim history to maintain context length
+        total_length = sum(len(str(item)) for item in self.conversation_history)
+        while total_length > self.max_context_length and len(self.conversation_history) > 1:
+            removed = self.conversation_history.pop(0)
+            total_length -= len(str(removed))
+            """,
+            "dependencies": ["time"],
+            "config": {
+                "max_context_length": 2000,
+                "history_retention_hours": 24
+            }
+        }
+    },
+
+    # ===================================
+    # PROCESSOR: Data processing units
+    # ===================================
+    "PROCESSOR": {
+        "description": "Data processing and transformation units",
+        "color": "#2196F3",
+        "icon": "⚙️",
+        "shape": "rect",
+        "sub_components": ["QUERY_PROCESSOR", "CONTENT_RETRIEVAL", "PROMPT_TEMPLATE", "RESPONSE_FORMATTER"]
+    },
+    
+    "QUERY_PROCESSOR": {
+        "shape": "rect",
+        "color": "#2196F3",
+        "icon": "🔎",
+        "description": [
+            "• Parses and enriches incoming queries",
+            "• Extracts intent and entities",
+            "• Normalizes query structure",
+            "• Handles query validation"
+        ],
+        "implementation": {
+            "python_snippet": """
+class QueryProcessor:
+    def __init__(self):
+        self.intent_classifier = IntentClassifier()
+        self.entity_extractor = EntityExtractor()
+    
+    async def process_query(self, query_text):
+        # Classify intent and extract entities
+        intent = await self.intent_classifier.classify(query_text)
+        entities = await self.entity_extractor.extract(query_text)
+        
+        return {
+            "original_query": query_text,
+            "intent": intent,
+            "entities": entities,
+            "processed_query": self._normalize_query(query_text, entities)
+        }
+    
+    def _normalize_query(self, query, entities):
+        # Normalize query for downstream processing
+        normalized = query
+        for entity, value in entities.items():
+            normalized = normalized.replace(value, f"[{entity}]")
+        return normalized
+            """,
+            "dependencies": ["spacy", "transformers"],
+            "config": {
+                "max_query_length": 1000,
+                "confidence_threshold": 0.7
+            }
+        }
+    },
+    
+    "CONTENT_RETRIEVAL": {
+        "shape": "rect",
+        "color": "#2196F3",
+        "icon": "📤",
+        "description": [
+            "• Fetches relevant content from data stores",
+            "• Implements semantic and keyword search",
+            "• Ranks and filters retrieved content",
+            "• Handles multi-source retrieval"
+        ],
+        "implementation": {
+            "python_snippet": """
+class ContentRetrieval:
+    def __init__(self, data_sources):
+        self.data_sources = data_sources
+    
+    async def retrieve(self, query, top_k=5, sources=None):
+        all_results = []
+        
+        for source_name, source in self.data_sources.items():
+            if sources is None or source_name in sources:
+                results = await source.search(query, top_k)
+                all_results.extend(results)
+        
+        # Rank and deduplicate results
+        ranked_results = self._rank_results(all_results, query)
+        return ranked_results[:top_k]
+    
+    def _rank_results(self, results, query):
+        # Implement ranking algorithm
+        return sorted(results, key=lambda x: x.get('relevance_score', 0), reverse=True)
+            """,
+            "dependencies": ["numpy", "scikit-learn"],
+            "config": {
+                "top_k": 5,
+                "max_sources": 10,
+                "relevance_threshold": 0.5
+            }
+        }
+    },
+    
+    "PROMPT_TEMPLATE": {
+        "shape": "rect",
+        "color": "#2196F3",
+        "icon": "📝",
+        "description": [
+            "• Template-based prompt construction",
+            "• Supports variable substitution",
+            "• Handles different prompt formats",
+            "• Manages prompt versioning"
+        ],
+        "implementation": {
+            "python_snippet": """
+from jinja2 import Template
+
+class PromptTemplate:
+    def __init__(self, template_string):
+        self.template = Template(template_string)
+    
+    async def format(self, **kwargs):
+        return self.template.render(**kwargs)
+    
+    @classmethod
+    def load_from_file(cls, file_path):
+        with open(file_path, 'r') as f:
+            template_string = f.read()
+        return cls(template_string)
+    
+    def validate_variables(self, required_vars):
+        # Validate that all required variables are provided
+        pass
+            """,
+            "dependencies": ["jinja2"],
+            "config": {
+                "default_template": "You are a helpful assistant. User: {query}",
+                "max_template_length": 5000
+            }
+        }
+    },
+    
+    "RESPONSE_FORMATTER": {
+        "shape": "rect",
+        "color": "#2196F3",
+        "icon": "📄",
+        "description": [
+            "• Structures final output (JSON, XML, markdown, etc.)",
+            "• Applies formatting rules and styles",
+            "• Validates response structure",
+            "• Supports multiple output formats"
+        ],
+        "implementation": {
+            "python_snippet": """
+class ResponseFormatter:
+    def __init__(self):
+        self.formatters = {
+            'json': self._format_json,
+            'xml': self._format_xml,
+            'markdown': self._format_markdown,
+            'text': self._format_text
+        }
+    
+    async def format(self, data, format_type='json'):
+        formatter = self.formatters.get(format_type)
+        if formatter:
+            return formatter(data)
+        else:
+            raise ValueError(f"Unsupported format: {format_type}")
+    
+    def _format_json(self, data):
+        import json
+        return json.dumps(data, indent=2)
+            """,
+            "dependencies": ["json", "xml.etree.ElementTree"],
+            "config": {
+                "default_format": "json",
+                "max_output_length": 10000
+            }
+        }
+    },
+
+    # ===================================
+    # ROUTER: Decision points and workflow routing
+    # ===================================
+    "ROUTER": {
+        "description": "Decision points and workflow routing",
+        "color": "#FF9800",
+        "icon": "🎯",
+        "shape": "diamond",
+        "sub_components": ["INTENT_DISCOVERY", "MODEL_SELECTOR", "WORKFLOW_ROUTER", "VALIDATOR"]
+    },
+    
+    "INTENT_DISCOVERY": {
+        "shape": "diamond",
+        "color": "#FF9800",
+        "icon": "🎯",
+        "description": [
+            "• Identifies user intent from input",
+            "• Uses machine learning classification",
+            "• Handles intent confidence scoring",
+            "• Supports intent hierarchy"
+        ],
+        "implementation": {
+            "python_snippet": """
+class IntentDiscovery:
+    def __init__(self, model_path):
+        self.model = self.load_model(model_path)
+    
+    async def discover_intent(self, text):
+        # Classify intent using trained model
+        predictions = await self.model.predict(text)
+        top_intent = max(predictions, key=predictions.get)
+        confidence = predictions[top_intent]
+        
+        return {
+            "intent": top_intent,
+            "confidence": confidence,
+            "all_predictions": predictions
+        }
+            """,
+            "dependencies": ["transformers", "torch"],
+            "config": {
+                "confidence_threshold": 0.8,
+                "fallback_intent": "unknown"
+            }
+        }
+    },
+    
+    "MODEL_SELECTOR": {
+        "shape": "diamond",
+        "color": "#FF9800",
+        "icon": "🧠",
+        "description": [
+            "• Selects appropriate model based on task",
+            "• Considers task complexity and cost",
+            "• Handles model availability and load",
+            "• Supports A/B testing of models"
+        ],
+        "implementation": {
+            "python_snippet": """
+class ModelSelector:
+    def __init__(self, models):
+        self.models = models
+        self.model_performance = {}
+    
+    async def select_model(self, task_description, context=None):
+        # Select best model based on task requirements
+        suitable_models = self._filter_suitable_models(task_description)
+        
+        # Choose based on performance metrics and availability
+        best_model = self._select_best_model(suitable_models)
+        return best_model
+    
+    def _filter_suitable_models(self, task_description):
+        # Filter models based on task compatibility
+        return [model for model in self.models if model.can_handle(task_description)]
+            """,
+            "dependencies": ["numpy"],
+            "config": {
+                "selection_strategy": "performance_weighted",
+                "max_model_candidates": 5
+            }
+        }
+    },
+    
+    "WORKFLOW_ROUTER": {
+        "shape": "diamond",
+        "color": "#FF9800",
+        "icon": "🔄",
+        "description": [
+            "• Routes requests through appropriate workflows",
+            "• Manages workflow state and transitions",
+            "• Handles parallel and sequential execution",
+            "• Supports workflow versioning"
+        ],
+        "implementation": {
+            "python_snippet": """
+class WorkflowRouter:
+    def __init__(self, workflows):
+        self.workflows = workflows
+        self.current_executions = {}
+    
+    async def route(self, request, workflow_name=None):
+        if workflow_name:
+            workflow = self.workflows.get(workflow_name)
+        else:
+            workflow = await self._auto_select_workflow(request)
+        
+        execution_id = str(uuid.uuid4())
+        self.current_executions[execution_id] = workflow
+        
+        result = await workflow.execute(request)
+        del self.current_executions[execution_id]
+        
+        return result
+            """,
+            "dependencies": ["uuid", "asyncio"],
+            "config": {
+                "max_concurrent_workflows": 100,
+                "workflow_timeout": 300
+            }
+        }
+    },
+    
+    "VALIDATOR": {
+        "shape": "diamond",
+        "color": "#FF9800",
+        "icon": "✅",
+        "description": [
+            "• Validates inputs, outputs, and intermediate results",
+            "• Implements schema and business rule validation",
+            "• Handles data quality checks",
+            "• Provides validation feedback"
+        ],
+        "implementation": {
+            "python_snippet": """
+from pydantic import BaseModel, ValidationError
+
+class Validator:
+    def __init__(self, schema_class: BaseModel):
+        self.schema_class = schema_class
+    
+    async def validate(self, data):
+        try:
+            validated_data = self.schema_class(**data)
+            return {
+                "valid": True,
+                "data": validated_data.dict(),
+                "errors": []
+            }
+        except ValidationError as e:
+            return {
+                "valid": False,
+                "data": None,
+                "errors": e.errors()
+            }
+            """,
+            "dependencies": ["pydantic"],
+            "config": {
+                "strict_validation": True,
+                "validation_timeout": 10
+            }
+        }
+    },
+
+    # ===================================
+    # INFRASTRUCTURE: System services
+    # ===================================
+    "INFRASTRUCTURE": {
+        "description": "System infrastructure and services",
+        "color": "#FF5722",
+        "icon": "🌐",
+        "shape": "rect",
+        "sub_components": ["PROVIDER", "MONITOR", "FALLBACK", "ORCHESTRATOR"]
+    },
+    
+    "PROVIDER": {
+        "shape": "rect",
+        "color": "#FF5722",
+        "icon": "🌐",
+        "description": [
+            "• API connection to LLM service",
+            "• Manages authentication and rate limits",
+            "• Handles retries and error recovery",
+            "• Tracks usage and costs"
+        ],
+        "implementation": {
+            "python_snippet": """
+class LLMProvider:
+    def __init__(self, base_url: str, api_key: str = None, model: str = "default"):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.model = model
+        self.client = AsyncOpenAI(base_url=base_url, api_key=api_key)
+        self.usage_tracker = UsageTracker()
+    
+    async def generate(self, prompt: str, **kwargs) -> str:
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=[{"role": "user", "content": prompt}],
+                **kwargs
+            )
+            self.usage_tracker.record_usage(response.usage)
+            return response.choices[0].message.content
+        except Exception as e:
+            raise ProviderError(f"Generation failed: {e}")
+    
+    def get_cost_estimate(self) -> float:
+        return self.usage_tracker.calculate_cost()
+            """,
+            "supported_providers": {
+                "openai": {"base_url": "https://api.openai.com/v1", "models": ["gpt-4", "gpt-3.5-turbo"]},
+                "anthropic": {"base_url": "https://api.anthropic.com/v1", "models": ["claude-3", "claude-2"]},
+                "local": {"base_url": "http://localhost:1234/v1", "models": ["local-model"]},
+                "azure": {"base_url": "https://your-resource.openai.azure.com/", "models": ["gpt-4", "gpt-35-turbo"]}
+            },
+            "config_template": {
+                "base_url": "https://api.openai.com/v1",
+                "api_key": "your-api-key-here",
+                "model": "gpt-4",
+                "max_retries": 3,
+                "timeout": 30
+            }
+        }
+    },
+    
+    "MONITOR": {
+        "shape": "rect",
+        "color": "#FF5722",
+        "icon": "📊",
+        "description": [
+            "• Tracks system performance and metrics",
+            "• Monitors resource usage and errors",
+            "• Provides health checks and alerts",
+            "• Supports logging and analytics"
+        ],
+        "implementation": {
+            "python_snippet": """
+import time
+import logging
+from collections import defaultdict
+
+class Monitor:
+    def __init__(self):
+        self.metrics = defaultdict(list)
+        self.logger = logging.getLogger(__name__)
+    
+    async def record_metric(self, name, value, timestamp=None):
+        if timestamp is None:
+            timestamp = time.time()
+        self.metrics[name].append((timestamp, value))
+    
+    async def get_health_status(self):
+        recent_errors = [m for m in self.metrics['errors'] if time.time() - m[0] < 300]
+        avg_response_time = self._calculate_avg_time('response_time', 300)
+        
+        return {
+            "status": "healthy" if len(recent_errors) == 0 else "degraded",
+            "recent_errors": len(recent_errors),
+            "avg_response_time": avg_response_time
+        }
+            """,
+            "dependencies": ["logging", "time"],
+            "config": {
+                "metrics_retention_hours": 24,
+                "alert_thresholds": {"error_rate": 0.05, "response_time": 5.0}
+            }
+        }
+    },
+    
+    "FALLBACK": {
+        "shape": "rect",
+        "color": "#FF5722",
+        "icon": "🔄",
+        "description": [
+            "• Provides alternative execution paths",
+            "• Handles primary system failures",
+            "• Implements graceful degradation",
+            "• Maintains service availability"
+        ],
+        "implementation": {
+            "python_snippet": """
+class FallbackHandler:
+    def __init__(self, primary_handler, fallback_handlers):
+        self.primary = primary_handler
+        self.fallbacks = fallback_handlers
+    
+    async def execute_with_fallback(self, *args, **kwargs):
+        try:
+            return await self.primary(*args, **kwargs)
+        except PrimaryError as e:
+            self.logger.warning(f"Primary failed: {e}, trying fallbacks")
+            
+            for fallback in self.fallbacks:
+                try:
+                    return await fallback(*args, **kwargs)
+                except FallbackError:
+                    continue
+            
+            raise ServiceUnavailableError("All fallbacks exhausted")
+            """,
+            "dependencies": ["logging"],
+            "config": {
+                "max_fallback_attempts": 3,
+                "fallback_timeout": 10
+            }
+        }
+    },
+    
+    "ORCHESTRATOR": {
+        "shape": "rect",
+        "color": "#FF5722",
+        "icon": "🎬",
+        "description": [
+            "• Coordinates complex multi-step processes",
+            "• Manages component interactions",
+            "• Handles state and error propagation",
+            "• Supports distributed execution"
+        ],
+        "implementation": {
+            "python_snippet": """
+class Orchestrator:
+    def __init__(self, components):
+        self.components = components
+        self.state = {}
+    
+    async def orchestrate(self, workflow_definition, input_data):
+        current_state = input_data.copy()
+        
+        for step in workflow_definition.steps:
+            component = self.components[step.component]
+            step_result = await component.execute(current_state, step.config)
+            current_state.update(step_result)
+        
+        return current_state
+            """,
+            "dependencies": ["asyncio"],
+            "config": {
+                "max_workflow_steps": 100,
+                "step_timeout": 60
+            }
+        }
+    }
+}
+
+# Hierarchical Component definitions
+COMPONENT_HIERARCHY = {
+    "HIGH_LEVEL": {
+        "AGENT": {
+            "description": "Autonomous reasoning and decision-making units",
+            "color": "#4CAF50",
+            "icon": "🤖",
+            "shape": "rect",
+            "sub_components": ["REASONING_AGENT", "ACTION_AGENT", "PLANNER_AGENT", "REACT_AGENT", "MULTI_AGENT"]
+        },
+        "USER": {
+            "description": "User interaction points and interfaces",
+            "color": "#9C27B0",
+            "icon": "👤",
+            "shape": "ellipse",
+            "sub_components": ["USER_INPUT", "USER_OUTPUT", "MULTIMODAL_INTERFACE"]
+        },
+        "TOOL": {
+            "description": "External functions and capabilities",
+            "color": "#795548",
+            "icon": "🔧",
+            "shape": "hexagon",
+            "sub_components": ["MCP_TOOL", "API_TOOL", "LOCAL_TOOL", "AGENT_TOOL", "FUNCTION_TOOL"]
+        },
+        "DATA": {
+            "description": "Data sources and storage systems",
+            "color": "#009688",
+            "icon": "💾",
+            "shape": "cylinder",
+            "sub_components": ["KNOWLEDGE_BASE", "VECTOR_DB", "DOCUMENT_STORE", "CACHE", "MEMORY"]
+        },
+        "PROCESSOR": {
+            "description": "Data processing and transformation units",
+            "color": "#2196F3",
+            "icon": "⚙️",
+            "shape": "rect",
+            "sub_components": ["QUERY_PROCESSOR", "CONTENT_RETRIEVAL", "PROMPT_TEMPLATE", "RESPONSE_FORMATTER"]
+        },
+        "ROUTER": {
+            "description": "Decision points and workflow routing",
+            "color": "#FF9800",
+            "icon": "🎯",
+            "shape": "diamond",
+            "sub_components": ["INTENT_DISCOVERY", "MODEL_SELECTOR", "WORKFLOW_ROUTER", "VALIDATOR"]
+        },
+        "INFRASTRUCTURE": {
+            "description": "System infrastructure and services",
+            "color": "#FF5722",
+            "icon": "🌐",
+            "shape": "rect",
+            "sub_components": ["PROVIDER", "MONITOR", "FALLBACK", "ORCHESTRATOR"]
+        }
+    }
+}
+
+# Enhanced Example workflows
+EXAMPLE_WORKFLOWS = {
+    "Simple Chat Agent": {
+        "description": "Basic conversational agent with single LLM call",
+        "nodes": [
+            {"id": "user_1", "type": "USER_INPUT", "x": 150, "y": 200},
+            {"id": "agent_1", "type": "REASONING_AGENT", "x": 400, "y": 200},
+            {"id": "provider_1", "type": "PROVIDER", "x": 650, "y": 200},
+            {"id": "output_1", "type": "USER_OUTPUT", "x": 900, "y": 200}
+        ],
+        "connections": [
+            {"from": "user_1", "to": "agent_1"},
+            {"from": "agent_1", "to": "provider_1"},
+            {"from": "provider_1", "to": "output_1"}
+        ]
+    },
+    "Intent-Driven Routing": {
+        "description": "Routes to specialized agents based on user intent",
+        "nodes": [
+            {"id": "user_1", "type": "USER_INPUT", "x": 150, "y": 300},
+            {"id": "intent_1", "type": "INTENT_DISCOVERY", "x": 400, "y": 300},
+            {"id": "agent_1", "type": "REASONING_AGENT", "x": 650, "y": 150},
+            {"id": "agent_2", "type": "ACTION_AGENT", "x": 650, "y": 450},
+            {"id": "output_1", "type": "USER_OUTPUT", "x": 900, "y": 300}
+        ],
+        "connections": [
+            {"from": "user_1", "to": "intent_1"},
+            {"from": "intent_1", "to": "agent_1"},
+            {"from": "intent_1", "to": "agent_2"},
+            {"from": "agent_1", "to": "output_1"},
+            {"from": "agent_2", "to": "output_1"}
+        ]
+    },
+    "RAG Pipeline": {
+        "description": "Retrieval-Augmented Generation with context",
+        "nodes": [
+            {"id": "user_1", "type": "USER_INPUT", "x": 100, "y": 250},
+            {"id": "query_1", "type": "QUERY_PROCESSOR", "x": 250, "y": 250},
+            {"id": "content_1", "type": "CONTENT_RETRIEVAL", "x": 400, "y": 250},
+            {"id": "prompt_1", "type": "PROMPT_TEMPLATE", "x": 550, "y": 250},
+            {"id": "agent_1", "type": "REASONING_AGENT", "x": 700, "y": 250},
+            {"id": "output_1", "type": "USER_OUTPUT", "x": 900, "y": 250}
+        ],
+        "connections": [
+            {"from": "user_1", "to": "query_1"},
+            {"from": "query_1", "to": "content_1"},
+            {"from": "content_1", "to": "prompt_1"},
+            {"from": "prompt_1", "to": "agent_1"},
+            {"from": "agent_1", "to": "output_1"}
+        ]
+    },
+    "Multi-Agent with Tools": {
+        "description": "Coordinated agents with tool access and validation",
+        "nodes": [
+            {"id": "user_1", "type": "USER_INPUT", "x": 100, "y": 300},
+            {"id": "intent_1", "type": "INTENT_DISCOVERY", "x": 280, "y": 300},
+            {"id": "agent_1", "type": "REASONING_AGENT", "x": 460, "y": 150},
+            {"id": "agent_2", "type": "ACTION_AGENT", "x": 460, "y": 450},
+            {"id": "tool_1", "type": "MCP_TOOL", "x": 640, "y": 150},
+            {"id": "tool_2", "type": "API_TOOL", "x": 640, "y": 450},
+            {"id": "validator_1", "type": "VALIDATOR", "x": 820, "y": 300},
+            {"id": "output_1", "type": "USER_OUTPUT", "x": 980, "y": 300}
+        ],
+        "connections": [
+            {"from": "user_1", "to": "intent_1"},
+            {"from": "intent_1", "to": "agent_1"},
+            {"from": "intent_1", "to": "agent_2"},
+            {"from": "agent_1", "to": "tool_1"},
+            {"from": "agent_2", "to": "tool_2"},
+            {"from": "tool_1", "to": "validator_1"},
+            {"from": "tool_2", "to": "validator_1"},
+            {"from": "validator_1", "to": "output_1"}
+        ]
+    },
+    "Advanced RAG with Cache": {
+        "description": "Enhanced RAG with caching and monitoring",
+        "nodes": [
+            {"id": "user_1", "type": "USER_INPUT", "x": 100, "y": 200},
+            {"id": "query_1", "type": "QUERY_PROCESSOR", "x": 250, "y": 200},
+            {"id": "cache_1", "type": "CACHE", "x": 400, "y": 100},
+            {"id": "knowledge_1", "type": "KNOWLEDGE_BASE", "x": 400, "y": 300},
+            {"id": "prompt_1", "type": "PROMPT_TEMPLATE", "x": 550, "y": 200},
+            {"id": "agent_1", "type": "REASONING_AGENT", "x": 700, "y": 200},
+            {"id": "monitor_1", "type": "MONITOR", "x": 850, "y": 100},
+            {"id": "output_1", "type": "USER_OUTPUT", "x": 850, "y": 300}
+        ],
+        "connections": [
+            {"from": "user_1", "to": "query_1"},
+            {"from": "query_1", "to": "cache_1"},
+            {"from": "query_1", "to": "knowledge_1"},
+            {"from": "cache_1", "to": "prompt_1"},
+            {"from": "knowledge_1", "to": "prompt_1"},
+            {"from": "prompt_1", "to": "agent_1"},
+            {"from": "agent_1", "to": "monitor_1"},
+            {"from": "agent_1", "to": "output_1"}
+        ]
+    },
+    "MCP Tool Agent": {
+        "description": "Agent using MCP tools for extended capabilities",
+        "nodes": [
+            {"id": "user_1", "type": "USER_INPUT", "x": 100, "y": 250},
+            {"id": "agent_1", "type": "REACT_AGENT", "x": 300, "y": 250},
+            {"id": "mcp_tool_1", "type": "MCP_TOOL", "x": 500, "y": 150},
+            {"id": "mcp_tool_2", "type": "MCP_TOOL", "x": 500, "y": 350},
+            {"id": "memory_1", "type": "MEMORY", "x": 700, "y": 250},
+            {"id": "output_1", "type": "USER_OUTPUT", "x": 900, "y": 250}
+        ],
+        "connections": [
+            {"from": "user_1", "to": "agent_1"},
+            {"from": "agent_1", "to": "mcp_tool_1"},
+            {"from": "agent_1", "to": "mcp_tool_2"},
+            {"from": "mcp_tool_1", "to": "agent_1"},
+            {"from": "mcp_tool_2", "to": "agent_1"},
+            {"from": "agent_1", "to": "memory_1"},
+            {"from": "agent_1", "to": "output_1"}
+        ]
+    }
+}
+
+@dataclass
+class ComponentData:
+    """Complete component information"""
+    type: str
+    shape: str
+    color: str
+    icon: str
+    description: List[str]
+    category: Optional[str] = None
+    sub_category: Optional[str] = None
+
+@dataclass
+class AgentNode:
+    id: str
+    type: str
+    x: int
+    y: int
+    component_data: ComponentData = field(default_factory=lambda: ComponentData("", "", "", "", []))
+
+@dataclass
+class Connection:
+    from_node: str
+    to_node: str
+    
+class CustomNodeManager:
+    def __init__(self, storage_path: str = "custom_nodes.pkl"):
+        self.storage_path = storage_path
+        self.custom_nodes: Dict[str, Dict[str, Any]] = {}
+        self.load_custom_nodes()
+    
+    def load_custom_nodes(self):
+        """Load custom nodes from storage"""
+        if os.path.exists(self.storage_path):
+            try:
+                with open(self.storage_path, 'rb') as f:
+                    self.custom_nodes = pickle.load(f)
+            except Exception as e:
+                print(f"Error loading custom nodes: {e}")
+                self.custom_nodes = {}
+    
+    def save_custom_nodes(self):
+        """Save custom nodes to storage"""
+        try:
+            with open(self.storage_path, 'wb') as f:
+                pickle.dump(self.custom_nodes, f)
+        except Exception as e:
+            print(f"Error saving custom nodes: {e}")
+    
+    def create_custom_node(self, name: str, config: Dict[str, Any]):
+        """Create a new custom node"""
+        node_id = f"custom_{name.lower().replace(' ', '_')}"
+        self.custom_nodes[node_id] = {
+            "id": node_id,
+            "name": name,
+            "type": "CUSTOM",
+            "config": config,
+            "created_at": __import__('datetime').datetime.now().isoformat()
+        }
+        self.save_custom_nodes()
+        return node_id
+    
+    def get_custom_node_info(self, node_id: str) -> Dict[str, Any]:
+        """Get information for a custom node"""
+        return self.custom_nodes.get(node_id, {})
+    
+    def delete_custom_node(self, node_id: str):
+        """Delete a custom node"""
+        if node_id in self.custom_nodes:
+            del self.custom_nodes[node_id]
+            self.save_custom_nodes()
+
+# Initialize custom node manager
+custom_node_manager = CustomNodeManager()
+
+class WorkflowDesigner:
+    def __init__(self):
+        self.nodes: Dict[str, AgentNode] = {}
+        self.connections: List[Connection] = []
+        self.node_counter = 0
+        self.selected_node: Optional[str] = None
+    
+    def select_node(self, node_id: str) -> None:
+        """Select a node and deselect others"""
+        self.selected_node = node_id if node_id in self.nodes else None
+    
+    def move_selected_node(self, dx: int, dy: int) -> None:
+        """Move selected node by delta"""
+        if self.selected_node and self.selected_node in self.nodes:
+            node = self.nodes[self.selected_node]
+            node.x = max(0, node.x + dx)
+            node.y = max(0, node.y + dy)
+    def add_custom_node(self, custom_config: Dict[str, Any]) -> AgentNode:
+        """Add a custom node to the workflow"""
+        self.node_counter += 1
+        node_id = f"custom_{self.node_counter}"
+        
+        # Create custom node configuration
+        custom_node_config = {
+            "shape": custom_config.get("shape", "rect"),
+            "color": custom_config.get("color", "#666666"),
+            "icon": custom_config.get("icon", "🔧"),
+            "description": custom_config.get("description", ["Custom node"]),
+            "implementation": custom_config.get("implementation", {})
+        }
+        
+        # Add to COMPONENT_INFO for rendering
+        COMPONENT_INFO[node_id] = custom_node_config
+        
+        col = len(self.nodes) % 3
+        row = len(self.nodes) // 3
+        x_pos = 200 + (col * 350)
+        y_pos = 150 + (row * 200)
+        
+        node = AgentNode(
+            id=node_id,
+            type=node_id,  # Use node_id as type for custom nodes
+            x=x_pos,
+            y=y_pos
+        )
+        
+        self.nodes[node_id] = node
+        self.selected_node = node_id
+        return node
+    
+    def get_workflow_json(self) -> Dict[str, Any]:
+        """Get complete workflow data including component implementations"""
+        nodes_data = []
+        for node in self.nodes.values():
+            node_info = COMPONENT_INFO.get(node.type, {})
+            nodes_data.append({
+                "id": node.id,
+                "type": node.type,
+                "x": node.x,
+                "y": node.y,
+                "component_info": node_info,
+                "implementation": node_info.get("implementation", {})
+            })
+        
+        return {
+            "nodes": nodes_data,
+            "connections": [asdict(c) for c in self.connections],
+            "selected_node": self.selected_node,
+            "metadata": {
+                "total_nodes": len(self.nodes),
+                "total_connections": len(self.connections),
+                "generated_at": __import__('datetime').datetime.now().isoformat()
+            }
+        }
+    
+    def add_node(self, node_type: str) -> AgentNode:
+        self.node_counter += 1
+        node_id = f"{node_type}_{self.node_counter}"
+        
+        col = len(self.nodes) % 3
+        row = len(self.nodes) // 3
+        x_pos = 200 + (col * 350)
+        y_pos = 150 + (row * 200)
+        
+        # Get complete component information
+        component_info = COMPONENT_INFO.get(node_type, {
+            "shape": "rect",
+            "color": "#666666", 
+            "icon": "❓",
+            "description": ["Unknown component type"]
+        })
+        
+        # Create component data with full information
+        component_data = ComponentData(
+            type=node_type,
+            shape=component_info["shape"],
+            color=component_info["color"],
+            icon=component_info["icon"],
+            description=component_info["description"],
+            category=self._find_component_category(node_type),
+            sub_category=self._find_component_sub_category(node_type)
+        )
+        
+        node = AgentNode(
+            id=node_id,
+            type=node_type,
+            x=x_pos,
+            y=y_pos,
+            component_data=component_data
+        )
+        
+        self.nodes[node_id] = node
+        self.selected_node = node_id
+        return node
+    
+    def _find_component_category(self, node_type: str) -> Optional[str]:
+        """Find which high-level category this component belongs to"""
+
+        for category, components in COMPONENT_HIERARCHY["HIGH_LEVEL"].items():
+            if node_type == category or node_type in components.get('sub_components', []):
+                return category
+        return None
+    
+    def _find_component_sub_category(self, node_type: str) -> Optional[str]:
+        """Determine if this is a high-level or sub-component"""
+        
+        for category, components in COMPONENT_HIERARCHY["HIGH_LEVEL"].items():
+            if node_type == category:
+                return "HIGH_LEVEL"
+            elif node_type in components.get('sub_components', []):
+                return "SUB_COMPONENT"
+        return None
+    
+    def load_example(self, example_name: str):
+        if example_name not in EXAMPLE_WORKFLOWS:
+            return
+        
+        example = EXAMPLE_WORKFLOWS[example_name]
+        self.nodes.clear()
+        self.connections.clear()
+        
+        for node_data in example["nodes"]:
+            node_type = node_data["type"]
+            
+            # Get complete component information for example nodes too
+            component_info = COMPONENT_INFO.get(node_type, {
+                "shape": "rect",
+                "color": "#666666",
+                "icon": "❓",
+                "description": ["Unknown component type"]
+            })
+            
+            component_data = ComponentData(
+                type=node_type,
+                shape=component_info["shape"],
+                color=component_info["color"],
+                icon=component_info["icon"],
+                description=component_info["description"],
+                category=self._find_component_category(node_type),
+                sub_category=self._find_component_sub_category(node_type)
+            )
+            
+            node = AgentNode(
+                id=node_data["id"],
+                type=node_type,
+                x=node_data["x"],
+                y=node_data["y"],
+                component_data=component_data
+            )
+            self.nodes[node.id] = node
+        
+        for conn_data in example["connections"]:
+            conn = Connection(
+                from_node=conn_data["from"],
+                to_node=conn_data["to"]
+            )
+            self.connections.append(conn)
+        
+        if self.nodes:
+            self.selected_node = list(self.nodes.keys())[0]
+    
+    def get_workflow_json(self) -> Dict[str, Any]:
+        """Get complete workflow data including full component information"""
+        return {
+            "metadata": {
+                "total_nodes": len(self.nodes),
+                "total_connections": len(self.connections),
+                "selected_node": self.selected_node,
+                "generated_with": "Agent Workflow Designer"
+            },
+            "nodes": [
+                {
+                    "id": node.id,
+                    "type": node.type,
+                    "position": {"x": node.x, "y": node.y},
+                    "component_data": {
+                        "type": node.component_data.type,
+                        "shape": node.component_data.shape,
+                        "color": node.component_data.color,
+                        "icon": node.component_data.icon,
+                        "description": node.component_data.description,
+                        "category": node.component_data.category,
+                        "sub_category": node.component_data.sub_category
+                    }
+                }
+                for node in self.nodes.values()
+            ],
+            "connections": [
+                {
+                    "from": conn.from_node,
+                    "to": conn.to_node
+                }
+                for conn in self.connections
+            ]
+        }
+    
+    def render_svg(self) -> str:
+        """Render workflow as beautiful SVG with selection support"""
+        if not self.nodes:
+            return '''
+            <svg width="1200" height="600" style="border-radius: 12px;">
+            <defs>
+            <linearGradient id="bg" x1="0%" y1="0%" x2="100%" y2="100%">
+            <stop offset="0%" style="stop-color:#667eea;stop-opacity:1" />
+            <stop offset="100%" style="stop-color:#764ba2;stop-opacity:1" />
+            </linearGradient>
+            </defs>
+            <rect width="1200" height="600" fill="url(#bg)"/>
+            <text x="600" y="280" text-anchor="middle" fill="white" font-size="32" font-weight="bold">🚀 Start Building Your Workflow</text>
+            <text x="600" y="320" text-anchor="middle" fill="white" font-size="18" opacity="0.9">Add components from the library on the left</text>
+            </svg>
+            '''
+
+        width = 1200
+        height = max(600, max([n.y for n in self.nodes.values()], default=0) + 200)
+        
+        svg_parts = [
+            f'<svg width="{width}" height="{height}" style="border-radius: 12px; cursor: pointer;">',
+            '<defs>',
+            '<linearGradient id="bg" x1="0%" y1="0%" x2="100%" y2="100%">',
+            '<stop offset="0%" style="stop-color:#667eea;stop-opacity:1" />',
+            '<stop offset="100%" style="stop-color:#764ba2;stop-opacity:1" />',
+            '</linearGradient>',
+            '<marker id="arrowhead" markerWidth="12" markerHeight="12" refX="11" refY="3" orient="auto">',
+            '<polygon points="0 0, 12 3, 0 6" fill="white" opacity="0.9"/>',
+            '</marker>',
+            '<filter id="glow">',
+            '<feGaussianBlur stdDeviation="3" result="coloredBlur"/>',
+            '<feMerge><feMergeNode in="coloredBlur"/><feMergeNode in="SourceGraphic"/></feMerge>',
+            '</filter>',
+            '<filter id="shadow">',
+            '<feDropShadow dx="0" dy="4" stdDeviation="4" flood-opacity="0.3"/>',
+            '</filter>',
+            '<filter id="selected-glow">',
+            '<feGaussianBlur stdDeviation="5" result="coloredBlur"/>',
+            '<feMerge><feMergeNode in="coloredBlur"/><feMergeNode in="SourceGraphic"/></feMerge>',
+            '</filter>',
+            '</defs>',
+            '<rect width="100%" height="100%" fill="url(#bg)"/>'
+        ]
+        
+        # Draw connections with glow
+        for conn in self.connections:
+            if conn.from_node in self.nodes and conn.to_node in self.nodes:
+                from_node = self.nodes[conn.from_node]
+                to_node = self.nodes[conn.to_node]
+                
+                from_x = from_node.x + 85
+                from_y = from_node.y + 60
+                to_x = to_node.x + 15
+                to_y = to_node.y + 60
+                
+                mid_x = (from_x + to_x) / 2
+                
+                # Glow path
+                svg_parts.append(
+                    f'<path d="M {from_x} {from_y} C {mid_x} {from_y}, {mid_x} {to_y}, {to_x} {to_y}" '
+                    f'stroke="white" stroke-width="8" fill="none" opacity="0.3" filter="url(#glow)"/>'
+                )
+                
+                # Main path
+                svg_parts.append(
+                    f'<path d="M {from_x} {from_y} C {mid_x} {from_y}, {mid_x} {to_y}, {to_x} {to_y}" '
+                    f'stroke="white" stroke-width="3" fill="none" opacity="0.8" marker-end="url(#arrowhead)"/>'
+                )
+        
+        # Draw nodes with selection support
+        for node in self.nodes.values():
+            # Use the stored component data instead of looking it up
+            shape = node.component_data.shape
+            color = node.component_data.color
+            icon = node.component_data.icon
+            
+            cx = node.x + 85
+            cy = node.y + 60
+            label = node.id.replace("_", " ").title()
+            
+            is_selected = (node.id == self.selected_node)
+            selection_glow = 'filter="url(#selected-glow)"' if is_selected else 'filter="url(#shadow)"'
+            selection_stroke = "6" if is_selected else "4"
+            
+            # Node background with selection highlight
+            if shape == "ellipse":
+                svg_parts.append(
+                    f'<ellipse cx="{cx}" cy="{cy}" rx="80" ry="50" '
+                    f'fill="white" stroke="{color}" stroke-width="{selection_stroke}" {selection_glow} '
+                    f'class="node" id="node_{node.id}" style="cursor: move;"/>'
+                )
+            elif shape == "diamond":
+                size = 70
+                points = f"{cx},{cy-size} {cx+size},{cy} {cx},{cy+size} {cx-size},{cy}"
+                svg_parts.append(
+                    f'<polygon points="{points}" '
+                    f'fill="white" stroke="{color}" stroke-width="{selection_stroke}" {selection_glow} '
+                    f'class="node" id="node_{node.id}" style="cursor: move;"/>'
+                )
+            elif shape == "hexagon":
+                w, h = 70, 50
+                points = f"{cx-w},{cy-h/2} {cx-w/2},{cy-h} {cx+w/2},{cy-h} {cx+w},{cy-h/2} {cx+w},{cy+h/2} {cx+w/2},{cy+h} {cx-w/2},{cy+h} {cx-w},{cy+h/2}"
+                svg_parts.append(
+                    f'<polygon points="{points}" '
+                    f'fill="white" stroke="{color}" stroke-width="{selection_stroke}" {selection_glow} '
+                    f'class="node" id="node_{node.id}" style="cursor: move;"/>'
+                )
+            elif shape == "cylinder":
+                svg_parts.append(
+                    f'<ellipse cx="{cx}" cy="{cy-35}" rx="70" ry="18" '
+                    f'fill="white" stroke="{color}" stroke-width="3"/>'
+                )
+                svg_parts.append(
+                    f'<rect x="{cx-70}" y="{cy-35}" width="140" height="70" '
+                    f'fill="white" stroke="none"/>'
+                )
+                svg_parts.append(
+                    f'<line x1="{cx-70}" y1="{cy-35}" x2="{cx-70}" y2="{cy+35}" '
+                    f'stroke="{color}" stroke-width="3"/>'
+                )
+                svg_parts.append(
+                    f'<line x1="{cx+70}" y1="{cy-35}" x2="{cx+70}" y2="{cy+35}" '
+                    f'stroke="{color}" stroke-width="3"/>'
+                )
+                svg_parts.append(
+                    f'<ellipse cx="{cx}" cy="{cy+35}" rx="70" ry="18" '
+                    f'fill="white" stroke="{color}" stroke-width="3" {selection_glow} '
+                    f'class="node" id="node_{node.id}" style="cursor: move;"/>'
+                )
+            else:  # rect
+                svg_parts.append(
+                    f'<rect x="{cx-80}" y="{cy-45}" width="160" height="90" rx="12" '
+                    f'fill="white" stroke="{color}" stroke-width="{selection_stroke}" {selection_glow} '
+                    f'class="node" id="node_{node.id}" style="cursor: move;"/>'
+                )
+            
+            # Icon
+            svg_parts.append(
+                f'<text x="{cx}" y="{cy-10}" text-anchor="middle" font-size="36">{icon}</text>'
+            )
+            
+            # Label
+            svg_parts.append(
+                f'<text x="{cx}" y="{cy+25}" text-anchor="middle" '
+                f'fill="#333" font-size="13" font-weight="600">{label}</text>'
+            )
+        
+        # Add JavaScript for drag and drop
+        svg_parts.append('''
+        <script>
+        // Node selection and drag functionality
+        let selectedNode = null;
+        let isDragging = false;
+        let startX, startY;
+        let originalX, originalY;
+        
+        // Add click handlers for all nodes
+        document.querySelectorAll('.node').forEach(node => {
+            node.addEventListener('click', (e) => {
+                e.stopPropagation();
+                const nodeId = node.id.replace('node_', '');
+                selectNode(nodeId);
+            });
+            
+            node.addEventListener('mousedown', startDrag);
+        });
+        
+        // Click on canvas to deselect
+        document.querySelector('svg').addEventListener('click', (e) => {
+            if (e.target.tagName === 'svg') {
+                selectedNode = null;
+                updateSelection();
+            }
+        });
+        
+        function selectNode(nodeId) {
+            selectedNode = nodeId;
+            updateSelection();
+            
+            // Notify Gradio about selection
+            if (window.gradio_api) {
+                window.gradio_api('select_node', nodeId);
+            }
+        }
+        
+        function updateSelection() {
+            // Visual feedback handled by server-side re-render
+            // This will trigger when we call back to Python
+        }
+        
+        function startDrag(e) {
+            if (!selectedNode) return;
+            
+            isDragging = true;
+            startX = e.clientX;
+            startY = e.clientY;
+            
+            const node = document.getElementById('node_' + selectedNode);
+            const transform = node.getAttribute('transform') || '';
+            const match = transform.match(/translate\\(([^,]+),([^)]+)\\)/);
+            originalX = match ? parseFloat(match[1]) : 0;
+            originalY = match ? parseFloat(match[2]) : 0;
+            
+            document.addEventListener('mousemove', doDrag);
+            document.addEventListener('mouseup', stopDrag);
+            e.preventDefault();
+        }
+        
+        function doDrag(e) {
+            if (!isDragging || !selectedNode) return;
+            
+            const dx = e.clientX - startX;
+            const dy = e.clientY - startY;
+            
+            const node = document.getElementById('node_' + selectedNode);
+            node.setAttribute('transform', `translate(${originalX + dx}, ${originalY + dy})`);
+        }
+        
+        function stopDrag(e) {
+            if (!isDragging || !selectedNode) return;
+            
+            const dx = e.clientX - startX;
+            const dy = e.clientY - startY;
+            
+            // Final position update to Gradio
+            if (window.gradio_api && (Math.abs(dx) > 5 || Math.abs(dy) > 5)) {
+                window.gradio_api('move_node', {
+                    node_id: selectedNode,
+                    dx: Math.round(dx),
+                    dy: Math.round(dy)
+                });
+            }
+            
+            isDragging = false;
+            document.removeEventListener('mousemove', doDrag);
+            document.removeEventListener('mouseup', stopDrag);
+        }
+        </script>
+        ''')
+        
+        svg_parts.append('</svg>')
+        return '\n'.join(svg_parts)
+
+workflow = WorkflowDesigner()
+
+# Report generation class
+class WorkflowReporter:
+    def __init__(self):
+        try:
+            self.client = AsyncOpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")
+        except Exception as e:
+            print("LM Studio client init failed:", e)
+
+    async def generate_report(self, workflow_json: str) -> str:
+        prompt = f"""
+        Generate a comprehensive system design report based on the following workflow:
+        {workflow_json}
+
+        The report should include a detailed repost and system breif with full examples and implimentations where possible and explanaion of requirement in cases where the workflow is complexed and need further deconstruction, as well as example usages :
+        1. A high-level system overview
+        2. User stories for each component or connection expetation
+        3. Use case briefs for each component interaction and component relationship
+        4. Pseudocode for the implementation for each component and for the overall workflow
+        5. Component responsibilities and interfaces
+        6. Data flow description and example use-cases
+        
+        """
+
+        try:
+            response = await self.client.chat.completions.create(
+                model="leroydyer/qwen/qwen3-0.6b-q4_k_m.gguf",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.7,
+                max_tokens=2048
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"Error generating report: {str(e)}"
+
+# Initialize reporter
+reporter = WorkflowReporter()
+
+def create_workflow_ui():
+    with gr.Blocks(title="Agent Workflow Designer", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🎓 Agentic System Workflow Designer")
+        gr.Markdown("**Educational tool for planning and understanding agent architectures**")
+
+        # Hidden components for JavaScript communication
+        select_node_trigger = gr.Textbox(visible=False)
+        move_node_trigger = gr.Textbox(visible=False)
+
+        # Define all UI components first
+        with gr.Row():
+            # Left Sidebar - Component Library
+            with gr.Column(scale=1):
+                gr.Markdown("## 📚 Component Library")
+
+                # Store component buttons for later connection
+                component_buttons = []
+
+                # High-level component accordions
+                for category, components in COMPONENT_HIERARCHY["HIGH_LEVEL"].items():
+                    with gr.Accordion(f"{components['icon']} {category}", open=False):
+                        # High-level component button
+                        high_level_btn = gr.Button(
+                            f"{components['icon']} {category}",
+                            size="sm",
+                            variant="primary"
+                        )
+                        component_buttons.append((high_level_btn, category))
+
+                        # Sub-components
+                        if components['sub_components']:
+                            gr.Markdown("**Sub-components:**")
+                            for sub_comp in components['sub_components']:
+                                sub_info = COMPONENT_INFO[sub_comp]
+                                sub_btn = gr.Button(
+                                    f"{sub_info['icon']} {sub_comp.replace('_', ' ').title()}",
+                                    size="sm"
+                                )
+                                component_buttons.append((sub_btn, sub_comp))
+
+                gr.Markdown("---")
+                gr.Markdown("## 🔗 Connect Nodes")
+                from_node = gr.Dropdown(label="From", choices=[], interactive=True)
+                to_node = gr.Dropdown(label="To", choices=[], interactive=True)
+                connect_btn = gr.Button("➡️ Connect", variant="secondary")
+
+                gr.Markdown("---")
+                gr.Markdown("## 📋 Examples")
+                example_dropdown = gr.Dropdown(
+                    choices=list(EXAMPLE_WORKFLOWS.keys()),
+                    label="Load Example Workflow",
+                    interactive=True
+                )
+                load_example_btn = gr.Button("📥 Load Example")
+
+                gr.Markdown("---")
+                with gr.Row():
+                    download_json_btn = gr.Button("💾 Download JSON", variant="primary", size="sm")
+                    download_svg_btn = gr.Button("🖼️ Download SVG", variant="primary", size="sm")
+                    clear_btn = gr.Button("🗑️ Clear All", variant="stop", size="sm")
+
+                # Output for multiple downloadable files
+                download_files = gr.Files(label="📥 Download Files", visible=True)
+
+            # Center - Canvas
+            with gr.Column(scale=3):
+                gr.Markdown("## 🎨 Workflow Canvas")
+                gr.Markdown("**💡 Tip:** Click nodes to select, then drag or use arrow keys")
+                canvas = gr.HTML()
+
+                gr.Markdown("## 📖 Component Information")
+                component_info = gr.Markdown("Select a component to see its description")
+
+            # Right Sidebar - Movement Controls
+            with gr.Column(scale=1):
+                gr.Markdown("## 🎯 Selection & Movement")
+
+                gr.Markdown("**Navigation:**")
+                with gr.Row():
+                    select_prev_btn = gr.Button("⬅️ Prev", size="sm")
+                    select_next_btn = gr.Button("➡️ Next", size="sm")
+                    deselect_btn = gr.Button("❌ Deselect", size="sm")
+
+                gr.Markdown("**Selected Node:**")
+                selected_node_info = gr.Markdown("No node selected")
+
+                gr.Markdown("**Move Selected:**")
+                with gr.Row():
+                    move_left_btn = gr.Button("⬅️", size="sm")
+                    move_up_btn = gr.Button("⬆️", size="sm")
+                    move_down_btn = gr.Button("⬇️", size="sm")
+                    move_right_btn = gr.Button("➡️", size="sm")
+
+                gr.Markdown("**Movement Modes:**")
+                with gr.Row():
+                    move_fine_btn = gr.Button("🎯 Fine (5px)", size="sm")
+                    move_coarse_btn = gr.Button("🚀 Coarse (50px)", size="sm")
+
+                gr.Markdown("---")
+                with gr.Accordion("🗑️ Delete Selected", open=False):
+                    delete_selected_btn = gr.Button("❌ Delete Selected Node", variant="stop", size="sm")
+
+                gr.Markdown("---")
+                with gr.Accordion("📊 Workflow Data", open=False):
+                    json_output = gr.Code(language="json", label="Workflow JSON", lines=10)
+
+                gr.Markdown("---")
+                with gr.Accordion("📋 Generate Report", open=False):
+                    report_btn = gr.Button("📄 Generate System Report", variant="primary")
+                    report_output = gr.Textbox(label="System Design Report", lines=15, interactive=False)
+                    download_report_btn = gr.Button("📝 Download Report", variant="secondary", size="sm")
+
+        # Now define all the handler functions after UI components are defined
+        def get_full_state():
+            svg = workflow.render_svg()
+            node_choices = list(workflow.nodes.keys())
+            workflow_json = json.dumps({
+                "nodes": [asdict(n) for n in workflow.nodes.values()],
+                "connections": [asdict(c) for c in workflow.connections],
+                "selected_node": workflow.selected_node
+            }, indent=2)
+
+            selected_info = "**No node selected**"
+            comp_info = "Select a component to see its description"
+
+            if workflow.selected_node and workflow.selected_node in workflow.nodes:
+                node = workflow.nodes[workflow.selected_node]
+                info = COMPONENT_INFO[node.type]
+                selected_info = f"**Selected:** `{node.id}` ({info['icon']} {node.type.replace('_', ' ').title()}) at position ({node.x}, {node.y})"
+                comp_info = f"### {node.type.replace('_', ' ').title()} {info['icon']}\n\n" + "\n".join(info["description"])
+
+            return svg, workflow_json, node_choices, selected_info, comp_info
+
+        def add_node_handler(node_type):
+            node = workflow.add_node(node_type)
+            svg, wf_json, choices, selected_info, comp_info = get_full_state()
+            return svg, wf_json, gr.Dropdown(choices=choices), gr.Dropdown(choices=choices), selected_info, comp_info
+
+        # Connect all component buttons
+        for btn, comp_type in component_buttons:
+            btn.click(
+                lambda ct=comp_type: add_node_handler(ct),
+                outputs=[canvas, json_output, from_node, to_node, selected_node_info, component_info]
+            )
+
+        # Selection handlers
+        def select_node_handler(node_id):
+            if node_id:
+                workflow.select_node(node_id)
+                svg, wf_json, choices, selected_info, comp_info = get_full_state()
+                return svg, wf_json, selected_info, comp_info
+            return workflow.render_svg(), "", "No node selected", "Select a component to see its description"
+
+        def select_next_node():
+            if workflow.nodes:
+                node_ids = list(workflow.nodes.keys())
+                if not workflow.selected_node:
+                    workflow.selected_node = node_ids[0]
+                else:
+                    current_idx = node_ids.index(workflow.selected_node)
+                    next_idx = (current_idx + 1) % len(node_ids)
+                    workflow.selected_node = node_ids[next_idx]
+
+            svg, wf_json, choices, selected_info, comp_info = get_full_state()
+            return svg, wf_json, selected_info, comp_info
+
+        def select_prev_node():
+            if workflow.nodes:
+                node_ids = list(workflow.nodes.keys())
+                if not workflow.selected_node:
+                    workflow.selected_node = node_ids[-1]
+                else:
+                    current_idx = node_ids.index(workflow.selected_node)
+                    prev_idx = (current_idx - 1) % len(node_ids)
+                    workflow.selected_node = node_ids[prev_idx]
+
+            svg, wf_json, choices, selected_info, comp_info = get_full_state()
+            return svg, wf_json, selected_info, comp_info
+
+        def deselect_all():
+            workflow.selected_node = None
+            svg, wf_json, choices, selected_info, comp_info = get_full_state()
+            return svg, wf_json, selected_info, comp_info
+
+        # Delete selected node
+        def delete_selected_node():
+            if workflow.selected_node and workflow.selected_node in workflow.nodes:
+                workflow.connections = [
+                    c for c in workflow.connections
+                    if c.from_node != workflow.selected_node and c.to_node != workflow.selected_node
+                ]
+                del workflow.nodes[workflow.selected_node]
+                workflow.selected_node = None
+
+            svg, wf_json, choices, selected_info, comp_info = get_full_state()
+            return svg, wf_json, gr.Dropdown(choices=choices), gr.Dropdown(choices=choices), selected_info, comp_info
+
+        # Movement handlers
+        def move_selected_node(dx, dy):
+            if workflow.selected_node:
+                workflow.move_selected_node(dx, dy)
+                svg, wf_json, choices, selected_info, comp_info = get_full_state()
+                return svg, wf_json, selected_info, comp_info
+            return workflow.render_svg(), "", "No node selected", component_info.value
+
+        # Connect selection events
+        select_node_trigger.change(
+            select_node_handler,
+            inputs=[select_node_trigger],
+            outputs=[canvas, json_output, selected_node_info, component_info]
+        )
+
+        select_next_btn.click(select_next_node, outputs=[canvas, json_output, selected_node_info, component_info])
+        select_prev_btn.click(select_prev_node, outputs=[canvas, json_output, selected_node_info, component_info])
+        deselect_btn.click(deselect_all, outputs=[canvas, json_output, selected_node_info, component_info])
+
+        # Movement buttons
+        move_left_btn.click(lambda: move_selected_node(-20, 0), outputs=[canvas, json_output, selected_node_info, component_info])
+        move_right_btn.click(lambda: move_selected_node(20, 0), outputs=[canvas, json_output, selected_node_info, component_info])
+        move_up_btn.click(lambda: move_selected_node(0, -20), outputs=[canvas, json_output, selected_node_info, component_info])
+        move_down_btn.click(lambda: move_selected_node(0, 20), outputs=[canvas, json_output, selected_node_info, component_info])
+        move_fine_btn.click(lambda: move_selected_node(-5, 0), outputs=[canvas, json_output, selected_node_info, component_info])
+        move_coarse_btn.click(lambda: move_selected_node(-50, 0), outputs=[canvas, json_output, selected_node_info, component_info])
+
+        # Delete button
+        delete_selected_btn.click(
+            delete_selected_node,
+            outputs=[canvas, json_output, from_node, to_node, selected_node_info, component_info]
+        )
+
+        # Drag handler
+        def handle_node_drag(move_data):
+            try:
+                data = json.loads(move_data)
+                node_id = data.get('node_id')
+                dx = data.get('dx', 0)
+                dy = data.get('dy', 0)
+                if node_id and node_id in workflow.nodes:
+                    workflow.select_node(node_id)
+                    workflow.move_selected_node(dx, dy)
+                    svg, wf_json, choices, selected_info, comp_info = get_full_state()
+                    return svg, wf_json, selected_info, comp_info
+            except Exception as e:
+                print("Drag error:", e)
+            return workflow.render_svg(), "", "Drag completed", component_info.value
+
+        move_node_trigger.change(
+            handle_node_drag,
+            inputs=[move_node_trigger],
+            outputs=[canvas, json_output, selected_node_info, component_info]
+        )
+
+        # Connection handler
+        def connect_nodes(from_n, to_n):
+            if from_n and to_n and from_n != to_n:
+                existing = [c for c in workflow.connections if c.from_node == from_n and c.to_node == to_n]
+                if not existing:
+                    workflow.connections.append(Connection(from_node=from_n, to_node=to_n))
+                    svg, wf_json, choices, selected_info, comp_info = get_full_state()
+                    return svg, wf_json, selected_info
+            return workflow.render_svg(), "", selected_node_info.value
+
+        connect_btn.click(connect_nodes, inputs=[from_node, to_node], outputs=[canvas, json_output, selected_node_info])
+
+        # Example loading
+        def load_example_handler(example_name):
+            if example_name:
+                workflow.load_example(example_name)
+                svg, wf_json, choices, selected_info, comp_info = get_full_state()
+                desc = EXAMPLE_WORKFLOWS[example_name]["description"]
+                info_text = f"### {example_name}\n\n{desc}"
+                return svg, wf_json, gr.Dropdown(choices=choices), gr.Dropdown(choices=choices), selected_info, info_text
+            return workflow.render_svg(), "", gr.Dropdown(choices=[]), gr.Dropdown(choices=[]), "No node selected", "Select a component to see its description"
+
+        load_example_btn.click(
+            load_example_handler,
+            inputs=[example_dropdown],
+            outputs=[canvas, json_output, from_node, to_node, selected_node_info, component_info]
+        )
+
+        # Unified download handler (returns list of files)
+        def download_all_files():
+            file_list = []
+            fid = str(uuid.uuid4())
+
+            # JSON
+            json_data = { ... }
+            json_path = tempfile.mktemp(suffix=f"_{fid}.json")
+            with open(json_path, "w", encoding="utf-8") as f:
+                json.dump(json_data, f, indent=2)
+            file_list.append(json_path)
+
+            # SVG
+            svg_path = tempfile.mktemp(suffix=f"_{fid}.svg")
+            with open(svg_path, "w", encoding="utf-8") as f:
+                f.write(workflow.render_svg())
+            file_list.append(svg_path)
+
+            return file_list
+        # In your download_json function, replace:
+        def download_json():
+            fid = str(uuid.uuid4())
+            # Use the new method that includes full component data
+            json_data = workflow.get_workflow_json()
+            json_path = tempfile.mktemp(suffix=f"_{fid}.json")
+            with open(json_path, "w", encoding="utf-8") as f:
+                json.dump(json_data, f, indent=2)
+            return [json_path]
+        # Download SVG only
+        def download_svg():
+            fid = str(uuid.uuid4())
+            svg_content = workflow.render_svg()
+            svg_path = tempfile.mktemp(suffix=f"_{fid}.svg")
+            with open(svg_path, "w", encoding="utf-8") as f:  # ←← KEY CHANGE: encoding="utf-8"
+                f.write(svg_content)
+            return [svg_path]
+        # Report generation (sync wrapper)
+        def sync_generate_report():
+            workflow_data = {
+                "nodes": [asdict(n) for n in workflow.nodes.values()],
+                "connections": [asdict(c) for c in workflow.connections],
+                "selected_node": workflow.selected_node
+            }
+            json_str = json.dumps(workflow_data, indent=2)
+            try:
+                report = asyncio.run(reporter.generate_report(json_str))
+            except Exception as e:
+                report = f"Failed to generate report: {e}"
+            return report
+
+        def download_report():
+            report_text = sync_generate_report()
+            fid = str(uuid.uuid4())
+            txt_path = tempfile.mktemp(suffix=f"_report_{fid}.txt")
+            with open(txt_path, "w", encoding="utf-8") as f:  # ←←
+                f.write(f"Agentic Workflow Design Report\nGenerated on: {str(__import__('datetime').datetime.now())}\n\n")
+                f.write(report_text)
+            return [txt_path]
+
+
+        # Attach handlers
+        download_json_btn.click(download_json, outputs=[download_files])
+        download_svg_btn.click(download_svg, outputs=[download_files])
+        report_btn.click(sync_generate_report, outputs=[report_output])
+        download_report_btn.click(download_report, outputs=[download_files])
+
+        # Clear handler
+        def clear_all():
+            workflow.nodes.clear()
+            workflow.connections.clear()
+            workflow.node_counter = 0
+            workflow.selected_node = None
+            svg = workflow.render_svg()
+            return (
+                svg,
+                "{}",
+                gr.Dropdown(choices=[]),
+                gr.Dropdown(choices=[]),
+                "No node selected",
+                "Canvas cleared. Ready to build!"
+            )
+
+        clear_btn.click(clear_all, outputs=[canvas, json_output, from_node, to_node, selected_node_info, component_info])
+
+        # Initialize with JavaScript support
+        def init_app():
+            svg = workflow.render_svg()
+            js_code = '''
+            <script>
+            window.gradio_api = function(type, data) {
+                if (type === 'select_node') {
+                    const triggers = document.querySelectorAll('input[type="hidden"]');
+                    const selectTrigger = triggers[0];
+                    if (selectTrigger) {
+                        selectTrigger.value = data;
+                        selectTrigger.dispatchEvent(new Event('change'));
+                    }
+                } else if (type === 'move_node') {
+                    const triggers = document.querySelectorAll('input[type="hidden"]');
+                    const moveTrigger = triggers[1];
+                    if (moveTrigger) {
+                        moveTrigger.value = JSON.stringify(data);
+                        moveTrigger.dispatchEvent(new Event('change'));
+                    }
+                }
+            };
+            </script>
+            '''
+            return svg + js_code
+
+        demo.load(init_app, outputs=[canvas])
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_workflow_ui()
+    demo.launch()