Upload 9 files

concept_map_generator.py

@@ -0,0 +1,244 @@
+import graphviz
+import json
+from tempfile import NamedTemporaryFile
+import os
+from graph_generator_utils import add_nodes_and_edges
+
+def generate_concept_map(json_input: str, output_format: str) -> str:
+    """
+    Generates a concept map from JSON input.
+
+    Args:
+        json_input (str): A JSON string describing the concept map structure.
+                          It must follow the Expected JSON Format Example below.
+
+    Expected JSON Format Example:
+    {
+      "central_node": "Artificial Intelligence (AI)",
+      "nodes": [
+        {
+          "id": "ml_fundamental",
+          "label": "Machine Learning",
+          "relationship": "is essential for",
+          "subnodes": [
+            {
+              "id": "dl_branch",
+              "label": "Deep Learning",
+              "relationship": "for example",
+              "subnodes": [
+                {
+                  "id": "cnn_example",
+                  "label": "CNNs",
+                  "relationship": "for example"
+                },
+                {
+                  "id": "rnn_example",
+                  "label": "RNNs",
+                  "relationship": "for example"
+                }
+              ]
+            },
+            {
+              "id": "rl_branch",
+              "label": "Reinforcement Learning",
+              "relationship": "for example",
+              "subnodes": [
+                {
+                  "id": "qlearning_example",
+                  "label": "Q-Learning",
+                  "relationship": "example"
+                },
+                {
+                  "id": "pg_example",
+                  "label": "Policy Gradients",
+                  "relationship": "example"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "id": "ai_types",
+          "label": "Types",
+          "relationship": "formed by",
+          "subnodes": [
+            {
+              "id": "agi_type",
+              "label": "AGI",
+              "relationship": "this is",
+              "subnodes": [
+                {
+                  "id": "strong_ai",
+                  "label": "Strong AI",
+                  "relationship": "provoked by",
+                  "subnodes": [
+                    {
+                      "id": "human_intel",
+                      "label": "Human-level Intel.",
+                      "relationship": "of"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "id": "ani_type",
+              "label": "ANI",
+              "relationship": "this is",
+              "subnodes": [
+                {
+                  "id": "weak_ai",
+                  "label": "Weak AI",
+                  "relationship": "provoked by",
+                  "subnodes": [
+                    {
+                      "id": "narrow_tasks",
+                      "label": "Narrow Tasks",
+                      "relationship": "of"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "id": "ai_capabilities",
+          "label": "Capabilities",
+          "relationship": "change",
+          "subnodes": [
+            {
+              "id": "data_proc",
+              "label": "Data Processing",
+              "relationship": "can",
+              "subnodes": [
+                {
+                  "id": "big_data",
+                  "label": "Big Data",
+                  "relationship": "as",
+                  "subnodes": [
+                    {
+                      "id": "analysis_example",
+                      "label": "Data Analysis",
+                      "relationship": "example"
+                    },
+                    {
+                      "id": "prediction_example",
+                      "label": "Prediction",
+                      "relationship": "example"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "id": "decision_making",
+              "label": "Decision Making",
+              "relationship": "can be",
+              "subnodes": [
+                {
+                  "id": "automation",
+                  "label": "Automation",
+                  "relationship": "as",
+                  "subnodes": [
+                    {
+                      "id": "robotics_example",
+                      "label": "Robotics",
+                      "relationship": "Example"},
+                    {
+                      "id": "autonomous_example",
+                      "label": "Autonomous Vehicles",
+                      "relationship": "of one"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "id": "problem_solving",
+              "label": "Problem Solving",
+              "relationship": "can",
+              "subnodes": [
+                {
+                  "id": "optimization",
+                  "label": "Optimization",
+                  "relationship": "as is",
+                  "subnodes": [
+                    {
+                      "id": "algorithms_example",
+                      "label": "Algorithms",
+                      "relationship": "for example"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+
+    Returns:
+        str: The filepath to the generated PNG image file.
+    """
+    try:
+        if not json_input.strip():
+            return "Error: Empty input"
+            
+        data = json.loads(json_input)
+        
+        if 'central_node' not in data or 'nodes' not in data:
+            raise ValueError("Missing required fields: central_node or nodes")
+
+        # 한글 폰트 설정
+        # 환경 변수에서 폰트 경로 가져오기
+        font_path = os.environ.get('KOREAN_FONT_PATH', '')
+        
+        # Graphviz는 시스템 폰트를 사용하므로 폰트 이름으로 지정
+        # NanumGothic이 시스템에 설치되어 있어야 함
+        korean_font = 'NanumGothic'
+        
+        dot = graphviz.Digraph(
+            name='ConceptMap',
+            format='png',
+            graph_attr={
+                'rankdir': 'TB',        # Top-to-Bottom layout (vertical hierarchy)
+                'splines': 'ortho',     # Straight lines
+                'bgcolor': 'white',     # White background
+                'pad': '0.5',           # Padding around the graph
+                'fontname': korean_font,  # 그래프 전체 폰트 설정
+                'charset': 'UTF-8'      # UTF-8 인코딩
+            },
+            node_attr={
+                'fontname': korean_font  # 모든 노드의 기본 폰트
+            },
+            edge_attr={
+                'fontname': korean_font  # 모든 엣지의 기본 폰트
+            }
+        )
+        
+        base_color = '#19191a' # Hardcoded base color
+
+        # Central node styling (rounded box, dark color)
+        dot.node(
+            'central',
+            data['central_node'],
+            shape='box',            # Rectangular shape
+            style='filled,rounded', # Filled and rounded corners
+            fillcolor=base_color,   # Darkest color
+            fontcolor='white',      # White text for dark background
+            fontsize='16',          # Larger font for central node
+            fontname=korean_font    # 한글 폰트 명시적 지정
+        )
+        
+        # Add child nodes and edges recursively starting from depth 1
+        add_nodes_and_edges(dot, 'central', data.get('nodes', []), current_depth=1, base_color=base_color)
+
+        with NamedTemporaryFile(delete=False, suffix=f'.{output_format}') as tmp:
+            dot.render(tmp.name, format=output_format, cleanup=True)
+            return f"{tmp.name}.{output_format}"
+
+    except json.JSONDecodeError:
+        return "Error: Invalid JSON format"
+    except Exception as e:
+        return f"Error: {str(e)}"

graph_generator_utils.py

