Basic Chatbot 제거 및 ML Pipeline만 남김

- basic_chatbot_workflow.py 삭제
- app.py를 ML Pipeline 단일 인터페이스로 간소화
- TabbedInterface 제거하고 단일 ChatInterface로 변경
- README 업데이트 (Basic Chatbot 기능 설명 제거)

더 집중된 ML Pipeline 전용 애플리케이션

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

README.md

@@ -14,15 +14,6 @@ pinned: false
 A Gradio-based chat interface for LangGraph supervisor workflow with nested agent visualization and ML pipeline automation.
 
 ## Features
-
-### Basic Chatbot
-- 🤖 Multi-agent system with supervisor workflow
-- 🔍 Research agent with web search capabilities
-- 🧮 Math agent for calculations
-- 💬 Interactive chat interface with nested thoughts visualization
-- 🎨 Real-time streaming of agent execution steps
-
-### ML Pipeline Automation
 - 📊 Data extraction from RDB tables using SQL
 - 🔤 Language model pretraining with tokenization
 - 🎯 Classification model finetuning
@@ -79,8 +70,7 @@ To deploy on HuggingFace Spaces, set these secrets:
 
 ## Project Structure
 
-- `app.py` - Main application with tabbed interface
-- `basic_chatbot_workflow.py` - Basic chatbot supervisor workflow with research and math agents
+- `app.py` - Main Gradio application
 - `ml_pipeline_workflow.py` - ML pipeline supervisor workflow with 4 specialized agents
 - `pyproject.toml` - Project dependencies managed by uv
 - `.env` - Environment variables (not tracked in git)

app.py

@@ -2,8 +2,7 @@ import gradio as gr
 from gradio import ChatMessage
 from langchain_core.messages import BaseMessage, HumanMessage
 import time
-from basic_chatbot_workflow import app as basic_chatbot_workflow
-from ml_pipeline_workflow import ml_app as ml_pipeline_workflow
+from ml_pipeline_workflow import ml_app as workflow
 
 
 def format_namespace(namespace):
@@ -11,182 +10,6 @@ def format_namespace(namespace):
     return namespace[-1].split(":")[0] if len(namespace) > 0 else "root graph"
 
 
