Add ML pipeline automation system with tabbed interface

- Create tabbed interface with Basic Chatbot and ML Pipeline tabs
- Add tab_basic_chatbot.py for existing multi-agent chatbot
- Add tab_ml_pipeline.py for ML pipeline automation
- Add ml_workflow.py with 4 specialized agents (Korean prompts):
- data_extraction_expert: SQL and RDB operations
- pretraining_expert: Data preparation and model pretraining
- finetuning_expert: Finetuning data creation and classification training
- evaluation_expert: Model evaluation with precision, recall, F1, accuracy
- Add tools.py with realistic ML pipeline tool functions:
- extract_events_from_rdb, prepare_pretraining_data
- pretrain_model, create_finetuning_data
- train_classification_model, evaluate_model
- Update README.md with new features and project structure
- Simplify app.py to use TabbedInterface

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

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

README.md

@@ -11,16 +11,25 @@ pinned: false
 
 # LangGraph UI
 
-A Gradio-based chat interface for LangGraph supervisor workflow with nested agent visualization.
+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
+- 📈 Comprehensive model evaluation (Precision, Recall, F1-score, Accuracy)
+- 🤝 4 specialized agents coordinated by supervisor
+- 🇰🇷 Korean language support
+
 ## Setup
 
 ### Local Development
@@ -55,8 +64,12 @@ To deploy on HuggingFace Spaces, you need to set the `OPENAI_API_KEY` as a secre
 
 ## Project Structure
 
-- `app.py` - Gradio chat interface
-- `graph.py` - LangGraph supervisor workflow and agents
+- `app.py` - Main application with tabbed interface
+- `tab_basic_chatbot.py` - Basic chatbot with research and math agents
+- `tab_ml_pipeline.py` - ML pipeline automation chatbot
+- `graph.py` - Basic LangGraph supervisor workflow
+- `ml_workflow.py` - ML pipeline supervisor workflow with 4 specialized agents
+- `tools.py` - ML pipeline tools (data extraction, pretraining, finetuning, evaluation)
 - `pyproject.toml` - Project dependencies managed by uv
 - `.env` - Environment variables (not tracked in git)
 

app.py

@@ -1,91 +1,12 @@
 import gradio as gr
-import time
-from gradio import ChatMessage
-from langchain_core.runnables import RunnableConfig
-from langchain_core.messages import BaseMessage, HumanMessage
-from pprint import pprint
-from graph import app as workflow
+from tab_basic_chatbot import demo as basic_chatbot
+from tab_ml_pipeline import demo as ml_pipeline
 
