app.py

import gradio as gr
from huggingface_hub import InferenceClient
import os
import pandas as pd
from typing import List, Dict, Tuple
import json
import io
import traceback
import csv
from openai import OpenAI
from functools import lru_cache
from concurrent.futures import ThreadPoolExecutor
import math

# CSS 설정
css = """
footer {
    visibility: hidden;
}
#chatbot-container, #chatbot-data-upload {
    height: 700px;
    overflow-y: scroll;
}
#chatbot-container .message, #chatbot-data-upload .message {
    font-size: 14px;
}
/* 입력창 배경색 및 글자색 변경 */
textarea, input[type="text"] {
    background-color: #ffffff;
    color: #000000;
}
/* 파일 업로드 영역 높이 조절 */
#parquet-upload-area {
    max-height: 150px;
    overflow-y: auto;
}
/* 초기 설명 글씨 크기 조절 */
#initial-description {
    font-size: 14px;
}
/* API Key 입력 섹션 스타일 */
.api-key-section {
    margin: 10px 0;
    padding: 10px;
    border: 1px solid #ddd;
    border-radius: 5px;
}
.api-key-status {
    margin-top: 5px;
    font-weight: bold;
}
"""

# 추론 API 클라이언트 설정
hf_client = InferenceClient(
    "CohereForAI/c4ai-command-r-plus-08-2024", token=os.getenv("HF_TOKEN")
)

def load_code(filename: str) -> str:
    try:
        with open(filename, 'r', encoding='utf-8') as file:
            return file.read()
    except FileNotFoundError:
        return f"{filename} 파일을 찾을 수 없습니다."
    except Exception as e:
        return f"파일을 읽는 중 오류가 발생했습니다: {str(e)}"

def load_parquet(filename: str) -> str:
    try:
        df = pd.read_parquet(filename, engine='pyarrow')
        return df.head(10).to_markdown(index=False)
    except FileNotFoundError:
        return f"{filename} 파일을 찾을 수 없습니다."
    except Exception as e:
        return f"파일을 읽는 중 오류가 발생했습니다: {str(e)}"

def clean_response(text: str) -> str:
    """응답 텍스트 정제 함수"""
    sentences = [s.strip() for s in text.split('.') if s.strip()]
    unique_sentences = []
    seen = set()
    
    for sentence in sentences:
        normalized = ' '.join(sentence.lower().split())
        if normalized not in seen:
            seen.add(normalized)
            unique_sentences.append(sentence)
    
    cleaned_text = '. '.join(unique_sentences)
    if cleaned_text and not cleaned_text.endswith('.'):
        cleaned_text += '.'
        
    return cleaned_text

def remove_duplicates(text: str) -> str:
    """중복 문장 제거 함수"""
    sentences = text.split('.')
    unique_sentences = []
    seen = set()
    
    for sentence in sentences:
        sentence = sentence.strip()
        if sentence and sentence not in seen:
            seen.add(sentence)
            unique_sentences.append(sentence)
    
    return '. '.join(unique_sentences)

def upload_csv(file_path: str) -> Tuple[str, str]:
    try:
        df = pd.read_csv(file_path, sep=',')
        required_columns = {'id', 'text', 'label', 'metadata'}
        available_columns = set(df.columns)
        missing_columns = required_columns - available_columns
        if missing_columns:
            return f"CSV 파일에 다음 필수 컬럼이 누락되었습니다: {', '.join(missing_columns)}", ""
        
        df.drop_duplicates(inplace=True)
        df.fillna('', inplace=True)
        df = df.astype({'id': 'int32', 'text': 'string', 'label': 'category', 'metadata': 'string'})
        
        parquet_filename = os.path.splitext(os.path.basename(file_path))[0] + '.parquet'
        df.to_parquet(parquet_filename, engine='pyarrow', compression='snappy')
        return f"{parquet_filename} 파일이 성공적으로 업로드되고 변환되었습니다.", parquet_filename
    except Exception as e:
        return f"CSV 파일 업로드 및 변환 중 오류가 발생했습니다: {str(e)}", ""

