Update app.py

app.py

@@ -6,10 +6,32 @@ MOUSE Workflow - Visual Workflow Builder with UI Execution
 ✓ Auto-generate UI from workflow for end-user execution
 """
 
-import os, json, typing, tempfile
+import os, json, typing, tempfile, traceback
 import gradio as gr
 from gradio_workflowbuilder import WorkflowBuilder
 
+# Optional imports for LLM APIs
+try:
+    from openai import OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    print("OpenAI library not available. Install with: pip install openai")
+
+try:
+    import anthropic
+    ANTHROPIC_AVAILABLE = True
+except ImportError:
+    ANTHROPIC_AVAILABLE = False
+    print("Anthropic library not available. Install with: pip install anthropic")
+
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+    print("Requests library not available. Install with: pip install requests")
+
 # -------------------------------------------------------------------
 # 🛠️  헬퍼 함수들
 # -------------------------------------------------------------------
@@ -108,50 +130,172 @@ def create_sample_workflow():
         ]
     }
 
-# UI 실행을 위한 간단한 실행 함수
+# UI 실행을 위한 실제 워크플로우 실행 함수
 def execute_workflow_simple(workflow_data: dict, input_values: dict) -> dict:
-    """워크플로우 실행 시뮬레이션"""
+    """워크플로우 실제 실행"""
+    import traceback
+    
+    # API 키 확인
+    friendli_token = os.getenv("FRIENDLI_TOKEN")
+    openai_key = os.getenv("OPENAI_API_KEY")
+    anthropic_key = os.getenv("ANTHROPIC_API_KEY")
+    
+    # OpenAI 라이브러리 확인
+    try:
+        from openai import OpenAI
+        openai_available = True
+    except ImportError:
+        openai_available = False
+        print("OpenAI library not available")
+    
+    # Anthropic 라이브러리 확인
+    try:
+        import anthropic
+        anthropic_available = True
+    except ImportError:
+        anthropic_available = False
+        print("Anthropic library not available")
+    
     results = {}
+    nodes = workflow_data.get("nodes", [])
+    edges = workflow_data.get("edges", [])
     
-    # 입력 노드 처리
-    for node in workflow_data.get("nodes", []):
+    # 노드를 순서대로 처리
+    for node in nodes:
         node_id = node.get("id")
         node_type = node.get("type", "")
+        node_data = node.get("data", {})
         
-        if node_type in ["ChatInput", "textInput", "Input"]:
-            # UI에서 제공된 입력값 사용
-            if node_id in input_values:
-                results[node_id] = input_values[node_id]
-            else:
-                # 기본값 사용
-                template = node.get("data", {}).get("template", {})
-                default_value = template.get("input_value", {}).get("value", "")
-                results[node_id] = default_value
-        
-        elif node_type == "llmNode":
-            # LLM 처리 시뮬레이션
-            # 실제로는 여기서 API 호출을 하겠지만, 지금은 시뮬레이션
-            input_text = ""
+        try:
+            if node_type in ["ChatInput", "textInput", "Input"]:
+                # UI에서 제공된 입력값 사용
+                if node_id in input_values:
+                    results[node_id] = input_values[node_id]
+                else:
+                    # 기본값 사용
+                    template = node_data.get("template", {})
+                    default_value = template.get("input_value", {}).get("value", "")
+                    results[node_id] = default_value
             
-            # 연결된 입력 찾기
-            for edge in workflow_data.get("edges", []):
-                if edge.get("target") == node_id:
-                    source_id = edge.get("source")
-                    if source_id in results:
-                        input_text = results[source_id]
-                        break
+            elif node_type in ["llmNode", "OpenAIModel", "ChatModel"]:
+                # LLM 노드 처리
+                template = node_data.get("template", {})
+                
+                # 모델 정보 추출
+                model_info = template.get("model", {})
+                model = model_info.get("value", "gpt-3.5-turbo") if isinstance(model_info, dict) else "gpt-3.5-turbo"
+                
+                # 온도 정보 추출
+                temp_info = template.get("temperature", {})
+                temperature = temp_info.get("value", 0.7) if isinstance(temp_info, dict) else 0.7
+                
+                # 시스템 프롬프트 추출
+                prompt_info = template.get("system_prompt", {})
+                system_prompt = prompt_info.get("value", "") if isinstance(prompt_info, dict) else ""
+                
+                # 프로바이더 정보 추출
+                provider_info = template.get("provider", {})
+                provider = provider_info.get("value", "OpenAI") if isinstance(provider_info, dict) else "OpenAI"
+                
+                # 입력 텍스트 찾기
+                input_text = ""
+                for edge in edges:
+                    if edge.get("target") == node_id:
+                        source_id = edge.get("source")
+                        if source_id in results:
+                            input_text = results[source_id]
+                            break
+                
+                # 실제 API 호출
+                if provider == "OpenAI" and openai_key and openai_available:
+                    try:
+                        client = OpenAI(api_key=openai_key)
+                        
+                        messages = []
+                        if system_prompt:
+                            messages.append({"role": "system", "content": system_prompt})
+                        messages.append({"role": "user", "content": input_text})
+                        
+                        response = client.chat.completions.create(
+                            model=model,
+                            messages=messages,
+                            temperature=temperature,
+                            max_tokens=1000
+                        )
+                        
+                        results[node_id] = response.choices[0].message.content
+                        
+                    except Exception as e:
+                        results[node_id] = f"[OpenAI Error: {str(e)}]"
+                
+                elif provider == "Anthropic" and anthropic_key and anthropic_available:
+                    try:
+                        client = anthropic.Anthropic(api_key=anthropic_key)
+                        
+                        message = client.messages.create(
+                            model="claude-3-haiku-20240307",
+                            max_tokens=1000,
+                            temperature=temperature,
+                            system=system_prompt if system_prompt else None,
+                            messages=[{"role": "user", "content": input_text}]
+                        )
+                        
+                        results[node_id] = message.content[0].text
+                        
+                    except Exception as e:
+                        results[node_id] = f"[Anthropic Error: {str(e)}]"
+                
+                elif provider == "Friendly" and friendli_token:
+                    try:
+                        import requests
+                        
+                        headers = {
+                            "Authorization": f"Bearer {friendli_token}",
+                            "Content-Type": "application/json"
+                        }
+                        
+                        payload = {
+                            "model": "dep89a2fld32mcm",
+                            "messages": [
+                                {"role": "system", "content": system_prompt} if system_prompt else {"role": "system", "content": "You are a helpful assistant."},
+                                {"role": "user", "content": input_text}
+                            ],
+                            "max_tokens": 1000,
+                            "temperature": temperature
+                        }
+                        
+                        response = requests.post(
+                            "https://api.friendli.ai/dedicated/v1/chat/completions",
+                            headers=headers,
+                            json=payload,
+                            timeout=30
+                        )
+                        
+                        if response.status_code == 200:
+                            response_json = response.json()
+                            results[node_id] = response_json["choices"][0]["message"]["content"]
+                        else:
+                            results[node_id] = f"[Friendly API Error: {response.status_code}]"
+                            
+                    except Exception as e:
+                        results[node_id] = f"[Friendly Error: {str(e)}]"
+                
+                else:
+                    # API 키가 없는 경우 시뮬레이션
+                    results[node_id] = f"[Simulated AI Response to: {input_text[:50]}...]"
             
-            # 간단한 응답 생성
-            results[node_id] = f"[AI Response to: {input_text}]"
-        
-        elif node_type in ["ChatOutput", "textOutput", "Output"]:
-            # 출력 노드는 연결된 노드의 결과를 가져옴
-            for edge in workflow_data.get("edges", []):
-                if edge.get("target") == node_id:
-                    source_id = edge.get("source")
-                    if source_id in results:
-                        results[node_id] = results[source_id]
-                        break
+            elif node_type in ["ChatOutput", "textOutput", "Output"]:
+                # 출력 노드는 연결된 노드의 결과를 가져옴
+                for edge in edges:
+                    if edge.get("target") == node_id:
+                        source_id = edge.get("source")
+                        if source_id in results:
+                            results[node_id] = results[source_id]
+                            break
+                        
+        except Exception as e:
+            results[node_id] = f"[Node Error: {str(e)}]"
+            print(f"Error processing node {node_id}: {traceback.format_exc()}")
     
     return results
 
@@ -201,6 +345,22 @@ with gr.Blocks(title="🐭 MOUSE Workflow", theme=gr.themes.Soft(), css=CSS) as
             """
         )
         