@@ -0,0 +1,86 @@
+import graphviz
+import os
+
+def add_nodes_and_edges(dot: graphviz.Digraph, parent_id: str, nodes_list: list, current_depth: int, base_color: str):
+    """
+    Recursively adds nodes and edges to a Graphviz Digraph object,
+    applying a color gradient and consistent styling.
+    Args:
+        dot (graphviz.Digraph): The Graphviz Digraph object to modify.
+        parent_id (str): The ID of the parent node for the current set of nodes.
+        nodes_list (list): A list of dictionaries, each representing a node
+                           with 'id', 'label', 'relationship', and optional 'subnodes'.
+        current_depth (int): The current depth in the graph hierarchy (0 for central node).
+        base_color (str): The hexadecimal base color for the deepest nodes.
+    """
+    # 한글 폰트 설정
+    korean_font = 'NanumGothic'
+    
+    # Calculate color for current depth, making it lighter
+    # This factor determines how quickly the color lightens per level.
+    lightening_factor = 0.12 
+    
+    # Convert base_color hex to RGB for interpolation
+    # Ensure base_color is a valid hex string before converting
+    if not isinstance(base_color, str) or not base_color.startswith('#') or len(base_color) != 7:
+        base_color = '#19191a' # Fallback to default dark if invalid
+    base_r = int(base_color[1:3], 16)
+    base_g = int(base_color[3:5], 16)
+    base_b = int(base_color[5:7], 16)
+    
+    # Calculate current node color by blending towards white
+    current_r = base_r + int((255 - base_r) * current_depth * lightening_factor)
+    current_g = base_g + int((255 - base_g) * current_depth * lightening_factor)
+    current_b = base_b + int((255 - base_b) * current_depth * lightening_factor)
+    
+    # Clamp values to 255 to stay within valid RGB range
+    current_r = min(255, current_r)
+    current_g = min(255, current_g)
+    current_b = min(255, current_b)
+    
+    node_fill_color = f'#{current_r:02x}{current_g:02x}{current_b:02x}'
+    
+    # Font color: white for dark nodes, black for very light nodes for readability
+    font_color = 'white' if current_depth * lightening_factor < 0.6 else 'black'
+    
+    # Edge colors and font sizes
+    edge_color = '#4a4a4a' # Dark gray for lines
+    # Font size adjusts based on depth, ensuring a minimum size
+    font_size = max(9, 14 - (current_depth * 2)) 
+    edge_font_size = max(7, 10 - (current_depth * 1))
+    
+    for node in nodes_list:
+        node_id = node.get('id')
+        label = node.get('label')
+        relationship = node.get('relationship')
+        
+        # Basic validation for node data
+        if not all([node_id, label, relationship]):
+            raise ValueError(f"Invalid node: {node}")
+            
+        # Add node with specified style and Korean font
+        dot.node(
+            node_id,
+            label,
+            shape='box',                # All nodes are rectangular
+            style='filled,rounded',     # Filled and rounded corners
+            fillcolor=node_fill_color, 
+            fontcolor=font_color,
+            fontsize=str(font_size),
+            fontname=korean_font        # 한글 폰트 추가
+        )
+        
+        # Add edge from parent to current node with Korean font
+        dot.edge(
+            parent_id,
+            node_id,
+            label=relationship,
+            color=edge_color,
+            fontcolor=edge_color,       # Edge label color also dark gray
+            fontsize=str(edge_font_size),
+            fontname=korean_font        # 한글 폰트 추가
+        )
+        
+        # Recursively call for subnodes
+        if 'subnodes' in node:
+            add_nodes_and_edges(dot, node_id, node['subnodes'], current_depth + 1, base_color)

packages (7).txt

@@ -0,0 +1 @@
+graphviz

process_flow_generator.py

@@ -0,0 +1,207 @@
+import graphviz
+import json
+from tempfile import NamedTemporaryFile
+import os
+
+def generate_process_flow_diagram(json_input: str, output_format: str) -> str:
+    """
+    Generates a Process Flow Diagram (Flowchart) from JSON input.
+
+    Args:
+        json_input (str): A JSON string describing the process flow structure.
+                          It must follow the Expected JSON Format Example below.
+
+    Expected JSON Format Example:
+    {
+      "start_node": "Start Inference Request",
+      "nodes": [
+        {
+          "id": "user_input",
+          "label": "Receive User Input (Data)",
+          "type": "io"
+        },
+        {
+          "id": "preprocess_data",
+          "label": "Preprocess Data",
+          "type": "process"
+        },
+        {
+          "id": "validate_data",
+          "label": "Validate Data Format/Type",
+          "type": "decision"
+        },
+        {
+          "id": "data_valid_yes",
+          "label": "Data Valid?",
+          "type": "decision"
+        },
+        {
+          "id": "load_model",
+          "label": "Load AI Model (if not cached)",
+          "type": "process"
+        },
+        {
+          "id": "run_inference",
+          "label": "Run AI Model Inference",
+          "type": "process"
+        },
+        {
+          "id": "postprocess_output",
+          "label": "Postprocess Model Output",
+          "type": "process"
+        },
+        {
+          "id": "send_response",
+          "label": "Send Response to User",
+          "type": "io"
+        },
+        {
+          "id": "log_error",
+          "label": "Log Error & Notify User",
+          "type": "process"
+        },
+        {
+          "id": "end_inference_process",
+          "label": "End Inference Process",
+          "type": "end"
+        }
+      ],
+      "connections": [
+        {"from": "start_node", "to": "user_input", "label": "Request"},
+        {"from": "user_input", "to": "preprocess_data", "label": "Data Received"},
+        {"from": "preprocess_data", "to": "validate_data", "label": "Cleaned"},
+        {"from": "validate_data", "to": "data_valid_yes", "label": "Check"},
+        {"from": "data_valid_yes", "to": "load_model", "label": "Yes"},
+        {"from": "data_valid_yes", "to": "log_error", "label": "No"},
+        {"from": "load_model", "to": "run_inference", "label": "Model Ready"},
+        {"from": "run_inference", "to": "postprocess_output", "label": "Output Generated"},
+        {"from": "postprocess_output", "to": "send_response", "label": "Ready"},
+        {"from": "send_response", "to": "end_inference_process", "label": "Response Sent"},
+        {"from": "log_error", "to": "end_inference_process", "label": "Error Handled"}
+      ]
+    }
+
+    Returns:
+        str: The filepath to the generated PNG image file.
+    """
+    try:
+        if not json_input.strip():
+            return "Error: Empty input"
+            
+        data = json.loads(json_input)
+        
+        # Validate required top-level keys for a flowchart
+        if 'start_node' not in data or 'nodes' not in data or 'connections' not in data:
+            raise ValueError("Missing required fields: 'start_node', 'nodes', or 'connections'")
+
+        # Define specific node shapes for flowchart types
+        node_shapes = {
+            "process": "box",          # Rectangle for processes
+            "decision": "diamond",     # Diamond for decisions
+            "start": "oval",           # Oval for start
+            "end": "oval",             # Oval for end
+            "io": "parallelogram",     # Input/Output
+            "document": "note",        # Document symbol
+            "default": "box"           # Fallback
+        }
+
+        # 한글 폰트 설정
+        # GDFONTPATH가 설정되어 있으면 폰트 파일명(확장자 제외) 사용
+        korean_font = 'NanumGothic-Regular'
+
+        dot = graphviz.Digraph(
+            name='ProcessFlowDiagram',
+            format='png',
+            graph_attr={
+                'rankdir': 'TB',        # Top-to-Bottom flow is common for flowcharts
+                'splines': 'ortho',     # Straight lines with 90-degree bends
+                'bgcolor': 'white',     # White background
+                'pad': '0.5',           # Padding around the graph
+                'nodesep': '0.6',       # Spacing between nodes on same rank
+                'ranksep': '0.8',       # Spacing between ranks
+                'fontname': korean_font,  # 그래프 전체 한글 폰트
+                'charset': 'UTF-8'      # UTF-8 인코딩
+            },
+            node_attr={
+                'fontname': korean_font  # 모든 노드의 기본 폰트
+            },
+            edge_attr={
+                'fontname': korean_font  # 모든 엣지의 기본 폰트
+            }
+        )
+        
+        base_color = '#19191a' # Hardcoded base color
+
+        fill_color_for_nodes = base_color
+        font_color_for_nodes = 'white' if base_color == '#19191a' or base_color.lower() in ['#000000', '#19191a'] else 'black'
+        
+        # Store all nodes by ID for easy lookup
+        all_defined_nodes = {node['id']: node for node in data['nodes']}
+        
+        # Add start node explicitly
+        start_node_id = data['start_node']
+        dot.node(
+            start_node_id,
+            start_node_id, # Label is typically the ID itself for start/end
+            shape=node_shapes['start'],
+            style='filled,rounded',
+            fillcolor='#2196F3', # A distinct blue for Start
+            fontcolor='white',
+            fontsize='14',
+            fontname=korean_font  # 한글 폰트 추가
+        )
+
+        # Add all other nodes (process, decision, etc.)
+        for node_id, node_info in all_defined_nodes.items():
+            if node_id == start_node_id: # Skip if it's the start node, already added
+                continue
+
+            node_type = node_info.get("type", "default")
+            shape = node_shapes.get(node_type, "box")
+
+            node_label = node_info['label']
+
+            # Use distinct color for end node if it exists
+            if node_type == 'end':
+                 dot.node(
+                    node_id,
+                    node_label,
+                    shape=shape,
+                    style='filled,rounded',
+                    fillcolor='#F44336', # A distinct red for End
+                    fontcolor='white',
+                    fontsize='14',
+                    fontname=korean_font  # 한글 폰트 추가
+                )
+            else: # Regular process, decision, etc. nodes use the selected base color
+                dot.node(
+                    node_id,
+                    node_label,
+                    shape=shape,
+                    style='filled,rounded',
+                    fillcolor=fill_color_for_nodes, 
+                    fontcolor=font_color_for_nodes,
+                    fontsize='14',
+                    fontname=korean_font  # 한글 폰트 추가
+                )
+
+        # Add connections (edges)
+        for connection in data['connections']:
+            dot.edge(
+                connection['from'],
+                connection['to'],
+                label=connection.get('label', ''),
+                color='#4a4a4a', # Dark gray for lines
+                fontcolor='#4a4a4a',
+                fontsize='10',
+                fontname=korean_font  # 한글 폰트 추가
+            )
+        
+        with NamedTemporaryFile(delete=False, suffix=f'.{output_format}') as tmp:
+            dot.render(tmp.name, format=output_format, cleanup=True)
+            return f"{tmp.name}.{output_format}"
+
+    except json.JSONDecodeError:
+        return "Error: Invalid JSON format"
+    except Exception as e:
+        return f"Error: {str(e)}"

