Spaces:
Running
Running
| """ | |
| Travel planner based on Agentic AI workflow. | |
| This module deploys a portal which can customize a day to day travel itinerary | |
| for a person using multiple specialized AI crews. | |
| Implemented using Sambanova Cloud, Gradio and Crew AI. | |
| A deployment is available at https://huggingface.co/spaces/sambanovasystems/trip-planner | |
| """ | |
| import datetime | |
| import json | |
| import logging | |
| from typing import List, Tuple | |
| import gradio as gr | |
| import plotly.graph_objects as go | |
| import os | |
| import openai | |
| from crew import AddressSummaryCrew, TravelCrew | |
| from db import log_query | |
| from fpdf import FPDF | |
| client = openai.OpenAI( | |
| api_key=os.environ.get("SAMBANOVA_API_KEY"), | |
| base_url="https://api.sambanova.ai/v1", | |
| ) | |
| def start_chat(context): | |
| return gr.Chatbot(visible=True), gr.Textbox(visible=True), context | |
| def respond(message, chat_history, context, model="Meta-Llama-3.1-70B-Instruct"): | |
| # Simple response incorporating context | |
| response = client.chat.completions.create( | |
| model=model, | |
| messages=[{"role":"system", | |
| "content":"You are a helpful assistant"}, | |
| {"role": "user", | |
| "content": "Here is a trip itinerary: %s. Please answer the specific question asked by the user. %s " % (message, context)}], | |
| temperature=0.1, | |
| top_p=0.1 | |
| ) | |
| result = response.choices[0].message.content | |
| bot_message = result | |
| chat_history.append((message, bot_message)) | |
| return "", chat_history | |
| def export_pdf(input_text:str, input_chat:str): | |
| """ | |
| Create a downloadable pdf for the given input text | |
| Args: | |
| input_text: The text that needs to be made a pdf | |
| input_chat: Chat messages | |
| Result: | |
| Downloadable pdf | |
| """ | |
| current_datetime = datetime.datetime.now() | |
| # Format the current date and time as YYYY-MM-DD_HH-MM-SS | |
| datetime_str = current_datetime.strftime("%Y-%m-%d_%H-%M-%S") | |
| file_name = "itinerary_%s.pdf" % datetime_str | |
| pdf = FPDF() | |
| pdf.add_page() | |
| pdf.set_font("helvetica", size=12) | |
| for line in input_text.split('\n'): | |
| clean_line = line.strip() | |
| if clean_line.startswith('**'): | |
| pdf.set_font("Arial", size=12, style='B') | |
| pdf.multi_cell(0, 5, clean_line[2:].lstrip()[:-2].rstrip()) | |
| pdf.set_font("Arial", size=12, style='') | |
| else: | |
| pdf.multi_cell(0, 5, clean_line) | |
| pdf.ln() | |
| for conversation in input_chat: | |
| counter = 0 | |
| for line in conversation: | |
| clean_line = line.strip() | |
| if clean_line: | |
| if counter == 0: | |
| pdf.ln() | |
| pdf.set_font("Arial", size=12, style='I') | |
| counter += 1 | |
| else: | |
| pdf.set_font("Arial", size=12, style='') | |
| pdf.multi_cell(0, 5, clean_line) | |
| pdf.output(file_name).encode('latin-1') | |
| return file_name | |
| def filter_map(text_list: List[str], lat: List[str], lon: List[str]) -> go.Figure: | |
| """ | |
| Create a Map showing the points specified in the inputs. | |
| Args: | |
| text_list: List of the description of all locations that will be shown on the map. | |
| lat: List of latitude coordinates of the locations. | |
| lon: List of longitude coordinates of the locations. | |
| Returns: | |
| Figure: Map with the points specified in the inputs | |
| """ | |
| # Creating a map with the provided markers using their latitude and longitude coordinates. | |
| fig = go.Figure( | |
| go.Scattermapbox(lat=lat, lon=lon, mode='markers', marker=go.scattermapbox.Marker(size=11), hovertext=text_list) | |
| ) | |
| # Update the map by centering it on of the the provided longitude and latitude coordinates | |
| fig.update_layout( | |
| mapbox_style='open-street-map', | |
| hovermode='closest', | |
| mapbox=dict(bearing=0, center=go.layout.mapbox.Center(lat=lat[1], lon=lon[1]), pitch=0, zoom=10), | |
| ) | |
| return fig | |
| def run( | |
| origin: str, | |
| destination: str, | |
| arrival_date: str, | |
| age: int, | |
| trip_duration: int, | |
| interests: List[str], | |
| cuisine_preferences: List[str], | |
| children: bool, | |
| budget: int, | |
| model_name:str='Meta-Llama-3.1-70B-Instruct' | |
| ) -> Tuple[str, go.Figure]: | |
| """ | |
| Run the specfied query using Crew AI agents. | |
| Args: | |
| origin: Origin city of the traveller. | |
| destination: Destination to which the traveller is going. | |
| arrival_date: Approximate date when the trip will begin in epoch time. | |
| age: Age profile of traveller. | |
| interests: Specific interests of the traveller. | |
| cuisine_preferences: Specific cuisine preferences of the traveller. | |
| children: Whether traveller has children travelling with them. | |
| budget: Total budget of traveller in US Dollars. | |
| Returns: | |
| Returns a tuple containing the itinerary and map | |
| """ | |
| # Gradio Datetime is currently not working on HF | |
| # See https://github.com/gradio-app/gradio/issues/10358 | |
| # Hece disabling datetime input and reverting back to string input | |
| """ | |
| if arrival_date: | |
| arrival_date_input = datetime.datetime.fromtimestamp(arrival_date).strftime("%m-%d-%Y") | |
| else: | |
| arrival_date_input = None | |
| """ | |
| if arrival_date: | |
| arrival_date_input = arrival_date.strip() | |
| else: | |
| arrival_date_input = None | |
| log_query(origin, destination, age, trip_duration, budget) | |
| logger.info( | |
| f'Origin: {origin}, Destination: {destination}, Arrival Date: {arrival_date_input},' | |
| f' Age: {age}, Duration: {trip_duration},' | |
| f' Interests: {interests}, Cuisines: {cuisine_preferences},' | |
| f' Children: {children}, Daily Budget: {budget}, Model Name: {model_name}' | |
| ) | |
| # Creating a dictionary of user provided preferences and providing these to the crew agents | |
| # to work on. | |
| user_preferences = { | |
| 'origin': origin, | |
| 'destination': destination, | |
| 'arrival_date': arrival_date_input, | |
| 'age': age, | |
| 'trip_duration': trip_duration, | |
| 'interests': interests, | |
| 'cuisine_preferences': cuisine_preferences, | |
| 'children': children, | |
| 'budget': budget, | |
| } | |
| #result = TravelCrew(model_name).crew().kickoff(inputs=user_preferences) | |
| crew = TravelCrew(model_name).crew() | |
| result = crew.kickoff(inputs=user_preferences) | |
| metrics = crew.usage_metrics | |
| logger.info("Result Metrics") | |
| logger.info(metrics) | |
| """ | |
| Now we will pass the result to a address summary crew whose job is to extract position | |
| coordinates of the addresses (latitude and longitude), so that the addresses in the | |
| result can be displayed in map coordinates | |
| """ | |
| inputs_for_address = {'text': str(result)} | |
| addresses = AddressSummaryCrew(model_name).crew().kickoff(inputs=inputs_for_address) | |
| """ | |
| We have requested the crew agent to return latitude, longitude coordinates. | |
| But the exact way the LLMs return varies. Hence we try multiple different ways of | |
| extracting addresses in JSON format from the result. | |
| """ | |
| json_addresses = None | |
| if addresses.json_dict is not None: | |
| json_addresses = addresses.json_dict | |
| if json_addresses is None: | |
| try: | |
| json_addresses = json.loads(addresses.raw) | |
| except json.JSONDecodeError as e: | |
| # Try with different format of result data generated with ```json and ending with ```. | |
| try: | |
| json_addresses = json.loads(addresses.raw[8:-4]) | |
| except json.JSONDecodeError as e: | |
| # Try with different format of result data generated with ``` and ending with ```. | |
| try: | |
| json_addresses = json.loads(addresses.raw[4:-4]) | |
| except json.JSONDecodeError as e: | |
| logger.error('Error loading Crew Output for addresses') | |
| logger.info(addresses.raw) | |
| return (result, None) | |
| fig = filter_map(json_addresses['name'], json_addresses['lat'], json_addresses['lon']) | |
| return (result, fig) | |
| logger = logging.getLogger() | |
| logger.setLevel(logging.INFO) | |
| with gr.Blocks() as demo: | |
| gr.Markdown('Use this app to create a detailed itinerary on how to explore a new place.' | |
| ' Itinerary is customized to your taste. Powered by Sambanova Cloud.') | |
| # Store context between interactions | |
| context = gr.State() | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| inp_source = gr.Textbox(label='Where are you travelling from?') | |
| inp_dest = gr.Textbox(label='Where are you going?') | |
| inp_cal = gr.Textbox(label='Approximate arrival date in mm-dd-yyyy') | |
| inp_age = gr.Slider(label='Your age?', value=30, minimum=15, maximum=90, step=5) | |
| inp_days = gr.Slider(label='How many days are you travelling?', value=5, minimum=1, maximum=14, step=1) | |
| inp_interests =\ | |
| gr.CheckboxGroup( | |
| [ | |
| 'Museums', | |
| 'Outdoor Adventures', | |
| 'Shopping', | |
| 'Children\'s Entertainment', | |
| 'Off the beat activities', | |
| 'Night Life', | |
| ], | |
| label='Checkbox your interests.', | |
| ) | |
| inp_cuisine =\ | |
| gr.CheckboxGroup( | |
| [ | |
| 'Ethnic', | |
| 'American', | |
| 'Italian', | |
| 'Mexican', | |
| 'Chinese', | |
| 'Japanese', | |
| 'Indian', | |
| 'Thai', | |
| 'French', | |
| 'Vietnamese', | |
| 'Vegan', | |
| ], | |
| label='Checkbox your cuisine preferences.', | |
| ) | |
| inp_children = gr.Checkbox(label='Check if children are travelling with you') | |
| inp_budget =\ | |
| gr.Slider( | |
| label='Total budget of trip in USD', show_label=True, value=1000, minimum=500, maximum=10000, step=500 | |
| ) | |
| inp_model = gr.Textbox(value="Meta-Llama-3.1-70B-Instruct", label='Sambanova Model Name') | |
| plan_button = gr.Button("Plan your Trip") | |
| inputs = [inp_source, inp_dest, inp_cal, inp_age, inp_days, inp_interests, inp_cuisine, inp_children, inp_budget, inp_model] | |
| with gr.Column(scale=2): | |
| with gr.Row(): | |
| output_itinerary =\ | |
| gr.Textbox( | |
| label='Complete Personalized Itinerary of your Trip', | |
| show_label=True, | |
| show_copy_button=True, | |
| autoscroll=False, | |
| ) | |
| # Chat interface (hidden initially) | |
| with gr.Row(visible=False) as chat_interface: | |
| chatbot = gr.Chatbot(label='Chat with the itinerary') | |
| input_msg = gr.Textbox(label='Ask a question') | |
| # Chat controls | |
| start_chat_btn = gr.Button("Start Chat", visible=False) | |
| # Download button | |
| download_btn = gr.Button("Download Itinerary") | |
| output_map = gr.Plot(label='Venues on a Map. Please verify with a Navigation System before traveling.') | |
| output = [output_itinerary, output_map] | |
| plan_button.click(fn=run, inputs=inputs, outputs=output).then( | |
| lambda: gr.Button(visible=True), | |
| outputs=start_chat_btn) | |
| download_btn_hidden = gr.DownloadButton(visible=False, elem_id="download_btn_hidden") | |
| download_btn.click(fn=export_pdf, inputs=[output_itinerary, chatbot], outputs=[download_btn_hidden]).then(fn=None, inputs=None, outputs=None, js="() => document.querySelector('#download_btn_hidden').click()") | |
| start_chat_btn.click( | |
| start_chat, | |
| inputs=output_itinerary, | |
| outputs=[chatbot, input_msg, context] | |
| ).then( | |
| lambda: gr.Row(visible=True), | |
| outputs=chat_interface | |
| ).then( | |
| lambda: gr.Button(visible=False), | |
| outputs=start_chat_btn) | |
| input_msg.submit( | |
| respond, | |
| inputs=[input_msg, chatbot, context, inp_model], | |
| outputs=[input_msg, chatbot] | |
| ) | |
| demo.launch() | |