Rename travel.py to paper.py

paper.py

@@ -0,0 +1,199 @@
+import os
+import json
+import logging
+from datetime import datetime, timedelta
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.schema import SystemMessage, HumanMessage
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+class Agent:
+    def __init__(self, role: str, goal: str, backstory: str, personality: str = "", llm=None) -> None:
+        """
+        Initialize an Agent with role, goal, backstory, personality, and assigned LLM.
+        """
+        self.role = role
+        self.goal = goal
+        self.backstory = backstory
+        self.personality = personality
+        self.tools = []  # Initialize with empty list for future tool integrations
+        self.llm = llm
+
+class Task:
+    def __init__(self, description: str, agent: Agent, expected_output: str, context=None) -> None:
+        """
+        Initialize a Task with its description, the responsible agent, expected output, and optional context.
+        """
+        self.description = description
+        self.agent = agent
+        self.expected_output = expected_output
+        self.context = context or []
+
+google_api_key = os.getenv("GEMINI_API_KEY")  # 실제 Google API 키 사용
+if not google_api_key:
+    logging.error("GEMINI_API_KEY is not set in the environment variables.")
+llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", google_api_key=google_api_key)
+
+# -------------------------------------------------------------------------------
+# Define Academic Research Agents
+# -------------------------------------------------------------------------------
+literature_research_agent = Agent(
+    role="Literature Research Agent",
+    goal="Research and provide a comprehensive review of existing literature on the research topic.",
+    backstory="An experienced academic researcher specialized in literature reviews and meta-analyses.",
+    personality="Analytical, thorough, and detail-oriented.",
+    llm=llm,
+)
+
+outline_agent = Agent(
+    role="Outline Agent",
+    goal="Generate a structured and detailed outline for a research paper based on the research topic and literature.",
+    backstory="A methodical academic planner who organizes research findings into coherent paper structures.",
+    personality="Organized, systematic, and insightful.",
+    llm=llm,
+)
+
+draft_writing_agent = Agent(
+    role="Draft Writing Agent",
+    goal="Compose a first draft of the research paper based on the literature review and outline.",
+    backstory="A skilled academic writer capable of synthesizing research findings into well-structured drafts.",
+    personality="Articulate, precise, and scholarly.",
+    llm=llm,
+)
+
+citation_agent = Agent(
+    role="Citation Agent",
+    goal="Generate a list of relevant citations and references in the required format for the research paper.",
+    backstory="A detail-oriented bibliographic expert with extensive knowledge of citation standards.",
+    personality="Meticulous, accurate, and research-savvy.",
+    llm=llm,
+)
+
+editing_agent = Agent(
+    role="Editing Agent",
+    goal="Revise and polish the draft for clarity, coherence, and academic tone.",
+    backstory="An expert editor skilled in improving academic manuscripts and ensuring high-quality presentation.",
+    personality="Critical, precise, and supportive.",
+    llm=llm,
+)
+
+chatbot_agent = Agent(
+    role="Chatbot Agent",
+    goal="Engage in interactive conversation to answer queries related to the academic research process.",
+    backstory="A conversational AI assistant with extensive knowledge in academia and research methodologies.",
+    personality="Helpful, conversational, and knowledgeable.",
+    llm=llm,
+)
+
+# -------------------------------------------------------------------------------
+# Define Tasks for Academic Research and Writing
+# -------------------------------------------------------------------------------
+literature_research_task = Task(
+    description="""Research academic literature on {topic} considering the keywords {keywords}.
+    
+Please provide:
+- A summary of the current state of research,
+- Key trends and gaps in the literature,
+- Notable studies and their findings,
+- Relevant theoretical frameworks and methodologies.
+Format the response with bullet points and concise summaries.""",
+    agent=literature_research_agent,
+    expected_output="""A comprehensive literature review summary covering:
+1. Summary of current research trends
+2. Identification of gaps and controversies
+3. Key studies with brief descriptions
+4. Theoretical frameworks and methodologies used"""
+)
+
+outline_task = Task(
+    description="""Based on the research topic {topic} and literature review findings, generate a detailed outline for a research paper.
+    
+Include sections such as:
+- Abstract
+- Introduction (including research questions and objectives)
+- Literature Review
+- Methodology
+- Results/Findings
+- Discussion
+- Conclusion
+- References
+Format the outline in a structured manner with bullet points and subheadings.""",
+    agent=outline_agent,
+    expected_output="A structured outline for a research paper including all major sections and key points to cover in each section."
+)
+
+draft_writing_task = Task(
+    description="""Using the research topic {topic}, the literature review, and the generated outline, compose a first draft of the research paper.
+    
+The draft should include:
+- A coherent narrative flow,
+- Detailed sections as per the outline,
+- Integration of key findings from the literature review.
+Ensure the tone is academic and the content is well-organized.""",
+    agent=draft_writing_agent,
+    expected_output="A complete first draft of the research paper covering all sections with sufficient academic detail."
+)
+
+citation_task = Task(
+    description="""Based on the literature review for {topic}, generate a list of key references and citations in APA format.
+    
+Include:
+- Author names, publication year, title, and source,
+- At least 10 key references relevant to the research topic.
+Format the output as a numbered list of citations.""",
+    agent=citation_agent,
+    expected_output="A list of 10+ relevant citations in APA format."
+)
+
+editing_task = Task(
+    description="""Review and edit the draft for clarity, coherence, and academic tone.
+    
+Focus on:
+- Improving sentence structure,
+- Ensuring logical flow between sections,
+- Correcting grammar and stylistic issues,
+- Enhancing academic tone.
+Provide the polished version of the paper.""",
+    agent=editing_agent,
+    expected_output="A refined and polished version of the research paper draft."
+)
+
+chatbot_task = Task(
+    description="Provide a conversational and detailed response to academic research-related queries.",
+    agent=chatbot_agent,
+    expected_output="A friendly, informative response addressing the query."
+)
+
+def run_task(task: Task, input_text: str) -> str:
+    """
+    Executes the given task using the associated agent's LLM and returns the response content.
+    """
+    try:
+        if not isinstance(task, Task):
+            raise ValueError(f"Expected 'task' to be an instance of Task, got {type(task)}")
+        if not hasattr(task, 'agent') or not isinstance(task.agent, Agent):
+            raise ValueError("Task must have a valid 'agent' attribute of type Agent.")
+        system_input = (
+            f"Agent Details:\n"
+            f"Role: {task.agent.role}\n"
+            f"Goal: {task.agent.goal}\n"
+            f"Backstory: {task.agent.backstory}\n"
+            f"Personality: {task.agent.personality}\n"
+        )
+        task_input = (
+            f"Task Details:\n"
+            f"Task Description: {task.description}\n"
+            f"Expected Output: {task.expected_output}\n"
+            f"Input for Task:\n{input_text}\n"
+        )
+        messages = [
+            SystemMessage(content=system_input),
+            HumanMessage(content=task_input)
+        ]
+        response = task.agent.llm.invoke(messages)
+        if not response or not response.content:
+            raise ValueError("Empty response from LLM.")
+        return response.content
+    except Exception as e:
+        logging.error(f"Error in task '{task.agent.role}': {e}")
+        return f"Error in {task.agent.role}: {e}"

