app-in-apikey.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
# HuggingFace 클라이언트 대신 OpenAI 클라이언트 사용
from openai import OpenAI
import os

# 추론 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)}"


# OpenAI 클라이언트 설정
client = OpenAI(api_key=os.getenv("OPEN_AI"))

# respond 함수 수정
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) -> str:
    # 시스템 프롬프트 설정
    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:
        # OpenAI API 호출
        response = client.chat.completions.create(
            model="gpt-4o-mini",  # GPT-4-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
                # 응답 정제
                cleaned_response = clean_response(full_response)
                yield cleaned_response

    except Exception as e:
        error_message = f"추론 오류: {str(e)}"
        print(error_message)
        yield error_message

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:
        # CSV 파일 읽기
        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 파일로 변환
        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:
        # Parquet 파일 읽기
        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)
        
        # DataFrame을 JSON 문자열로 변환 (Q&A에서 사용)
        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 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) -> str:
    try:
        if parquet_data:
            # JSON 문자열을 DataFrame으로 변환
            df = pd.read_json(io.StringIO(parquet_data))
            
            # 데이터셋 컨텍스트 생성
            columns_info = []
            for col in df.columns:
                if df[col].dtype in ['int64', 'float64']:
                    col_type = "수치형"
                    stats = df[col].describe()
                    col_info = f"- {col} ({col_type}): 평균={stats['mean']:.2f}, 최소={stats['min']}, 최대={stats['max']}"
                else:
                    col_type = "텍스트"
                    unique_count = df[col].nunique()
                    col_info = f"- {col} ({col_type}): 고유값 {unique_count}개"
                columns_info.append(col_info)

            data_context = f"""
현재 업로드된 데이터셋 정보:
- 총 {len(df)} 개의 레코드
- 컬럼 정보:
{chr(10).join(columns_info)}

샘플 데이터:
{df.head(20).to_string()}
"""
            system_prompt = f"""당신은 업로드된 데이터셋을 분석하고 질문에 답변하는 AI 어시스턴트입니다.

주요 지침:
1. 반드시 한글로 답변할 것
2. 데이터셋의 실제 내용을 기반으로 정확하게 답변할 것
3. 데이터에 없는 내용은 추측하지 말 것
4. 답변은 간단명료하게 할 것
5. 데이터 프라이버시를 고려하여 답변할 것

데이터셋 구조 설명:
{chr(10).join(columns_info)}

참고할 데이터 샘플:
{data_context}
"""
        else:
            system_prompt = system_message or "너는 AI 조언자 역할이다."

        # OpenAI API 호출
        messages = [{"role": "system", "content": system_prompt}]
        
        # 최근 대화 기록 추가
        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})

        response = client.chat.completions.create(
            model="gpt-4-0125-preview",
            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 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:
                # 정규식을 사용하여 CSV 형식 파싱
                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 "변환할 데이터가 없습니다.", "", ""
        
        # DataFrame 생성
        df = pd.DataFrame(data)
        
        # 데이터 타입 설정
        df = df.astype({
            'id': 'int32',
            'text': 'string',
            'label': 'string',
            'metadata': 'string'
        })
        
        # Parquet 파일로 변환
        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, "", ""

# preprocess_text_with_llm 함수도 수정
def preprocess_text_with_llm(input_text: str) -> str:
    if not input_text.strip():
        return "입력 텍스트가 비어있습니다."
        
    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)
        
        # CSV 형식 검증
        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# preprocess_text_with_llm 함수도 수정
def preprocess_text_with_llm(input_text: str) -> str:
    if not input_text.strip():
        return "입력 텍스트가 비어있습니다."
        
    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-4o-mini",
            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)
        
        # CSV 형식 검증
        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

# 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;
}
"""

# Gradio Blocks 인터페이스 설정
with gr.Blocks(css=css) as demo:
    gr.Markdown("# MyEzRAG: LLM이 나만의 데이터로 학습한 콘텐츠 생성/답변", elem_id="initial-description")
    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):
            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,  # 낮은 temperature 사용
                    top_p=top_p, 
                    parquet_data=parquet_data
                )
        
                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,  # parquet_data_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]
                )

    # 세 번째 탭: 텍스트 to csv to parquet 변환 (탭 이름 변경: "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]
                )

    # 네번째 탭의 UI 부분 수정
    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
                )
                
                # Parquet 변환 및 다운로드 섹션
                convert_to_parquet_button = gr.Button("Parquet으로 변환")
                download_parquet = gr.File(label="변환된 Parquet 파일 다운로드")




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

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

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

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