+        # API Status Display
+        with gr.Accordion("🔌 API Status", open=False):
+            gr.Markdown(f"""
+            **Available APIs:**
+            - FRIENDLI_TOKEN: {'✅ Connected' if os.getenv("FRIENDLI_TOKEN") else '❌ Not found'}
+            - OPENAI_API_KEY: {'✅ Connected' if os.getenv("OPENAI_API_KEY") else '❌ Not found'}
+            - ANTHROPIC_API_KEY: {'✅ Connected' if os.getenv("ANTHROPIC_API_KEY") else '❌ Not found'}
+            
+            **Libraries:**
+            - OpenAI: {'✅ Installed' if OPENAI_AVAILABLE else '❌ Not installed'}
+            - Anthropic: {'✅ Installed' if ANTHROPIC_AVAILABLE else '❌ Not installed'}
+            - Requests: {'✅ Installed' if REQUESTS_AVAILABLE else '❌ Not installed'}
+            
+            *Note: Without API keys, the UI will simulate AI responses.*
+            """)
+        
         # State for storing workflow data
         loaded_data = gr.State(None)
         trigger_update = gr.State(False)
@@ -352,8 +512,25 @@ with gr.Blocks(title="🐭 MOUSE Workflow", theme=gr.themes.Soft(), css=CSS) as
                         if i < len(input_values):
                             inputs_dict[key] = input_values[i]
                     