travel.py

@@ -1,453 +0,0 @@
-import os
-import json
-import logging
-from datetime import datetime, timedelta
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain.schema import SystemMessage, HumanMessage
-
-# Setup logging configuration
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-
-# -------------------------------------------------------------------------------
-# Agent and Task Classes with Type Hints and Docstrings
-# -------------------------------------------------------------------------------
-class Agent:
-    def __init__(self, role: str, goal: str, backstory: str, personality: str = "", llm=None) -> None:
-        """
-        Initialize an Agent with role, goal, backstory, personality, and assigned LLM.
-        """
-        self.role = role
-        self.goal = goal
-        self.backstory = backstory
-        self.personality = personality
-        self.tools = []  # Initialize with empty list for future tool integrations
-        self.llm = llm
-
-class Task:
-    def __init__(self, description: str, agent: Agent, expected_output: str, context=None) -> None:
-        """
-        Initialize a Task with its description, the responsible agent, expected output, and optional context.
-        """
-        self.description = description
-        self.agent = agent
-        self.expected_output = expected_output
-        self.context = context or []
-
-# -------------------------------------------------------------------------------
-# Initialize LLM
-# -------------------------------------------------------------------------------
-google_api_key = os.getenv("GEMINI_API_KEY")  # 실제 Google API 키 사용
-if not google_api_key:
-    logging.error("GEMINI_API_KEY is not set in the environment variables.")
-llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", google_api_key=google_api_key)
-
-# -------------------------------------------------------------------------------
-# Define Travel Agents
-# -------------------------------------------------------------------------------
-destination_research_agent = Agent(
-    role="Destination Research Agent",
-    goal=(
-        "Research and provide comprehensive information about the destination including popular attractions, "
-        "local culture, weather patterns, best times to visit, and local transportation options."
-    ),
-    backstory=(
-        "An experienced travel researcher with extensive knowledge of global destinations. "
-        "I specialize in uncovering both popular attractions and hidden gems that match travelers' interests."
-    ),
-    personality="Curious, detail-oriented, and knowledgeable about global cultures and travel trends.",
-    llm=llm,
-)
-
-accommodation_agent = Agent(
-    role="Accommodation Agent",
-    goal="Find and recommend suitable accommodations based on the traveler's preferences, budget, and location requirements.",
-    backstory="A hospitality expert who understands different types of accommodations and can match travelers with their ideal places to stay.",
-    personality="Attentive, resourceful, and focused on comfort and value.",
-    llm=llm,
-)
-
-transportation_agent = Agent(
-    role="Transportation Agent",
-    goal="Plan efficient transportation between the origin, destination, and all points of interest in the itinerary.",
-    backstory="A logistics specialist with knowledge of global transportation systems, from flights to local transit options.",
-    personality="Efficient, practical, and detail-oriented.",
-    llm=llm,
-)
-
-activities_agent = Agent(
-    role="Activities & Attractions Agent",
-    goal="Curate personalized activities and attractions that align with the traveler's interests, preferences, and time constraints.",
-    backstory="An enthusiastic explorer who has experienced diverse activities around the world and knows how to match experiences to individual preferences.",
-    personality="Enthusiastic, creative, and personable.",
-    llm=llm,
-)
-
-dining_agent = Agent(
-    role="Dining & Culinary Agent",
-    goal="Recommend dining experiences that showcase local cuisine while accommodating dietary preferences and budget considerations.",
-    backstory="A culinary expert with knowledge of global food scenes and an appreciation for authentic local dining experiences.",
-    personality="Passionate about food, culturally aware, and attentive to preferences.",
-    llm=llm,
-)
-
-itinerary_agent = Agent(
-    role="Itinerary Integration Agent",
-    goal="Compile all recommendations into a cohesive, day-by-day itinerary that optimizes time, minimizes travel fatigue, and maximizes enjoyment.",
-    backstory="A master travel planner who understands how to balance activities, rest, and logistics to create the perfect travel experience.",
-    personality="Organized, balanced, and practical.",
-    llm=llm,
-)
-
-# -------------------------------------------------------------------------------
-# Define Chatbot Agent and Task for Interactive Conversation
-# -------------------------------------------------------------------------------
-chatbot_agent = Agent(
-    role="Chatbot Agent",
-    goal="Engage in interactive conversation to answer travel-related queries.",
-    backstory="A conversational AI assistant who provides instant, accurate travel information and recommendations.",
-    personality="Friendly, conversational, and knowledgeable about travel.",
-    llm=llm,
-)
-
-chatbot_task = Task(
-    description="Provide a conversational and detailed response to travel-related queries.",
-    agent=chatbot_agent,
-    expected_output="A friendly, helpful response to the user's query."
-)
-
-# -------------------------------------------------------------------------------
-# Define Other Travel Tasks
-# -------------------------------------------------------------------------------
-destination_research_task = Task(
-    description="""Research {destination} thoroughly, considering the traveler's interests in {preferences}.
-    
-Efficient research parameters:
-- Prioritize research in these critical categories:
-    * Top attractions that match specific {preferences} (not generic lists)
-    * Local transportation systems with cost-efficiency analysis
-    * Neighborhood breakdown with accommodation recommendations by budget tier
-    * Seasonal considerations for the specific travel dates
-    * Safety assessment with specific areas to embrace or avoid
-    * Cultural norms that impact visitor experience (dress codes, tipping, etiquette)
-    
-- Apply efficiency filters:
-    * Focus exclusively on verified information from official tourism boards, recent travel guides, and reliable local sources
-    * Analyze recent visitor reviews (< 6 months old) to identify changing conditions
-    * Evaluate price-to-experience value for attractions instead of just popularity
-    * Identify logistical clusters where multiple interests can be satisfied efficiently
-    * Research off-peak times for popular attractions to minimize waiting
-    * Evaluate digital tools (apps, passes, reservation systems) that streamline the visit
-    
-- Create practical knowledge matrices:
-    * Transportation method comparison (cost vs. time vs. convenience)
-    * Weather impact on specific activities
-    * Budget allocation recommendations based on preference priorities
-    * Time-saving opportunity identification""",
-    agent=destination_research_agent,
-    expected_output="""Targeted destination brief containing:
-1. Executive summary highlighting the 5 most relevant aspects based on {preferences}
-2. Neighborhood analysis with accommodation recommendations mapped to specific interests
-3. Transportation efficiency guide with cost/convenience matrix
-4. Cultural briefing focusing only on need-to-know information that impacts daily activities
-5. Seasonal advantages and challenges specific to travel dates
-6. Digital resource toolkit (essential apps, websites, reservation systems)
-7. Budget optimization strategies with price ranges for key experiences
-8. Safety and health quick-reference including emergency contacts
-9. Logistics efficiency map showing optimal activity clustering
-10. Local insider advantage recommendations that save time or money
-
-Format should prioritize scannable information with bullet points, comparison tables, and decision matrices rather than lengthy prose."""
-)
-
-accommodation_task = Task(
-    description="Find suitable accommodations in {destination} based on a {budget} budget and preferences for {preferences}.",
-    agent=accommodation_agent,
-    expected_output="List of recommended accommodations with details on location, amenities, price range, and availability."
-)
-
-transportation_task = Task(
-    description="Plan transportation from {origin} to {destination} and local transportation options during the stay.",
-    agent=transportation_agent,
-    expected_output="Transportation plan including flights/routes to the destination and recommendations for getting around locally."
-)
-
-activities_task = Task(
-    description="""Suggest activities and attractions in {destination} that align with interests in {preferences}.
-    
-Detailed requirements:
-- Categorize activities into: Cultural Experiences, Outdoor Adventures, Culinary Experiences, 
-  Entertainment & Nightlife, Family-Friendly Activities, and Local Hidden Gems
-- For each activity, include:
-    * Detailed description with historical/cultural context where relevant
-    * Precise location with neighborhood information
-    * Operating hours with seasonal variations noted
-    * Pricing information with different ticket options/packages
-    * Accessibility considerations for travelers with mobility limitations
-    * Recommended duration for the activity (minimum and ideal time)
-    * Best time of day/week/year to visit
-    * Crowd levels by season
-    * Photography opportunities and restrictions
-    * Required reservations or booking windows
-- Include a mix of iconic must-see attractions and off-the-beaten-path experiences
-- Consider weather patterns in {destination} during travel period
-- Analyze the {preferences} to match specific personality types and interest levels
-- Include at least 2-3 rainy day alternatives for outdoor activities
-- Provide local transportation options to reach each attraction
-- Note authentic local experiences that provide cultural immersion
-- Flag any activities requiring special equipment, permits, or physical fitness levels""",
-    agent=activities_agent,
-    expected_output="""Comprehensive curated list of activities and attractions with:
-1. Clear categorization by type (cultural, outdoor, culinary, entertainment, family-friendly, hidden gems)
-2. Detailed descriptions that include historical and cultural context
-3. Complete practical information (hours, pricing, location, accessibility)
-4. Time optimization recommendations (best time to visit, how to avoid crowds)
-5. Personalized matches explaining why each activity aligns with specific {preferences}
-6. Local transportation details to reach each attraction
-7. Alternative options for inclement weather or unexpected closures
-8. Insider tips from locals that enhance the experience
-9. Suggested combinations of nearby activities for efficient itinerary planning
-10. Risk level assessment and safety considerations where applicable
-11. Sustainability impact and responsible tourism notes
-12. Photographic highlights and optimal viewing points
-
-Format should include a summary table for quick reference followed by detailed cards for each activity."""
-)
-
-dining_task = Task(
-    description="Recommend dining experiences in {destination} that showcase local cuisine while considering {preferences}.",
-    agent=dining_agent,
-    expected_output="List of recommended restaurants and food experiences with cuisine types, price ranges, and special notes."
-)
-
-itinerary_task = Task(
-    description="""Create a day-by-day itinerary for a {duration} trip to {destination} from {origin}, incorporating all recommendations.
-    
-Detailed requirements:
-- Begin with arrival logistics including airport transfer options, check-in times, and first-day orientation activities
-- Structure each day with:
-    * Morning, afternoon, and evening activity blocks with precise timing
-    * Estimated travel times between locations using various transportation methods
-    * Buffer time for rest, spontaneous exploration, and unexpected delays
-    * Meal recommendations with reservation details and backup options
-    * Sunset/sunrise opportunities for optimal photography or experiences
-- Apply intelligent sequencing to:
-    * Group attractions by geographic proximity to minimize transit time
-    * Schedule indoor activities strategically for predicted weather patterns
-    * Balance high-energy activities with relaxation periods
-    * Alternate between cultural immersion and entertainment experiences
-    * Account for opening days/hours of attractions and potential closures
-- Include practical timing considerations:
-    * Museum/attraction fatigue limitations
-    * Jet lag recovery for first 1-2 days
-    * Time zone adjustment strategies
-    * Local rush hours and traffic patterns to avoid
-    * Cultural norms for meal times and business hours
-- End with departure logistics including check-out procedures, airport transfer timing, and luggage considerations
-- Add specialized planning elements:
-    * Local festivals or events coinciding with the travel dates
-    * Free time blocks for personal exploration or shopping
-    * Contingency recommendations for weather disruptions
-    * Early booking requirements for popular attractions/restaurants
-    * Local emergency contacts and nearby medical facilities""",
-    agent=itinerary_agent,
-    expected_output="""Comprehensive day-by-day itinerary featuring:
-1. Detailed timeline for each day with hour-by-hour scheduling and transit times
-2. Color-coded activity blocks that visually distinguish between types of activities
-3. Intelligent geographic clustering to minimize transportation time
-4. Strategic meal placements with both reservation-required and casual options
-5. Built-in flexibility with free time blocks and alternative suggestions
-6. Weather-adaptive scheduling with indoor/outdoor activity balance
-7. Energy level considerations throughout the trip arc
-8. Cultural timing adaptations (accommodating local siesta times, religious observances, etc.)
-9. Practical logistical details (bag storage options, dress code reminders, etc.)
-10. Local transportation guidance including transit cards, apps, and pre-booking requirements
-11. Visual map representation showing daily movement patterns
-12. Key phrases in local language for each day's activities
-
-Format should include both a condensed overview calendar and detailed daily breakdowns with time, activity, location, notes, and contingency plans."""
-)
-
-# -------------------------------------------------------------------------------
-# Helper Function to Run a Task with Full Agent & Task Information
-# -------------------------------------------------------------------------------
-def run_task(task: Task, input_text: str) -> str:
-    """
-    Executes the given task using the associated agent's LLM and returns the response content.
-    """
-    try:
-        if not isinstance(task, Task):
-            raise ValueError(f"Expected 'task' to be an instance of Task, got {type(task)}")
-        if not hasattr(task, 'agent') or not isinstance(task.agent, Agent):
-            raise ValueError("Task must have a valid 'agent' attribute of type Agent.")
-
-        system_input = (
-            f"Agent Details:\n"
-            f"Role: {task.agent.role}\n"
-            f"Goal: {task.agent.goal}\n"
-            f"Backstory: {task.agent.backstory}\n"
-            f"Personality: {task.agent.personality}\n"
-        )
-        task_input = (
-            f"Task Details:\n"
-            f"Task Description: {task.description}\n"
-            f"Expected Output: {task.expected_output}\n"
-            f"Input for Task:\n{input_text}\n"
-        )
-        messages = [
-            SystemMessage(content=system_input),
-            HumanMessage(content=task_input)
-        ]
-        response = task.agent.llm.invoke(messages)
-        if not response or not response.content:
-            raise ValueError("Empty response from LLM.")
-        return response.content
-    except Exception as e:
-        logging.error(f"Error in task '{task.agent.role}': {e}")
-        return f"Error in {task.agent.role}: {e}"
-
-# -------------------------------------------------------------------------------
-# User Input Functions
-# -------------------------------------------------------------------------------
-def get_user_input() -> dict:
-    """
-    Collects user input for travel itinerary generation.
-    """
-    print("\n=== Travel Itinerary Generator ===\n")
-    origin = input("Enter your origin city/country: ")
-    destination = input("Enter your destination city/country: ")
-    duration = input("Enter trip duration (number of days): ")
-    budget = input("Enter your budget level (budget, moderate, luxury): ")
-    
-    print("\nEnter your travel preferences and interests (comma-separated):")
-    print("Examples: museums, hiking, food, shopping, beaches, history, nightlife, family-friendly, etc.")
-    preferences = input("> ")
-    
-    special_requirements = input("\nAny special requirements or notes (dietary restrictions, accessibility needs, etc.)? ")
-    
-    return {
-        "origin": origin,
-        "destination": destination,
-        "duration": duration,
-        "budget": budget,
-        "preferences": preferences,
-        "special_requirements": special_requirements
-    }
-
-# -------------------------------------------------------------------------------
-# Main Function to Generate Travel Itinerary
-# -------------------------------------------------------------------------------
-def generate_travel_itinerary(user_input: dict) -> str:
-    """
-    Generates a personalized travel itinerary by sequentially running defined tasks.
-    """
-    print("\nGenerating your personalized travel itinerary...\n")
-    
-    # Create input context using f-string formatting
-    input_context = (
-        f"Travel Request Details:\n"
-        f"Origin: {user_input['origin']}\n"
-        f"Destination: {user_input['destination']}\n"
-        f"Duration: {user_input['duration']} days\n"
-        f"Budget Level: {user_input['budget']}\n"
-        f"Preferences/Interests: {user_input['preferences']}\n"
-        f"Special Requirements: {user_input['special_requirements']}\n"
-    )
-    
-    # Step 1: Destination Research
-    print("Researching your destination...")
-    destination_info = run_task(destination_research_task, input_context)
-    print("✓ Destination research completed")
-    
-    # Step 2: Accommodation Recommendations
-    print("Finding ideal accommodations...")
-    accommodation_info = run_task(accommodation_task, input_context)
-    print("✓ Accommodation recommendations completed")
-    
-    # Step 3: Transportation Planning
-    print("Planning transportation...")
-    transportation_info = run_task(transportation_task, input_context)
-    print("✓ Transportation planning completed")
-    
-    # Step 4: Activities & Attractions
-    print("Curating activities and attractions...")
-    activities_info = run_task(activities_task, input_context)
-    print("✓ Activities and attractions curated")
-    
-    # Step 5: Dining Recommendations
-    print("Finding dining experiences...")
-    dining_info = run_task(dining_task, input_context)
-    print("✓ Dining recommendations completed")
-    
-    # Step 6: Create Day-by-Day Itinerary
-    print("Creating your day-by-day itinerary...")
-    combined_info = (
-        input_context + "\n"
-        "Destination Information:\n" + destination_info + "\n"
-        "Accommodation Options:\n" + accommodation_info + "\n"
-        "Transportation Plan:\n" + transportation_info + "\n"
-        "Recommended Activities:\n" + activities_info + "\n"
-        "Dining Recommendations:\n" + dining_info + "\n"
-    )
-    itinerary = run_task(itinerary_task, combined_info)
-    print("✓ Itinerary creation completed")
-    print("✓ Itinerary generation completed")
-    
-    return itinerary
-
-# -------------------------------------------------------------------------------
-# Save Itinerary to File
-# -------------------------------------------------------------------------------
-def save_itinerary_to_file(itinerary: str, user_input: dict, output_dir: str = None) -> str:
-    """
-    Saves the generated itinerary to a text file and returns the filepath.
-    """
-    date_str = datetime.now().strftime("%Y-%m-%d")
-    filename = f"{user_input['destination'].replace(' ', '_')}_{date_str}_itinerary.txt"
-    
-    if output_dir:
-        if not os.path.exists(output_dir):
-            try:
-                os.makedirs(output_dir)
-                logging.info(f"Created output directory: {output_dir}")
-            except Exception as e:
-                logging.error(f"Error creating directory {output_dir}: {e}")
-                return ""
-        filepath = os.path.join(output_dir, filename)
-    else:
-        filepath = filename
-    
-    try:
-        with open(filepath, "w", encoding="utf-8") as f:
-            f.write(itinerary)
-        logging.info(f"Your itinerary has been saved as: {filepath}")
-        return filepath
-    except Exception as e:
-        logging.error(f"Error saving itinerary: {e}")
-        return ""
-
-# -------------------------------------------------------------------------------
-# Main Function
-# -------------------------------------------------------------------------------
-def main() -> None:
-    """
-    Main entry point for the travel itinerary generator application.
-    """
-    print("Welcome to BlockX Travel Itinerary Generator!")
-    print("This AI-powered tool will create a personalized travel itinerary based on your preferences.")
-    
-    user_input = get_user_input()
-    
-    print("\nWhere would you like to save the itinerary?")
-    print("Press Enter to save in the current directory, or specify a path:")
-    output_dir = input("> ").strip() or None
-    
-    itinerary = generate_travel_itinerary(user_input)
-    
-    filepath = save_itinerary_to_file(itinerary, user_input, output_dir)
-    
-    if filepath:
-        print(f"\nYour personalized travel itinerary is ready! Open {filepath} to view it.")
-        print("Thank you for using BlockX Travel Itinerary Generator!")
-
-if __name__ == "__main__":
-    main()