IDEA-DESIGN

Running

App Files Files Community

ginipick commited on 20 days ago

Commit

d3caf4c

verified ·

1 Parent(s): 3358147

Update app.py

Browse files

Files changed (1) hide show

app.py +330 -439

app.py CHANGED Viewed

@@ -13,31 +13,170 @@ import PyPDF2  # For handling PDF files
 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"
-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"
 }
-BLOG_TONES = {
-    "professional": "Professional and formal tone",
-    "casual": "Friendly and conversational tone",
-    "humorous": "Humorous approach",
-    "storytelling": "Story-driven approach"
-}
-# 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"
 }
 # ──────────────────────────────── Logging ────────────────────────────────
@@ -46,7 +185,6 @@ logging.basicConfig(level=logging.INFO,
 # ──────────────────────────────── OpenAI Client ──────────────────────────
-# OpenAI 클라이언트에 타임아웃과 재시도 로직 추가
 @st.cache_resource
 def get_openai_client():
     """Create an OpenAI client with timeout and retry settings."""
@@ -57,246 +195,49 @@ def get_openai_client():
         timeout=60.0,  # 타임아웃 60초로 설정
         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:
     """
-    Generate a system prompt that includes:
-    - The 8-step blog writing framework
-    - The selected template and tone
-    - 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
-"""
-    # 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
-""",
-        "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
-""",
-        "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
-""",
-        "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
-"""
-    }
-    # 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."
-    }
-    # 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
-"""
-    # 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
-"""
-    # Choose base prompt
-    if template == "ginigen":
-        final_prompt = ginigen_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]
-    # If a specific tone is selected, append that guideline
-    if tone in tone_guides:
-        final_prompt += f"\n\nTone and Manner: {tone_guides[tone]}"
-    # If web search results should be included
-    if include_search_results:
-        final_prompt += f"\n\n{search_guide}"
-    # If uploaded files should be included
-    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"
-    )
-    return final_prompt
 # ──────────────────────────────── Brave Search API ────────────────────────
 @st.cache_data(ttl=3600)
@@ -306,7 +247,7 @@ def brave_search(query: str, count: int = 20):
     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",
@@ -351,15 +292,14 @@ def brave_search(query: str, count: int = 20):
     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 the blog 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:
@@ -370,7 +310,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"
         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"
@@ -446,19 +386,15 @@ def process_csv_file(file):
 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 = ""
@@ -469,17 +405,15 @@ def process_pdf_file(file):
                 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
@@ -504,7 +438,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"
     for file in files:
         try:
@@ -541,95 +475,35 @@ 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):
-    """
-    Generate a single-line English image prompt from the blog 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{blog_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="Ginigen Blog"):
     """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 ginigen_app():
-    st.title("Ginigen Blog")
     # 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 "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
     # Sidebar UI
     sb = st.sidebar
-    sb.title("Blog Settings")
-    # 모델 선택 제거 (고정 모델 사용)
-    sb.subheader("Blog Style Settings")
-    sb.selectbox(
-        "Blog Template",
-        options=list(BLOG_TEMPLATES.keys()),
-        format_func=lambda x: BLOG_TEMPLATES[x],
-        key="blog_template"
-    )
-    sb.selectbox(
-        "Blog Tone",
-        options=list(BLOG_TONES.keys()),
-        format_func=lambda x: BLOG_TONES[x],
-        key="blog_tone"
-    )
-    sb.slider("Blog Length (word count)", 800, 3000, key="word_count")
-    # Example topics
-    sb.subheader("Example Topics")
-    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"])
-    sb.subheader("Other Settings")
     sb.toggle("Auto Save", key="auto_save")
     sb.toggle("Auto Image Generation", key="generate_image")
@@ -637,22 +511,38 @@ 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.")
-    # Download the latest blog (markdown/HTML)
-    latest_blog = 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")
         d1, d2 = sb.columns(2)
-        d1.download_button("Download as Markdown", latest_blog,
                            file_name=f"{title}.md", mime="text/markdown")
-        d2.download_button("Download as HTML", md_to_html(latest_blog, title),
                            file_name=f"{title}.html", mime="text/html")
     # JSON conversation record upload
@@ -667,16 +557,16 @@ def ginigen_app():
     # 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="chat_history.json",
             mime="application/json"
         )
     # File Upload