def upload_parquet(file_path: str) -> Tuple[str, str, str]:
    try:
        df = pd.read_parquet(file_path, engine='pyarrow')
        
        data_info = {
            "총 레코드 수": len(df),
            "컬럼 목록": list(df.columns),
            "데이터 타입": df.dtypes.to_dict(),
            "결측치 정보": df.isnull().sum().to_dict()
        }
        
        summary = []
        summary.append(f"### 데이터셋 기본 정보:")
        summary.append(f"- 총 레코드 수: {data_info['총 레코드 수']}")
        summary.append(f"- 컬럼 목록: {', '.join(data_info['컬럼 목록'])}")
        
        summary.append("\n### 컬럼별 정보:")
        for col in df.columns:
            if df[col].dtype in ['int64', 'float64']:
                stats = df[col].describe()
                summary.append(f"\n{col} (수치형):")
                summary.append(f"- 평균: {stats['mean']:.2f}")
                summary.append(f"- 최소: {stats['min']}")
                summary.append(f"- 최대: {stats['max']}")
            elif df[col].dtype == 'object' or df[col].dtype == 'string':
                unique_count = df[col].nunique()
                summary.append(f"\n{col} (텍스트):")
                summary.append(f"- 고유값 수: {unique_count}")
                if unique_count < 10:
                    value_counts = df[col].value_counts().head(5)
                    summary.append("- 상위 5개 값:")
                    for val, count in value_counts.items():
                        summary.append(f"  • {val}: {count}개")
        
        preview = df.head(10).to_markdown(index=False)
        summary.append("\n### 데이터 미리보기:")
        summary.append(preview)
        
        parquet_content = "\n".join(summary)
        parquet_json = df.to_json(orient='records', force_ascii=False)
        
        return "Parquet 파일이 성공적으로 업로드되었습니다.", parquet_content, parquet_json
    except Exception as e:
        return f"Parquet 파일 업로드 중 오류가 발생했습니다: {str(e)}", "", ""

def text_to_parquet(text: str) -> Tuple[str, str, str]:
    try:
        lines = [line.strip() for line in text.split('\n') if line.strip()]
        data = []
        
        for line in lines:
            try:
                import re
                pattern = r'(\d+),([^,]+),([^,]+),(.+)'
                match = re.match(pattern, line)
                
                if match:
                    id_val, text_val, label_val, metadata_val = match.groups()
                    text_val = text_val.strip().strip('"')
                    label_val = label_val.strip().strip('"')
                    metadata_val = metadata_val.strip().strip('"')
                    
                    data.append({
                        'id': int(id_val),
                        'text': text_val,
                        'label': label_val,
                        'metadata': metadata_val
                    })
            except Exception as e:
                print(f"라인 파싱 오류: {line}\n{str(e)}")
                continue
        
        if not data:
            return "변환할 데이터가 없습니다.", "", ""
        
        df = pd.DataFrame(data)
        df = df.astype({
            'id': 'int32',
            'text': 'string',
            'label': 'string',
            'metadata': 'string'
        })
        
        parquet_filename = 'text_to_parquet.parquet'
        df.to_parquet(parquet_filename, engine='pyarrow', compression='snappy')
        preview = df.to_markdown(index=False)
        
        return (
            f"{parquet_filename} 파일이 성공적으로 변환되었습니다. 총 {len(df)}개의 레코드가 처리되었습니다.", 
            preview, 
            parquet_filename
        )
        
    except Exception as e:
        error_message = f"텍스트 변환 중 오류가 발생했습니다: {str(e)}"
        print(f"{error_message}\n{traceback.format_exc()}")
        return error_message, "", ""