radial_diagram_generator.py

@@ -0,0 +1,127 @@
+import graphviz
+import json
+from tempfile import NamedTemporaryFile
+import os
+from graph_generator_utils import add_nodes_and_edges
+
+def generate_radial_diagram(json_input: str, output_format: str) -> str:
+    """
+    Generates a radial (center-expanded) diagram from JSON input.
+
+    Args:
+        json_input (str): A JSON string describing the radial diagram structure.
+                          It must follow the Expected JSON Format Example below.
+
+    Expected JSON Format Example:
+    {
+      "central_node": "AI Core Concepts & Domains",
+      "nodes": [
+        {
+          "id": "foundational_ml",
+          "label": "Foundational ML",
+          "relationship": "builds on",
+          "subnodes": [
+            {"id": "supervised_l", "label": "Supervised Learning", "relationship": "e.g."},
+            {"id": "unsupervised_l", "label": "Unsupervised Learning", "relationship": "e.g."}
+          ]
+        },
+        {
+          "id": "dl_architectures",
+          "label": "Deep Learning Arch.",
+          "relationship": "evolved from",
+          "subnodes": [
+            {"id": "cnns_rad", "label": "CNNs", "relationship": "e.g."},
+            {"id": "rnns_rad", "label": "RNNs", "relationship": "e.g."}
+          ]
+        },
+        {
+          "id": "major_applications",
+          "label": "Major AI Applications",
+          "relationship": "applied in",
+          "subnodes": [
+            {"id": "nlp_rad", "label": "Natural Language Processing", "relationship": "e.g."},
+            {"id": "cv_rad", "label": "Computer Vision", "relationship": "e.g."}
+          ]
+        },
+        {
+          "id": "ethical_concerns",
+          "label": "Ethical AI Concerns",
+          "relationship": "addresses",
+          "subnodes": [
+            {"id": "fairness_rad", "label": "Fairness & Bias", "relationship": "e.g."},
+            {"id": "explainability", "label": "Explainability (XAI)", "relationship": "e.g."}
+          ]
+        },
+        {
+          "id": "future_trends",
+          "label": "Future AI Trends",
+          "relationship": "looking at",
+          "subnodes": [
+            {"id": "agi_future", "label": "AGI Development", "relationship": "e.g."},
+            {"id": "quantum_ai", "label": "Quantum AI", "relationship": "e.g."}
+          ]
+        }
+      ]
+    }
+
+    Returns:
+        str: The filepath to the generated PNG image file.
+    """
+    try:
+        if not json_input.strip():
+            return "Error: Empty input"
+            
+        data = json.loads(json_input)
+        
+        if 'central_node' not in data or 'nodes' not in data:
+            raise ValueError("Missing required fields: central_node or nodes")
+
+        # 한글 폰트 설정
+        # GDFONTPATH가 설정되어 있으면 폰트 파일명(확장자 제외) 사용
+        korean_font = 'NanumGothic-Regular'
+
+        dot = graphviz.Digraph(
+            name='RadialDiagram',
+            format='png',
+            engine='neato', # Use 'neato' or 'fdp' for radial/force-directed layout
+            graph_attr={
+                'overlap': 'false',     # Prevent node overlap
+                'splines': 'true',      # Smooth splines for edges
+                'bgcolor': 'white',     # White background
+                'pad': '0.5',          # Padding around the graph
+                'layout': 'neato',      # Explicitly set layout engine for consistency
+                'fontname': korean_font,  # 그래프 전체 한글 폰트
+                'charset': 'UTF-8'      # UTF-8 인코딩
+            },
+            node_attr={
+                'fixedsize': 'false',   # Allow nodes to resize based on content
+                'fontname': korean_font  # 모든 노드의 기본 폰트
+            },
+            edge_attr={
+                'fontname': korean_font  # 모든 엣지의 기본 폰트
+            }
+        )
+        
+        base_color = '#19191a' # Hardcoded base color
+
+        dot.node(
+            'central',
+            data['central_node'],
+            shape='box',            # Rectangular shape
+            style='filled,rounded', # Filled and rounded corners
+            fillcolor=base_color,   # Darkest color
+            fontcolor='white',      # White text for dark background
+            fontsize='16',          # Larger font for central node
+            fontname=korean_font    # 한글 폰트 명시적 지정
+        )
+        
+        add_nodes_and_edges(dot, 'central', data.get('nodes', []), current_depth=1, base_color=base_color)
+
+        with NamedTemporaryFile(delete=False, suffix=f'.{output_format}') as tmp:
+            dot.render(tmp.name, format=output_format, cleanup=True)
+            return f"{tmp.name}.{output_format}"
+
+    except json.JSONDecodeError:
+        return "Error: Invalid JSON format"
+    except Exception as e:
+        return f"Error: {str(e)}"