-    st.subheader("File Upload")
     uploaded_files = st.file_uploader(
-        "Upload files to be referenced in your blog (txt, csv, pdf)",
         type=["txt", "csv", "pdf"],
         accept_multiple_files=True,
         key="file_uploader"
@@ -684,7 +574,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.")
         with st.expander("Preview Uploaded Files", expanded=False):
             for idx, file in enumerate(uploaded_files):
@@ -721,7 +611,7 @@ def ginigen_app():
                         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")
@@ -731,27 +621,25 @@ def ginigen_app():
                 if idx < file_count - 1:
                     st.divider()
-    # 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", ""))
-    # User input
-    prompt = st.chat_input("Enter a blog topic or keywords.")
     if prompt:
         process_input(prompt, 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_input(topic, [])
 def process_input(prompt: str, uploaded_files):
@@ -771,116 +659,120 @@ def process_input(prompt: str, uploaded_files):
         has_uploaded_files = bool(uploaded_files) and len(uploaded_files) > 0
         try:
-            # 상태 표시를 위한 상태 컴포넌트
-            status = st.status("Preparing to generate blog...")
             status.update(label="Initializing client...")
             client = get_openai_client()
-            # Prepare conversation messages
-            messages = []
-            # Web search
             search_content = None
             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))
-            # 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)
-            # Build system prompt
-            status.update(label="Preparing blog draft...")
-            sys_prompt = get_system_prompt(
-                template=st.session_state.blog_template,
-                tone=st.session_state.blog_tone,
-                word_count=st.session_state.word_count,
-                include_search_results=use_web_search,
-                include_uploaded_files=has_uploaded_files
-            )
-            # OpenAI API 호출 준비
-            status.update(label="Writing blog content...")
-            # 메시지 구성
-            api_messages = [
-                {"role": "system", "content": sys_prompt}
-            ]
             user_content = prompt
-            # 검색 결과가 있으면 사용자 프롬프트에 추가
             if search_content:
                 user_content += "\n\n" + search_content
-            # 파일 내용이 있으면 사용자 프롬프트에 추가
             if file_content:
                 user_content += "\n\n" + file_content
-            # 사용자 메시지 추가
-            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 + "▌")
-                # 최종 응답 표시 (커서 제거)
                 message_placeholder.markdown(full_response)
-                status.update(label="Blog completed!", state="complete")
             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}")
-            # 이미지 생성
             answer_entry_saved = False
             if st.session_state.generate_image and full_response:
-                with st.spinner("Generating image..."):
-                    try:
-                        ip = extract_image_prompt(full_response, prompt)
-                        img, cap = generate_image(ip)
-                        if img:
-                            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})
             # Download buttons
             if full_response:
-                st.subheader("Download This Blog")
                 c1, c2 = st.columns(2)
                 c1.download_button(
                     "Markdown",
@@ -895,7 +787,7 @@ def process_input(prompt: str, uploaded_files):
                     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"
@@ -911,10 +803,9 @@ def process_input(prompt: str, uploaded_files):
             ans = f"An error occurred while processing your request: {error_message}"
             st.session_state.messages.append({"role": "assistant", "content": ans})
 # ──────────────────────────────── main ────────────────────────────────────
 def main():
-    ginigen_app()
 if __name__ == "__main__":
-    main()

 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"
+IMAGE_API_URL  = "http://211.233.58.201:7896"  # 이미지 생성용 API
 MAX_TOKENS     = 7999
+# ──────────────────────────────── Physical Transformation Categories (KR & EN) ─────────────────
+physical_transformation_categories = {
+    "센서 기능": [
+        "시각 센서/감지", "청각 센서/감지", "촉각 센서/감지", "미각 센서/감지", "후각 센서/감지",
+        "온도 센서/감지", "습도 센서/감지", "압력 센서/감지", "가속도 센서/감지", "회전 센서/감지",
+        "근접 센서/감지", "위치 센서/감지", "운동 센서/감지", "가스 센서/감지", "적외선 센서/감지",
+        "자외선 센서/감지", "방사선 센서/감지", "자기장 센서/감지", "전기장 센서/감지", "화학물질 센서/감지",
+        "생체신호 센서/감지", "진동 센서/감지", "소음 센서/감지", "빛 세기 센서/감지", "빛 파장 센서/감지",
+        "기울기 센서/감지", "pH 센서/감지", "전류 센서/감지", "전압 센서/감지", "이미지 센서/감지",
+        "거리 센서/감지", "깊이 센서/감지", "중력 센서/감지", "속도 센서/감지", "흐름 센서/감지",
+        "수위 센서/감지", "탁도 센서/감지", "염도 센서/감지", "금속 감지", "압전 센서/감지",
+        "광전 센서/감지", "열전대 센서/감지", "홀 효과 센서/감지", "초음파 센서/감지", "레이더 센서/감지",
+        "라이다 센서/감지", "터치 센서/감지", "제스처 센서/감지", "심박 센서/감지", "혈압 센서/감지"
+    ],
+    "크기와 형태 변화": [
+        "부피 늘어남/줄어듦", "길이 늘어남/줄어듦", "너비 늘어남/줄어듦", "높이 늘어남/줄어듦",
+        "밀도 변화", "무게 증가/감소", "모양 변형", "상태 변화", "불균등 변형",
+        "복잡한 형태 변형", "비틀림/꼬임", "불균일한 확장/축소", "모서리 둥글게/날카롭게",
+        "깨짐/갈라짐", "여러 조각 나눠짐", "물 저항", "먼지 저항", "찌그러짐/복원",
+        "접힘/펼쳐짐", "압착/팽창", "늘어남/수축", "구겨짐/평평해짐", "뭉개짐/단단해짐",
+        "말림/펴짐", "꺾임/구부러짐"
+    ],
+    "표면 및 외관 변화": [
+        "색상 변화", "질감 변화", "투명/불투명 변화", "반짝임/무광 변화",
+        "빛 반사 정도 변화", "무늬 변화", "각도에 따른 색상 변화", "빛에 따른 색상 변화",
+        "온도에 따른 색상 변화", "홀로그램 효과", "표면 각도별 빛 반사", "표면 모양 변형",
+        "초미세 표면 구조 변화", "자가 세정 효과", "얼룩/패턴 생성", "흐림/선명함 변화",
+        "광택/윤기 변화", "색조/채도 변화", "발광/형광", "빛 산란 효과",
+        "빛 흡수 변화", "반투명 효과", "그림자 효과 변화", "자외선 반응 변화",
+        "야광 효과"
+    ],
+    "물질의 상태 변화": [
+        "고체/액체/기체 전환", "결정화/용해", "산화/부식", "딱딱해짐/부드러워짐",
+        "특수 상태 전환", "무정형/결정형 전환", "성분 분리", "미세 입자 형성/분해",
+        "젤 형성/풀어짐", "준안정 상태 변화", "분자 자가 정렬/분해", "상태변화 지연 현상",
+        "녹음", "굳음", "증발/응축", "승화/증착", "침전/부유", "분산/응집",
+        "건조/습윤", "팽윤/수축", "동결/해동", "풍화/침식", "충전/방전",
+        "결합/분리", "발효/부패"
+    ],
+    "움직임 특성 변화": [
+        "가속/감속", "일정 속도 유지", "진동/진동 감소", "부딪힘/튕김",
+        "회전 속도 증가/감소", "회전 방향 변화", "불규칙 움직임", "멈췄다 미끄러지는 현상",
+        "공진/반공진", "유체 속 저항/양력 변화", "움직임 저항 변화", "복합 진동 움직임",
+        "특수 유체 속 움직임", "회전-이동 연계 움직임", "관성 정지", "충격 흡수",
+        "충격 전달", "운동량 보존", "마찰력 변화", "관성 탈출", "불안정 균형",
+        "동적 안정성", "흔들림 감쇠", "경로 예측성", "회피 움직임"
+    ],
+    "구조적 변화": [
+        "부품 추가/제거", "조립/분해", "접기/펴기", "변형/원상복구", "최적 구조 변화",
+        "자가 재배열", "자연 패턴 형성/소멸", "규칙적 패턴 변화", "모듈식 변형",
+        "복잡성 증가 구조", "원래 모양 기억 효과", "시간에 따른 형태 변화", "부분 제거",
+        "부분 교체", "결합", "분리", "분할/통합", "중첩/겹침", "내부 구조 변화",
+        "외부 구조 변화", "중심축 이동", "균형점 변화", "계층 구조 변화", "지지 구조 변화",
+        "응력 분산 구조", "충격 흡수 구조", "그리드/매트릭스 구조 변화", "상호 연결성 변화"
+    ],
+    "공간 이동": [
+        "앞/뒤 이동", "좌/우 이동", "위/아래 이동", "세로축 회전(고개 끄덕임)",
+        "가로축 회전(고개 젓기)", "길이축 회전(옆으로 기울임)", "원 운동", "나선형 이동",
+        "관성에 의한 미끄러짐", "회전축 변화", "불규칙 회전", "흔들림 운동", "포물선 이동",
+        "무중력 부유", "수면 위 부유", "점프/도약", "슬라이딩", "롤링", "자유 낙하",
+        "왕복 운동", "탄성 튕김", "관통", "회피 움직임", "지그재그 이동", "스윙 운동"
+    ],
+    "시간 관련 변화": [
+        "노화/풍화", "마모/부식", "색 바램/변색", "손상/회복", "수명 주기 변화",
+        "사용자 상호작용에 따른 적응", "학습 기반 형태 최적화", "시간에 따른 물성 변화",
+        "집단 기억 효과", "문화적 의미 변화", "지연 반응", "이전 상태 의존 변화",
+        "점진적 시간 변화", "진화적 변화", "주기적 재생", "계절 변화 적응",
+        "생체리듬 변화", "생애 주기 단계", "성장/퇴화", "자가 복구/재생",
+        "자연 순환 적응", "지속성/일시성", "기억 효과", "지연된 작용", "누적 효과"
+    ],
+    "빛과 시각 효과": [
+        "발광/소등", "빛 투과/차단", "빛 산란/집중", "색상 스펙트럼 변화", "빛 회절",
+        "빛 간섭", "홀로그램 생성", "레이저 효과", "빛 편광", "형광/인광",
+        "자외선/적외선 발광", "광학적 착시", "빛 굴절", "그림자 생성/제거",
+        "색수차 효과", "무지개 효과", "글로우 효과", "플래시 효과", "조명 패턴",
+        "빔 효과", "광 필터 효과", "빛의 방향성 변화", "투영 효과", "빛 감지/반응",
+        "광도 변화"
+    ],
+    "소리와 진동 효과": [
+        "소리 발생/소멸", "음 높낮이 변화", "음량 변화", "음색 변화",
+        "공명/반공명", "음향 진동", "초음파/저음파 발생", "소리 집중/분산",
+        "음향 반사/흡수", "음향 도플러 효과", "음파 간섭", "음향 공진",
+        "진동 패턴 변화", "타악 효과", "음향 피드백", "음향 차폐/증폭",
+        "소리 지향성", "소리 왜곡", "비트 생성", "배음 생성", "주파수 변조",
+        "음향 충격파", "음향 필터링"
+    ],
+    "열 관련 변화": [
+        "온도 상승/하강", "열 팽창/수축", "열 전달/차단", "압력 상승/하강",
+        "열 변화에 따른 자화", "엔트로피 변화", "열전기 효과", "자기장에 의한 열 변화",
+        "상태 변화 중 열 저장/방출", "열 스트레스 발생/해소", "급격한 온도 변화 영향",
+        "복사 냉각/가열", "발열/흡열", "열 분포 변화", "열 반사/흡수",
+        "냉각 응축", "열 활성화", "열 변색", "열 팽창 계수 변화", "열 안정성 변화",
+        "내열성/내한성", "자가 발열", "열적 평형/불균형", "열적 변형", "열 분산/집중"
+    ],
+    "전기 및 자기 변화": [
+        "자성 생성/소멸", "전하량 증가/감소", "전기장 생성/소멸", "자기장 생성/소멸",
+        "초전도 상태 전환", "강유전체 특성 변화", "양자 상태 변화", "플라즈마 형성/소멸",
+        "스핀파 전달", "빛에 의한 전기 발생", "압력에 의한 전기 발생", "자기장 내 전류 변화",
+        "전기 저항 변화", "전기 전도성 변화", "정전기 발생/방전", "전자기 유도",
+        "전자기파 방출/흡수", "전기 용량 변화", "자기 이력 현상", "전기적 분극",
+        "전자 흐름 방향 변화", "전기적 공명", "전기적 차폐/노출", "자기 차폐/노출",
+        "자기장 정렬"
+    ],
+    "화학적 변화": [
+        "표면 코팅 변화", "물질 성분 변화", "화학 반응 변화", "촉매 작용 시작/중단",
+        "빛에 의한 화학 반응", "전기에 의한 화학 반응", "단분자막 형성", "분자 수준 구조 변화",
+        "생체 모방 표면 변화", "환경 반응형 물질 변화", "주기적 화학 반응", "산화", "환원",
+        "고분자화", "물 분해", "화합", "방사선 영향", "산-염기 반응", "중화 반응",
+        "이온화", "화학적 흡착/탈착", "촉매 효율 변화", "효소 활성 변화", "발�� 반응",
+        "pH 변화", "화학적 평형 이동", "결합 형성/분해", "용해도 변화"
+    ],
+    "생물학적 변화": [
+        "성장/위축", "세포 분열/사멸", "생물 발광", "신진대사 변화", "면역 반응",
+        "호르몬 분비", "신경 반응", "유전적 발현", "적응/진화", "생체리듬 변화",
+        "재생/치유", "노화/성숙", "생체 모방 변화", "바이오필름 형성", "생물학적 분해",
+        "효소 활성화/비활성화", "생물학적 신호 전달", "스트레스 반응", "체온 조절", "생물학적 시계 변화",
+        "세포외 기질 변화", "생체 역학적 반응", "세포 운동성", "세포 극성 변화", "영양 상태 변화"
+    ],
+    "환경 상호작용": [
+        "온도 반응", "습도 반응", "기압 반응", "중력 반응", "자기장 반응",
+        "빛 반응", "소리 반응", "화학 물질 감지", "기계적 자극 감지", "전기 자극 반응",
+        "방사선 반응", "진동 감지", "pH 반응", "용매 반응", "기체 교환",
+        "환경 오염 반응", "날씨 반응", "계절 반응", "일주기 반응", "생태계 상호작용",
+        "공생/경쟁 반응", "포식/피식 관계", "군집 형성", "영역 설정", "이주/정착 패턴"
+    ],
+    "비즈니스 아이디어": [
+        "시장 재정의/신규 시장 개척",
+        "비즈니스 모델 혁신/디지털 전환",
+        "고객 경험 혁신/서비스 혁신",
+        "협력 및 파트너십 강화/생태계 구축",
+        "글로벌 확장/지역화 전략",
+        "운영 효율성 증대/원가 절감",
+        "브랜드 리포지셔닝/이미지 전환",
+        "지속 가능한 성장/사회적 가치 창출",
+        "데이터 기반 의사결정/AI 도입",
+        "신기술 융합/혁신 투자"
+    ]
 }
+physical_transformation_categories_en = {
+    "Sensor Functions": [
+        "Visual sensor/detection", "Auditory sensor/detection", "Tactile sensor/detection", "Taste sensor/detection", "Olfactory sensor/detection",
+        "Temperature sensor/detection", "Humidity sensor/detection", "Pressure sensor/detection", "Acceleration sensor/detection", "Rotational sensor/detection",
+        "Proximity sensor/detection", "Position sensor/detection", "Motion sensor/detection", "Gas sensor/detection", "Infrared sensor/detection",
+        "Ultraviolet sensor/detection", "Radiation sensor/detection", "Magnetic sensor/detection", "Electric field sensor/detection", "Chemical sensor/detection",
+        "Biosignal sensor/detection", "Vibration sensor/detection", "Noise sensor/detection", "Light intensity sensor/detection", "Light wavelength sensor/detection",
+        "Tilt sensor/detection", "pH sensor/detection", "Current sensor/detection", "Voltage sensor/detection", "Image sensor/detection",
+        "Distance sensor/detection", "Depth sensor/detection", "Gravity sensor/detection", "Speed sensor/detection", "Flow sensor/detection",
+        "Water level sensor/detection", "Turbidity sensor/detection", "Salinity sensor/detection", "Metal detection", "Piezoelectric sensor/detection",
+        "Photovoltaic sensor/detection", "Thermocouple sensor/detection", "Hall effect sensor/detection", "Ultrasonic sensor/detection", "Radar sensor/detection",
+        "Lidar sensor/detection", "Touch sensor/detection", "Gesture sensor/detection", "Heart rate sensor/detection", "Blood pressure sensor/detection"
+    ],
+    "Size and Shape Change": [
+        "Volume increase/decrease", "Length increase/decrease", "Width increase/decrease", "Height increase/decrease",
+        "Density change", "Weight increase/decrease", "Shape deformation", "State change", "Uneven deformation",
+        "Complex shape deformation", "Twisting/entwining", "Non-uniform expansion/contraction", "Rounded/sharpened edges",
+        "Cracking/splitting", "Fragmentation", "Water resistance", "Dust resistance", "Denting/recovery",
+        "Folding/unfolding", "Compression/expansion", "Stretching/contraction", "Wrinkling/flattening", "Crushing/hardening",
+        "Rolling/unrolling", "Bending/curving"
+    ],
+    # 이하 동일 패턴으로 영문 버전 생략 (상동)
 }
 # ──────────────────────────────── Logging ────────────────────────────────
 # ──────────────────────────────── OpenAI Client ──────────────────────────
 @st.cache_resource
 def get_openai_client():
     """Create an OpenAI client with timeout and retry settings."""
         timeout=60.0,  # 타임아웃 60초로 설정
         max_retries=3  # 재시도 횟수 3회로 설정
     )