def respond(message: str, history: List[Dict[str, str]], system_message: str = "", max_tokens: int = 4000, temperature: float = 0.5, top_p: float = 0.9, parquet_data: str = None, api_key: str = None) -> str:
    if not api_key:
        yield "⚠️ API Key가 설정되지 않았습니다. 서비스 이용을 위해 API Key를 입력해주세요."
        return

    # OpenAI 클라이언트 초기화
    client = OpenAI(api_key=api_key)
    
    system_prefix = """반드시 한글로 답변할 것. 너는 업로드된 데이터를 기반으로 질문에 답변하는 역할을 한다.

주요 지침:
1. 질문과 직접 관련된 내용만 간단명료하게 답변할 것
2. 이전 답변과 중복되는 내용은 제외할 것
3. 불필요한 예시나 부연 설명은 하지 말 것
4. 동일한 내용을 다른 표현으로 반복하지 말 것
5. 핵심 정보만 전달할 것
"""

    if parquet_data:
        try:
            df = pd.read_json(io.StringIO(parquet_data))
            data_summary = df.describe(include='all').to_string()
            system_prefix += f"\n\n데이터 요약:\n{data_summary}"
        except Exception as e:
            print(f"데이터 로드 오류: {str(e)}")

    messages = [{"role": "system", "content": system_prefix}]
    recent_history = history[-3:] if history else []
    for chat in recent_history:
        messages.append({"role": chat["role"], "content": chat["content"]})
    
    messages.append({"role": "user", "content": message})

    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            max_tokens=max_tokens,
            temperature=temperature,
            top_p=top_p,
            stream=True
        )

        full_response = ""
        for chunk in response:
            if chunk.choices[0].delta.content:
                full_response += chunk.choices[0].delta.content
                yield clean_response(full_response)

    except Exception as e:
        error_message = f"응답 생성 중 오류 발생: {str(e)}"
        print(f"{error_message}\n{traceback.format_exc()}")
        yield error_message

def preprocess_text_with_llm(input_text: str, api_key: str = None) -> str:
    if not api_key:
        return "⚠️ API Key가 설정되지 않았습니다. 서비스 이용을 위해 API Key를 입력해주세요."

    # OpenAI 클라이언트 초기화
    client = OpenAI(api_key=api_key)
        
    system_prompt = """반드시 한글(한국어)로 답변하시오. 당신은 데이터 전처리 전문가입니다. 입력된 텍스트를 CSV 데이터셋 형식으로 변환하세요.

규칙:
1. 출력 형식: id,text,label,metadata
2. id: 1부터 시작하는 순차적 번호
3. text: 의미 있는 단위로 분리된 텍스트
4. label: 텍스트의 주제나 카테고리를 아래 기준으로 정확하게 한 개만 선택
   - Historical_Figure (역사적 인물)
   - Military_History (군사 역사)
   - Technology (기술)
   - Politics (정치)
   - Culture (문화)
5. metadata: 날짜, 출처 등 추가 정보"""

    try:
        response = client.chat.completions.create(
            model="gpt-4-0125-preview",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": input_text}
            ],
            max_tokens=4000,
            temperature=0.1,
            stream=True
        )

        full_response = ""
        for chunk in response:
            if chunk.choices[0].delta.content:
                full_response += chunk.choices[0].delta.content

        processed_text = clean_response(full_response)
        
        try:
            from io import StringIO
            import csv
            csv.reader(StringIO(processed_text))
            return processed_text
        except csv.Error:
            return "LLM이 올바른 CSV 형식을 생성하지 못했습니다. 다시 시도해주세요."
            
    except Exception as e:
        error_message = f"전처리 중 오류가 발생했습니다: {str(e)}"
        print(error_message)
        return error_message