-                    # Execute workflow
-                    log = f"Executing workflow with {len(inputs_dict)} inputs...\n"
+                    # Check API status
+                    log = "=== Workflow Execution Started ===\n"
+                    log += f"Inputs provided: {len(inputs_dict)}\n"
+                    
+                    # API 상태 확인
+                    friendli_token = os.getenv("FRIENDLI_TOKEN")
+                    openai_key = os.getenv("OPENAI_API_KEY")
+                    anthropic_key = os.getenv("ANTHROPIC_API_KEY")
+                    
+                    log += "\nAPI Status:\n"
+                    log += f"- FRIENDLI_TOKEN: {'✅ Found' if friendli_token else '❌ Not found'}\n"
+                    log += f"- OPENAI_API_KEY: {'✅ Found' if openai_key else '❌ Not found'}\n"
+                    log += f"- ANTHROPIC_API_KEY: {'✅ Found' if anthropic_key else '❌ Not found'}\n"
+                    
+                    if not friendli_token and not openai_key and not anthropic_key:
+                        log += "\n⚠️ No API keys found. Results will be simulated.\n"
+                        log += "To get real AI responses, set API keys in environment variables.\n"
+                    
+                    log += "\n--- Processing Nodes ---\n"
                     
                     try:
                         results = execute_workflow_simple(workflow_data, inputs_dict)
@@ -363,16 +540,20 @@ with gr.Blocks(title="🐭 MOUSE Workflow", theme=gr.themes.Soft(), css=CSS) as
                         for node_id in output_components.keys():
                             value = results.get(node_id, "No output")
                             output_values.append(value)
-                            log += f"Output {node_id}: {value}\n"
+                            
+                            # Log 길이 제한
+                            display_value = value[:100] + "..." if len(str(value)) > 100 else value
+                            log += f"\nOutput [{node_id}]: {display_value}\n"
                         
-                        log += "\n✅ Execution completed!"
+                        log += "\n=== Execution Completed Successfully! ===\n"
                         output_values.append(log)
                         
                         return output_values
                         
                     except Exception as e:
                         error_msg = f"❌ Error: {str(e)}"
-                        log += error_msg
+                        log += f"\n{error_msg}\n"
+                        log += "=== Execution Failed ===\n"
                         return [error_msg] * len(output_components) + [log]
                 
                 # Connect execution