+# ──────────────────────────────── New System Prompt for Idea Generation ─────────────────────
+def get_idea_system_prompt() -> str:
     """
+    아이디어 생성용 시스템 프롬프트:
+    - 제공된 physical_transformation_categories를 활용
+    - 3가지 발상 접근: (1) 유사성 기반 증강, (2) 반유사성(대조) 기반 발상의 전환, (3) 무작위(우연적 착안)
+    - 각 아이디어를 논리적으로 설명 가능하도록 지시
+    - 아이디어마다 이미지 프롬프트도 함께 제시할 것
     """
+    prompt = """
+You are an advanced Idea Generation AI. Your goal is to take the user's prompt (topic, concept, or question) and create **3 distinct ideas** around it, drawing from the vast categories of **physical or conceptual transformations**. Specifically, you must produce:
+1. **Similarity-based Augmentation**
+   - Build upon the user's original concept by closely aligning to its core attributes.
+   - Reference relevant categories or subcategories that naturally extend or amplify the original idea.
+   - Provide a practical, logical explanation.
+2. **Contrarian/Inverse Approach**
+   - Intentionally invert or contradict the core assumptions of the original concept.
+   - Use contrasting categories to spark unconventional thinking.
+   - Clearly justify why this contrarian perspective might reveal novel possibilities.
+3. **Random (Fortuitous Spark)**
+   - Randomly select one or more categories or subcategories from any domain to introduce surprising or serendipitous ideas.
+   - Show how this unexpected combination can yield fresh insights or opportunities.
+For each of the 3 approaches:
+- Provide a concise name or title for the idea.
+- Offer a clear, structured explanation (a few paragraphs) on how this idea works or could be realized.
+- Incorporate references to the relevant category or categories from the provided classification, explaining how they link to the idea.
+- Suggest a short, single-line **English prompt for generating an image** that best represents that idea.
+Finally:
+- Return your answer in Markdown format with headings (e.g., "## Idea 1: ...", "## Idea 2: ...", "## Idea 3: ...").
+- Do **not** mention that you are responding with "3 ideas" because of a prompt or instruction. Simply present them as the final structured output.
+- Never mention "blog," "SEO," or "prompt" instructions in your final text.
+- Do **not** mention that you're an AI. Present the content as a straightforward creative text for each idea.
+---
+**Important**: You have access to a list of "physical_transformation_categories" (in Korean) and possibly an English version. Use them to anchor or inspire each idea, but do not simply copy the entire list. Instead, selectively reference a few relevant subcategories.
+    """
+    return prompt.strip()
 # ──────────────────────────────── Brave Search API ────────────────────────
 @st.cache_data(ttl=3600)
     Returns fields: index, title, link, snippet, displayed_link
     """
     if not BRAVE_KEY:
+        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) 환경 변수가 비어있습니다.")
     headers = {
         "Accept": "application/json",
     return []
 def mock_results(query: str) -> str:
+    """Fallback if search API fails"""
     ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     return (f"# Fallback Search Content (Generated: {ts})\n\n"
+            f"The web search API request failed. Please generate the ideas based on general knowledge about '{query}'.\n\n"
+            f"You may consider aspects such as:\n\n"
+            f"- Basic definition or concept of {query}\n"
+            f"- Commonly known facts or challenges\n"
+            f"- Potential categories from the transformation list\n\n"
             f"Note: This is fallback guidance, not real-time data.\n\n")
 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 inspire or validate your ideas.\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"
 def process_pdf_file(file):
     """Handle PDF file"""
     try:
         file_bytes = file.read()
         file.seek(0)
         pdf_file = io.BytesIO(file_bytes)
         reader = PyPDF2.PdfReader(pdf_file, strict=False)
         result = f"## PDF File: {file.name}\n\n"
         result += f"- Total pages: {len(reader.pages)}\n\n"
         max_pages = min(5, len(reader.pages))
         all_text = ""
                 current_page_text = f"### Page {i+1}\n\n"
                 if page_text and len(page_text.strip()) > 0:
                     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)\n\n"
                 all_text += current_page_text
                 if len(all_text) > 8000:
                     all_text += "...(truncating remaining pages; PDF is too large)...\n\n"
                     break
         return None
     result = "# Uploaded File Contents\n\n"
+    result += "Below is the content from the files provided by the user. Integrate this data as needed for generating ideas.\n\n"
     for file in files:
         try:
         logging.error(e)
         return None, str(e)
+def md_to_html(md: str, title="Idea Output"):
     """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 (for web search)."""
     cleaned = re.sub(r"[^가-힣a-zA-Z0-9\s]", "", text)
     return " ".join(cleaned.split()[:top])
 # ──────────────────────────────── Streamlit UI ────────────────────────────
+def idea_generator_app():
+    st.title("Creative Idea Generator")
     # 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 = True  # 기본값: True
     if "web_search_enabled" not in st.session_state:
         st.session_state.web_search_enabled = True
     # Sidebar UI
     sb = st.sidebar
+    sb.title("Idea Generator Settings")
     sb.toggle("Auto Save", key="auto_save")
     sb.toggle("Auto Image Generation", key="generate_image")
     st.session_state.web_search_enabled = web_search_enabled
     if web_search_enabled:
+        sb.info("✅ Web search results will be integrated.")
+    # 예시 주제들 (원래 예시 블로그 토픽 -> 이제는 예시 아이디어 주제로 전환)
+    example_topics = {
+        "example1": "AI로 인한 비즈니스 모델 변화",
+        "example2": "스마트 소재를 활용한 친환경 건축",
+        "example3": "미래형 교육 서비스 구상"
+    }
+    sb.subheader("Example Prompts")
+    c1, c2, c3 = sb.columns(3)
+    if c1.button("AI & 비즈니스", key="ex1"):
+        process_example(example_topics["example1"])
+    if c2.button("스마트 소재 건축", key="ex2"):
+        process_example(example_topics["example2"])
+    if c3.button("미래형 교육", key="ex3"):
+        process_example(example_topics["example3"])
+    # Download the latest ideas
+    latest_ideas = next(
         (m["content"] for m in reversed(st.session_state.messages)
          if m["role"] == "assistant" and m["content"].strip()),
         None
     )
+    if latest_ideas:
+        title_match = re.search(r"# (.*?)(\n|$)", latest_ideas)
+        title = title_match.group(1).strip() if title_match else "ideas"
+        sb.subheader("Download Latest Ideas")
         d1, d2 = sb.columns(2)
+        d1.download_button("Download as Markdown", latest_ideas,
                            file_name=f"{title}.md", mime="text/markdown")
+        d2.download_button("Download as HTML", md_to_html(latest_ideas, title),
                            file_name=f"{title}.html", mime="text/html")
     # JSON conversation record upload
     # JSON conversation record download
     if sb.button("Download Conversation as JSON"):
         sb.download_button(
+            "Save JSON",
             data=json.dumps(st.session_state.messages, ensure_ascii=False, indent=2),
             file_name="chat_history.json",
             mime="application/json"
         )
     # File Upload
+    st.subheader("File Upload (Optional)")
     uploaded_files = st.file_uploader(
+        "Upload files to reference in the idea generation (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.")
         with st.expander("Preview Uploaded Files", expanded=False):
             for idx, file in enumerate(uploaded_files):
                         if pc > 0:
                             try:
                                 page_text = reader.pages[0].extract_text()
+                                preview = page_text[:500] if page_text else "(No text)"
                                 st.text_area("Preview of the first page", preview + "...", height=150)
                             except:
                                 st.warning("Failed to extract text from the first page")
                 if idx < file_count - 1:
                     st.divider()
+    # Display existing messages in chat
     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", ""))
+    # User input for idea generation
+    prompt = st.chat_input("Enter a topic or concept to generate 3 new ideas.")
     if prompt:
         process_input(prompt, uploaded_files)
+    # Sidebar footer
     sb.markdown("---")
+    sb.markdown("Created by [Ginigen.com](https://ginigen.com) | [YouTube](https://www.youtube.com/@ginipickaistudio)")
 def process_example(topic):
+    """Handle example prompts."""
     process_input(topic, [])
 def process_input(prompt: str, uploaded_files):
         has_uploaded_files = bool(uploaded_files) and len(uploaded_files) > 0
         try:
+            status = st.status("Preparing to generate ideas...")
             status.update(label="Initializing client...")
             client = get_openai_client()
+            # Prepare system prompt
+            sys_prompt = get_idea_system_prompt()
+            # Optional: gather search results
             search_content = None
             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))
+            # File contents
             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)
+            # Build messages
             user_content = prompt
             if search_content:
                 user_content += "\n\n" + search_content
             if file_content:
                 user_content += "\n\n" + file_content
+            api_messages = [
+                {"role": "system", "content": sys_prompt},
+                {"role": "user", "content": user_content}
+            ]
+            # OpenAI API streaming
+            status.update(label="Generating creative ideas...")
             try:
                 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 + "▌")
                 message_placeholder.markdown(full_response)
+                status.update(label="Ideas created!", state="complete")
             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"Idea generation error: {error_message}")
+            # Store final text
             answer_entry_saved = False
+            # 자동 이미지 생성이 활성화되어 있다면
             if st.session_state.generate_image and full_response:
+                # 아이디어를 3개로 구분하고, 각 아이디어마다 이미지 프롬프트를 추출
+                # 간단한 방식: 정규식으로 `Image Prompt:` 형태를 찾는다고 가정 (시스템프롬프트에 지시)
+                # 혹은 단순히 한 번만 추출 -> 여기서는 3개 아이디어 각각을 찾기 위해 나눠본다.
+                # 일단은 전체 답변에서 "English prompt for generating an image" 부분을 찾는다.
+                # 매우 단순한 파싱 예시 (개선 가능)
+                idea_sections = re.split(r"(## Idea \d+:)", full_response)
+                # idea_sections는 ['', '## Idea 1:', ' ...', '## Idea 2:', ' ...', '## Idea 3:', ' ...'] 형태
+                # 다시 묶어서 [('## Idea 1:', idea_text), ('## Idea 2:', idea_text), ...] 형태로
+                pairs = []
+                for i in range(1, len(idea_sections), 2):
+                    idea_title = idea_sections[i].strip()
+                    idea_body = idea_sections[i+1].strip() if i+1 < len(idea_sections) else ""
+                    pairs.append((idea_title, idea_body))
+                # 각 아이디어마다 이미지 생성
+                for idx, (title, text_block) in enumerate(pairs, start=1):
+                    image_prompt_match = re.search(r"(?i)(image prompt\s*\:\s*)(.+)", text_block)
+                    if image_prompt_match:
+                        raw_prompt = image_prompt_match.group(2).strip()
+                        # 만약 문장 끝에 불필요한 구두점이나 줄바꿈이 있을 시 제거
+                        raw_prompt = re.sub(r"[\r\n]+", " ", raw_prompt)
+                        raw_prompt = re.sub(r"[\"'`]", "", raw_prompt)
+                        # 이미지 생성
+                        with st.spinner(f"Generating image for {title}..."):
+                            img, cap = generate_image(raw_prompt)
+                            if img:
+                                st.image(img, caption=f"{title} - {cap}")
+                                # 대화에 저장
+                                st.session_state.messages.append({
+                                    "role": "assistant",
+                                    "content": "",
+                                    "image": img,
+                                    "image_caption": f"{title} - {cap}"
+                                })
+                # 3개 이미지 생성 프로세스�� 마친 후 최종 텍스트를 저장
+                st.session_state.messages.append({"role": "assistant", "content": full_response})
+                answer_entry_saved = True
             if not answer_entry_saved and full_response:
+                # 이미지 생성이 비활성화거나 실패했을 경우 텍스트만 저장
                 st.session_state.messages.append({"role": "assistant", "content": full_response})
             # Download buttons
             if full_response:
+                st.subheader("Download This Output")
                 c1, c2 = st.columns(2)
                 c1.download_button(
                     "Markdown",
                     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"
             ans = f"An error occurred while processing your request: {error_message}"
             st.session_state.messages.append({"role": "assistant", "content": ans})
 # ──────────────────────────────── main ────────────────────────────────────
 def main():
+    idea_generator_app()
 if __name__ == "__main__":
+    main()