# Gradio Blocks 인터페이스 설정
with gr.Blocks(css=css) as demo:
    api_key_state = gr.State("")  # API 키를 저장할 State 추가
    
    gr.Markdown("# MyEzRAG: LLM이 나만의 데이터로 학습한 콘텐츠 생성/답변", elem_id="initial-description")
    
    # API 키 입력 섹션 추가
    with gr.Row(elem_classes="api-key-section"):
        with gr.Column(scale=3):
            api_key_input = gr.Textbox(
                label="OpenAI API Key",
                placeholder="sk-...",
                type="password",
                show_label=True
            )
        with gr.Column(scale=1):
            api_key_button = gr.Button("API Key 설정", variant="primary")
    
    # API 키 상태 표시
    api_key_status = gr.Markdown("⚠️ API Key가 설정되지 않았습니다. 서비스 이용을 위해 API Key를 입력해주세요.", elem_classes="api-key-status")

    # API 키 설정 함수
    def set_api_key(api_key: str):
        if not api_key.strip():
            return "⚠️ API Key가 설정되지 않았습니다. 서비스 이용을 위해 API Key를 입력해주세요.", ""
        if not api_key.startswith("sk-"):
            return "❌ 올바르지 않은 API Key 형식입니다. 다시 확인해주세요.", ""
        return "✅ API Key가 성공적으로 설정되었습니다.", api_key

    # API 키 설정 이벤트 연결
    api_key_button.click(
        set_api_key,
        inputs=[api_key_input],
        outputs=[api_key_status, api_key_state]
    )

    gr.Markdown(
        "### '사용 방법' 탭을 통해 자세한 이용 방법을 참고하세요.\n"
        "### Tip) '예제'를 통해 다양한 활용 방법을 체험하고 응용해 보세요, 데이터셋 업로드시 미리보기는 10건만 출력",
        elem_id="initial-description"
    )

    # 첫 번째 탭: My 데이터셋+LLM
    with gr.Tab("My 데이터셋+LLM"):
        gr.Markdown("### LLM과 대화하기")
        chatbot_data_upload = gr.Chatbot(label="챗봇", type="messages", elem_id="chatbot-data-upload")
        msg_data_upload = gr.Textbox(label="메시지 입력", placeholder="여기에 메시지를 입력하세요...")
        send_data_upload = gr.Button("전송")

        with gr.Accordion("시스템 프롬프트 및 옵션 설정", open=False):
            system_message = gr.Textbox(label="System Message", value="너는 AI 조언자 역할이다.")
            max_tokens = gr.Slider(minimum=1, maximum=8000, value=1000, label="Max Tokens")
            temperature = gr.Slider(minimum=0, maximum=1, value=0.7, label="Temperature")
            top_p = gr.Slider(minimum=0, maximum=1, value=0.9, label="Top P")

        parquet_data_state = gr.State()

        def handle_message_data_upload(message: str, history: List[Dict[str, str]], system_message: str, max_tokens: int, temperature: float, top_p: float, parquet_data: str, api_key: str):
            if not api_key:
                history = history or []
                history.append({"role": "assistant", "content": "⚠️ API Key가 설정되지 않았습니다. 서비스 이용을 위해 API Key를 입력해주세요."})
                yield history, ""
                return

            history = history or []
            recent_questions = [chat['content'].strip().lower() for chat in history[-3:] if chat['role'] == 'user']
            if message.strip().lower() in recent_questions:
                yield history + [{"role": "assistant", "content": "동일한 질문이 최근에 있었습니다. 다른 질문을 해주세요."}], ""
                return
    
            try:
                history.append({"role": "user", "content": message})
                response_gen = respond(
                    message, 
                    history, 
                    system_message, 
                    max_tokens, 
                    temperature=0.3,
                    top_p=top_p, 
                    parquet_data=parquet_data,
                    api_key=api_key
                )
        
                partial_response = ""
                for partial in response_gen:
                    partial_response = partial
                    display_history = history + [{"role": "assistant", "content": partial_response}]
                    yield display_history, ""
            
                history.append({"role": "assistant", "content": partial_response})
            except Exception as e:
                response = f"오류 발생: {str(e)}"
                history.append({"role": "assistant", "content": response})
                yield history, ""

        send_data_upload.click(
            handle_message_data_upload,
            inputs=[
                msg_data_upload,
                chatbot_data_upload,
                system_message,
                max_tokens,
                temperature,
                top_p,
                parquet_data_state,
                api_key_state,
            ],
            outputs=[chatbot_data_upload, msg_data_upload],
            queue=True
        )