-def generate_response_basic_chatbot(message, history):
-    """Basic Chatbot 워크플로우에 대한 nested thought 응답 생성"""
-    inputs = {
-        "messages": [HumanMessage(content=message)],
-    }
-
-    response = []
-    message_id_counter = [0]  # Use list for mutable counter
-    agent_header_ids = {}  # Map agent names to their header message IDs
-    current_namespace = None  # Track current namespace to detect changes
-
-    for namespace, chunk in basic_chatbot_workflow.stream(
-        inputs,
-        stream_mode="updates",
-        subgraphs=True
-    ):
-        start_time = time.time()
-
-        for node_name, node_chunk in chunk.items():
-            formatted_namespace = format_namespace(namespace)
-
-            # Complete previous non-header message FIRST (before namespace change check)
-            if len(response) > 0 and response[-1].metadata.get("status") == "pending":
-                # Only complete if it's not an agent header
-                if response[-1].metadata.get("id") not in agent_header_ids.values():
-                    prev_msg = response[-1]
-                    prev_msg.metadata["status"] = "done"
-                    if "start_time" in prev_msg.metadata:
-                        prev_msg.metadata["duration"] = time.time() - prev_msg.metadata["start_time"]
-
-                    # Update parent agent header to show completion
-                    prev_parent_id = prev_msg.metadata.get("parent_id")
-                    if prev_parent_id:
-                        prev_title = prev_msg.metadata.get("title", "unknown")
-                        for msg in response:
-                            if msg.metadata.get("id") == prev_parent_id and msg.metadata.get("is_agent_header"):
-                                # Add completion log
-                                if not msg.content or "🔄" in msg.content:
-                                    msg.content = f"✓ {prev_title}"
-                                else:
-                                    msg.content += f"\n✓ {prev_title}"
-                                break
-
-                    yield response  # Yield to show completion
-
-            # If namespace changed, complete the previous agent header
-            if current_namespace and current_namespace != formatted_namespace:
-                if current_namespace in agent_header_ids:
-                    header_id = agent_header_ids[current_namespace]
-                    # Find and complete the agent header
-                    for msg in response:
-                        if msg.metadata.get("id") == header_id and msg.metadata.get("status") == "pending":
-                            msg.metadata["status"] = "done"
-                            if "start_time" in msg.metadata:
-                                msg.metadata["duration"] = time.time() - msg.metadata["start_time"]
-                            yield response
-                            break
-
-            current_namespace = formatted_namespace
-
-            # If this is a subgraph node, ensure parent header exists
-            parent_id = None
-            if formatted_namespace != "root graph":
-                # This node is inside an agent subgraph
-                if formatted_namespace not in agent_header_ids:
-                    # Create agent header message first
-                    message_id_counter[0] += 1
-                    header_id = message_id_counter[0]
-                    agent_header_ids[formatted_namespace] = header_id
-
-                    agent_emojis = {
-                        "supervisor": "👔",
-                        "research_expert": "🔍",
-                        "math_expert": "🔢"
-                    }
-                    emoji = agent_emojis.get(formatted_namespace, "🧠")
-
-                    header_message = ChatMessage(
-                        content="",
-                        metadata={
-                            "title": f"{emoji} {formatted_namespace}",
-                            "id": header_id,
-                            "status": "pending",
-                            "start_time": time.time(),
-                            "is_agent_header": True  # Mark as agent header
-                        }
-                    )
-                    response.append(header_message)
-                    yield response
-
-                parent_id = agent_header_ids[formatted_namespace]
-
-            # Create current node message
-            message_id_counter[0] += 1
-            current_id = message_id_counter[0]
-
-            # Create title
-            if formatted_namespace == "root graph":
-                if node_name == "supervisor":
-                    title = f"👔 {node_name}"
-                elif node_name in ["research_expert", "math_expert"]:
-                    # Skip - we'll handle these when we see their subgraph
-                    continue
-                else:
-                    title = f"🧠 {node_name}"
-            else:
-                # This is inside an agent
-                title = f"⚙️ {node_name}"
-
-            # Create node message
-            node_message = ChatMessage(
-                content="",
-                metadata={
-                    "title": title,
-                    "id": current_id,
-                    "status": "pending",
-                    "start_time": time.time()
-                }
-            )
-
-            if parent_id:
-                node_message.metadata["parent_id"] = parent_id
-
-            response.append(node_message)
-            yield response
-
-            # Process node content
-            out_str = []
-            if isinstance(node_chunk, dict):
-                for k, v in node_chunk.items():
-                    if isinstance(v, BaseMessage):
-                        out_str.append(v.pretty_repr())
-                    elif isinstance(v, list):
-                        for list_item in v:
-                            if isinstance(list_item, BaseMessage):
-                                out_str.append(list_item.pretty_repr())
-                            else:
-                                out_str.append(str(list_item))
-                    else:
-                        out_str.append(f"{k}:\n{v}")
-
-                response[-1].content = "\n".join(out_str)
-
-                # Update parent agent header with current activity
-                if parent_id:
-                    for msg in response:
-                        if msg.metadata.get("id") == parent_id and msg.metadata.get("is_agent_header"):
-                            # Update agent header content with summary of current activity
-                            activity_summary = f"🔄 Working on: {node_name}"
-                            if len(out_str) > 0:
-                                # Add a brief preview of the content
-                                preview = out_str[0][:100].replace('\n', ' ')
-                                activity_summary += f"\n📝 {preview}..."
-                            msg.content = activity_summary
-                            break
-
-                yield response
-
-            # Keep the node as pending - it will be completed when the next node starts
-            # Just yield to show current state
-            yield response
-
-    # Complete any remaining pending messages (both agent headers and sub nodes)
-    for msg in response:
-        if msg.metadata.get("status") == "pending":
-            msg.metadata["status"] = "done"
-            if "start_time" in msg.metadata:
-                msg.metadata["duration"] = time.time() - msg.metadata["start_time"]
-
-    # Add final response (without metadata so it displays as regular message)
-    if node_chunk and isinstance(node_chunk, dict) and 'messages' in node_chunk:
-        final_message = node_chunk['messages'][-1].content
-        response.append(ChatMessage(content=final_message))
-        yield response
-
-
 def handle_like(data: gr.LikeData):
     """Like/dislike 이벤트 핸들러"""
     if data.liked:
@@ -195,7 +18,7 @@ def handle_like(data: gr.LikeData):
         print(f"👎 Downvoted: {data.value}")
 
 