ruff (3).toml

@@ -0,0 +1,4 @@
+line-length = 120
+target-version = "py310"
+
+lint.select = ["I"]

sample_data.py

@@ -0,0 +1,690 @@
+# Enhanced Sample Data for AI Diagram Generator
+# Modern and practical AI-related sample data
+
+CONCEPT_MAP_JSON = """
+{
+  "central_node": "Generative AI Ecosystem",
+  "nodes": [
+    {
+      "id": "foundation_models",
+      "label": "Foundation Models",
+      "relationship": "powered by",
+      "subnodes": [
+        {
+          "id": "llm_models",
+          "label": "Large Language Models",
+          "relationship": "includes",
+          "subnodes": [
+            {
+              "id": "gpt_family",
+              "label": "GPT Family",
+              "relationship": "such as",
+              "subnodes": [
+                {
+                  "id": "gpt4",
+                  "label": "GPT-4",
+                  "relationship": "latest version"
+                },
+                {
+                  "id": "chatgpt",
+                  "label": "ChatGPT",
+                  "relationship": "application"
+                }
+              ]
+            },
+            {
+              "id": "claude_family",
+              "label": "Claude Family",
+              "relationship": "such as",
+              "subnodes": [
+                {
+                  "id": "claude3",
+                  "label": "Claude 3 Opus",
+                  "relationship": "advanced model"
+                },
+                {
+                  "id": "claude_sonnet",
+                  "label": "Claude Sonnet",
+                  "relationship": "balanced model"
+                }
+              ]
+            },
+            {
+              "id": "opensource_llm",
+              "label": "Open Source LLMs",
+              "relationship": "alternatives",
+              "subnodes": [
+                {
+                  "id": "llama3",
+                  "label": "LLaMA 3",
+                  "relationship": "by Meta"
+                },
+                {
+                  "id": "mistral",
+                  "label": "Mistral 7B",
+                  "relationship": "efficient"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "id": "multimodal_models",
+          "label": "Multimodal Models",
+          "relationship": "extends to",
+          "subnodes": [
+            {
+              "id": "vision_language",
+              "label": "Vision-Language Models",
+              "relationship": "including",
+              "subnodes": [
+                {
+                  "id": "dall_e3",
+                  "label": "DALL-E 3",
+                  "relationship": "image generation"
+                },
+                {
+                  "id": "midjourney",
+                  "label": "Midjourney v6",
+                  "relationship": "artistic creation"
+                }
+              ]
+            },
+            {
+              "id": "video_models",
+              "label": "Video Generation",
+              "relationship": "emerging with",
+              "subnodes": [
+                {
+                  "id": "sora",
+                  "label": "Sora",
+                  "relationship": "by OpenAI"
+                },
+                {
+                  "id": "runway",
+                  "label": "Runway Gen-2",
+                  "relationship": "creative tools"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "ai_applications",
+      "label": "Real-World Applications",
+      "relationship": "deployed in",
+      "subnodes": [
+        {
+          "id": "enterprise_ai",
+          "label": "Enterprise Solutions",
+          "relationship": "transforming",
+          "subnodes": [
+            {
+              "id": "ai_assistants",
+              "label": "AI Assistants",
+              "relationship": "like",
+              "subnodes": [
+                {
+                  "id": "copilot",
+                  "label": "GitHub Copilot",
+                  "relationship": "code generation"
+                },
+                {
+                  "id": "duet_ai",
+                  "label": "Google Duet AI",
+                  "relationship": "workspace integration"
+                }
+              ]
+            },
+            {
+              "id": "automation",
+              "label": "Process Automation",
+              "relationship": "through",
+              "subnodes": [
+                {
+                  "id": "rpa_ai",
+                  "label": "AI-Enhanced RPA",
+                  "relationship": "intelligent automation"
+                },
+                {
+                  "id": "document_ai",
+                  "label": "Document Intelligence",
+                  "relationship": "data extraction"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "id": "creative_ai",
+          "label": "Creative Industries",
+          "relationship": "revolutionizing",
+          "subnodes": [
+            {
+              "id": "content_creation",
+              "label": "Content Generation",
+              "relationship": "enabling",
+              "subnodes": [
+                {
+                  "id": "marketing_ai",
+                  "label": "Marketing Copy",
+                  "relationship": "automated creation"
+                },
+                {
+                  "id": "game_assets",
+                  "label": "Game Asset Generation",
+                  "relationship": "procedural design"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "ai_infrastructure",
+      "label": "AI Infrastructure",
+      "relationship": "supported by",
+      "subnodes": [
+        {
+          "id": "compute_resources",
+          "label": "Compute Resources",
+          "relationship": "requiring",
+          "subnodes": [
+            {
+              "id": "gpu_clusters",
+              "label": "GPU Clusters",
+              "relationship": "powered by",
+              "subnodes": [
+                {
+                  "id": "nvidia_h100",
+                  "label": "NVIDIA H100",
+                  "relationship": "latest generation"
+                },
+                {
+                  "id": "tpu_v5",
+                  "label": "Google TPU v5",
+                  "relationship": "specialized chips"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "id": "mlops_platform",
+          "label": "MLOps Platforms",
+          "relationship": "managed by",
+          "subnodes": [
+            {
+              "id": "model_serving",
+              "label": "Model Serving",
+              "relationship": "via",
+              "subnodes": [
+                {
+                  "id": "huggingface",
+                  "label": "Hugging Face",
+                  "relationship": "model hub"
+                },
+                {
+                  "id": "vertex_ai",
+                  "label": "Vertex AI",
+                  "relationship": "Google Cloud"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
+"""
+
+SYNOPTIC_CHART_JSON = """
+{
+  "central_node": "Modern AI Development Pipeline",
+  "nodes": [
+    {
+      "id": "phase1",
+      "label": "I. Data Engineering & Preparation",
+      "relationship": "begins with",
+      "subnodes": [
+        {
+          "id": "data_strategy",
+          "label": "1. Data Strategy",
+          "relationship": "establishing",
+          "subnodes": [
+            {"id": "data_sources", "label": "1.1. Multi-Source Integration", "relationship": "includes", "subnodes": []},
+            {"id": "data_governance", "label": "1.2. Privacy & Compliance", "relationship": "ensures", "subnodes": []}
+          ]
+        },
+        {
+          "id": "data_pipeline",
+          "label": "2. Data Pipeline",
+          "relationship": "building",
+          "subnodes": [
+            {"id": "etl_process", "label": "2.1. ETL/ELT Workflows", "relationship": "implements", "subnodes": []},
+            {"id": "feature_store", "label": "2.2. Feature Store Setup", "relationship": "centralizes", "subnodes": []}
+          ]
+        }
+      ]
+    },
+    {
+      "id": "phase2",
+      "label": "II. Model Development & Training",
+      "relationship": "continues to",
+      "subnodes": [
+        {
+          "id": "experimentation",
+          "label": "1. Experimentation Platform",
+          "relationship": "enabling",
+          "subnodes": [
+            {"id": "experiment_tracking", "label": "1.1. MLflow/W&B Integration", "relationship": "tracks", "subnodes": []},
+            {"id": "hyperparameter_opt", "label": "1.2. AutoML & HPO", "relationship": "optimizes", "subnodes": []}
+          ]
+        },
+        {
+          "id": "distributed_training",
+          "label": "2. Scalable Training",
+          "relationship": "leveraging",
+          "subnodes": [
+            {"id": "multi_gpu", "label": "2.1. Multi-GPU Training", "relationship": "accelerates", "subnodes": []},
+            {"id": "model_parallelism", "label": "2.2. Model Parallelism", "relationship": "enables", "subnodes": []}
+          ]
+        }
+      ]
+    },
+    {
+      "id": "phase3",
+      "label": "III. Deployment & Operations",
+      "relationship": "culminates in",
+      "subnodes": [
+        {
+          "id": "model_deployment",
+          "label": "1. Production Deployment",
+          "relationship": "implementing",
+          "subnodes": [
+            {"id": "edge_deployment", "label": "1.1. Edge Computing", "relationship": "optimizes", "subnodes": []},
+            {"id": "api_gateway", "label": "1.2. API Management", "relationship": "exposes", "subnodes": []}
+          ]
+        },
+        {
+          "id": "monitoring_ops",
+          "label": "2. AI Operations",
+          "relationship": "maintaining",
+          "subnodes": [
+            {"id": "model_monitoring", "label": "2.1. Drift Detection", "relationship": "monitors", "subnodes": []},
+            {"id": "feedback_loop", "label": "2.2. Continuous Learning", "relationship": "improves", "subnodes": []}
+          ]
+        }
+      ]
+    }
+  ]
+}
+"""
+
+RADIAL_DIAGRAM_JSON = """
+{
+  "central_node": "AI Innovation Hub",
+  "nodes": [
+    {
+      "id": "emerging_tech",
+      "label": "Emerging Technologies",
+      "relationship": "advancing through",
+      "subnodes": [
+        {"id": "quantum_ml", "label": "Quantum Machine Learning", "relationship": "breakthrough in", "subnodes": []},
+        {"id": "neuromorphic", "label": "Neuromorphic Computing", "relationship": "inspired by", "subnodes": []}
+      ]
+    },
+    {
+      "id": "ai_safety",
+      "label": "AI Safety & Ethics",
+      "relationship": "ensuring through",
+      "subnodes": [
+        {"id": "alignment", "label": "AI Alignment Research", "relationship": "focusing on", "subnodes": []},
+        {"id": "explainable_ai", "label": "Explainable AI (XAI)", "relationship": "providing", "subnodes": []}
+      ]
+    },
+    {
+      "id": "industry_impact",
+      "label": "Industry Transformation",
+      "relationship": "disrupting",
+      "subnodes": [
+        {"id": "healthcare_ai", "label": "AI in Healthcare", "relationship": "revolutionizing", "subnodes": []},
+        {"id": "fintech_ai", "label": "AI in Finance", "relationship": "automating", "subnodes": []}
+      ]
+    },
+    {
+      "id": "research_frontiers",
+      "label": "Research Frontiers",
+      "relationship": "exploring",
+      "subnodes": [
+        {"id": "agi_research", "label": "AGI Development", "relationship": "pursuing", "subnodes": []},
+        {"id": "consciousness_ai", "label": "Machine Consciousness", "relationship": "investigating", "subnodes": []}
+      ]
+    },
+    {
+      "id": "ai_ecosystem",
+      "label": "AI Ecosystem",
+      "relationship": "building",
+      "subnodes": [
+        {"id": "open_source", "label": "Open Source Community", "relationship": "contributing to", "subnodes": []},
+        {"id": "ai_startups", "label": "AI Startup Ecosystem", "relationship": "innovating in", "subnodes": []}
+      ]
+    }
+  ]
+}
+"""
+
+PROCESS_FLOW_JSON = """
+{
+  "start_node": "AI Request Initiated",
+  "nodes": [
+    {
+      "id": "auth_check",
+      "label": "Authentication & Rate Limiting",
+      "type": "process"
+    },
+    {
+      "id": "auth_valid",
+      "label": "Valid Request?",
+      "type": "decision"
+    },
+    {
+      "id": "request_router",
+      "label": "Request Router",
+      "type": "process"
+    },
+    {
+      "id": "cache_check",
+      "label": "Check Response Cache",
+      "type": "decision"
+    },
+    {
+      "id": "model_selector",
+      "label": "Model Selection Logic",
+      "type": "process"
+    },
+    {
+      "id": "load_balancer",
+      "label": "Load Balancer",
+      "type": "process"
+    },
+    {
+      "id": "inference_engine",
+      "label": "Run Inference",
+      "type": "process"
+    },
+    {
+      "id": "quality_check",
+      "label": "Quality Assessment",
+      "type": "decision"
+    },
+    {
+      "id": "post_processor",
+      "label": "Post-Processing & Filtering",
+      "type": "process"
+    },
+    {
+      "id": "response_cache",
+      "label": "Update Cache",
+      "type": "process"
+    },
+    {
+      "id": "analytics_log",
+      "label": "Log Analytics",
+      "type": "process"
+    },
+    {
+      "id": "deliver_response",
+      "label": "Deliver Response",
+      "type": "io"
+    },
+    {
+      "id": "error_handler",
+      "label": "Error Handler",
+      "type": "process"
+    },
+    {
+      "id": "fallback_model",
+      "label": "Fallback Model",
+      "type": "process"
+    },
+    {
+      "id": "end_process",
+      "label": "Complete",
+      "type": "end"
+    }
+  ],
+  "connections": [
+    {"from": "start_node", "to": "auth_check", "label": "Begin"},
+    {"from": "auth_check", "to": "auth_valid", "label": "Verify"},
+    {"from": "auth_valid", "to": "request_router", "label": "Authorized"},
+    {"from": "auth_valid", "to": "error_handler", "label": "Denied"},
+    {"from": "request_router", "to": "cache_check", "label": "Route"},
+    {"from": "cache_check", "to": "deliver_response", "label": "Cache Hit"},
+    {"from": "cache_check", "to": "model_selector", "label": "Cache Miss"},
+    {"from": "model_selector", "to": "load_balancer", "label": "Selected"},
+    {"from": "load_balancer", "to": "inference_engine", "label": "Assigned"},
+    {"from": "inference_engine", "to": "quality_check", "label": "Generated"},
+    {"from": "quality_check", "to": "post_processor", "label": "Pass"},
+    {"from": "quality_check", "to": "fallback_model", "label": "Fail"},
+    {"from": "fallback_model", "to": "post_processor", "label": "Retry"},
+    {"from": "post_processor", "to": "response_cache", "label": "Processed"},
+    {"from": "response_cache", "to": "analytics_log", "label": "Cached"},
+    {"from": "analytics_log", "to": "deliver_response", "label": "Logged"},
+    {"from": "deliver_response", "to": "end_process", "label": "Delivered"},
+    {"from": "error_handler", "to": "end_process", "label": "Handled"}
+  ]
+}
+"""
+
+WBS_DIAGRAM_JSON = """
+{
+  "project_title": "Enterprise AI Platform Implementation",
+  "phases": [
+    {
+      "id": "phase_foundation",
+      "label": "Foundation & Architecture",
+      "tasks": [
+        {
+          "id": "task_requirements",
+          "label": "Requirements Analysis",
+          "subtasks": [
+            {
+              "id": "subtask_stakeholder",
+              "label": "Stakeholder Mapping",
+              "sub_subtasks": [
+                {
+                  "id": "ss_task_interviews",
+                  "label": "Executive Interviews",
+                  "sub_sub_subtasks": [
+                    {
+                      "id": "sss_task_schedule",
+                      "label": "Schedule Sessions",
+                      "final_level_tasks": [
+                        {"id": "ft_prep_materials", "label": "Prepare Materials"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "id": "subtask_technical",
+              "label": "Technical Assessment",
+              "sub_subtasks": [
+                {
+                  "id": "ss_task_infra",
+                  "label": "Infrastructure Audit",
+                  "sub_sub_subtasks": [
+                    {
+                      "id": "sss_task_compute",
+                      "label": "Compute Resources",
+                      "final_level_tasks": [
+                        {"id": "ft_gpu_assessment", "label": "GPU Capacity Planning"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "id": "task_architecture",
+          "label": "Solution Architecture",
+          "subtasks": [
+            {
+              "id": "subtask_design",
+              "label": "System Design",
+              "sub_subtasks": [
+                {
+                  "id": "ss_task_microservices",
+                  "label": "Microservices Architecture",
+                  "sub_sub_subtasks": [
+                    {
+                      "id": "sss_task_api_design",
+                      "label": "API Design",
+                      "final_level_tasks": [
+                        {"id": "ft_api_specs", "label": "OpenAPI Specifications"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "phase_implementation",
+      "label": "Core Implementation",
+      "tasks": [
+        {
+          "id": "task_data_platform",
+          "label": "Data Platform",
+          "subtasks": [
+            {
+              "id": "subtask_data_lake",
+              "label": "Data Lake Setup",
+              "sub_subtasks": [
+                {
+                  "id": "ss_task_storage",
+                  "label": "Storage Configuration",
+                  "sub_sub_subtasks": [
+                    {
+                      "id": "sss_task_s3_setup",
+                      "label": "S3 Bucket Setup",
+                      "final_level_tasks": [
+                        {"id": "ft_lifecycle_policies", "label": "Lifecycle Policies"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "id": "subtask_streaming",
+              "label": "Real-time Pipeline",
+              "sub_subtasks": [
+                {
+                  "id": "ss_task_kafka",
+                  "label": "Kafka Implementation",
+                  "sub_sub_subtasks": [
+                    {
+                      "id": "sss_task_topics",
+                      "label": "Topic Design",
+                      "final_level_tasks": [
+                        {"id": "ft_schema_registry", "label": "Schema Registry"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "id": "task_ml_platform",
+          "label": "ML Platform",
+          "subtasks": [
+            {
+              "id": "subtask_mlops",
+              "label": "MLOps Setup",
+              "sub_subtasks": [
+                {
+                  "id": "ss_task_ci_cd",
+                  "label": "CI/CD Pipeline",
+                  "sub_sub_subtasks": [
+                    {
+                      "id": "sss_task_github_actions",
+                      "label": "GitHub Actions",
+                      "final_level_tasks": [
+                        {"id": "ft_model_registry", "label": "Model Registry Integration"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "phase_deployment",
+      "label": "Deployment & Operations",
+      "tasks": [
+        {
+          "id": "task_production",
+          "label": "Production Deployment",
+          "subtasks": [
+            {
+              "id": "subtask_kubernetes",
+              "label": "Kubernetes Orchestration",
+              "sub_subtasks": [
+                {
+                  "id": "ss_task_helm",
+                  "label": "Helm Charts",
+                  "sub_sub_subtasks": [
+                    {
+                      "id": "sss_task_autoscaling",
+                      "label": "Auto-scaling Config",
+                      "final_level_tasks": [
+                        {"id": "ft_hpa_setup", "label": "HPA Configuration"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "id": "subtask_monitoring",
+              "label": "Observability Stack",
+              "sub_subtasks": [
+                {
+                  "id": "ss_task_prometheus",
+                  "label": "Prometheus Setup",
+                  "sub_sub_subtasks": [
+                    {
+                      "id": "sss_task_grafana",
+                      "label": "Grafana Dashboards",
+                      "final_level_tasks": [
+                        {"id": "ft_alert_rules", "label": "Alert Configuration"}
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
+"""