# 예제 추가
        with gr.Accordion("예제", open=False):
            gr.Examples(
                examples=[
                    ["업로드된 데이터셋에 대해 요약 설명하라."],
                    ["업로드된 데이터셋 파일을 학습 데이터로 활용하여, 본 서비스를 SEO 최적화하여 블로그 포스트(개요, 배경 및 필요성, 기존 유사 제품/서비스와 비교하여 특장점, 활용처, 가치, 기대효과, 결론을 포함)로 4000 토큰 이상 작성하라"],
                    ["업로드된 데이터셋 파일을 학습 데이터로 활용하여, 사용 방법과 차별점, 특징, 강점을 중심으로 4000 토큰 이상 유튜브 영상 스크립트 형태로 작성하라"],
                    ["업로드된 데이터셋 파일을 학습 데이터로 활용하여, 제품 상세 페이지 형식의 내용을 4000 토큰 이상 자세히 설명하라"],
                    ["업로드된 데이터셋 파일을 학습 데이터로 활용하여, FAQ 20건을 상세하게 작성하라. 4000토큰 이상 사용하라."],
                    ["업로드된 데이터셋 파일을 학습 데이터로 활용하여, 특허 출원에 활용할 기술 및 비즈니스 모델 측면을 포함하여 특허 출원서 구성에 맞게 혁신적인 창의 발명 내용을 중심으로 4000 토큰 이상 작성하라."],
                ],
                inputs=msg_data_upload,
                label="예제 선택",
            )

        # Parquet 파일 업로드
        gr.Markdown("### Parquet 파일 업로드")
        with gr.Row():
            with gr.Column():
                parquet_upload = gr.File(
                    label="Parquet 파일 업로드", type="filepath", elem_id="parquet-upload-area"
                )
                parquet_upload_button = gr.Button("업로드")
                parquet_upload_status = gr.Textbox(label="업로드 상태", interactive=False)
                parquet_preview_chat = gr.Markdown(label="Parquet 파일 미리보기")

                def handle_parquet_upload(file_path: str):
                    message, parquet_content, parquet_json = upload_parquet(file_path)
                    if parquet_json:
                        return message, parquet_content, parquet_json
                    else:
                        return message, "", ""

                parquet_upload_button.click(
                    handle_parquet_upload,
                    inputs=parquet_upload,
                    outputs=[parquet_upload_status, parquet_preview_chat, parquet_data_state]
                )

    # 두 번째 탭: CSV to My 데이터셋
    with gr.Tab("CSV to My 데이터셋"):
        gr.Markdown("### CSV 파일 업로드 및 Parquet 변환")
        with gr.Row():
            with gr.Column():
                csv_file = gr.File(label="CSV 파일 업로드", type="filepath")
                upload_button = gr.Button("업로드 및 변환")
                upload_status = gr.Textbox(label="업로드 상태", interactive=False)
                parquet_preview = gr.Markdown(label="Parquet 파일 미리보기")
                download_button = gr.File(label="Parquet 파일 다운로드", interactive=False)

                def handle_csv_upload(file_path: str):
                    message, parquet_filename = upload_csv(file_path)
                    if parquet_filename:
                        parquet_content = load_parquet(parquet_filename)
                        return message, parquet_content, parquet_filename
                    else:
                        return message, "", None

                upload_button.click(
                    handle_csv_upload,
                    inputs=csv_file,
                    outputs=[upload_status, parquet_preview, download_button]
                )

    # 세 번째 탭: Text to My 데이터셋
    with gr.Tab("Text to My 데이터셋"):
        gr.Markdown("### 텍스트를 입력하면 CSV로 변환 후 Parquet으로 자동 전환됩니다.")
        with gr.Row():
            with gr.Column():
                text_input = gr.Textbox(
                    label="텍스트 입력 (각 행은 `id,text,label,metadata` 형식으로 입력)",
                    lines=10,
                    placeholder='예: 1,"이순신","장군","거북선"\n2,"원균","장군","모함"\n3,"선조","왕","시기"\n4,"도요토미 히데요시","왕","침략"'
                )
                convert_button = gr.Button("변환 및 다운로드")
                convert_status = gr.Textbox(label="변환 상태", interactive=False)
                parquet_preview_convert = gr.Markdown(label="Parquet 파일 미리보기")
                download_parquet_convert = gr.File(label="Parquet 파일 다운로드", interactive=False)

                def handle_text_to_parquet(text: str):
                    message, parquet_content, parquet_filename = text_to_parquet(text)
                    if parquet_filename:
                        return message, parquet_content, parquet_filename
                    else:
                        return message, "", None

                convert_button.click(
                    handle_text_to_parquet,
                    inputs=text_input,
                    outputs=[convert_status, parquet_preview_convert, download_parquet_convert]
                )

    # 네 번째 탭: Text Preprocessing with LLM
    with gr.Tab("Text Preprocessing with LLM"):
        gr.Markdown("### 텍스트를 입력하면 LLM이 데이터셋 형식에 맞게 전처리하여 출력합니다.")
        with gr.Row():
            with gr.Column():
                raw_text_input = gr.Textbox(
                    label="텍스트 입력",
                    lines=15,
                    placeholder="여기에 전처리할 텍스트를 입력하세요..."
                )
                
                with gr.Row():
                    preprocess_button = gr.Button("전처리 실행", variant="primary")
                    clear_button = gr.Button("초기화")
    
                preprocess_status = gr.Textbox(
                    label="전처리 상태",
                    interactive=False,
                    value="대기 중..."
                )
                
                processed_text_output = gr.Textbox(
                    label="전처리된 데이터셋 출력",
                    lines=15,
                    interactive=False
                )
                
                convert_to_parquet_button = gr.Button("Parquet으로 변환")
                download_parquet = gr.File(label="변환된 Parquet 파일 다운로드")

                def handle_text_preprocessing(input_text: str, api_key: str):
                    if not api_key:
                        yield "⚠️ API Key가 설정되지 않았습니다.", ""
                        return
                    
                    if not input_text.strip():
                        yield "입력 텍스트가 없습니다.", ""
                        return
                    
                    try:
                        yield "전처리를 시작합니다...", ""
                        processed_text = preprocess_text_with_llm(input_text, api_key)
                        
                        if processed_text:
                            yield "전처리가 완료되었습니다.", processed_text
                        else:
                            yield "전처리 결과가 없습니다.", ""
                            
                    except Exception as e:
                        yield f"처리 중 오류가 발생했습니다: {str(e)}", ""

                def clear_inputs():
                    return "", "대기 중...", ""

                def convert_to_parquet_file(processed_text: str):
                    if not processed_text.strip():
                        return "변환할 텍스트가 없습니다.", None
                    
                    try:
                        message, parquet_content, parquet_filename = text_to_parquet(processed_text)
                        if parquet_filename:
                            return message, parquet_filename
                        return message, None
                    except Exception as e:
                        return f"Parquet 변환 중 오류 발생: {str(e)}", None

                preprocess_button.click(
                    handle_text_preprocessing,
                    inputs=[raw_text_input, api_key_state],
                    outputs=[preprocess_status, processed_text_output],
                    queue=True
                )

                clear_button.click(
                    clear_inputs,
                    outputs=[raw_text_input, preprocess_status, processed_text_output]
                )

                convert_to_parquet_button.click(
                    convert_to_parquet_file,
                    inputs=[processed_text_output],
                    outputs=[preprocess_status, download_parquet]
                )

                with gr.Accordion("예제 텍스트", open=False):
                    gr.Examples(
                        examples=[
                            ["이순신은 조선 중기의 무신이다. 그는 임진왜란 당시 해군을 이끌었다. 거북선을 만들어 왜군과 싸웠다."],
                            ["인공지능은 컴퓨터 과학의 한 분야이다. 기계학습은 인공지능의 하위 분야이다. 딥러닝은 기계학습의 한 방법이다."]
                        ],
                        inputs=raw_text_input,
                        label="예제 선택"
                    )

