Update app.py

app.py

@@ -16,28 +16,27 @@ BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
 IMAGE_API_URL  = "http://211.233.58.201:7896"
 MAX_TOKENS     = 7999
 
-# Blog template and style definitions (in English)
-BLOG_TEMPLATES = {
-    "ginigen": "Recommended style by Ginigen",
-    "standard": "Standard 8-step framework blog",
-    "tutorial": "Step-by-step tutorial format",
-    "review": "Product/service review format",
-    "storytelling": "Storytelling format",
-    "seo_optimized": "SEO-optimized blog"
+# 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"
 }
 
-BLOG_TONES = {
+RESPONSE_STYLES = {
     "professional": "Professional and formal tone",
     "casual": "Friendly and conversational tone",
-    "humorous": "Humorous approach",
-    "storytelling": "Story-driven approach"
+    "simple": "Simple and easy to understand",
+    "detailed": "Detailed and thorough explanations"
 }
 
-# Example blog topics
-EXAMPLE_TOPICS = {
-    "example1": "Changes to the real estate tax system in 2025: Impact on average households and tax-saving strategies",
-    "example2": "Summer festivals in 2025: A comprehensive guide to major regional events and hidden attractions",
-    "example3": "Emerging industries to watch in 2025: An investment guide focused on AI opportunities"
+# 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 ────────────────────────────────
@@ -58,243 +57,129 @@ def get_openai_client():
         max_retries=3  # 재시도 횟수 3회로 설정
     )
     
-# ──────────────────────────────── Blog Creation System Prompt ─────────────
-def get_system_prompt(template="ginigen", tone="professional", word_count=1750, include_search_results=False, include_uploaded_files=False) -> str:
+# ──────────────────────────────── System Prompt ─────────────────────────
+def get_system_prompt(mode="comprehensive", style="professional", include_search_results=True, include_uploaded_files=False) -> str:
     """
-    Generate a system prompt that includes:
-    - The 8-step blog writing framework
-    - The selected template and tone
+    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
     """
 
-    # Ginigen recommended style prompt (English version)
-    ginigen_prompt = """
-
-You are an expert English SEO copywriter.
-
-◆ Purpose
-- Create a blog post based on the given YouTube video script that captivates both search engines and readers.
-- Always follow the 4 writing principles: **[Lead with the main point → Keep it simple and short → Emphasize reader benefits → Call to action]**.
-
-◆ Complete Format (Use markdown, avoid unnecessary explanations)
-1. **Title**
-  - Emoji + Curiosity question/exclamation + Core keywords (Within 70 characters)
-  - Example: `# 🧬 Can Reducing Inflammation Help You Lose Weight?! 5 Amazing Benefits of Quercetin`
-
-2. **Hook (2-3 lines)**
-  - Present problem → Mention solution keyword → Summarize the benefit of reading this post
-
-3. `---` Divider
-
-4. **Section 1: Core Concept Introduction**
-  - `## 🍏 What is [Keyword]?`
-  - 1-2 paragraphs definition + 📌 One-line summary
-
-5. `---`
-
-6. **Section 2: 5 Benefits/Reasons**
-  - `## 💪 5 Reasons Why [Keyword] Is Beneficial`
-  - Each subsection format:
-
-  
-### 1. [Keyword-focused subheading]
-1-2 paragraphs explanation
-> ✔ One-line key point emphasis
-
-- Total of 5 items
-
-7. **Section 3: Consumption/Usage Methods**
-- `## 🥗 How to Use [Keyword] Effectively!`
-- Emoji bullet list of around 5 items + Additional tips
-
-8. `---`
-
-9. **Concluding Call to Action**
-- `## 📌 Conclusion – Start Using [Keyword] Today!`
-- 2-3 sentences on benefits/changes → **Action directive** (purchase, subscribe, share, etc.)
-
-10. `---`
-
-11. **Key Summary Table**
- | Item | Effect |
- |---|---|
- | [Keyword] | [Effect summary] |
- | Key foods/products | [List] |
-
-12. `---`
-
-13. **Quiz & CTA**
- - Simple Q&A quiz (1 question) → Reveal answer
- - "If you found this helpful, please share/comment" phrase
- - Preview of next post
-
-◆ Additional Guidelines
-- Total length 1,200-1,800 words.
-- Use simple vocabulary and short sentences, enhance readability with emojis, bold text, and quoted sections.
-- Increase credibility with specific numbers, research results, and analogies.
-- No meta-mentions of "prompts" or "instructions".
-- Use conversational but professional tone throughout.
-- Minimize expressions like "according to research" if no external sources are provided.
-
-◆ Output
-- Return **only the completed blog post** in the above format. No additional text.  
-
-"""
-
-    # Standard 8-step framework (English version)
-    base_prompt = """
-You are an expert in writing professional blog posts. For every blog writing request, strictly follow this 8-step framework to produce a coherent, engaging post:
-
-Reader Connection Phase
-1.1. Friendly greeting to build rapport
-1.2. Reflect actual reader concerns through introductory questions
-1.3. Stimulate immediate interest in the topic
-
-Problem Definition Phase
-2.1. Define the reader's pain points in detail
-2.2. Analyze the urgency and impact of the problem
-2.3. Build a consensus on why it needs to be solved
-
-Establish Expertise Phase
-3.1. Analyze based on objective data
-3.2. Cite expert views and research findings
-3.3. Use real-life examples to further clarify the issue
-
-Solution Phase
-4.1. Provide step-by-step guidance
-4.2. Suggest practical tips that can be applied immediately
-4.3. Mention potential obstacles and how to overcome them
-
-Build Trust Phase
-5.1. Present actual success stories
-5.2. Quote real user feedback
-5.3. Use objective data to prove effectiveness
-
-Action Phase
-6.1. Suggest the first clear step the reader can take
-6.2. Urge timely action by emphasizing urgency
-6.3. Motivate by highlighting incentives or benefits
-
-Authenticity Phase
-7.1. Transparently disclose any limits of the solution
-7.2. Admit that individual experiences may vary
-7.3. Mention prerequisites or cautionary points
-
-Relationship Continuation Phase
-8.1. Conclude with sincere gratitude
-8.2. Preview upcoming content to build anticipation
-8.3. Provide channels for further communication
+    # 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
 """
 
-    # Additional guidelines for each template
-    template_guides = {
-        "tutorial": """
-This blog should be in a tutorial style:
-- Clearly state the goal and the final outcome first
-- Provide step-by-step explanations with clear separations
-- Indicate where images could be inserted for each step
-- Mention approximate time requirements and difficulty level
-- List necessary tools or prerequisite knowledge
-- Give troubleshooting tips and common mistakes to avoid
-- Conclude with suggestions for next steps or advanced applications
+    # 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
 """,
-        "review": """
-This blog should be in a review style:
-- Separate objective facts from subjective opinions
-- Clearly list your evaluation criteria
-- Discuss both pros and cons in a balanced way
-- Compare with similar products/services
-- Specify the target audience for whom it is suitable
-- Provide concrete use cases and outcomes
-- Conclude with a final recommendation or alternatives
+        "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
 """,
-        "storytelling": """
-This blog should be in a storytelling style:
-- Start with a real or hypothetical person or case
-- Emphasize emotional connection with the problem scenario
-- Follow a narrative structure centered on conflict and resolution
-- Include meaningful insights or lessons learned
-- Maintain an emotional thread the reader can relate to
-- Balance storytelling with useful information
-- Encourage the reader to reflect on their own story
+        "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
 """,
-        "seo_optimized": """
-This blog should be SEO-optimized:
-- Include the main keyword in the title, headings, and first paragraph
-- Spread related keywords naturally throughout the text
-- Keep paragraphs around 300-500 characters
-- Use question-based subheadings
-- Make use of lists, tables, and bold text to diversify formatting
-- Indicate where internal links could be inserted
-- Provide sufficient content of at least 2000-3000 characters
+        "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
 """
     }
 
-    # Additional guidelines for each tone
-    tone_guides = {
-        "professional": "Use a professional, authoritative voice. Clearly explain any technical terms and present data or research to maintain a logical flow.",
-        "casual": "Use a relaxed, conversational style. Employ personal experiences, relatable examples, and a friendly voice (e.g., 'It's super useful!').",
-        "humorous": "Use humor and witty expressions. Add funny analogies or jokes while preserving accuracy and usefulness.",
-        "storytelling": "Write as if telling a story, with emotional depth and narrative flow. Incorporate characters, settings, conflicts, and resolutions."
+    # 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:
-- Accurately incorporate key information from the search results into the blog
-- Include recent data, statistics, and case studies from the search results
-- When quoting, specify the source within the text (e.g., "According to XYZ website...")
-- At the end of the blog, add a "References" section and list major sources with links
-- If there are conflicting pieces of information, present multiple perspectives
-- Make sure to reflect the latest trends and data from the 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 (Highest Priority):
-- The uploaded files must be a main source of information for the blog
-- Carefully examine the data, statistics, or examples in the file and integrate them
-- Directly quote and thoroughly explain any key figures or claims from the file
-- Highlight the file content as a crucial aspect of the blog
-- Mention the source clearly, e.g., "According to the uploaded data..."
-- For CSV files, detail important stats or numerical data in the blog
-- For PDF files, quote crucial segments or statements
-- For text files, integrate relevant content effectively
-- Even if the file content seems tangential, do your best to connect it to the blog topic
-- Keep consistency throughout and ensure the file's data is appropriately reflected
+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
-    if template == "ginigen":
-        final_prompt = ginigen_prompt
+    # Choose base prompt based on mode
+    if mode == "comprehensive":
+        final_prompt = comprehensive_prompt
     else:
-        final_prompt = base_prompt
-
-    # If the user chose a specific template (and not ginigen), append the relevant guidelines
-    if template != "ginigen" and template in template_guides:
-        final_prompt += "\n" + template_guides[template]
+        final_prompt = comprehensive_prompt + "\n" + mode_prompts.get(mode, "")
 
-    # If a specific tone is selected, append that guideline
-    if tone in tone_guides:
-        final_prompt += f"\n\nTone and Manner: {tone_guides[tone]}"
+    # Add style guide
+    if style in style_guides:
+        final_prompt += f"\n\nTone and Style: {style_guides[style]}"
 
-    # If web search results should be included
+    # Add search results guidance
     if include_search_results:
         final_prompt += f"\n\n{search_guide}"
 
-    # If uploaded files should be included
+    # Add uploaded files guidance
     if include_uploaded_files:
         final_prompt += f"\n\n{upload_guide}"
 
-    # Word count guidelines
-    final_prompt += (
-        f"\n\nWriting Requirements:\n"
-        f"9.1. Word Count: around {word_count-250}-{word_count+250} characters\n"
-        f"9.2. Paragraph Length: 3-4 sentences each\n"
-        f"9.3. Visual Cues: Use subheadings, separators, and bullet/numbered lists\n"
-        f"9.4. Data: Cite all sources\n"
-        f"9.5. Readability: Use clear paragraph breaks and highlights where necessary"
-    )
+    # 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
 
@@ -354,7 +239,7 @@ 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 the blog based on any pre-existing knowledge about '{query}'.\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"
@@ -370,7 +255,7 @@ def do_web_search(query: str) -> str:
             logging.warning("No search results, using fallback content")
             return mock_results(query)
 
-        hdr = "# Web Search Results\nUse the information below to enhance the reliability of your blog. When you quote, please cite the source, and add a References section at the end of the blog.\n\n"
+        hdr = "# Web Search Results\nUse these results to provide a comprehensive answer with multiple sources. Include relevant images, videos, and links.\n\n"
         body = "\n".join(
             f"### Result {a['index']}: {a['title']}\n\n{a['snippet']}\n\n"
             f"**Source**: [{a['displayed_link']}]({a['link']})\n\n---\n"
@@ -504,7 +389,7 @@ def process_uploaded_files(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 the blog.\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:
@@ -524,6 +409,31 @@ def process_uploaded_files(files):
     return result
 
 # ──────────────────────────────── Image & Utility ─────────────────────────
+def get_images_for_query(query, count=5):
+    """
+    Simulate getting relevant images for a query.
+    In a real implementation, this would call an image search API.
+    """
+    # This is a placeholder - in production, you would use a real image search API
+    sample_images = [
+        "https://source.unsplash.com/random/800x600/?"+query.replace(" ", "+"),
+        "https://source.unsplash.com/random/600x400/?"+query.replace(" ", "+"),
+        "https://source.unsplash.com/random/400x300/?"+query.replace(" ", "+"),
+    ]
+    return sample_images[:min(count, len(sample_images))]
+
+def get_videos_for_query(query, count=2):
+    """
+    Simulate getting relevant videos for a query.
+    In a real implementation, this would call a video search API.
+    """
+    # This is a placeholder - in production, you would use a real video search API
+    sample_videos = [
+        {"title": f"Introduction to {query}", "url": "https://www.youtube.com/results?search_query="+query.replace(" ", "+")},
+        {"title": f"Detailed explanation of {query}", "url": "https://www.youtube.com/results?search_query=advanced+"+query.replace(" ", "+")}
+    ]
+    return sample_videos[:min(count, len(sample_videos))]
+
 def generate_image(prompt, w=768, h=768, g=3.5, steps=30, seed=3):
     """Image generation function."""
     if not prompt:
@@ -541,18 +451,18 @@ def generate_image(prompt, w=768, h=768, g=3.5, steps=30, seed=3):
         logging.error(e)
         return None, str(e)
 
-def extract_image_prompt(blog_text: str, topic: str):
+def extract_image_prompt(response_text: str, topic: str):
     """
-    Generate a single-line English image prompt from the blog content.
+    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",  # 일반적으로 사용 가능한 모델로 설정
+            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{blog_text}\n\n---"}
+                {"role": "user", "content": f"Topic: {topic}\n\n---\n{response_text}\n\n---"}
             ],
             temperature=1,
             max_tokens=80,
@@ -564,7 +474,7 @@ def extract_image_prompt(blog_text: str, topic: str):
         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="Ginigen Blog"):
+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>"
 
@@ -574,8 +484,8 @@ def keywords(text: str, top=5):
     return " ".join(cleaned.split()[:top])
 
 # ──────────────────────────────── Streamlit UI ────────────────────────────
-def ginigen_app():
-    st.title("Ginigen Blog")
+def perplexity_app():
+    st.title("Perplexity-like AI Assistant")
 
     # Set default session state
     if "ai_model" not in st.session_state:
@@ -588,46 +498,39 @@ def ginigen_app():
         st.session_state.generate_image = False
     if "web_search_enabled" not in st.session_state:
         st.session_state.web_search_enabled = True
-    if "blog_template" not in st.session_state:
-        st.session_state.blog_template = "ginigen"  # Ginigen recommended style by default
-    if "blog_tone" not in st.session_state:
-        st.session_state.blog_tone = "professional"
-    if "word_count" not in st.session_state:
-        st.session_state.word_count = 1750
+    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("Blog Settings")
+    sb.title("Search Settings")
     
-    # 모델 선택 제거 (고정 모델 사용)
-    
-    sb.subheader("Blog Style Settings")
+    sb.subheader("Response Configuration")
     sb.selectbox(
-        "Blog Template", 
-        options=list(BLOG_TEMPLATES.keys()), 
-        format_func=lambda x: BLOG_TEMPLATES[x],
-        key="blog_template"
+        "Search Mode", 
+        options=list(SEARCH_MODES.keys()), 
+        format_func=lambda x: SEARCH_MODES[x],
+        key="search_mode"
     )
     
     sb.selectbox(
-        "Blog Tone",
-        options=list(BLOG_TONES.keys()),
-        format_func=lambda x: BLOG_TONES[x],
-        key="blog_tone"
+        "Response Style",
+        options=list(RESPONSE_STYLES.keys()),
+        format_func=lambda x: RESPONSE_STYLES[x],
+        key="response_style"
     )
     
-    sb.slider("Blog Length (word count)", 800, 3000, key="word_count")
-
-    
-    # Example topics
-    sb.subheader("Example Topics")
+    # Example queries
+    sb.subheader("Example Queries")
     c1, c2, c3 = sb.columns(3)
-    if c1.button("Real Estate Tax", key="ex1"):
-        process_example(EXAMPLE_TOPICS["example1"])
-    if c2.button("Summer Festivals", key="ex2"):
-        process_example(EXAMPLE_TOPICS["example2"])
-    if c3.button("Investment Guide", key="ex3"):
-        process_example(EXAMPLE_TOPICS["example3"])
+    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")
@@ -637,22 +540,28 @@ def ginigen_app():
     st.session_state.web_search_enabled = web_search_enabled
     
     if web_search_enabled:
-        st.sidebar.info("✅ Web search results will be integrated into the blog.")
+        st.sidebar.info("✅ Web search results will be integrated into the response.")
 
-    # Download the latest blog (markdown/HTML)
-    latest_blog = next(
+    # 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_blog:
-        title_match = re.search(r"# (.*?)(\n|$)", latest_blog)
-        title = title_match.group(1).strip() if title_match else "blog"
-        sb.subheader("Download Latest Blog")
+    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_blog, 
+        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_blog, title),
+        d2.download_button("Download as HTML", md_to_html(latest_response, title),
                            file_name=f"{title}.html", mime="text/html")
 
     # JSON conversation record upload
@@ -669,14 +578,14 @@ def ginigen_app():
         sb.download_button(
             "Save",
             data=json.dumps(st.session_state.messages, ensure_ascii=False, indent=2),
-            file_name="chat_history.json",
+            file_name="conversation_history.json",
             mime="application/json"
         )
 
     # File Upload
-    st.subheader("File Upload")
+    st.subheader("Upload Files")
     uploaded_files = st.file_uploader(
-        "Upload files to be referenced in your blog (txt, csv, pdf)",
+        "Upload files to be used as reference (txt, csv, pdf)",
         type=["txt", "csv", "pdf"],
         accept_multiple_files=True,
         key="file_uploader"
@@ -684,7 +593,7 @@ def ginigen_app():
     
     if uploaded_files:
         file_count = len(uploaded_files)
-        st.success(f"{file_count} files uploaded. They will be referenced in the blog.")
+        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):
@@ -734,33 +643,44 @@ def ginigen_app():
     # Display existing messages
     for m in st.session_state.messages:
         with st.chat_message(m["role"]):
-            st.markdown(m["content"])
-            if "image" in m:
-                st.image(m["image"], caption=m.get("image_caption", ""))
+            # 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_url, caption) in enumerate(m["images"]):
+                    col_idx = i % len(cols)
+                    with cols[col_idx]:
+                        st.image(img_url, caption=caption, use_column_width=True)
+            
+            # Display videos if present
+            if "videos" in m and m["videos"]:
+                st.subheader("Related Videos")
+                for video in m["videos"]:
+                    st.markdown(f"[🎬 {video['title']}]({video['url']})", unsafe_allow_html=True)
 
     # User input
-    prompt = st.chat_input("Enter a blog topic or keywords.")
-    if prompt:
-        process_input(prompt, uploaded_files)
-
+    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 topic."""
+    """Process the selected example query."""
     process_input(topic, [])
 
-def process_input(prompt: str, uploaded_files):
+def process_input(query: str, uploaded_files):
     # Add user's message
-    if not any(m["role"] == "user" and m["content"] == prompt for m in st.session_state.messages):
-        st.session_state.messages.append({"role": "user", "content": prompt})
+    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(prompt)
+        st.markdown(query)
     
     with st.chat_message("assistant"):
         placeholder = st.empty()
@@ -772,7 +692,7 @@ def process_input(prompt: str, uploaded_files):
         
         try:
             # 상태 표시를 위한 상태 컴포넌트
-            status = st.status("Preparing to generate blog...")
+            status = st.status("Preparing to answer your query...")
             status.update(label="Initializing client...")
             
             client = get_openai_client()
@@ -785,7 +705,7 @@ def process_input(prompt: str, uploaded_files):
             if use_web_search:
                 status.update(label="Performing web search...")
                 with st.spinner("Searching the web..."):
-                    search_content = do_web_search(keywords(prompt, top=5))
+                    search_content = do_web_search(keywords(query, top=5))
             
             # Process uploaded files → content
             file_content = None
@@ -794,25 +714,29 @@ def process_input(prompt: str, uploaded_files):
                 with st.spinner("Analyzing files..."):
                     file_content = process_uploaded_files(uploaded_files)
             
+            # Get relevant images and videos (before generating response)
+            status.update(label="Finding related media...")
+            related_images = get_images_for_query(query) if use_web_search else []
+            related_videos = get_videos_for_query(query) if use_web_search else []
+            
             # Build system prompt
-            status.update(label="Preparing blog draft...")
+            status.update(label="Preparing comprehensive answer...")
             sys_prompt = get_system_prompt(
-                template=st.session_state.blog_template,
-                tone=st.session_state.blog_tone,
-                word_count=st.session_state.word_count,
+                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="Writing blog content...")
+            status.update(label="Generating response...")
             
             # 메시지 구성
             api_messages = [
                 {"role": "system", "content": sys_prompt}
             ]
             
-            user_content = prompt
+            user_content = query
             
             # 검색 결과가 있으면 사용자 프롬프트에 추가
             if search_content:
@@ -822,6 +746,17 @@ def process_input(prompt: str, uploaded_files):
             if file_content:
                 user_content += "\n\n" + file_content
             
+            # Add image and video information to the prompt
+            if related_images:
+                user_content += "\n\n# Related Images\n"
+                for i, img_url in enumerate(related_images):
+                    user_content += f"\n![Image {i+1}]({img_url})"
+            
+            if related_videos:
+                user_content += "\n\n# Related Videos\n"
+                for video in related_videos:
+                    user_content += f"\n[Video: {video['title']}]({video['url']})"
+            
             # 사용자 메시지 추가
             api_messages.append({"role": "user", "content": user_content})
             
@@ -842,63 +777,78 @@ def process_input(prompt: str, uploaded_files):
                     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 + "▌")
+                        message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
                 
                 # 최종 응답 표시 (커서 제거)
-                message_placeholder.markdown(full_response)
-                status.update(label="Blog completed!", state="complete")
+                message_placeholder.markdown(full_response, unsafe_allow_html=True)
+                
+                # Display related images if available
+                if related_images:
+                    image_captions = [f"Related image {i+1}" for i in range(len(related_images))]
+                    images_with_captions = list(zip(related_images, image_captions))
+                    
+                    cols = st.columns(min(3, len(related_images)))
+                    for i, (img_url, caption) in enumerate(images_with_captions):
+                        col_idx = i % len(cols)
+                        with cols[col_idx]:
+                            st.image(img_url, caption=caption, use_column_width=True)
+                
+                # Display related videos if available
+                if related_videos:
+                    st.subheader("Related Videos")
+                    for video in related_videos:
+                        st.markdown(f"[🎬 {video['title']}]({video['url']})", unsafe_allow_html=True)
+                
+                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": list(zip(related_images, image_captions)) if related_images else [],
+                    "videos": related_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"Blog generation error: {error_message}")
+                raise Exception(f"Response generation error: {error_message}")
             
-            # 이미지 생성
-            answer_entry_saved = False
+            # Additional image generation if enabled
             if st.session_state.generate_image and full_response:
-                with st.spinner("Generating image..."):
+                with st.spinner("Generating custom image..."):
                     try:
-                        ip = extract_image_prompt(full_response, prompt)
+                        ip = extract_image_prompt(full_response, query)
                         img, cap = generate_image(ip)
                         if img:
+                            st.subheader("AI-Generated Image")
                             st.image(img, caption=cap)
-                            st.session_state.messages.append({
-                                "role": "assistant",
-                                "content": full_response,
-                                "image": img,
-                                "image_caption": cap
-                            })
-                            answer_entry_saved = True
                     except Exception as img_error:
                         logging.error(f"Image generation error: {str(img_error)}")
-                        st.warning("이미지 생성에 실패했습니다. 블로그 콘텐츠만 저장됩니다.")
-
-            # Save the answer if not saved above
-            if not answer_entry_saved and full_response:
-                st.session_state.messages.append({"role": "assistant", "content": full_response})
+                        st.warning("Custom image generation failed. Using web images only.")
 
             # Download buttons
             if full_response:
-                st.subheader("Download This Blog")
+                st.subheader("Download This Response")
                 c1, c2 = st.columns(2)
                 c1.download_button(
                     "Markdown", 
                     data=full_response, 
-                    file_name=f"{prompt[:30]}.md",
+                    file_name=f"{query[:30]}.md",
                     mime="text/markdown"
                 )
                 c2.download_button(
                     "HTML",
-                    data=md_to_html(full_response, prompt[:30]),
-                    file_name=f"{prompt[:30]}.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"chat_history_auto_{datetime.now():%Y%m%d_%H%M%S}.json"
+                    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:
@@ -914,7 +864,7 @@ def process_input(prompt: str, uploaded_files):
 
 # ──────────────────────────────── main ────────────────────────────────────
 def main():
-    ginigen_app()
+    perplexity_app()
 
 if __name__ == "__main__":
     main()