-def generate_response_ml_pipeline(message, history):
+def generate_response(message, history):
     """ML Pipeline 워크플로우에 대한 nested thought 응답 생성"""
     inputs = {
         "messages": [HumanMessage(content=message)],
@@ -206,7 +29,7 @@ def generate_response_ml_pipeline(message, history):
     agent_header_ids = {}  # Map agent names to their header message IDs
     current_namespace = None  # Track current namespace to detect changes
 
-    for namespace, chunk in ml_pipeline_workflow.stream(
+    for namespace, chunk in workflow.stream(
         inputs,
         stream_mode="updates",
         subgraphs=True
@@ -375,43 +198,20 @@ def generate_response_ml_pipeline(message, history):
         yield response
 
 
-# Create interfaces with Blocks for like functionality
-with gr.Blocks() as basic_chatbot_demo:
-    basic_chatbot = gr.Chatbot(
+# Create interface with Blocks for like functionality
+with gr.Blocks() as demo:
+    chatbot = gr.Chatbot(
         type="messages",
         show_copy_button=True,
         show_copy_all_button=True,
         show_share_button=True
     )
-    basic_chatbot.like(handle_like, None, None)
+    chatbot.like(handle_like, None, None)
 
     gr.ChatInterface(
-        generate_response_basic_chatbot,
+        generate_response,
         type="messages",
-        chatbot=basic_chatbot,
-        title="🤖 Multi-Agent Chatbot",
-        description="Research와 Math 에이전트가 협력하여 작업을 수행합니다. 각 에이전트의 사고 과정을 실시간으로 확인할 수 있습니다.",
-        examples=[
-            "2024년의 FAANG companies 총 근로자규모에 대한 분석을 한국어로 부탁해!",
-            "123과 456을 곱하고 그 결과에 789를 더해줘",
-            "구글의 직원 수를 찾아서 애플의 직원 수와 비교해줘"
-        ],
-        cache_examples=False
-    )
-
-with gr.Blocks() as ml_pipeline_demo:
-    ml_pipeline_chatbot = gr.Chatbot(
-        type="messages",
-        show_copy_button=True,
-        show_copy_all_button=True,
-        show_share_button=True
-    )
-    ml_pipeline_chatbot.like(handle_like, None, None)
-
-    gr.ChatInterface(
-        generate_response_ml_pipeline,
-        type="messages",
-        chatbot=ml_pipeline_chatbot,
+        chatbot=chatbot,
         title="🔬 ML Pipeline Automation",
         description="데이터 추출, 사전학습, 파인튜닝, 평가 단계를 거치는 완전한 ML 파이프라인입니다. 각 전문가 에이전트의 작업 과정을 단계별로 확인할 수 있습니다.",
         examples=[
@@ -433,12 +233,5 @@ with gr.Blocks() as ml_pipeline_demo:
         cache_examples=False
     )
 
-# Create tabbed interface
-demo = gr.TabbedInterface(
-    [ml_pipeline_demo, basic_chatbot_demo],
-    ["ML Pipeline", "Basic Chatbot"],
-    title="Multi-Agent Systems"
-)
-
 if __name__ == "__main__":
     demo.launch(ssr_mode=False)

basic_chatbot_workflow.py

@@ -1,57 +0,0 @@
-from dotenv import load_dotenv
-from langchain_openai import ChatOpenAI
-from langgraph_supervisor import create_supervisor
-from langgraph.prebuilt import create_react_agent
-
-# Load environment variables from .env file
-load_dotenv()
-
-model = ChatOpenAI(model="gpt-4o")
-
-# Create specialized agents
-
-def add(a: float, b: float) -> float:
-    """두 숫자를 더합니다."""
-    return a + b
-
-def multiply(a: float, b: float) -> float:
-    """두 숫자를 곱합니다."""
-    return a * b
-
-def web_search(query: str) -> str:
-    """웹에서 정보를 검색합니다."""
-    return (
-        "Here are the headcounts for each of the FAANG companies in 2024:\n"
-        "1. **Facebook (Meta)**: 67,317 employees.\n"
-        "2. **Apple**: 164,000 employees.\n"
-        "3. **Amazon**: 1,551,000 employees.\n"
-        "4. **Netflix**: 14,000 employees.\n"
-        "5. **Google (Alphabet)**: 181,269 employees."
-    )
-
-math_agent = create_react_agent(
-    model=model,
-    tools=[add, multiply],
-    name="math_expert",
-    prompt="당신은 수학 전문가입니다. 항상 한 번에 하나의 도구만 사용하세요."
-)
-
-research_agent = create_react_agent(
-    model=model,
-    tools=[web_search],
-    name="research_expert",
-    prompt="당신은 웹 검색 기능을 가진 세계적인 수준의 연구자입니다. 수학 계산은 하지 마세요."
-)
-
-workflow = create_supervisor(
-    [research_agent, math_agent],
-    model=model,
-    prompt=(
-        "당신은 연구 전문가와 수학 전문가를 관리하는 팀 감독자입니다. "
-        "최신 이슈나 정보 검색이 필요한 경우 research_agent를 사용하세요. "
-        "수학 문제는 math_agent를 사용하세요."
-    )
-)
-
-# Compile and run
-app = workflow.compile()