synoptic_chart_generator.py

@@ -0,0 +1,156 @@
+import graphviz
+import json
+from tempfile import NamedTemporaryFile
+import os
+from graph_generator_utils import add_nodes_and_edges
+
+def generate_synoptic_chart(json_input: str, output_format: str) -> str:
+    """
+    Generates a synoptic chart (horizontal flowchart) from JSON input.
+
+    Args:
+        json_input (str): A JSON string describing the synoptic chart structure.
+                          It must follow the Expected JSON Format Example below.
+
+    Expected JSON Format Example:
+    {
+      "central_node": "AI Project Lifecycle",
+      "nodes": [
+        {
+          "id": "phase1",
+          "label": "I. Problem Definition & Data Acquisition",
+          "relationship": "Starts with",
+          "subnodes": [
+            {
+              "id": "sub1_1",
+              "label": "1. Problem Formulation",
+              "relationship": "Involves",
+              "subnodes": [
+                {"id": "sub1_1_1", "label": "1.1. Identify Business Need", "relationship": "e.g."},
+                {"id": "sub1_1_2", "label": "1.2. Define KPIs", "relationship": "e.g."}
+              ]
+            },
+            {
+              "id": "sub1_2",
+              "label": "2. Data Collection",
+              "relationship": "Followed by",
+              "subnodes": [
+                {"id": "sub1_2_1", "label": "2.1. Source Data", "relationship": "from"},
+                {"id": "sub1_2_2", "label": "2.2. Data Cleaning", "relationship": "includes"}
+              ]
+            }
+          ]
+        },
+        {
+          "id": "phase2",
+          "label": "II. Model Development",
+          "relationship": "Proceeds to",
+          "subnodes": [
+            {
+              "id": "sub2_1",
+              "label": "1. Feature Engineering",
+              "relationship": "Comprises",
+              "subnodes": [
+                {"id": "sub2_1_1", "label": "1.1. Feature Selection", "relationship": "e.g."},
+                {"id": "sub2_1_2", "label": "1.2. Feature Transformation", "relationship": "e.g."}
+              ]
+            },
+            {
+              "id": "sub2_2",
+              "label": "2. Model Training",
+              "relationship": "Involves",
+              "subnodes": [
+                {"id": "sub2_2_1", "label": "2.1. Algorithm Selection", "relationship": "uses"},
+                {"id": "sub2_2_2", "label": "2.2. Hyperparameter Tuning", "relationship": "optimizes"}
+              ]
+            }
+          ]
+        },
+        {
+          "id": "phase3",
+          "label": "III. Evaluation & Deployment",
+          "relationship": "Culminates in",
+          "subnodes": [
+            {
+              "id": "sub3_1",
+              "label": "1. Model Evaluation",
+              "relationship": "Includes",
+              "subnodes": [
+                {"id": "sub3_1_1", "label": "1.1. Performance Metrics", "relationship": "measures"},
+                {"id": "sub3_1_2", "label": "1.2. Bias & Fairness Audits", "relationship": "ensures"}
+              ]
+            },
+            {
+              "id": "sub3_2",
+              "label": "2. Deployment & Monitoring",
+              "relationship": "Requires",
+              "subnodes": [
+                {"id": "sub3_2_1", "label": "2.1. API/Integration Development", "relationship": "for"},
+                {"id": "sub3_2_2", "label": "2.2. Continuous Monitoring", "relationship": "ensures"}
+              ]
+            }
+          ]
+        }
+      ]
+    }
+
+    Returns:
+        str: The filepath to the generated PNG image file.
+    """
+    try:
+        if not json_input.strip():
+            return "Error: Empty input"
+            
+        data = json.loads(json_input)
+        
+        if 'central_node' not in data or 'nodes' not in data:
+            raise ValueError("Missing required fields: central_node or nodes")
+
+        # 한글 폰트 설정
+        # GDFONTPATH가 설정되어 있으면 폰트 파일명(확장자 제외) 사용
+        korean_font = 'NanumGothic-Regular'
+
+        dot = graphviz.Digraph(
+            name='SynopticChart',
+            format='png',
+            graph_attr={
+                'rankdir': 'LR',        # Left-to-Right layout (horizontal hierarchy)
+                'splines': 'ortho',     # Straight lines
+                'bgcolor': 'white',     # White background
+                'pad': '0.5',           # Padding around the graph
+                'ranksep': '0.7',       # Reduced horizontal separation between ranks (columns)
+                'nodesep': '0.3',       # Adjusted vertical separation between nodes in the same rank
+                'fontname': korean_font,  # 그래프 전체 한글 폰트
+                'charset': 'UTF-8'      # UTF-8 인코딩
+            },
+            node_attr={
+                'fontname': korean_font  # 모든 노드의 기본 폰트
+            },
+            edge_attr={
+                'fontname': korean_font  # 모든 엣지의 기본 폰트
+            }
+        )
+        
+        base_color = '#19191a' 
+
+        dot.node(
+            'central',
+            data['central_node'],
+            shape='box',            # Rectangular shape
+            style='filled,rounded', # Filled and rounded corners
+            fillcolor=base_color,   # Darkest color
+            fontcolor='white',      # White text for dark background
+            fontsize='16',          # Larger font for central node
+            fontname=korean_font    # 한글 폰트 명시적 지정
+        )
+        
+        add_nodes_and_edges(dot, 'central', data.get('nodes', []), current_depth=1, base_color=base_color)
+
+        with NamedTemporaryFile(delete=False, suffix=f'.{output_format}') as tmp:
+            dot.render(tmp.name, format=output_format, cleanup=True)
+            return f"{tmp.name}.{output_format}"
+
+    except json.JSONDecodeError:
+        return "Error: Invalid JSON format"
+    except Exception as e:
+        return f"Error: {str(e)}"