-def format_namespace(namespace):
-    return namespace[-1].split(":")[0] if len(namespace) > 0 else "root graph"
-
-def generate_response(message, history):
-    inputs = {
-            "messages": [HumanMessage(content=message)],
-        }
-    node_names = []
-    response = []
-    for namespace, chunk in workflow.stream(
-            inputs,
-            stream_mode="updates", subgraphs=True
-        ):
-        for node_name, node_chunk in chunk.items():
-            # node_names가 비어있지 않은 경우에만 필터링
-            if len(node_names) > 0 and node_name not in node_names:
-                continue
-
-        if len(response) > 0:
-            response[-1].metadata["status"] = "done"
-        # print("\n" + "=" * 50)
-        msg = []
-        formatted_namespace = format_namespace(namespace)
-        if formatted_namespace == "root graph":
-            print(f"🔄 Node: \033[1;36m{node_name}\033[0m 🔄")
-            meta_title = f"🤔 `{node_name}`"
-        else:
-            print(
-                f"🔄 Node: \033[1;36m{node_name}\033[0m in [\033[1;33m{formatted_namespace}\033[0m] 🔄"
-            )
-            meta_title = f"🤔 `{node_name}` in `{formatted_namespace}`"
-
-        response.append(ChatMessage(content="", metadata={"title": meta_title, "status": "pending"}))
-        yield response
-        print("- " * 25)
-
-        # 노드의 청크 데이터 출력
-        out_str = []
-        if isinstance(node_chunk, dict):
-            for k, v in node_chunk.items():
-                if isinstance(v, BaseMessage):
-                    v.pretty_print()
-                    out_str.append(v.pretty_repr())
-                elif isinstance(v, list):
-                    for list_item in v:
-                        if isinstance(list_item, BaseMessage):
-                            list_item.pretty_print()
-                            out_str.append(list_item.pretty_repr())
-                        else:
-                            out_str.append(list_item)
-                            print(list_item)
-                elif isinstance(v, dict):
-                    for node_chunk_key, node_chunk_value in node_chunk.items():
-                        out_str.append(f"{node_chunk_key}:\n{node_chunk_value}")
-                        print(f"{node_chunk_key}:\n{node_chunk_value}")
-                else:
-                    out_str.append(f"{k}:\n{v}")
-                    print(f"\033[1;32m{k}\033[0m:\n{v}")
-                response[-1].content = "\n".join(out_str)
-                yield response
-        else:
-            if node_chunk is not None:
-                for item in node_chunk:
-                    out_str.append(item)
-                    print(item)
-                response[-1].content = "\n".join(out_str)
-                yield response
-        yield response
-        print("=" * 50)
-    response[-1].metadata["status"] = "done"
-    response.append(ChatMessage(content=node_chunk['messages'][-1].content))
-    yield response
-
-demo = gr.ChatInterface(
-    generate_response,
-    type="messages",
-    title="Nested Thoughts Chat Interface",
-    examples=["2024년의 the FAANG companies 총 근로자규모에 대한 분석을 한국어로 부탁해!"],
-    cache_examples=False
+demo = gr.TabbedInterface(
+    [basic_chatbot, ml_pipeline],
+    ["Basic Chatbot", "ML Pipeline"],
+    title="Multi-Agent Systems"
 )
 
 if __name__ == "__main__":
-    demo.launch(ssr_mode=False)
+    demo.launch(ssr_mode=False)

ml_workflow.py

@@ -0,0 +1,87 @@
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from langgraph_supervisor import create_supervisor
+from langgraph.prebuilt import create_react_agent
+from tools import (
+    extract_events_from_rdb,
+    prepare_pretraining_data,
+    pretrain_model,
+    create_finetuning_data,
+    train_classification_model,
+    evaluate_model
+)
+
+load_dotenv()
+
+model = ChatOpenAI(model="gpt-4o")
+
+data_extraction_agent = create_react_agent(
+    model=model,
+    tools=[extract_events_from_rdb],
+    name="data_extraction_expert",
+    prompt=(
+        "당신은 SQL과 RDB 작업에 특화된 데이터 추출 전문가입니다. "
+        "데이터베이스 테이블에서 이벤트 레코드를 추출하고 텍스트 형식으로 변환하는 역할을 합니다. "
+        "테이블 이름, 날짜 범위, 이벤트 타입에 대한 명확한 정보를 제공해야 합니다. "
+        "레코드 수와 파일 크기를 포함한 추출 통계를 보고하세요."
+    )
+)
+
+pretraining_agent = create_react_agent(
+    model=model,
+    tools=[prepare_pretraining_data, pretrain_model],
+    name="pretraining_expert",
+    prompt=(
+        "당신은 언어모델 사전학습 전문가입니다. "
+        "토큰화된 데이터를 준비하고 모델을 처음부터 학습시키는 책임을 맡고 있습니다. "
+        "Loss와 Perplexity 같은 학습 지표를 모니터링하세요. "
+        "데이터 준비 및 모델 학습 진행 상황에 대한 자세한 통계를 보고하세요. "
+        "한 번에 하나의 도구만 사용하세요."
+    )
+)
+
+finetuning_agent = create_react_agent(
+    model=model,
+    tools=[create_finetuning_data, train_classification_model],
+    name="finetuning_expert",
+    prompt=(
+        "당신은 분류 작업에 특화된 파인튜닝 전문가입니다. "
+        "고품질의 파인튜닝 데이터셋을 만들고 분류 모델을 학습시키는 역할을 합니다. "
+        "적절한 데이터 분할과 클래스 분포를 보장하세요. "
+        "파인튜닝 과정 전반에 걸쳐 학습 및 검증 지표를 모니터링하세요. "
+        "한 번에 하나의 도구만 사용하세요."
+    )
+)
+
+evaluation_agent = create_react_agent(
+    model=model,
+    tools=[evaluate_model],
+    name="evaluation_expert",
+    prompt=(
+        "당신은 분류 지표에 특화된 모델 평가 전문가입니다. "
+        "Precision, Recall, F1-score, Accuracy를 사용하여 학습된 모델을 철저히 평가하는 역할을 합니다. "
+        "클래스별 세부 지표와 전체 성능 통계를 제공하세요. "
+        "Confusion matrix를 분석하고 개선이 필요한 영역을 파악하세요."
+    )
+)
+
+workflow = create_supervisor(
+    [data_extraction_agent, pretraining_agent, finetuning_agent, evaluation_agent],
+    model=model,
+    prompt=(
+        "당신은 완전한 모델 개발 워크플로우를 관리하는 ML 파이프라인 감독자입니다. "
+        "팀은 4명의 전문가로 구성되어 있습니다:\n\n"
+        "1. data_extraction_expert: SQL을 사용하여 RDB 테이블에서 이벤트 데이터를 추출합니다\n"
+        "2. pretraining_expert: 데이터를 준비하고 언어모델을 사전학습시킵니다\n"
+        "3. finetuning_expert: 파인튜닝 데이터를 생성하고 분류 모델을 학습시킵니다\n"
+        "4. evaluation_expert: Precision, Recall 등의 지표로 모델을 평가합니다\n\n"
+        "작업 순서:\n"
+        "1. data_extraction_expert를 사용하여 RDB에서 이벤트 데이터를 추출합니다\n"
+        "2. pretraining_expert를 사용하여 데이터를 준비하고 모델을 사전학습시킵니다\n"
+        "3. finetuning_expert를 사용하여 파인튜닝 데이터를 만들고 분류 모델을 학습시킵니다\n"
+        "4. evaluation_expert를 사용하여 최종 모델을 평가합니다\n\n"
+        "팀을 조율하여 전체 ML 파이프라인을 효율적으로 완료하세요."
+    )
+)
+
+ml_app = workflow.compile()

tab_basic_chatbot.py

@@ -0,0 +1,85 @@
+import gradio as gr
+from gradio import ChatMessage
+from langchain_core.messages import BaseMessage, HumanMessage
+from graph import app as workflow
+
+
+def format_namespace(namespace):
+    return namespace[-1].split(":")[0] if len(namespace) > 0 else "root graph"
+
+
+def generate_response(message, history):
+    inputs = {
+        "messages": [HumanMessage(content=message)],
+    }
+    node_names = []
+    response = []
+    for namespace, chunk in workflow.stream(
+        inputs,
+        stream_mode="updates", subgraphs=True
+    ):
+        for node_name, node_chunk in chunk.items():
+            if len(node_names) > 0 and node_name not in node_names:
+                continue
+
+        if len(response) > 0:
+            response[-1].metadata["status"] = "done"
+        msg = []
+        formatted_namespace = format_namespace(namespace)
+        if formatted_namespace == "root graph":
+            print(f"🔄 Node: \033[1;36m{node_name}\033[0m 🔄")
+            meta_title = f"🤔 `{node_name}`"
+        else:
+            print(
+                f"🔄 Node: \033[1;36m{node_name}\033[0m in [\033[1;33m{formatted_namespace}\033[0m] 🔄"
+            )
+            meta_title = f"🤔 `{node_name}` in `{formatted_namespace}`"
+
+        response.append(ChatMessage(content="", metadata={"title": meta_title, "status": "pending"}))
+        yield response
+        print("- " * 25)
+
+        out_str = []
+        if isinstance(node_chunk, dict):
+            for k, v in node_chunk.items():
+                if isinstance(v, BaseMessage):
+                    v.pretty_print()
+                    out_str.append(v.pretty_repr())
+                elif isinstance(v, list):
+                    for list_item in v:
+                        if isinstance(list_item, BaseMessage):
+                            list_item.pretty_print()
+                            out_str.append(list_item.pretty_repr())
+                        else:
+                            out_str.append(list_item)
+                            print(list_item)
+                elif isinstance(v, dict):
+                    for node_chunk_key, node_chunk_value in node_chunk.items():
+                        out_str.append(f"{node_chunk_key}:\n{node_chunk_value}")
+                        print(f"{node_chunk_key}:\n{node_chunk_value}")
+                else:
+                    out_str.append(f"{k}:\n{v}")
+                    print(f"\033[1;32m{k}\033[0m:\n{v}")
+                response[-1].content = "\n".join(out_str)
+                yield response
+        else:
+            if node_chunk is not None:
+                for item in node_chunk:
+                    out_str.append(item)
+                    print(item)
+                response[-1].content = "\n".join(out_str)
+                yield response
+        yield response
+        print("=" * 50)
+    response[-1].metadata["status"] = "done"
+    response.append(ChatMessage(content=node_chunk['messages'][-1].content))
+    yield response
+
+
+demo = gr.ChatInterface(
+    generate_response,
+    type="messages",
+    title="Basic Multi-Agent Chatbot",
+    examples=["2024년의 the FAANG companies 총 근로자규모에 대한 분석을 한국어로 부탁해!"],
+    cache_examples=False
+)

tab_ml_pipeline.py

@@ -0,0 +1,88 @@
+import gradio as gr
+from gradio import ChatMessage
+from langchain_core.messages import BaseMessage, HumanMessage
+from ml_workflow import ml_app as workflow
+
+
+def format_namespace(namespace):
+    return namespace[-1].split(":")[0] if len(namespace) > 0 else "root graph"
+
+
+def generate_response(message, history):
+    inputs = {
+        "messages": [HumanMessage(content=message)],
+    }
+    node_names = []
+    response = []
+    for namespace, chunk in workflow.stream(
+        inputs,
+        stream_mode="updates", subgraphs=True
+    ):
+        for node_name, node_chunk in chunk.items():
+            if len(node_names) > 0 and node_name not in node_names:
+                continue
+
+        if len(response) > 0:
+            response[-1].metadata["status"] = "done"
+        msg = []
+        formatted_namespace = format_namespace(namespace)
+        if formatted_namespace == "root graph":
+            print(f"🔄 Node: \033[1;36m{node_name}\033[0m 🔄")
+            meta_title = f"🤔 `{node_name}`"
+        else:
+            print(
+                f"🔄 Node: \033[1;36m{node_name}\033[0m in [\033[1;33m{formatted_namespace}\033[0m] 🔄"
+            )
+            meta_title = f"🤔 `{node_name}` in `{formatted_namespace}`"
+
+        response.append(ChatMessage(content="", metadata={"title": meta_title, "status": "pending"}))
+        yield response
+        print("- " * 25)
+
+        out_str = []
+        if isinstance(node_chunk, dict):
+            for k, v in node_chunk.items():
+                if isinstance(v, BaseMessage):
+                    v.pretty_print()
+                    out_str.append(v.pretty_repr())
+                elif isinstance(v, list):
+                    for list_item in v:
+                        if isinstance(list_item, BaseMessage):
+                            list_item.pretty_print()
+                            out_str.append(list_item.pretty_repr())
+                        else:
+                            out_str.append(list_item)
+                            print(list_item)
+                elif isinstance(v, dict):
+                    for node_chunk_key, node_chunk_value in node_chunk.items():
+                        out_str.append(f"{node_chunk_key}:\n{node_chunk_value}")
+                        print(f"{node_chunk_key}:\n{node_chunk_value}")
+                else:
+                    out_str.append(f"{k}:\n{v}")
+                    print(f"\033[1;32m{k}\033[0m:\n{v}")
+                response[-1].content = "\n".join(out_str)
+                yield response
+        else:
+            if node_chunk is not None:
+                for item in node_chunk:
+                    out_str.append(item)
+                    print(item)
+                response[-1].content = "\n".join(out_str)
+                yield response
+        yield response
+        print("=" * 50)
+    response[-1].metadata["status"] = "done"
+    response.append(ChatMessage(content=node_chunk['messages'][-1].content))
+    yield response
+
+
+demo = gr.ChatInterface(
+    generate_response,
+    type="messages",
+    title="ML Pipeline Automation System",
+    examples=[
+        "user_events 테이블에서 2024-01-01부터 2024-12-31까지 이벤트 데이터를 추출하고, 모델을 사전학습한 후 5개 클래스 분류 모델을 학습하고 평가해줘",
+        "Extract events from transaction_logs table for Q1 2024, pretrain a GPT2 model, create finetuning data for 3-class classification, and evaluate the results"
+    ],
+    cache_examples=False
+)

tools.py

@@ -0,0 +1,236 @@
+from typing import Dict, List, Any
+import time
+
+
+def extract_events_from_rdb(
+    table_name: str,
+    start_date: str,
+    end_date: str,
+    event_types: List[str] = None
+) -> Dict[str, Any]:
+    """
+    Extract event records from RDB table and convert to text format.
+
+    Args:
+        table_name: Name of the RDB table
+        start_date: Start date in YYYY-MM-DD format
+        end_date: End date in YYYY-MM-DD format
+        event_types: Optional list of event types to filter
+
+    Returns:
+        Dictionary containing extracted data statistics and file path
+    """
+    time.sleep(0.5)
+    return {
+        "status": "success",
+        "records_extracted": 125847,
+        "output_file": f"/data/events/{table_name}_{start_date}_{end_date}.txt",
+        "total_size_mb": 482.3,
+        "event_type_distribution": {
+            "user_action": 45230,
+            "system_event": 32145,
+            "error_log": 18472,
+            "transaction": 30000
+        },
+        "processing_time_seconds": 12.5
+    }
+
+
+def prepare_pretraining_data(
+    input_file: str,
+    tokenizer: str = "gpt2",
+    max_length: int = 512,
+    min_length: int = 50
+) -> Dict[str, Any]:
+    """
+    Prepare text data for pretraining by tokenization and formatting.
+
+    Args:
+        input_file: Path to input text file
+        tokenizer: Tokenizer to use
+        max_length: Maximum sequence length
+        min_length: Minimum sequence length
+
+    Returns:
+        Dictionary containing prepared data statistics
+    """
+    time.sleep(0.5)
+    return {
+        "status": "success",
+        "output_file": "/data/pretraining/tokenized_data.bin",
+        "total_sequences": 89234,
+        "total_tokens": 45623890,
+        "avg_sequence_length": 511.2,
+        "vocab_size": 50257,
+        "processing_time_seconds": 34.2
+    }
+
+
+def pretrain_model(
+    data_file: str,
+    model_architecture: str = "gpt2-small",
+    num_epochs: int = 3,
+    batch_size: int = 32,
+    learning_rate: float = 5e-5
+) -> Dict[str, Any]:
+    """
+    Pretrain language model on prepared data.
+
+    Args:
+        data_file: Path to tokenized data
+        model_architecture: Model architecture to use
+        num_epochs: Number of training epochs
+        batch_size: Batch size for training
+        learning_rate: Learning rate
+
+    Returns:
+        Dictionary containing training metrics and model path
+    """
+    time.sleep(0.5)
+    return {
+        "status": "success",
+        "model_path": "/models/pretrained/model_checkpoint_epoch3",
+        "final_loss": 2.341,
+        "perplexity": 10.39,
+        "training_time_hours": 4.5,
+        "total_steps": 8340,
+        "best_checkpoint": "checkpoint-7800",
+        "gpu_hours": 36.0,
+        "metrics": {
+            "epoch_1_loss": 3.245,
+            "epoch_2_loss": 2.789,
+            "epoch_3_loss": 2.341
+        }
+    }
+
+
+def create_finetuning_data(
+    source_data: str,
+    task_type: str = "classification",
+    num_classes: int = 5,
+    train_ratio: float = 0.8,
+    augmentation: bool = True
+) -> Dict[str, Any]:
+    """
+    Create finetuning dataset for classification task.
+
+    Args:
+        source_data: Path to source data
+        task_type: Type of task (classification, regression, etc.)
+        num_classes: Number of classification classes
+        train_ratio: Ratio of training data
+        augmentation: Whether to apply data augmentation
+
+    Returns:
+        Dictionary containing dataset statistics and file paths
+    """
+    time.sleep(0.5)
+    return {
+        "status": "success",
+        "train_file": "/data/finetuning/train.jsonl",
+        "val_file": "/data/finetuning/val.jsonl",
+        "test_file": "/data/finetuning/test.jsonl",
+        "train_samples": 12456,
+        "val_samples": 3114,
+        "test_samples": 3114,
+        "class_distribution": {
+            "class_0": 2489,
+            "class_1": 3201,
+            "class_2": 2845,
+            "class_3": 2134,
+            "class_4": 1787
+        },
+        "augmentation_applied": True,
+        "processing_time_seconds": 8.3
+    }
+
+
+def train_classification_model(
+    pretrained_model: str,
+    train_data: str,
+    val_data: str,
+    num_classes: int = 5,
+    num_epochs: int = 10,
+    batch_size: int = 16,
+    learning_rate: float = 2e-5
+) -> Dict[str, Any]:
+    """
+    Train classification model using finetuning data.
+
+    Args:
+        pretrained_model: Path to pretrained model
+        train_data: Path to training data
+        val_data: Path to validation data
+        num_classes: Number of classes
+        num_epochs: Number of training epochs
+        batch_size: Batch size
+        learning_rate: Learning rate
+
+    Returns:
+        Dictionary containing training results and model path
+    """
+    time.sleep(0.5)
+    return {
+        "status": "success",
+        "model_path": "/models/finetuned/classification_model",
+        "best_checkpoint": "checkpoint-epoch8",
+        "final_train_loss": 0.234,
+        "final_val_loss": 0.312,
+        "best_val_accuracy": 0.923,
+        "training_time_hours": 1.2,
+        "total_steps": 7785,
+        "early_stopping_epoch": 8,
+        "metrics_per_epoch": {
+            "epoch_1": {"train_loss": 0.892, "val_loss": 0.845, "val_acc": 0.712},
+            "epoch_5": {"train_loss": 0.345, "val_loss": 0.389, "val_acc": 0.887},
+            "epoch_8": {"train_loss": 0.234, "val_loss": 0.312, "val_acc": 0.923}
+        }
+    }
+
+
+def evaluate_model(
+    model_path: str,
+    test_data: str,
+    metrics: List[str] = None
+) -> Dict[str, Any]:
+    """
+    Evaluate trained model on test data with comprehensive metrics.
+
+    Args:
+        model_path: Path to trained model
+        test_data: Path to test data
+        metrics: List of metrics to compute
+
+    Returns:
+        Dictionary containing evaluation metrics
+    """
+    time.sleep(0.5)
+    if metrics is None:
+        metrics = ["precision", "recall", "f1", "accuracy"]
+
+    return {
+        "status": "success",
+        "test_samples": 3114,
+        "overall_accuracy": 0.918,
+        "macro_precision": 0.912,
+        "macro_recall": 0.908,
+        "macro_f1": 0.910,
+        "weighted_precision": 0.916,
+        "weighted_recall": 0.918,
+        "weighted_f1": 0.917,
+        "per_class_metrics": {
+            "class_0": {"precision": 0.935, "recall": 0.921, "f1": 0.928, "support": 623},
+            "class_1": {"precision": 0.948, "recall": 0.952, "f1": 0.950, "support": 640},
+            "class_2": {"precision": 0.899, "recall": 0.887, "f1": 0.893, "support": 569},
+            "class_3": {"precision": 0.887, "recall": 0.901, "f1": 0.894, "support": 427},
+            "class_4": {"precision": 0.891, "recall": 0.879, "f1": 0.885, "support": 357}
+        },
+        "confusion_matrix": [
+            [574, 12, 18, 10, 9],
+            [8, 609, 11, 7, 5],
+            [15, 9, 505, 28, 12],
+            [11, 8, 22, 385, 1],
+            [14, 6, 18, 5, 314]
+        ],
+        "inference_time_ms": 1247.5
+    }