# 사용 방법 탭
    with gr.Tab("📚 사용 방법"):
        gr.Markdown("""
        # MyEzRAG 사용 가이드
        
        ## 🔑 API Key 설정
        1. OpenAI API Key를 상단 입력창에 입력
        2. 'API Key 설정' 버튼 클릭
        3. 설정 성공 메시지 확인
        
        ## 1️⃣ My 데이터셋+LLM 탭
        ### 기능
        - 업로드된 Parquet 데이터셋을 기반으로 LLM과 대화
        - 데이터셋의 내용을 활용한 콘텐츠 생성
        
        ### 사용 방법
        1. Parquet 파일 업로드 섹션에서 데이터셋 파일을 업로드
        2. 채팅창에 원하는 질문이나 요청사항 입력
        3. 예제 버튼을 활용하여 다양한 활용 사례 체험
        
        ### 팁
        - 시스템 프롬프트 설정으로 응답 스타일 조정 가능
        - 상세한 질문일수록 더 정확한 답변 제공
        
        ---
        
        ## 2️⃣ CSV to My 데이터셋 탭
        ### 기능
        - CSV 파일을 Parquet 형식으로 변환
        - 데이터 최적화 및 정제
        
        ### 사용 방법
        1. CSV 파일 준비 (필수 컬럼: id, text, label, metadata)
        2. 파일 업로드 후 '업로드 및 변환' 버튼 클릭
        3. 변환된 Parquet 파일 다운로드
        
        ### 주의사항
        - CSV 파일은 반드시 필수 컬럼을 포함해야 함
        - 인코딩은 UTF-8 권장
        
        ---
        
        ## 3️⃣ Text to My 데이터셋 탭
        ### 기능
        - 텍스트 형식의 데이터를 Parquet으로 변환
        - 수동 데이터 입력 지원
        
        ### 사용 방법
        1. 지정된 형식으로 텍스트 입력
        ```
        1,"이순신","장군","거북선"
        2,"원균","장군","모함"
        ```
        2. '변환 및 다운로드' 버튼 클릭
        3. 변환된 파일 확인 및 다운로드
        
        ### 입력 형식
        - id: 순차적 번호
        - text: 실제 텍스트 내용
        - label: 분류 라벨
        - metadata: 부가 정보
        
        ---
        
        ## 4️⃣ Text Preprocessing with LLM 탭
        ### 기능
        - LLM을 활용한 자동 텍스트 전처리
        - 구조화된 데이터셋 생성
        
        ### 사용 방법
        1. 원문 텍스트 입력
        2. '전처리 실행' 버튼 클릭
        3. 결과 확인 후 필요시 Parquet 변환
        
        ### 특징
        - 자동 레이블링
        - 문장 단위 분리
        - 중복 제거
        - 데이터 정규화
        
        ## 💡 일반적인 팁
        - API Key는 안전하게 보관하고 주기적으로 갱신
        - 각 탭의 예제를 참고하여 사용법 익히기
        - 데이터 품질이 좋을수록 더 나은 결과 제공
        - 오류 발생 시 입력 데이터 형식 확인
        - 대용량 처리 시 적절한 청크 크기로 분할 처리
        
        ## ⚠️ 주의사항
        - API Key를 타인과 공유하지 않기
        - 민감한 개인정보 포함하지 않기
        - 데이터 백업 권장
        - 네트워크 상태 확인
        - 브라우저 캐시 주기적 정리
        
        ## 🔍 문제 해결
        - API Key 오류: 키 형식 및 유효성 확인
        - 오류 발생 시 입력 데이터 형식 확인
        - 파일 업로드 실패 시 파일 크기 및 형식 확인
        - 변환 실패 시 데이터 인코딩 확인
        - 응답이 느릴 경우 데이터 크기 조정
        """)

    gr.Markdown("### [email protected]", elem_id="initial-description")

if __name__ == "__main__":
    demo.launch(share=True)