wbs_diagram_generator.py

@@ -0,0 +1,286 @@
+import graphviz
+import json
+from tempfile import NamedTemporaryFile
+import os
+
+def generate_wbs_diagram(json_input: str, output_format: str) -> str:
+    """
+    Generates a Work Breakdown Structure (WBS) Diagram from JSON input.
+
+    Args:
+        json_input (str): A JSON string describing the WBS structure.
+                          It must follow the Expected JSON Format Example below.
+
+    Expected JSON Format Example:
+    {
+      "project_title": "AI Model Development Project",
+      "phases": [
+        {
+          "id": "phase_prep",
+          "label": "Preparation",
+          "tasks": [
+            {
+              "id": "task_1_1_vision",
+              "label": "Identify Vision",
+              "subtasks": [
+                {
+                  "id": "subtask_1_1_1_design_staff",
+                  "label": "Design & Staffing",
+                  "sub_subtasks": [
+                    {
+                      "id": "ss_task_1_1_1_1_env_setup",
+                      "label": "Environment Setup",
+                      "sub_sub_subtasks": [
+                        {
+                          "id": "sss_task_1_1_1_1_1_lib_install",
+                          "label": "Install Libraries",
+                          "final_level_tasks": [
+                            {"id": "ft_1_1_1_1_1_1_data_access", "label": "Grant Data Access"}
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "id": "phase_plan",
+          "label": "Planning",
+          "tasks": [
+            {
+              "id": "task_2_1_cost_analysis",
+              "label": "Cost Analysis",
+              "subtasks": [
+                {
+                  "id": "subtask_2_1_1_benefit_analysis",
+                  "label": "Benefit Analysis",
+                  "sub_subtasks": [
+                    {
+                      "id": "ss_task_2_1_1_1_risk_assess",
+                      "label": "AI Risk Assessment",
+                      "sub_sub_subtasks": [
+                        {
+                          "id": "sss_task_2_1_1_1_1_model_selection",
+                          "label": "Model Selection",
+                          "final_level_tasks": [
+                            {"id": "ft_2_1_1_1_1_1_data_strategy", "label": "Data Strategy"}
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "id": "phase_dev",
+          "label": "Development",
+          "tasks": [
+            {
+              "id": "task_3_1_change_mgmt",
+              "label": "Data Preprocessing",
+              "subtasks": [
+                {
+                  "id": "subtask_3_1_1_implementation",
+                  "label": "Feature Engineering",
+                  "sub_subtasks": [
+                    {
+                      "id": "ss_task_3_1_1_1_beta_testing",
+                      "label": "Model Training",
+                      "sub_sub_subtasks": [
+                        {
+                          "id": "sss_task_3_1_1_1_1_other_task",
+                          "label": "Model Evaluation",
+                          "final_level_tasks": [
+                            {"id": "ft_3_1_1_1_1_1_hyperparam_tune", "label": "Hyperparameter Tuning"}
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+
+    Returns:
+        str: The filepath to the generated PNG image file.
+    """
+    try:
+        if not json_input.strip():
+            return "Error: Empty input"
+            
+        data = json.loads(json_input)
+        
+        if 'project_title' not in data or 'phases' not in data:
+            raise ValueError("Missing required fields: project_title or phases")
+
+        # 한글 폰트 설정
+        # GDFONTPATH가 설정되어 있으면 폰트 파일명(확장자 제외) 사용
+        korean_font = 'NanumGothic-Regular'
+
+        dot = graphviz.Digraph(
+            name='WBSDiagram',
+            graph_attr={
+                'rankdir': 'TB',        # Top-to-Bottom hierarchy
+                'splines': 'polyline',  # polyline으로 변경 (ortho 대신)
+                'bgcolor': 'white',     # White background
+                'pad': '0.5',           # Padding
+                'ranksep': '0.6',       # Adjust vertical separation between ranks
+                'nodesep': '0.5',       # Adjust horizontal separation between nodes
+                'fontname': korean_font,  # 그래프 전체 한글 폰트
+                'charset': 'UTF-8'      # UTF-8 인코딩
+            },
+            node_attr={
+                'fontname': korean_font  # 모든 노드의 기본 폰트
+            },
+            edge_attr={
+                'fontname': korean_font  # 모든 엣지의 기본 폰트
+            }
+        )
+        
+        base_color = '#19191a' # Hardcoded base color
+        
+        # ID 정규화 함수 - 한글 ID를 안전한 형태로 변환
+        def normalize_id(id_str):
+            """노드 ID를 안전한 형태로 변환"""
+            import re
+            # 영문, 숫자, 언더스코어만 허용
+            safe_id = re.sub(r'[^a-zA-Z0-9_]', '_', str(id_str))
+            # 숫자로 시작하면 'n_' 접두사 추가
+            if safe_id and safe_id[0].isdigit():
+                safe_id = 'n_' + safe_id
+            # 빈 문자열이면 기본값
+            if not safe_id:
+                safe_id = 'node_' + str(hash(id_str))
+            return safe_id
+
+        # Project Title node (main node)
+        dot.node(
+            'project_root',
+            data['project_title'],
+            shape='box',
+            style='filled,rounded',
+            fillcolor=base_color,
+            fontcolor='white',
+            fontsize='18',
+            fontname=korean_font  # 한글 폰트 추가
+        )
+
+        # Helper for color and font based on depth for WBS
+        def get_gradient_color(depth, base_hex_color, lightening_factor=0.12):
+            base_r = int(base_hex_color[1:3], 16)
+            base_g = int(base_hex_color[3:5], 16)
+            base_b = int(base_hex_color[5:7], 16)
+
+            current_r = base_r + int((255 - base_r) * depth * lightening_factor)
+            current_g = base_g + int((255 - base_g) * depth * lightening_factor)
+            current_b = base_b + int((255 - base_b) * depth * lightening_factor)
+            
+            return f'#{min(255, current_r):02x}{min(255, current_g):02x}{min(255, current_b):02x}'
+
+        def get_font_color_for_background(depth, base_hex_color, lightening_factor=0.12):
+            base_r = int(base_hex_color[1:3], 16)
+            base_g = int(base_hex_color[3:5], 16)
+            base_b = int(base_hex_color[5:7], 16)
+            current_r = base_r + (255 - base_r) * depth * lightening_factor
+            current_g = base_g + (255 - base_g) * depth * lightening_factor
+            current_b = base_b + (255 - base_b) * depth * lightening_factor
+            
+            luminance = (0.2126 * current_r + 0.7152 * current_g + 0.0722 * current_b) / 255
+            return 'white' if luminance < 0.5 else 'black'
+
+        def _add_wbs_nodes_recursive(parent_id, current_level_tasks, current_depth):
+            for task_data in current_level_tasks:
+                task_id = task_data.get('id')
+                task_label = task_data.get('label')
+                
+                if not all([task_id, task_label]):
+                    raise ValueError(f"Invalid task data at depth {current_depth}: {task_data}")
+                
+                # ID 정규화
+                safe_task_id = normalize_id(task_id)
+
+                node_fill_color = get_gradient_color(current_depth, base_color)
+                node_font_color = get_font_color_for_background(current_depth, base_color)
+                font_size = max(9, 14 - (current_depth * 2))
+
+                dot.node(
+                    safe_task_id,
+                    task_label,
+                    shape='box',
+                    style='filled,rounded',
+                    fillcolor=node_fill_color,
+                    fontcolor=node_font_color,
+                    fontsize=str(font_size),
+                    fontname=korean_font  # 한글 폰트 추가
+                )
+                dot.edge(parent_id, safe_task_id, color='#4a4a4a', arrowhead='none', fontname=korean_font)
+
+                # Recursively call for next level of tasks (subtasks, sub_subtasks, etc.)
+                # This handles arbitrary nested keys like 'subtasks', 'sub_subtasks', 'final_level_tasks'
+                next_level_keys = ['tasks', 'subtasks', 'sub_subtasks', 'sub_sub_subtasks', 'final_level_tasks']
+                for key_idx, key in enumerate(next_level_keys):
+                    if key in task_data and isinstance(task_data[key], list):
+                        _add_wbs_nodes_recursive(safe_task_id, task_data[key], current_depth + 1)
+                        break # Only process the first found sub-level key
+
+        # Process phases (level 1 from project_root)
+        phase_depth = 1
+        for phase in data['phases']:
+            phase_id = phase.get('id')
+            phase_label = phase.get('label')
+            
+            if not all([phase_id, phase_label]):
+                raise ValueError(f"Invalid phase data: {phase}")
+            
+            # ID 정규화
+            safe_phase_id = normalize_id(phase_id)
+
+            phase_fill_color = get_gradient_color(phase_depth, base_color)
+            phase_font_color = get_font_color_for_background(phase_depth, base_color)
+            font_size_phase = max(9, 14 - (phase_depth * 2))
+
+            dot.node(
+                safe_phase_id,
+                phase_label,
+                shape='box',
+                style='filled,rounded',
+                fillcolor=phase_fill_color,
+                fontcolor=phase_font_color,
+                fontsize=str(font_size_phase),
+                fontname=korean_font  # 한글 폰트 추가
+            )
+            dot.edge('project_root', safe_phase_id, color='#4a4a4a', arrowhead='none', fontname=korean_font)
+
+            # Start recursion for tasks under this phase
+            if 'tasks' in phase and isinstance(phase['tasks'], list):
+                _add_wbs_nodes_recursive(safe_phase_id, phase['tasks'], phase_depth + 1)
+
+        # 렌더링
+        try:
+            with NamedTemporaryFile(delete=False, suffix='.gv', prefix='wbs_') as tmp:
+                # 파일 이름에서 .gv 확장자 제거
+                output_filename = tmp.name[:-3]  # '.gv' 제거
+                output_path = dot.render(output_filename, format=output_format, cleanup=True)
+                return output_path
+        except Exception as render_error:
+            # 렌더링 실패 시 간단한 에러 메시지
+            return f"Error: Failed to render diagram - {str(render_error).split(';')[0]}"
+
+    except json.JSONDecodeError as e:
+        return "Error: Invalid JSON format"
+    except Exception as e:
+        # 에러 메시지를 간단하게 유지
+        error_msg = str(e).split('\n')[0]  # 첫 줄만 사용
+        if len(error_msg) > 100:
+            error_msg = error_msg[:100] + "..."
+        return f"Error: {error_msg}"