Create app.py

app.py

@@ -0,0 +1,1119 @@
+# ──────────────────────────────── Imports ────────────────────────────────
+import os, json, re, logging, requests, markdown, time, io
+from datetime import datetime
+
+import streamlit as st
+from openai import OpenAI  # OpenAI 라이브러리
+
+from gradio_client import Client
+import pandas as pd
+import PyPDF2  # For handling PDF files
+
+# ──────────────────────────────── Environment Variables / Constants ─────────────────────────
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")  
+BRAVE_KEY      = os.getenv("SERPHOUSE_API_KEY", "")  # Keep this name
+BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
+BRAVE_IMAGE_ENDPOINT = "https://api.search.brave.com/res/v1/images/search"
+BRAVE_VIDEO_ENDPOINT = "https://api.search.brave.com/res/v1/videos/search"
+BRAVE_NEWS_ENDPOINT = "https://api.search.brave.com/res/v1/news/search"
+IMAGE_API_URL  = "http://211.233.58.201:7896"
+MAX_TOKENS     = 7999
+
+# Search modes and style definitions (in English)
+SEARCH_MODES = {
+    "comprehensive": "Comprehensive answer with multiple sources",
+    "academic": "Academic and research-focused results",
+    "news": "Latest news and current events",
+    "technical": "Technical and specialized information",
+    "educational": "Educational and learning resources"
+}
+
+RESPONSE_STYLES = {
+    "professional": "Professional and formal tone",
+    "casual": "Friendly and conversational tone",
+    "simple": "Simple and easy to understand",
+    "detailed": "Detailed and thorough explanations"
+}
+
+# Example search queries
+EXAMPLE_QUERIES = {
+    "example1": "What are the latest developments in quantum computing?",
+    "example2": "How does climate change affect biodiversity in tropical rainforests?",
+    "example3": "What are the economic implications of artificial intelligence in the job market?"
+}
+
+# ──────────────────────────────── Logging ────────────────────────────────
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s - %(levelname)s - %(message)s")
+
+# ──────────────────────────────── OpenAI Client ──────────────────────────
+
+# OpenAI 클라이언트에 타임아웃과 재시도 로직 추가
+@st.cache_resource
+def get_openai_client():
+    """Create an OpenAI client with timeout and retry settings."""
+    if not OPENAI_API_KEY:
+        raise RuntimeError("⚠️ OPENAI_API_KEY 환경 변수가 설정되지 않았습니다.")
+    return OpenAI(
+        api_key=OPENAI_API_KEY,
+        timeout=60.0,  # 타임아웃 60초로 설정
+        max_retries=3  # 재시도 횟수 3회로 설정
+    )
+    
+# ──────────────────────────────── System Prompt ─────────────────────────
+def get_system_prompt(mode="comprehensive", style="professional", include_search_results=True, include_uploaded_files=False) -> str:
+    """
+    Generate a system prompt for the perplexity-like interface based on:
+    - The selected search mode and style
+    - Guidelines for using web search results and uploaded files
+    """
+
+    # Base prompt for comprehensive mode
+    comprehensive_prompt = """
+You are an advanced AI assistant that provides comprehensive answers with multiple sources, similar to Perplexity.
+
+Your task is to:
+1. Thoroughly analyze the user's query
+2. Provide a clear, well-structured answer integrating information from multiple sources
+3. Include relevant images, videos, and links in your response
+4. Format your answer with proper headings, bullet points, and sections
+5. Cite sources inline and provide a references section at the end
+
+Important guidelines:
+- Organize information logically with clear section headings
+- Use bullet points and numbered lists for clarity
+- Include specific, factual information whenever possible
+- Provide balanced perspectives on controversial topics
+- Display relevant statistics, data, or quotes when appropriate
+- Format your response using markdown for readability
+"""
+
+    # Alternative modes
+    mode_prompts = {
+        "academic": """
+Your focus is on providing academic and research-focused responses:
+- Prioritize peer-reviewed research and academic sources
+- Include citations in a formal academic format
+- Discuss methodologies and research limitations where relevant
+- Present different scholarly perspectives on the topic
+- Use precise, technical language appropriate for an academic audience
+""",
+        "news": """
+Your focus is on providing the latest news and current events:
+- Prioritize recent news articles and current information
+- Include publication dates for all news sources
+- Present multiple perspectives from different news outlets
+- Distinguish between facts and opinions/editorial content
+- Update information with the most recent developments
+""",
+        "technical": """
+Your focus is on providing technical and specialized information:
+- Use precise technical terminology appropriate to the field
+- Include code snippets, formulas, or technical diagrams where relevant
+- Break down complex concepts into step-by-step explanations
+- Reference technical documentation, standards, and best practices
+- Consider different technical approaches or methodologies
+""",
+        "educational": """
+Your focus is on providing educational and learning resources:
+- Structure information in a learning-friendly progression
+- Include examples, analogies, and visual explanations
+- Highlight key concepts and definitions
+- Suggest further learning resources at different difficulty levels
+- Present information that's accessible to learners at various levels
+"""
+    }
+
+    # Response styles
+    style_guides = {
+        "professional": "Use a professional, authoritative voice. Clearly explain technical terms and present data systematically.",
+        "casual": "Use a relaxed, conversational style with a friendly tone. Include relatable examples and occasionally use informal expressions.",
+        "simple": "Use straightforward language and avoid jargon. Keep sentences and paragraphs short. Explain concepts as if to someone with no background in the subject.",
+        "detailed": "Provide thorough explanations with comprehensive background information. Explore nuances and edge cases. Present multiple perspectives and detailed analysis."
+    }
+
+    # Guidelines for using search results
+    search_guide = """
+Guidelines for Using Search Results:
+- Include source links directly in your response using markdown: [Source Name](URL)
+- For each major claim or piece of information, indicate its source
+- If sources conflict, explain the different perspectives and their reliability
+- Include 3-5 relevant images by writing: ![Image description](image_url)
+- Include 1-2 relevant video links when appropriate by writing: [Video: Title](video_url)
+- Format search information into a cohesive, well-structured response
+- Include a "References" section at the end listing all major sources with links
+"""
+
+    # Guidelines for using uploaded files
+    upload_guide = """
+Guidelines for Using Uploaded Files:
+- Treat the uploaded files as primary sources for your response
+- Extract and highlight key information from files that directly addresses the query
+- Quote relevant passages and cite the specific file
+- For numerical data in CSV files, consider creating summary statements
+- For PDF content, reference specific sections or pages
+- Integrate file information seamlessly with web search results
+- When information conflicts, prioritize file content over general web results
+"""
+
+    # Choose base prompt based on mode
+    if mode == "comprehensive":
+        final_prompt = comprehensive_prompt
+    else:
+        final_prompt = comprehensive_prompt + "\n" + mode_prompts.get(mode, "")
+
+    # Add style guide
+    if style in style_guides:
+        final_prompt += f"\n\nTone and Style: {style_guides[style]}"
+
+    # Add search results guidance
+    if include_search_results:
+        final_prompt += f"\n\n{search_guide}"
+
+    # Add uploaded files guidance
+    if include_uploaded_files:
+        final_prompt += f"\n\n{upload_guide}"
+
+    # Additional formatting instructions
+    final_prompt += """
+\n\nAdditional Formatting Requirements:
+- Use markdown headings (## and ###) to organize your response 
+- Use bold text (**text**) for emphasis on important points
+- Include a "Related Questions" section at the end with 3-5 follow-up questions
+- Format your response with proper spacing and paragraph breaks
+- Make all links clickable by using proper markdown format: [text](url)
+"""
+
+    return final_prompt
+
+# ──────────────────────────────── Brave Search API ────────────────────────
+@st.cache_data(ttl=3600)
+def brave_search(query: str, count: int = 20):
+    """
+    Call the Brave Web Search API → list[dict]
+    Returns fields: index, title, link, snippet, displayed_link
+    """
+    if not BRAVE_KEY:
+        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")
+
+    headers = {
+        "Accept": "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": BRAVE_KEY
+    }
+    params = {"q": query, "count": str(count)}
+
+    for attempt in range(3):
+        try:
+            r = requests.get(BRAVE_ENDPOINT, headers=headers, params=params, timeout=15)
+            r.raise_for_status()
+            data = r.json()
+
+            logging.info(f"Brave search result data structure: {list(data.keys())}")
+
+            raw = data.get("web", {}).get("results") or data.get("results", [])
+            if not raw:
+                logging.warning(f"No Brave search results found. Response: {data}")
+                raise ValueError("No search results found.")
+            
+            arts = []
+            for i, res in enumerate(raw[:count], 1):
+                url = res.get("url", res.get("link", ""))
+                host = re.sub(r"https?://(www\.)?", "", url).split("/")[0]
+                arts.append({
+                    "index": i,
+                    "title": res.get("title", "No title"),
+                    "link": url,
+                    "snippet": res.get("description", res.get("text", "No snippet")),
+                    "displayed_link": host
+                })
+
+            logging.info(f"Brave search success: {len(arts)} results")
+            return arts
+
+        except Exception as e:
+            logging.error(f"Brave search failure (attempt {attempt+1}/3): {e}")
+            if attempt < 2:
+                time.sleep(2)
+
+    return []
+
+@st.cache_data(ttl=3600)
+def brave_image_search(query: str, count: int = 10):
+    """
+    Call the Brave Image Search API → list[dict]
+    Returns fields: index, title, image_url, source_url
+    """
+    if not BRAVE_KEY:
+        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")
+
+    headers = {
+        "Accept": "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": BRAVE_KEY
+    }
+    params = {
+        "q": query, 
+        "count": str(count),
+        "search_lang": "en",
+        "country": "us",
+        "spellcheck": "1"
+    }
+
+    for attempt in range(3):
+        try:
+            r = requests.get(BRAVE_IMAGE_ENDPOINT, headers=headers, params=params, timeout=15)
+            r.raise_for_status()
+            data = r.json()
+
+            results = []
+            for i, img in enumerate(data.get("results", [])[:count], 1):
+                results.append({
+                    "index": i,
+                    "title": img.get("title", "Image"),
+                    "image_url": img.get("image", {}).get("url", ""),
+                    "source_url": img.get("source", ""),
+                    "width": img.get("image", {}).get("width", 0),
+                    "height": img.get("image", {}).get("height", 0)
+                })
+
+            logging.info(f"Brave image search success: {len(results)} results")
+            return results
+
+        except Exception as e:
+            logging.error(f"Brave image search failure (attempt {attempt+1}/3): {e}")
+            if attempt < 2:
+                time.sleep(2)
+
+    return []
+
+@st.cache_data(ttl=3600)
+def brave_video_search(query: str, count: int = 5):
+    """
+    Call the Brave Video Search API → list[dict]
+    Returns fields: index, title, video_url, thumbnail_url, source
+    """
+    if not BRAVE_KEY:
+        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")
+
+    headers = {
+        "Accept": "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": BRAVE_KEY
+    }
+    params = {
+        "q": query, 
+        "count": str(count)
+    }
+
+    for attempt in range(3):
+        try:
+            r = requests.get(BRAVE_VIDEO_ENDPOINT, headers=headers, params=params, timeout=15)
+            r.raise_for_status()
+            data = r.json()
+
+            results = []
+            for i, vid in enumerate(data.get("results", [])[:count], 1):
+                results.append({
+                    "index": i,
+                    "title": vid.get("title", "Video"),
+                    "video_url": vid.get("url", ""),
+                    "thumbnail_url": vid.get("thumbnail", {}).get("src", ""),
+                    "source": vid.get("provider", {}).get("name", "Unknown source")
+                })
+
+            logging.info(f"Brave video search success: {len(results)} results")
+            return results
+
+        except Exception as e:
+            logging.error(f"Brave video search failure (attempt {attempt+1}/3): {e}")
+            if attempt < 2:
+                time.sleep(2)
+
+    return []
+
+@st.cache_data(ttl=3600)
+def brave_news_search(query: str, count: int = 5):
+    """
+    Call the Brave News Search API → list[dict]
+    Returns fields: index, title, url, description, source, date
+    """
+    if not BRAVE_KEY:
+        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")
+
+    headers = {
+        "Accept": "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": BRAVE_KEY
+    }
+    params = {
+        "q": query, 
+        "count": str(count)
+    }
+
+    for attempt in range(3):
+        try:
+            r = requests.get(BRAVE_NEWS_ENDPOINT, headers=headers, params=params, timeout=15)
+            r.raise_for_status()
+            data = r.json()
+
+            results = []
+            for i, news in enumerate(data.get("results", [])[:count], 1):
+                results.append({
+                    "index": i,
+                    "title": news.get("title", "News article"),
+                    "url": news.get("url", ""),
+                    "description": news.get("description", ""),
+                    "source": news.get("source", "Unknown source"),
+                    "date": news.get("age", "Unknown date")
+                })
+
+            logging.info(f"Brave news search success: {len(results)} results")
+            return results
+
+        except Exception as e:
+            logging.error(f"Brave news search failure (attempt {attempt+1}/3): {e}")
+            if attempt < 2:
+                time.sleep(2)
+
+    return []
+
+def mock_results(query: str) -> str:
+    """Fallback search results if API fails"""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    return (f"# Fallback Search Content (Generated: {ts})\n\n"
+            f"The search API request failed. Please generate a response based on any pre-existing knowledge about '{query}'.\n\n"
+            f"You may consider the following points:\n\n"
+            f"- Basic concepts and importance of {query}\n"
+            f"- Commonly known related statistics or trends\n"
+            f"- Typical expert opinions on this subject\n"
+            f"- Questions that readers might have\n\n"
+            f"Note: This is fallback guidance, not real-time data.\n\n")
+
+def do_web_search(query: str) -> str:
+    """Perform web search and format the results."""
+    try:
+        # Web search
+        arts = brave_search(query, 20)
+        if not arts:
+            logging.warning("No search results, using fallback content")
+            return mock_results(query)
+
+        # Image search
+        images = brave_image_search(query, 5)
+        
+        # Video search
+        videos = brave_video_search(query, 2)
+        
+        # News search
+        news = brave_news_search(query, 3)
+        
+        # Format all results
+        result = "# Web Search Results\nUse these results to provide a comprehensive answer with multiple sources. Include relevant images, videos, and links.\n\n"
+        
+        # Add web results
+        result += "## Web Results\n\n"
+        for a in arts[:10]:  # Limit to top 10 results
+            result += f"### Result {a['index']}: {a['title']}\n\n{a['snippet']}\n\n"
+            result += f"**Source**: [{a['displayed_link']}]({a['link']})\n\n---\n"
+        
+        # Add image results if available
+        if images:
+            result += "## Image Results\n\n"
+            for img in images:
+                if img.get('image_url'):
+                    result += f"![{img['title']}]({img['image_url']})\n\n"
+                    result += f"**Source**: [{img.get('source_url', 'Image source')}]({img.get('source_url', '#')})\n\n"
+        
+        # Add video results if available
+        if videos:
+            result += "## Video Results\n\n"
+            for vid in videos:
+                result += f"### {vid['title']}\n\n"
+                if vid.get('thumbnail_url'):
+                    result += f"![Thumbnail]({vid['thumbnail_url']})\n\n"
+                result += f"**Watch**: [{vid['source']}]({vid['video_url']})\n\n"
+        
+        # Add news results if available
+        if news:
+            result += "## News Results\n\n"
+            for n in news:
+                result += f"### {n['title']}\n\n{n['description']}\n\n"
+                result += f"**Source**: [{n['source']}]({n['url']}) - {n['date']}\n\n---\n"
+        
+        return result
+        
+    except Exception as e:
+        logging.error(f"Web search process failed: {str(e)}")
+        return mock_results(query)
+
+# ──────────────────────────────── File Upload Handling ─────────────────────
+def process_text_file(file):
+    """Handle text file"""
+    try:
+        content = file.read()
+        file.seek(0)
+
+        text = content.decode('utf-8', errors='ignore')
+        if len(text) > 10000:
+            text = text[:9700] + "...(truncated)..."
+
+        result = f"## Text File: {file.name}\n\n"
+        result += text
+        return result
+    except Exception as e:
+        logging.error(f"Error processing text file: {str(e)}")
+        return f"Error processing text file: {str(e)}"
+
+def process_csv_file(file):
+    """Handle CSV file"""
+    try:
+        content = file.read()
+        file.seek(0)
+
+        df = pd.read_csv(io.BytesIO(content))
+        result = f"## CSV File: {file.name}\n\n"
+        result += f"- Rows: {len(df)}\n"
+        result += f"- Columns: {len(df.columns)}\n"
+        result += f"- Column Names: {', '.join(df.columns.tolist())}\n\n"
+
+        result += "### Data Preview\n\n"
+        preview_df = df.head(10)
+        try:
+            markdown_table = preview_df.to_markdown(index=False)
+            if markdown_table:
+                result += markdown_table + "\n\n"
+            else:
+                result += "Unable to display CSV data.\n\n"
+        except Exception as e:
+            logging.error(f"Markdown table conversion error: {e}")
+            result += "Displaying data as text:\n\n"
+            result += str(preview_df) + "\n\n"
+
+        num_cols = df.select_dtypes(include=['number']).columns
+        if len(num_cols) > 0:
+            result += "### Basic Statistical Information\n\n"
+            try:
+                stats_df = df[num_cols].describe().round(2)
+                stats_markdown = stats_df.to_markdown()
+                if stats_markdown:
+                    result += stats_markdown + "\n\n"
+                else:
+                    result += "Unable to display statistical information.\n\n"
+            except Exception as e:
+                logging.error(f"Statistical info conversion error: {e}")
+                result += "Unable to generate statistical information.\n\n"
+
+        return result
+    except Exception as e:
+        logging.error(f"CSV file processing error: {str(e)}")
+        return f"Error processing CSV file: {str(e)}"
+
+def process_pdf_file(file):
+    """Handle PDF file"""
+    try:
+        # Read file in bytes
+        file_bytes = file.read()
+        file.seek(0)
+
+        # Use PyPDF2
+        pdf_file = io.BytesIO(file_bytes)
+        reader = PyPDF2.PdfReader(pdf_file, strict=False)
+
+        # Basic info
+        result = f"## PDF File: {file.name}\n\n"
+        result += f"- Total pages: {len(reader.pages)}\n\n"
+
+        # Extract text by page (limit to first 5 pages)
+        max_pages = min(5, len(reader.pages))
+        all_text = ""
+
+        for i in range(max_pages):
+            try:
+                page = reader.pages[i]
+                page_text = page.extract_text()
+
+                current_page_text = f"### Page {i+1}\n\n"
+                if page_text and len(page_text.strip()) > 0:
+                    # Limit to 1500 characters per page
+                    if len(page_text) > 1500:
+                        current_page_text += page_text[:1500] + "...(truncated)...\n\n"
+                    else:
+                        current_page_text += page_text + "\n\n"
+                else:
+                    current_page_text += "(No text could be extracted from this page)\n\n"
+
+                all_text += current_page_text
+
+                # If total text is too long, break
+                if len(all_text) > 8000:
+                    all_text += "...(truncating remaining pages; PDF is too large)...\n\n"
+                    break
+
+            except Exception as page_err:
+                logging.error(f"Error processing PDF page {i+1}: {str(page_err)}")
+                all_text += f"### Page {i+1}\n\n(Error extracting content: {str(page_err)})\n\n"
+
+        if len(reader.pages) > max_pages:
+            all_text += f"\nNote: Only the first {max_pages} pages are shown out of {len(reader.pages)} total.\n\n"
+
+        result += "### PDF Content\n\n" + all_text
+        return result
+
+    except Exception as e:
+        logging.error(f"PDF file processing error: {str(e)}")
+        return f"## PDF File: {file.name}\n\nError occurred: {str(e)}\n\nThis PDF file cannot be processed."
+
+def process_uploaded_files(files):
+    """Combine the contents of all uploaded files into one string."""
+    if not files:
+        return None
+
+    result = "# Uploaded File Contents\n\n"
+    result += "Below is the content from the files provided by the user. Integrate this data as a main source of information for your response.\n\n"
+
+    for file in files:
+        try:
+            ext = file.name.split('.')[-1].lower()
+            if ext == 'txt':
+                result += process_text_file(file) + "\n\n---\n\n"
+            elif ext == 'csv':
+                result += process_csv_file(file) + "\n\n---\n\n"
+            elif ext == 'pdf':
+                result += process_pdf_file(file) + "\n\n---\n\n"
+            else:
+                result += f"### Unsupported File: {file.name}\n\n---\n\n"
+        except Exception as e:
+            logging.error(f"File processing error {file.name}: {e}")
+            result += f"### File processing error: {file.name}\n\nError: {e}\n\n---\n\n"
+
+    return result
+
+# ──────────────────────────────── Image & Utility ─────────────────────────
+def extract_image_urls_from_search(image_results):
+    """Extract valid image URLs from Brave image search results."""
+    if not image_results:
+        return []
+    
+    valid_urls = []
+    for img in image_results:
+        url = img.get('image_url')
+        if url and url.startswith('http'):
+            valid_urls.append({
+                'url': url,
+                'title': img.get('title', 'Image'),
+                'source': img.get('source_url', '')
+            })
+    
+    return valid_urls
+
+def extract_video_data_from_search(video_results):
+    """Extract valid video data from Brave video search results."""
+    if not video_results:
+        return []
+    
+    valid_videos = []
+    for vid in video_results:
+        url = vid.get('video_url')
+        if url and url.startswith('http'):
+            valid_videos.append({
+                'url': url,
+                'title': vid.get('title', 'Video'),
+                'thumbnail': vid.get('thumbnail_url', ''),
+                'source': vid.get('source', 'Video source')
+            })
+    
+    return valid_videos
+
+def generate_image(prompt, w=768, h=768, g=3.5, steps=30, seed=3):
+    """Image generation function."""
+    if not prompt:
+        return None, "Insufficient prompt"
+    try:
+        res = Client(IMAGE_API_URL).predict(
+            prompt=prompt, width=w, height=h, guidance=g,
+            inference_steps=steps, seed=seed,
+            do_img2img=False, init_image=None,
+            image2image_strength=0.8, resize_img=True,
+            api_name="/generate_image"
+        )
+        return res[0], f"Seed: {res[1]}"
+    except Exception as e:
+        logging.error(e)
+        return None, str(e)
+
+def extract_image_prompt(response_text: str, topic: str):
+    """
+    Generate a single-line English image prompt from the response content.
+    """
+    client = get_openai_client()
+    
+    try:
+        response = client.chat.completions.create(
+            model="gpt-4.1-mini",
+            messages=[
+                {"role": "system", "content": "Generate a single-line English image prompt from the following text. Return only the prompt text, nothing else."},
+                {"role": "user", "content": f"Topic: {topic}\n\n---\n{response_text}\n\n---"}
+            ],
+            temperature=1,
+            max_tokens=80,
+            top_p=1
+        )
+        
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        logging.error(f"OpenAI image prompt generation error: {e}")
+        return f"A professional photo related to {topic}, high quality"
+
+def md_to_html(md: str, title="Perplexity-like Response"):
+    """Convert Markdown to HTML."""
+    return f"<!DOCTYPE html><html><head><title>{title}</title><meta charset='utf-8'></head><body>{markdown.markdown(md)}</body></html>"
+
+def keywords(text: str, top=5):
+    """Simple keyword extraction."""
+    cleaned = re.sub(r"[^가-힣a-zA-Z0-9\s]", "", text)
+    return " ".join(cleaned.split()[:top])
+
+# ──────────────────────────────── Streamlit UI ────────────────────────────
+def perplexity_app():
+    st.title("Perplexity-like AI Assistant")
+
+    # Set default session state
+    if "ai_model" not in st.session_state:
+        st.session_state.ai_model = "gpt-4.1-mini"  # 고정 모델 설정
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    if "auto_save" not in st.session_state:
+        st.session_state.auto_save = True
+    if "generate_image" not in st.session_state:
+        st.session_state.generate_image = False
+    if "web_search_enabled" not in st.session_state:
+        st.session_state.web_search_enabled = True
+    if "search_mode" not in st.session_state:
+        st.session_state.search_mode = "comprehensive"
+    if "response_style" not in st.session_state:
+        st.session_state.response_style = "professional"
+
+    # Sidebar UI
+    sb = st.sidebar
+    sb.title("Search Settings")
+    
+    sb.subheader("Response Configuration")
+    sb.selectbox(
+        "Search Mode", 
+        options=list(SEARCH_MODES.keys()), 
+        format_func=lambda x: SEARCH_MODES[x],
+        key="search_mode"
+    )
+    
+    sb.selectbox(
+        "Response Style",
+        options=list(RESPONSE_STYLES.keys()),
+        format_func=lambda x: RESPONSE_STYLES[x],
+        key="response_style"
+    )
+    
+    # Example queries
+    sb.subheader("Example Queries")
+    c1, c2, c3 = sb.columns(3)
+    if c1.button("Quantum Computing", key="ex1"):
+        process_example(EXAMPLE_QUERIES["example1"])
+    if c2.button("Climate Change", key="ex2"):
+        process_example(EXAMPLE_QUERIES["example2"])
+    if c3.button("AI Economics", key="ex3"):
+        process_example(EXAMPLE_QUERIES["example3"])
+    
+    sb.subheader("Other Settings")
+    sb.toggle("Auto Save", key="auto_save")
+    sb.toggle("Auto Image Generation", key="generate_image")
+    
+    web_search_enabled = sb.toggle("Use Web Search", value=st.session_state.web_search_enabled)
+    st.session_state.web_search_enabled = web_search_enabled
+    
+    if web_search_enabled:
+        st.sidebar.info("✅ Web search results will be integrated into the response.")
+
+    # Download the latest response
+    latest_response = next(
+        (m["content"] for m in reversed(st.session_state.messages) 
+         if m["role"] == "assistant" and m["content"].strip()), 
+        None
+    )
+    if latest_response:
+        # Extract a title from the response - first heading or first line
+        title_match = re.search(r"# (.*?)(\n|$)", latest_response)
+        if title_match:
+            title = title_match.group(1).strip()
+        else:
+            first_line = latest_response.split('\n', 1)[0].strip()
+            title = first_line[:40] + "..." if len(first_line) > 40 else first_line
+        
+        sb.subheader("Download Latest Response")
+        d1, d2 = sb.columns(2)
+        d1.download_button("Download as Markdown", latest_response, 
+                           file_name=f"{title}.md", mime="text/markdown")
+        d2.download_button("Download as HTML", md_to_html(latest_response, title),
+                           file_name=f"{title}.html", mime="text/html")
+
+    # JSON conversation record upload
+    up = sb.file_uploader("Load Conversation History (.json)", type=["json"], key="json_uploader")
+    if up:
+        try:
+            st.session_state.messages = json.load(up)
+            sb.success("Conversation history loaded successfully")
+        except Exception as e:
+            sb.error(f"Failed to load: {e}")
+
+    # JSON conversation record download
+    if sb.button("Download Conversation as JSON"):
+        sb.download_button(
+            "Save",
+            data=json.dumps(st.session_state.messages, ensure_ascii=False, indent=2),
+            file_name="conversation_history.json",
+            mime="application/json"
+        )
+
+    # File Upload
+    st.subheader("Upload Files")
+    uploaded_files = st.file_uploader(
+        "Upload files to be used as reference (txt, csv, pdf)",
+        type=["txt", "csv", "pdf"],
+        accept_multiple_files=True,
+        key="file_uploader"
+    )
+    
+    if uploaded_files:
+        file_count = len(uploaded_files)
+        st.success(f"{file_count} files uploaded. They will be used as sources for your query.")
+        
+        with st.expander("Preview Uploaded Files", expanded=False):
+            for idx, file in enumerate(uploaded_files):
+                st.write(f"**File Name:** {file.name}")
+                ext = file.name.split('.')[-1].lower()
+                
+                if ext == 'txt':
+                    preview = file.read(1000).decode('utf-8', errors='ignore')
+                    file.seek(0)
+                    st.text_area(
+                        f"Preview of {file.name}",
+                        preview + ("..." if len(preview) >= 1000 else ""),
+                        height=150
+                    )
+                elif ext == 'csv':
+                    try:
+                        df = pd.read_csv(file)
+                        file.seek(0)
+                        st.write("CSV Preview (up to 5 rows)")
+                        st.dataframe(df.head(5))
+                    except Exception as e:
+                        st.error(f"CSV preview failed: {e}")
+                elif ext == 'pdf':
+                    try:
+                        file_bytes = file.read()
+                        file.seek(0)
+                        
+                        pdf_file = io.BytesIO(file_bytes)
+                        reader = PyPDF2.PdfReader(pdf_file, strict=False)
+                        
+                        pc = len(reader.pages)
+                        st.write(f"PDF File: {pc} pages")
+                        
+                        if pc > 0:
+                            try:
+                                page_text = reader.pages[0].extract_text()
+                                preview = page_text[:500] if page_text else "(No text extracted)"
+                                st.text_area("Preview of the first page", preview + "...", height=150)
+                            except:
+                                st.warning("Failed to extract text from the first page")
+                    except Exception as e:
+                        st.error(f"PDF preview failed: {e}")
+
+                if idx < file_count - 1:
+                    st.divider()
+
+    # Display existing messages
+    for m in st.session_state.messages:
+        with st.chat_message(m["role"]):
+            # Process markdown to allow clickable links and properly rendered content
+            st.markdown(m["content"], unsafe_allow_html=True)
+            
+            # Display images if present
+            if "images" in m and m["images"]:
+                st.subheader("Related Images")
+                cols = st.columns(min(3, len(m["images"])))
+                for i, img_data in enumerate(m["images"]):
+                    col_idx = i % len(cols)
+                    with cols[col_idx]:
+                        try:
+                            img_url = img_data.get('url', '')
+                            caption = img_data.get('title', 'Related image')
+                            if img_url:
+                                st.image(img_url, caption=caption, use_column_width=True)
+                                if img_data.get('source'):
+                                    st.markdown(f"[Source]({img_data['source']})")
+                        except Exception as img_err:
+                            st.warning(f"Could not display image: {img_err}")
+            
+            # Display videos if present
+            if "videos" in m and m["videos"]:
+                st.subheader("Related Videos")
+                for video in m["videos"]:
+                    video_title = video.get('title', 'Related video')
+                    video_url = video.get('url', '')
+                    thumbnail = video.get('thumbnail', '')
+                    
+                    # Display video information with thumbnail if available
+                    if thumbnail:
+                        col1, col2 = st.columns([1, 3])
+                        with col1:
+                            try:
+                                st.image(thumbnail, width=120)
+                            except:
+                                st.write("🎬")
+                        with col2:
+                            st.markdown(f"**[{video_title}]({video_url})**")
+                            st.write(f"Source: {video.get('source', 'Unknown')}")
+                    else:
+                        st.markdown(f"🎬 **[{video_title}]({video_url})**")
+                        st.write(f"Source: {video.get('source', 'Unknown')}")
+
+    # User input
+    query = st.chat_input("Enter your query or question here.")
+    if query:
+        process_input(query, uploaded_files)
+
+    # 사이드바 하단 배지(링크) 추가
+    sb.markdown("---")
+    sb.markdown("Created by [https://ginigen.com](https://ginigen.com) | [YouTube Channel](https://www.youtube.com/@ginipickaistudio)")
+
+def process_example(topic):
+    """Process the selected example query."""
+    process_input(topic, [])
+
+def process_input(query: str, uploaded_files):
+    # Add user's message
+    if not any(m["role"] == "user" and m["content"] == query for m in st.session_state.messages):
+        st.session_state.messages.append({"role": "user", "content": query})
+
+    with st.chat_message("user"):
+        st.markdown(query)
+    
+    with st.chat_message("assistant"):
+        placeholder = st.empty()
+        message_placeholder = st.empty()
+        full_response = ""
+
+        use_web_search = st.session_state.web_search_enabled
+        has_uploaded_files = bool(uploaded_files) and len(uploaded_files) > 0
+        
+        try:
+            # 상태 표시를 위한 상태 컴포넌트
+            status = st.status("Preparing to answer your query...")
+            status.update(label="Initializing client...")
+            
+            client = get_openai_client()
+            
+            # Web search
+            search_content = None
+            image_results = []
+            video_results = []
+            news_results = []
+            
+            if use_web_search:
+                status.update(label="Performing web search...")
+                with st.spinner("Searching the web..."):
+                    search_content = do_web_search(keywords(query, top=5))
+                
+                # Perform specific searches for media
+                try:
+                    status.update(label="Finding images and videos...")
+                    image_results = brave_image_search(query, 5)
+                    video_results = brave_video_search(query, 2)
+                    news_results = brave_news_search(query, 3)
+                except Exception as search_err:
+                    logging.error(f"Media search error: {search_err}")
+            
+            # Process uploaded files → content
+            file_content = None
+            if has_uploaded_files:
+                status.update(label="Processing uploaded files...")
+                with st.spinner("Analyzing files..."):
+                    file_content = process_uploaded_files(uploaded_files)
+            
+            # Extract usable image and video data
+            valid_images = extract_image_urls_from_search(image_results)
+            valid_videos = extract_video_data_from_search(video_results)
+            
+            # Build system prompt
+            status.update(label="Preparing comprehensive answer...")
+            sys_prompt = get_system_prompt(
+                mode=st.session_state.search_mode,
+                style=st.session_state.response_style,
+                include_search_results=use_web_search,
+                include_uploaded_files=has_uploaded_files
+            )
+
+            # OpenAI API 호출 준비
+            status.update(label="Generating response...")
+            
+            # 메시지 구성
+            api_messages = [
+                {"role": "system", "content": sys_prompt}
+            ]
+            
+            user_content = query
+            
+            # 검색 결과가 있으면 사용자 프롬프트에 추가
+            if search_content:
+                user_content += "\n\n" + search_content
+            
+            # 파일 내용이 있으면 사용자 프롬프트에 추가
+            if file_content:
+                user_content += "\n\n" + file_content
+            
+            # Include specific image information
+            if valid_images:
+                user_content += "\n\n# Available Images\n"
+                for i, img in enumerate(valid_images[:5]):
+                    user_content += f"\n{i+1}. ![{img['title']}]({img['url']})\n"
+                    if img['source']:
+                        user_content += f"   Source: {img['source']}\n"
+            
+            # Include specific video information
+            if valid_videos:
+                user_content += "\n\n# Available Videos\n"
+                for i, vid in enumerate(valid_videos[:2]):
+                    user_content += f"\n{i+1}. **{vid['title']}** - [{vid['source']}]({vid['url']})\n"
+                    
+            # 사용자 메시지 추가
+            api_messages.append({"role": "user", "content": user_content})
+            
+            # OpenAI API 스트리밍 호출 - 고정 모델 "gpt-4.1-mini" 사용
+            try:
+                # 스트리밍 방식으로 API 호출
+                stream = client.chat.completions.create(
+                    model="gpt-4.1-mini",  # 고정 모델 사용
+                    messages=api_messages,
+                    temperature=1,
+                    max_tokens=MAX_TOKENS,
+                    top_p=1,
+                    stream=True  # 스트리밍 활성화
+                )
+                
+                # 스트리밍 응답 처리
+                for chunk in stream:
+                    if chunk.choices and len(chunk.choices) > 0 and chunk.choices[0].delta.content is not None:
+                        content_delta = chunk.choices[0].delta.content
+                        full_response += content_delta
+                        message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
+                
+                # 최종 응답 표시 (커서 제거)
+                message_placeholder.markdown(full_response, unsafe_allow_html=True)
+                
+                # Display related images if available
+                if valid_images:
+                    st.subheader("Related Images")
+                    image_cols = st.columns(min(3, len(valid_images)))
+                    
+                    for i, img_data in enumerate(valid_images):
+                        col_idx = i % len(image_cols)
+                        with image_cols[col_idx]:
+                            try:
+                                st.image(img_data['url'], caption=img_data['title'], use_column_width=True)
+                                if img_data['source']:
+                                    st.markdown(f"[Source]({img_data['source']})")
+                            except Exception as img_err:
+                                st.warning(f"Could not load image: {str(img_err)}")
+                
+                # Display related videos if available
+                if valid_videos:
+                    st.subheader("Related Videos")
+                    for video in valid_videos:
+                        video_title = video.get('title', 'Related video')
+                        video_url = video.get('url', '')
+                        thumbnail = video.get('thumbnail', '')
+                        
+                        # Display video information with thumbnail if available
+                        if thumbnail:
+                            col1, col2 = st.columns([1, 3])
+                            with col1:
+                                try:
+                                    st.image(thumbnail, width=120)
+                                except:
+                                    st.write("🎬")
+                            with col2:
+                                st.markdown(f"**[{video_title}]({video_url})**")
+                                st.write(f"Source: {video.get('source', 'Unknown')}")
+                        else:
+                            st.markdown(f"🎬 **[{video_title}]({video_url})**")
+                            st.write(f"Source: {video.get('source', 'Unknown')}")
+                
+                status.update(label="Response completed!", state="complete")
+                
+                # Save the response with images and videos in the session state
+                st.session_state.messages.append({
+                    "role": "assistant", 
+                    "content": full_response,
+                    "images": valid_images,
+                    "videos": valid_videos
+                })
+                
+            except Exception as api_error:
+                error_message = str(api_error)
+                logging.error(f"API error: {error_message}")
+                status.update(label=f"Error: {error_message}", state="error")
+                raise Exception(f"Response generation error: {error_message}")
+            
+            # Additional image generation if enabled
+            if st.session_state.generate_image and full_response:
+                with st.spinner("Generating custom image..."):
+                    try:
+                        ip = extract_image_prompt(full_response, query)
+                        img, cap = generate_image(ip)
+                        if img:
+                            st.subheader("AI-Generated Image")
+                            st.image(img, caption=cap)
+                    except Exception as img_error:
+                        logging.error(f"Image generation error: {str(img_error)}")
+                        st.warning("Custom image generation failed. Using web images only.")
+
+            # Download buttons
+            if full_response:
+                st.subheader("Download This Response")
+                c1, c2 = st.columns(2)
+                c1.download_button(
+                    "Markdown", 
+                    data=full_response, 
+                    file_name=f"{query[:30]}.md",
+                    mime="text/markdown"
+                )
+                c2.download_button(
+                    "HTML",
+                    data=md_to_html(full_response, query[:30]),
+                    file_name=f"{query[:30]}.html",
+                    mime="text/html"
+                )
+
+            # Auto save
+            if st.session_state.auto_save and st.session_state.messages:
+                try:
+                    fn = f"conversation_history_auto_{datetime.now():%Y%m%d_%H%M%S}.json"
+                    with open(fn, "w", encoding="utf-8") as fp:
+                        json.dump(st.session_state.messages, fp, ensure_ascii=False, indent=2)
+                except Exception as e:
+                    logging.error(f"Auto-save failed: {e}")
+
+        except Exception as e:
+            error_message = str(e)
+            placeholder.error(f"An error occurred: {error_message}")
+            logging.error(f"Process input error: {error_message}")
+            ans = f"An error occurred while processing your request: {error_message}"
+            st.session_state.messages.append({"role": "assistant", "content": ans})
+
+
+# ──────────────────────────────── main ────────────────────────────────────
+def main():
+    perplexity_app()
+
+if __name__ == "__main__":
+    main()