Duplicate from MinderaLabs/TL_GPT4

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: TL GPT4
+emoji: 🔥
+colorFrom: indigo
+colorTo: gray
+sdk: gradio
+sdk_version: 3.35.2
+app_file: app.py
+pinned: false
+duplicated_from: MinderaLabs/TL_GPT4
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agents/check_agent.py

@@ -0,0 +1,97 @@
+import os
+import platform
+
+import openai
+import chromadb
+import langchain
+
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.text_splitter import TokenTextSplitter
+from langchain.llms import OpenAI
+from langchain.chat_models import ChatOpenAI
+from langchain.chains import ChatVectorDBChain
+from langchain.document_loaders import GutenbergLoader
+
+from langchain.embeddings import LlamaCppEmbeddings
+from langchain.llms import LlamaCpp
+
+from langchain.output_parsers import StructuredOutputParser, ResponseSchema
+from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate
+from langchain.llms import OpenAI
+from langchain.chains import LLMChain
+from langchain.chains import SimpleSequentialChain
+
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field, validator
+from typing import List, Dict
+
+# class AnswerTemplate(BaseModel):
+#     isComplete: bool = Field(description="Is the input complete?")
+#     answer: str = Field(description="""If the answer to 'isComplete' is true leave this empty, else respond to user's last message in a cordial manner and then ask the user for the missing information. Just one question.""")
+
+class AnswerTemplate(BaseModel):
+    isComplete: bool = Field(description="Is the input complete?")
+
+class Check_Agent():
+    def __init__(self):
+
+        self.model_name = "gpt-4"
+        self.model = OpenAI(model_name=self.model_name, temperature=0)
+
+        self.output_parser = PydanticOutputParser(pydantic_object=AnswerTemplate)
+        self.format_instructions = self.output_parser.get_format_instructions()
+
+        # self.prompt = PromptTemplate(
+        #                     template="""\
+        #                             ### Instruction
+        #                             You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+        #                             As a smart itinerary planner with extensive knowledge of places around the
+        #                             world, your task is to determine the user's travel destinations and any specific interests or preferences from
+        #                             their message.
+        #                             ### Your task
+        #                             Is this input complete? If not, what is missing? 
+        #                             ### If something is missing then ask for the missing information.
+        #                             Don't ask more then one question.
+        #                             Ask just one of the following:
+        #                             If 'type' is empty then ask the user what type of the trip are you planning and with whom are you travelling?;
+        #                             If 'where' is empty then ask the user where is they going to travel to?;
+        #                             If 'start_date' is empty then ask the user what is the start date?;
+        #                             If 'end_date' is empty then ask the user what is the end date?;
+        #                             If 'time_constrains' is empty then ask the user if is there any time constrains that should be considered?;
+        #                             If 'preferences' is empty then ask the user if they have thought about any activities you want to do while you're there?;
+        #                             If 'conditions' is empty then ask the user if they have any special medical condition?;
+        #                             If 'dist_range' is empty then ask the user what is the distance range you prefer for your ativities? \n### Input: {input}
+        #                             \n### Response: {format_instructions}
+        #                             """,
+        #                     input_variables=["input", "format_instructions"]
+        # )
+    
+        self.prompt = PromptTemplate(
+                            template="""\
+                                    ### Instruction
+                                    You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+                                    As a smart itinerary planner with extensive knowledge of places around the
+                                    world, your task is to determine the user's travel destinations and any specific interests or preferences from
+                                    their message.
+                                    ### Your task
+                                    This input is a resume of what the user wants to do. From this you have to be able to retrieve all the following information:
+                                    "Where is the trip to", "Start and end dates for the trip", "Is there any time constrain", "activity preferences",
+                                    "Is there any medical condition" and "Is there a maximum distance range in which the activities have to be".
+                                    Is this input complete? Does it have all the information mention before or is it missing something? If it's not complete, what is missing? 
+                                    ### If something is missing then ask for the missing information.
+                                    The user don't like give much information at once. So try to minimize the quantity of information that you ask for in your response.
+                                    ### Input: {input}
+                                    ### Response: {format_instructions}
+                                    """,
+                            input_variables=["input", "format_instructions"]
+        )
+
+    def format_prompt(self, input):
+        return self.prompt.format_prompt(input=input, format_instructions=self.format_instructions)
+        return self.prompt.format_prompt(input=input)
+    
+    def get_parsed_result(self, input):
+        result= self.model(input.to_string())
+        parsed_result = self.output_parser.parse(result)
+        return parsed_result.isComplete

agents/gather_agent.py

@@ -0,0 +1,92 @@
+import os
+import platform
+
+import openai
+import chromadb
+import langchain
+
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.text_splitter import TokenTextSplitter
+from langchain.llms import OpenAI
+from langchain.chat_models import ChatOpenAI
+from langchain.chains import ChatVectorDBChain
+from langchain.document_loaders import GutenbergLoader
+
+from langchain.embeddings import LlamaCppEmbeddings
+from langchain.llms import LlamaCpp
+
+from langchain.output_parsers import StructuredOutputParser, ResponseSchema
+from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate
+from langchain.llms import OpenAI
+from langchain.chains import LLMChain
+from langchain.chains import SimpleSequentialChain
+
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field, validator
+from typing import List, Dict
+
+# class AnswerTemplate(BaseModel):
+#     type: List[str] = Field(description="What is the type of the trip: business, family, vactions. And with whom are you travelling? If can't anwser then leave it empty")
+#     where: str = Field(description="Where is the user going? If can't anwser then leave it empty")
+#     start_date: str = Field(description="What is the start date? If can't anwser then leave it empty")
+#     end_date: str = Field(description="What is the end date? If can't anwser then leave it empty")
+#     time_constrains: str = Field(description="Is there any time constrains? If can't anwser then leave it empty")
+#     # dates: Dict[str, str] = Field(description="What are the importante dates and times? If can't anwser then leave it empty")
+#     preferences: List[str] = Field(description="What does the user want to visit? If can't anwser then leave it empty")
+#     conditions: str = Field(description="Does the user has any special medical condition? If can't anwser then leave it empty")
+#     dist_range: str = Field(description="Max distance from a place? If can't anwser then leave it empty")
+#     # missing: str = Field(description="Is any more information needed?")
+
+class AnswerTemplate(BaseModel):
+    answer: str = Field(description="Response")
+
+
+class Gather_Agent():
+    def __init__(self):
+
+        self.model_name = "gpt-4"
+        self.model = OpenAI(model_name=self.model_name, temperature=0)
+
+        self.output_parser = PydanticOutputParser(pydantic_object=AnswerTemplate)
+        self.format_instructions = self.output_parser.get_format_instructions()
+
+        # self.prompt = PromptTemplate(
+        #     template="""\
+        #             ### Instruction
+        #             You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+        #             As a smart itinerary planner with extensive knowledge of places around the
+        #             world, your task is to determine the user's travel destinations and any specific interests or preferences from
+        #             their message. Here is the history that you have so far: {history} \n### User: \n{input}
+        #             \n### Response: {format_instructions}
+        #             """,
+        #     input_variables=["input", "history", "format_instructions"]
+        # )
+
+        self.prompt = PromptTemplate(
+            template="""\
+                    ### Instruction
+                    You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+                    As a smart itinerary planner with extensive knowledge of places around the
+                    world, your task is to determine the user's travel destinations and any specific interests or preferences from
+                    their message.
+                    ### Task
+                    From the following history and user input you should be able to retrieve and resume all the following information:
+                    Where is the trip to, start and end dates for the trip, is there any time constrain, activity preferences,
+                    is there any medical condition and is there a maximum distance range in which the activities have to be.
+                    ### History
+                    Here is the history that you have so far: {history} 
+                    ### User: \n{input}
+                    \n### Response:
+                    """,
+            input_variables=["input", "history"]
+        )
+    
+    def format_prompt(self, input, history):
+        # return self.prompt.format_prompt(history=history, input=input, format_instructions=self.format_instructions)
+        return self.prompt.format_prompt(input=input, history=history)
+    
+    def get_parsed_result(self, input):
+        result = self.model(input.to_string())
+        # return self.output_parser.parse(result)
+        return result

agents/planner_agent.py

@@ -0,0 +1,84 @@
+import os
+import platform
+
+import openai
+import chromadb
+import langchain
+
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.text_splitter import TokenTextSplitter
+from langchain.llms import OpenAI
+from langchain.chat_models import ChatOpenAI
+from langchain.chains import ChatVectorDBChain
+from langchain.document_loaders import GutenbergLoader
+
+from langchain.embeddings import LlamaCppEmbeddings
+from langchain.llms import LlamaCpp
+
+from langchain.output_parsers import StructuredOutputParser, ResponseSchema
+from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate
+from langchain.llms import OpenAI
+from langchain.chains import LLMChain
+from langchain.chains import SimpleSequentialChain
+
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field, validator
+from typing import List, Dict
+
+class GetPlacesTemplate(BaseModel):
+    answer: List[str] = Field(description="List of places and their adresses separated by ','")
+
+
+class Planner_Agent():
+    def __init__(self):
+
+        self.model_name = "gpt-4"
+        self.model = OpenAI(model_name=self.model_name, temperature=0)
+
+        self.output_parser_places = PydanticOutputParser(pydantic_object=GetPlacesTemplate)
+        self.format_instructions_places = self.output_parser_places.get_format_instructions()
+
+        self.prompt = PromptTemplate(
+                    template="""\
+                            ### Instruction
+                            You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+                            As a smart itinerary planner with extensive knowledge of places around the
+                            world, your task is to determine the user's travel destinations and any specific interests or preferences from
+                            their message. Create an itinerary that caters to the user's needs, making sure to name all activities,
+                            restaurants, and attractions specifically. When creating the itinerary, also consider factors such as time
+                            constraints and transportation options. Additionally, all attractions and restaurants listed in the itinerary
+                            must exist and be named specifically. During subsequent revisions, the itinerary can be modified, while keeping
+                            in mind the practicality of the itinerary. New place for each day. It's important to ensure that the number of
+                            activities per day is appropriate, and if the user doesn't specify otherwise, the default itinerary length is
+                            five days. The itinerary length should remain the same unless there is a change by the user's message. \n### User input to base itenerary on: \n{input}
+                            ### Response:
+                            """,
+                    input_variables=["input"]
+                    # partial_variables={"format_instructions": format_instructions_gether}
+        )
+
+        self.prompt_to_get_places = PromptTemplate(
+                    template="""\
+                            ### Instruction
+                            You are a place retriever. From a given input you can creat a list of all the places referenced in it, as well as the adress of each location.
+                            ### Input: {input}
+                            ### Response: {format_instructions}
+                            """,
+                    input_variables=["input", "format_instructions"]
+                    # partial_variables={"format_instructions": format_instructions_gether}
+        )
+    
+    def format_prompt(self, input):
+        return self.prompt.format_prompt(input=input)
+    
+    def get_itenerary(self, input):
+        return self.model(input.to_string())
+    
+    def format_prompt_to_get_places(self, input):
+        return self.prompt_to_get_places.format_prompt(input=input, format_instructions=self.format_instructions_places)
+    
+    def get_places_from_itenerary(self, itenerary):
+        result = self.model(itenerary.to_string())
+        parsed_result = self.output_parser_places.parse(result)
+        return parsed_result.answer

agents/response_agent.py

@@ -0,0 +1,99 @@
+import os
+import platform
+
+import openai
+import chromadb
+import langchain
+
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.text_splitter import TokenTextSplitter
+from langchain.llms import OpenAI
+from langchain.chat_models import ChatOpenAI
+from langchain.chains import ChatVectorDBChain
+from langchain.document_loaders import GutenbergLoader
+
+from langchain.embeddings import LlamaCppEmbeddings
+from langchain.llms import LlamaCpp
+
+from langchain.output_parsers import StructuredOutputParser, ResponseSchema
+from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate
+from langchain.llms import OpenAI
+from langchain.chains import LLMChain
+from langchain.chains import SimpleSequentialChain
+
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field, validator
+from typing import List, Dict
+
+# class AnswerTemplate(BaseModel):
+#     isComplete: bool = Field(description="Is the input complete?")
+#     answer: str = Field(description="""If the answer to 'isComplete' is true leave this empty, else respond to user's last message in a cordial manner and then ask the user for the missing information. Just one question.""")
+
+class AnswerTemplate(BaseModel):
+    # isComplete: bool = Field(description="Is the input complete?")
+    answer: str = Field(description="Question that you asked")
+
+class Response_Agent():
+    def __init__(self):
+
+        self.model_name = "gpt-4"
+        self.model = OpenAI(model_name=self.model_name, temperature=0)
+
+        self.output_parser = PydanticOutputParser(pydantic_object=AnswerTemplate)
+        self.format_instructions = self.output_parser.get_format_instructions()
+
+        # self.prompt = PromptTemplate(
+        #                     template="""\
+        #                             ### Instruction
+        #                             You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+        #                             As a smart itinerary planner with extensive knowledge of places around the
+        #                             world, your task is to determine the user's travel destinations and any specific interests or preferences from
+        #                             their message.
+        #                             ### Your task
+        #                             Is this input complete? If not, what is missing? 
+        #                             ### If something is missing then ask for the missing information.
+        #                             Don't ask more then one question.
+        #                             Ask just one of the following:
+        #                             If 'type' is empty then ask the user what type of the trip are you planning and with whom are you travelling?;
+        #                             If 'where' is empty then ask the user where is they going to travel to?;
+        #                             If 'start_date' is empty then ask the user what is the start date?;
+        #                             If 'end_date' is empty then ask the user what is the end date?;
+        #                             If 'time_constrains' is empty then ask the user if is there any time constrains that should be considered?;
+        #                             If 'preferences' is empty then ask the user if they have thought about any activities you want to do while you're there?;
+        #                             If 'conditions' is empty then ask the user if they have any special medical condition?;
+        #                             If 'dist_range' is empty then ask the user what is the distance range you prefer for your ativities? \n### Input: {input}
+        #                             \n### Response: {format_instructions}
+        #                             """,
+        #                     input_variables=["input", "format_instructions"]
+        # )
+    
+        self.prompt = PromptTemplate(
+                            template="""\
+                                    ### Instruction
+                                    You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+                                    As a smart itinerary planner with extensive knowledge of places around the
+                                    world, your task is to determine the user's travel destinations and any specific interests or preferences from
+                                    their message.
+                                    ### Your task
+                                    This input is a resume of what the user wants to do. From this you have to be able to retrieve all the following information:
+                                    "Where is the trip to", "Start and end dates for the trip", "Is there any time constrain that you should be aware of", "activity preferences",
+                                    "Is there any medical condition" and "Is there a maximum distance range in which the activities have to be".
+                                    ### If something is missing then ask for the missing information.
+                                    The user don't like give much information at once. So try to minimize the quantity of information that you ask for in your response.
+                                    Ask at maximum for information for two of the questions.
+                                    ### Input: {input}
+                                    ### Response: {format_instructions}
+                                    """,
+                            input_variables=["input", "format_instructions"]
+        )
+                                            # Is this input complete? Does it have all the information mention before or is it missing something? If it's not complete, what is missing? 
+
+    def format_prompt(self, input):
+        return self.prompt.format_prompt(input=input, format_instructions=self.format_instructions)
+        # return self.prompt.format_prompt(input=input)
+    
+    def get_parsed_result(self, input):
+        result= self.model(input.to_string())
+        parsed_result = self.output_parser.parse(result)
+        return parsed_result.answer

app.py

@@ -0,0 +1,173 @@
+import gradio as gr
+import os
+from gradio.themes import Size, GoogleFont
+
+from agents.gather_agent import Gather_Agent
+from agents.check_agent import Check_Agent
+from agents.response_agent import Response_Agent
+from agents.planner_agent import Planner_Agent
+
+import get_map
+
+# Create custom Color objects for our primary, secondary, and neutral colors
+primary_color = gr.themes.colors.green
+secondary_color = gr.themes.colors.amber
+neutral_color = gr.themes.colors.stone  # Assuming black for text
+# Set the sizes
+spacing_size = gr.themes.sizes.spacing_md
+radius_size = gr.themes.sizes.radius_md
+text_size = gr.themes.sizes.text_md
+# Set the fonts
+font = GoogleFont("Source Sans Pro")
+font_mono = GoogleFont("IBM Plex Mono")
+# Create the theme
+theme = gr.themes.Base(
+    primary_hue=primary_color,
+    secondary_hue=secondary_color,
+    neutral_hue=neutral_color,
+    spacing_size=spacing_size,
+    radius_size=radius_size,
+    text_size=text_size,
+    font=font,
+    font_mono=font_mono
+)
+
+gather_agent = Gather_Agent()
+check_agent = Check_Agent()
+response_agent = Response_Agent()
+planner_agent = Planner_Agent()
+
+def send_message(user_input, chat_history):
+    isComplete = False
+    helper_anwser = ""
+
+    _input_gather = gather_agent.format_prompt(history=chat_history, input=user_input)
+    parsed_result_gather = gather_agent.get_parsed_result(_input_gather)
+
+    _input_check = check_agent.format_prompt(input=parsed_result_gather)
+    isComplete = check_agent.get_parsed_result(_input_check)
+
+    if isComplete == False:
+        _input_response = response_agent.format_prompt(input=parsed_result_gather)
+        helper_anwser = response_agent.get_parsed_result(_input_response)
+
+    # _input_check = check_agent.format_prompt(input=parsed_result_gather)
+    # isComplete, helper_anwser = check_agent.get_parsed_result(_input_check)
+
+    return isComplete, helper_anwser, parsed_result_gather
+
+def get_itenerary(parsed_result_gather):
+    _input_planner = planner_agent.format_prompt(parsed_result_gather)
+    return planner_agent.get_itenerary(_input_planner)
+
+def get_itenerary_places(itenerary):
+    _input_places = planner_agent.format_prompt_to_get_places(itenerary)
+    return planner_agent.get_places_from_itenerary(_input_places)
+
+# isComplete = False
+# chat_history = ""
+
+# helper_anwser = "Hello, can you tell me your trip details and constraints so I can give you great recomendations?"
+# user_input = input("Helper: " + helper_anwser + "\nUser: ")
+
+with gr.Blocks(theme=theme, title="TrainLine") as demo:
+    gr.Markdown(
+    """
+    <div style="vertical-align: middle">
+    <div style="float: left">
+      <img src="https://static.trainlinecontent.com/content/vul/logos/trainline-mint.svg" alt=""
+    width="120" height="120">
+    </div>
+    </div>
+    """)
+
+    helper_anwser = "Hello, can you tell me your trip details and constraints so I can give you great recomendations?"
+    with gr.TabItem("Travel Companion"):
+        chatbot = gr.Chatbot(value=[[None, helper_anwser]])
+        user_input = gr.Textbox()
+        gr.Examples([
+            "I want to go to Rome. can you recommend a site seeing tour for one day?",
+            "I like to walk a lot and i prefer to visit fine arts museums",
+            "Porto for 3 days. i will arrive on monday and leave on thursday. i can only visit places after 5pm so be "
+            "sure i can visit those places",
+            "I would like to plan a trip to Europe with my family of four. We want to visit Paris, Rome, and Madrid in "
+            "10 days. Can you suggest an itinerary that includes transportation and accommodations? "
+            "Also, please provide information on the best restaurants in each city for a budget of $50 per person per meal."
+        ], user_input)
+    with gr.TabItem("Map"):
+        map = gr.Plot(visible=True).style()
+        result_df = gr.Dataframe(type="pandas", visible=True)
+    isComplete = False
+    history = ""
+    locations = []
+    
+    def user(user_message, history):
+        print(user_message, history)
+        return gr.update(value="", interactive=False), history + [[user_message, None]]
+    
+    # def bot(chat_history):
+    #     print(chat_history)
+    #     # Create history
+    #     history = ""
+    #     for i in range(len(chat_history)-1):
+    #         history += "User: " + chat_history[i][0] + "\nHelper: " + chat_history[i][1] + "\n"
+    #     history += "User: " + chat_history[-1][0]
+
+    #     # isComplete, helper_anwser, data_collected = send_message(message, history)
+    #     # if isComplete == True:
+    #         # helper_anwser = get_itenerary(data_collected)
+    #     # chat_history.append((message, helper_anwser))
+    #     return "", chat_history
+
+    def respond(chat_history):
+        print(chat_history)
+        # Create history
+        history = ""
+        for i in range(1, len(chat_history) - 1):
+            history += "User: " + chat_history[i][0] + "\nHelper: " + chat_history[i][1] + "\n"
+
+        message = chat_history[-1][0]
+        print(history)
+        print(message)
+        isComplete, helper_anwser, data_collected = send_message(message, history)
+
+        chat_history.pop(-1)
+
+        if isComplete == True:
+            itenerary = get_itenerary(data_collected)
+            locations = get_itenerary_places(itenerary)
+            helper_anwser = itenerary + "\nList of places with adresses: " + str(locations)
+            map, result_df = get_map.filter_map(locations)
+            chat_history.append((message, helper_anwser))
+            return chat_history, map, result_df
+        
+        chat_history.append((message, helper_anwser))
+        return chat_history, None, None
+
+    # user_input.submit(respond, [user_input, chatbot], [user_input, chatbot])
+
+    response = user_input.submit(user, [user_input, chatbot], [user_input, chatbot], queue=False).then(
+        respond, chatbot, [chatbot, map, result_df]
+    )
+    response.then(lambda: gr.update(interactive=True), None, [user_input], queue=False)
+
+    # if map != None:
+    #     map.update(visible=True)
+    #     result_df.update(visible=True)
+
+demo.launch(auth=( os.environ["USER"],os.environ["PASSWORD"]))
+
+
+
+# while isComplete == False:
+
+#     isComplete, helper_anwser, data_collected = main.send_message(user_input, chat_history)
+
+#     if isComplete == False:
+#         chat_history += "User: " + user_input + "\nHelper: " + helper_anwser + "\n"
+#         user_input = input("Helper: " + helper_anwser + "\nUser: ")
+
+# itenerary_response = main.get_itenerary(data_collected)
+
+
+# I would like to go to paris, from 12th of july to 15th of July, I want to visit museums, eat at local restaurants and visit the louvre on my first day. My son is allergic to peanuts, and I like to sleep in, so please don't book anything before 11am. I would also like to not get further then 2km from the city's center.

gather_details.py

@@ -0,0 +1,155 @@
+import os
+import platform
+
+import openai
+import chromadb
+import langchain
+
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.text_splitter import TokenTextSplitter
+from langchain.llms import OpenAI
+from langchain.chat_models import ChatOpenAI
+from langchain.chains import ChatVectorDBChain
+from langchain.document_loaders import GutenbergLoader
+
+from langchain.embeddings import LlamaCppEmbeddings
+from langchain.llms import LlamaCpp
+
+from langchain.output_parsers import StructuredOutputParser, ResponseSchema
+from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate
+from langchain.llms import OpenAI
+from langchain.chains import LLMChain
+from langchain.chains import SimpleSequentialChain
+
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field, validator
+from typing import List, Dict
+
+class AnswerTemplate(BaseModel):
+    type: List[str] = Field(description="What is the type of the trip: business, family, vactions. And with whom are you travelling? If can't anwser then leave it empty")
+    where: str = Field(description="Where is the user going? If can't anwser then leave it empty")
+    start_date: str = Field(description="What is the start date? If can't anwser then leave it empty")
+    end_date: str = Field(description="What is the end date? If can't anwser then leave it empty")
+    time_constrains: str = Field(description="Is there any time constrains? If can't anwser then leave it empty")
+    # dates: Dict[str, str] = Field(description="What are the importante dates and times? If can't anwser then leave it empty")
+    preferences: List[str] = Field(description="What does the user want to visit? If can't anwser then leave it empty")
+    conditions: str = Field(description="Does the user has any special medical condition? If can't anwser then leave it empty")
+    dist_range: str = Field(description="Max distance from a place? If can't anwser then leave it empty")
+    # missing: str = Field(description="Is any more information needed?")
+
+class CheckAnswerTemplate(BaseModel):
+    isComplete: bool = Field(description="Is the input complete?")
+    # missing: str = Field(description="If the answer to the last question is false, then what is missing?")
+    answer: str = Field(description="""If the answer to 'isComplete' is true leave this empty, else complete this by giving a nice compliment to the user's choices and asking the user for the missing information. Just one question.""")
+    
+
+# os.environ["OPENAI_API_KEY"] = "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"
+
+
+model_name = "gpt-4"
+# model_name = "gpt-3.5-turbo"
+
+chat_history = ""
+
+model = OpenAI(model_name=model_name, temperature=0)
+
+output_parser_gather = PydanticOutputParser(pydantic_object=AnswerTemplate)
+format_instructions_gather = output_parser_gather.get_format_instructions()
+
+output_parser_check = PydanticOutputParser(pydantic_object=CheckAnswerTemplate)
+format_instructions_check = output_parser_check.get_format_instructions()
+
+helper_anwser = "Hello, can you tell me your trip details and constraints so I can give you great recomendations?"
+
+user_input = input("Helper: " + helper_anwser + "\nUser: ")
+
+# output_parser_2 = PydanticOutputParser(pydantic_object=AnswerTemplate_2)
+# format_instructions_2 = output_parser_2.get_format_instructions()
+
+# prompt_gather = PromptTemplate(
+#     template="""\
+#             ### Instruction
+#             You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+#             As a smart itinerary planner with extensive knowledge of places around the
+#             world, your task is to determine the user's travel destinations and any specific interests or preferences from
+#             their message. Create an itinerary that caters to the user's needs, making sure to name all activities,
+#             restaurants, and attractions specifically. When creating the itinerary, also consider factors such as time
+#             constraints and transportation options. Additionally, all attractions and restaurants listed in the itinerary
+#             must exist and be named specifically. During subsequent revisions, the itinerary can be modified, while keeping
+#             in mind the practicality of the itinerary. New place for each day. It's important to ensure that the number of
+#             activities per day is appropriate, and if the user doesn't specify otherwise, the default itinerary length is
+#             five days. The itinerary length should remain the same unless there is a change by the user's message. Here is the history that you have so far: {history} \n### User: \n{input}
+#             \n### Response: {format_instructions}
+#             """,
+#     input_variables=["input", "history", "format_instructions"]
+#     # partial_variables={"format_instructions": format_instructions_gather}
+# )
+
+prompt_gather = PromptTemplate(
+    template="""\
+            ### Instruction
+            You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+            As a smart itinerary planner with extensive knowledge of places around the
+            world, your task is to determine the user's travel destinations and any specific interests or preferences from
+            their message. Here is the history that you have so far: {history} \n### User: \n{input}
+            \n### Response: {format_instructions}
+            """,
+    input_variables=["input", "history", "format_instructions"]
+    # partial_variables={"format_instructions": format_instructions_gather}
+)
+
+prompt_check = PromptTemplate(
+    template="""\
+            ### Instruction
+            Is this input complete? If not, what is missing? 
+            ### Important: Give a nice compliment to the user's choices: {user_input} 
+            ### Then ask for the missing information.
+            Don't ask more then one question.
+            Ask just one of the following:
+            If 'type' is empty then ask the user what is the objective of the trip and with whom are you travelling?;
+            If 'where' is empty then ask the user where is they going to travel to?;
+            If 'start_date' is empty then ask the user what is the start date?;
+            If 'end_date' is empty then ask the user what is the end date?;
+            If 'time_constrains' is empty then ask the user if is there any time constrains that should be considered?;
+            If 'preferences' is empty then ask the user if they have thought about any activities you want to do while you're there?;
+            If 'conditions' is empty then ask the user if they have any special medical condition?;
+            If 'dist_range' is empty then ask the user what is the distance range you prefer for your ativities? \n### Input: {input}
+            \n### Response: {format_instructions}
+            """,
+    input_variables=["input", "user_input", "format_instructions"]
+    # partial_variables={"format_instructions": format_instructions_check}
+    # f 'dates' is empty then ask the user what are the importante dates and times?;
+)
+
+isComplete = False
+
+while isComplete == False:
+
+    _input_gather = prompt_gather.format_prompt(history=chat_history, input=user_input, format_instructions=format_instructions_gather)
+
+    # chain_gather = LLMChain(llm=model, prompt=prompt_gather)
+    # chain_check = LLMChain(llm=model, prompt=prompt_check)
+
+    # overall_chain = SimpleSequentialChain(chains=[chain_gather, chain_check], verbose=True)
+
+    result_gather = model(_input_gather.to_string())
+    parsed_result_gather = output_parser_gather.parse(result_gather)
+    print(parsed_result_gather)
+
+    _input_check = prompt_check.format_prompt(input=parsed_result_gather, user_input="\nHelper: " + helper_anwser + "\nUser: " + user_input, format_instructions=format_instructions_check)
+    result_check = model(_input_check.to_string())
+    parsed_result_check = output_parser_check.parse(result_check)
+    # print(parsed_result_check)
+
+    isComplete = parsed_result_check.isComplete
+    helper_anwser = parsed_result_check.answer
+
+    if isComplete == False:
+        chat_history += "User: " + user_input + "\nHelper: " + helper_anwser + "\n"
+        user_input = input("Helper: " + helper_anwser + "\nUser: ")
+        
+
+    # print(overall_chain.run(input=user_input))
+
+print(parsed_result_gather)

gather_details_fewshots.py

@@ -0,0 +1,155 @@
+import os
+
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.text_splitter import TokenTextSplitter
+from langchain.llms import OpenAI, LlamaCpp
+from langchain.chat_models import ChatOpenAI
+from langchain.chains import ChatVectorDBChain
+
+from langchain.embeddings import LlamaCppEmbeddings
+
+from langchain.output_parsers import StructuredOutputParser, ResponseSchema, PydanticOutputParser
+from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, FewShotPromptTemplate
+from langchain.chains import LLMChain
+from langchain.chains import SimpleSequentialChain
+
+from pydantic import BaseModel, Field, validator
+from typing import List, Dict
+
+class AnswerTemplate(BaseModel):
+    type: List[str] = Field(description="What is the type of the trip: business, family, vactions. And with whom are you travelling? If can't anwser them leave it empty")
+    dates: Dict[str, str] = Field(description="What are the importante dates and times? If can't anwser them leave it empty")
+    preferences: List[str] = Field(description="What are the user's preferences? If can't anwser them leave it empty")
+    conditions: str = Field(description="Does the user has any special medical condition? If can't anwser them leave it empty.")
+    dist_range: str = Field(description="Max distance from a place? If can't anwser them leave it empty")
+
+class CheckAnswerTemplate(BaseModel):
+    isComplete: bool = Field(description="Is the input complete?")
+    answer: str = Field(description="""If the answer to 'isComplete' is true leave this empty, else complete this by asking the user for the missing information. Just one question.""")
+    
+
+# os.environ["OPENAI_API_KEY"] = "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"
+os.environ["OPENAI_API_KEY"] = "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" # Mindera's Key
+embeddings = OpenAIEmbeddings()
+# embeddings = LlamaCppEmbeddings()
+
+persist_directory="../../../chroma/"
+
+# model_name = "gpt-4"
+model_name = "gpt-3.5-turbo"
+
+chat_history = ""
+
+model = OpenAI(model_name=model_name, temperature=0)
+
+output_parser_gather = PydanticOutputParser(pydantic_object=AnswerTemplate)
+format_instructions_gather = output_parser_gather.get_format_instructions()
+
+output_parser_check = PydanticOutputParser(pydantic_object=CheckAnswerTemplate)
+format_instructions_check = output_parser_check.get_format_instructions()
+
+user_input = input("Helper: Hello, can you tell me your trip details and constraints so I can give you great recomendations?\nUser: ")
+
+examples = [
+    {"input": "i am travelling from 12 of july to 15 of july", "response": "start date: 12th july, end date: 15th july"},
+    {"input": "I like museums and cafes", "response": "preferences: museums and cafes"},
+    {"input": "Maximum 5km from the city's stadium", "response": "dist_range: 5km from the city's stadium"},
+    {"input": "It's a business trip and i am travelling alone", "response": "type: [business, alone]"}
+]
+
+example_formatter_template = """User: {input}
+Response: {response}
+"""
+
+example_prompt = PromptTemplate(
+    input_variables=["input", "response"],
+    template=example_formatter_template,
+)
+
+few_shot_prompt = FewShotPromptTemplate(
+    # These are the examples we want to insert into the prompt.
+    examples=examples,
+    # This is how we want to format the examples when we insert them into the prompt.
+    example_prompt=example_prompt,
+    # The prefix is some text that goes before the examples in the prompt.
+    # Usually, this consists of intructions.
+    prefix="""### Instruction
+            You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+            As a smart itinerary planner with extensive knowledge of places around the
+            world, your task is to determine the user's travel destinations and any specific interests or preferences from
+            their message. Here is the history that you have so far: {history} \n###""",
+    # The suffix is some text that goes after the examples in the prompt.
+    # Usually, this is where the user input will go
+    suffix="""\n### User: {input}
+            \n### Response: {format_instructions}""",
+    # The input variables are the variables that the overall prompt expects.
+    input_variables=["input", "history", "format_instructions"],
+    # The example_separator is the string we will use to join the prefix, examples, and suffix togather with.
+    example_separator="\n",
+)
+
+prompt_gather = PromptTemplate(
+    template="""\
+            ### Instruction
+            You are Trainline Mate an helpful assistant that plans tours for people at trainline.com.
+            As a smart itinerary planner with extensive knowledge of places around the
+            world, your task is to determine the user's travel destinations and any specific interests or preferences from
+            their message. Here is the history that you have so far: {history} \n### User: {input}
+            \n### Response: {format_instructions}
+            """,
+    input_variables=["input", "history", "format_instructions"]
+    # partial_variables={"format_instructions": format_instructions_gather}
+)
+
+prompt_check = PromptTemplate(
+    template="""\
+            ### Instruction
+            Is this input complete? If not, what is missing? If it's the first time responding to the user then thank the user for the details 
+            provided and then ask for the missing information. Don't ask more then one question.
+            Ask just one of the following:
+            If 'type' is empty then ask the user what is the objective of the trip and with whom are you travelling;
+            If 'dates' is empty then ask the user what are the importante dates and times;
+            If 'preferences' is empty then ask the user what are the user's preferences;
+            If 'conditions' is empty then ask the user if they have any special medical condition;
+            If 'dist_range' is empty then ask the user what is the distance range you prefer for your accommodations and activities? \n### Input: {input}
+            \n### Response: {format_instructions}
+            """,
+    input_variables=["input", "format_instructions"]
+    # partial_variables={"format_instructions": format_instructions_check}
+)
+
+examples_gather = [
+    {"input": "happy", "antonym": "sad"},
+    {"word": "tall", "antonym": "short"},
+]
+
+isComplete = False
+
+while isComplete == False:
+
+    _input_gather = few_shot_prompt.format_prompt(history=chat_history, input=user_input, format_instructions=format_instructions_gather)
+
+    # chain_gather = LLMChain(llm=model, prompt=prompt_gather)
+    # chain_check = LLMChain(llm=model, prompt=prompt_check)
+
+    # overall_chain = SimpleSequentialChain(chains=[chain_gather, chain_check], verbose=True)
+
+    result_gather = model(_input_gather.to_string())
+    parsed_result_gather = output_parser_gather.parse(result_gather)
+    print(parsed_result_gather)
+
+    _input_check = prompt_check.format_prompt(input=parsed_result_gather, format_instructions=format_instructions_check)
+    result_check = model(_input_check.to_string())
+    parsed_result_check = output_parser_check.parse(result_check)
+    # print(parsed_result_check)
+
+    isComplete = parsed_result_check.isComplete
+
+    if isComplete == False:
+        chat_history += "User: " + user_input + "\nHelper: " + parsed_result_check.answer + "\n"
+        user_input = input("Helper: " + parsed_result_check.answer + "\nUser: ")
+
+    # print(overall_chain.run(input=user_input))
+
+print(parsed_result_gather)

get_map.py

@@ -0,0 +1,159 @@
+import logging
+import pandas as pd
+import os
+from typing import Optional, Dict, Any
+import gradio as gr
+import googlemaps
+from PIL import Image
+from langchain.utilities.google_places_api import GooglePlacesAPIWrapper
+import plotly.graph_objects as go
+import requests
+from PIL import Image
+from io import BytesIO
+import tempfile
+class GooglePlacesAPIWrapperExtended(GooglePlacesAPIWrapper):
+    api_key = os.environ["GPLACES_API_KEY"]
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+    def run(self, query: str, **kwargs) -> pd.DataFrame:
+        """Run Places search and get k number of places that exist that match."""
+        search_results = self.google_map_client.places(query, **kwargs)["results"]
+        num_to_return = len(search_results)
+        places = []
+        if num_to_return == 0:
+            return pd.DataFrame(columns=["Name", "Address", "Phone Number", "Website",
+                                         "Opening Hours", "Is Open Now", "latitude", "longitude",
+                                         "Summary", "Rating", "Image", "Reviews"])
+        num_to_return = (
+            num_to_return
+            if self.top_k_results is None
+            else min(num_to_return, self.top_k_results)
+        )
+        for i in range(num_to_return):
+            result = search_results[i]
+            details = self.fetch_place_details(result["place_id"])
+            if details is not None:
+                places.append(details)
+        return pd.DataFrame(places)
+    def fetch_place_details(self, place_id: str) -> Optional[Dict[str, Any]]:
+        try:
+            place_details = self.google_map_client.place(place_id)
+            formatted_details = self.format_place_details(place_details)
+            return formatted_details
+        except Exception as e:
+            logging.error(f"An Error occurred while fetching place details: {e}")
+            return None
+    def format_place_details(self, place_details: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        try:
+            name = place_details.get("result", {}).get("name", "Unknown")
+            address = place_details.get("result", {}).get("formatted_address", "Unknown")
+            phone_number = place_details.get("result", {}).get("formatted_phone_number", "Unknown")
+            website = place_details.get("result", {}).get("website", "Unknown")
+            weekday_text = place_details.get("result", {}).get("opening_hours", {}).get("weekday_text", [])
+            is_open = place_details.get("result", {}).get("opening_hours", {}).get("open_now", "Unknown")
+            location = place_details.get("result", {}).get("geometry", {}).get("location", {})
+            latitude = location.get("lat", "Unknown")
+            longitude = location.get("lng", "Unknown")
+            summary = place_details.get("result", {}).get("editorial_summary", {}).get("overview", "Unknown")
+            rating = place_details.get("result", {}).get("rating", "Unknown")
+            image = place_details.get("result", {}).get("photos", [{}])[0].get("photo_reference", "Unknown")
+            image_url = f"https://maps.googleapis.com/maps/api/place/photo?maxwidth=400&photoreference={image}&key={self.api_key}"
+            first_three_reviews = place_details.get("result", {}).get("reviews", [])[:3]
+            formatted_details = {
+                "name": name,
+                "address": address,
+                "phone_number": phone_number,
+                "website": website,
+                "opening_hours": weekday_text,
+                "is_open_now": is_open,
+                "latitude": latitude,
+                "longitude": longitude,
+                "summary": summary,
+                "rating": rating,
+                "image": image_url,
+                "reviews": first_three_reviews
+            }
+            return formatted_details
+        except Exception as e:
+            logging.error(f"An error occurred while formatting place details: {e}")
+            return None
+#pd.set_option("display.max_columns", None)
+#pd.set_option("display.max_rows", None)
+#gplaceapi = GooglePlacesAPIWrapperExtended()
+#query = "Louvre, Paris"
+#result_df = gplaceapi.run(query)
+#print(result_df)
+#query = gr.inputs.Textbox(lines=2, label="Query")
+#result_df = gr.outputs.Dataframe(type="pandas")
+#gr.Interface(fn=GooglePlacesAPIWrapperExtended().run, inputs=query, outputs=result_df).launch(debug=True)
+def filter_map(locations):
+    dataframe = pd.DataFrame()
+    for location in locations: 
+        dataframe = pd.concat([dataframe, GooglePlacesAPIWrapperExtended().run(location)])
+
+    names = dataframe["name"].tolist()
+    summaries = dataframe["summary"].tolist()
+    image_urls = dataframe["image"].tolist()
+        
+    fig = go.Figure(go.Scattermapbox(
+        lat=dataframe['latitude'].tolist(),
+        lon=dataframe['longitude'].tolist(),
+        mode='markers',
+        marker=go.scattermapbox.Marker(
+            size=13,
+            color='rgb(255, 123, 0)',
+        ),
+        hovertemplate='Name: %{customdata[0]}<br>Summary: %{customdata[1]}',
+        customdata=list(zip(names, summaries)),
+        name='Places'
+    ))
+    fig.update_layout(
+        mapbox_style="open-street-map",
+        hovermode='closest',
+        mapbox=dict(
+            bearing=0,
+            center=go.layout.mapbox.Center(
+                lat=dataframe['latitude'].tolist()[0],
+                lon=dataframe['longitude'].tolist()[0]
+            ),
+            pitch=0,
+            zoom=12
+        ),
+    )
+    # Add images using layout.images attribute
+    #for i, url in enumerate(image_urls):
+    #    response = requests.get(url)
+    #    img = Image.open(BytesIO(response.content))
+    #    with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp:
+    #        img.save(temp.name)
+    #        fig.add_layout_image(
+    #            dict(
+    #                source=temp.name,
+    #                xref='x',
+    #                yref='y',
+    #                x=dataframe['longitude'].iloc[i],
+    #                y=dataframe['latitude'].iloc[i],
+    #                sizex=0.05,
+    #                sizey=0.05,
+    #                sizing='stretch',
+    #                opacity=0.7,
+    #                layer='above'
+    #            )
+    #        )
+#
+    #fig.update_layout(
+    #    xaxis=dict(range=[dataframe['longitude'].min(), dataframe['longitude'].max()]),
+    #    yaxis=dict(range=[dataframe['latitude'].min(), dataframe['latitude'].max()])
+    #)
+#
+    return fig, dataframe
+
+if __name__ == "main":
+    with gr.Blocks() as demo:
+        with gr.Column():
+            location = gr.Textbox(lines=2, label="Location")
+            btn = gr.Button(value="Update Filter")
+            map = gr.Plot().style()
+            result_df = gr.Dataframe(type="pandas")
+        btn.click(filter_map, [location], [map, result_df])
+    demo.queue(concurrency_count=6).launch()

main.py

@@ -0,0 +1,52 @@
+from agents.gather_agent import Gather_Agent
+from agents.check_agent import Check_Agent
+from agents.response_agent import Response_Agent
+from agents.planner_agent import Planner_Agent
+
+gather_agent = Gather_Agent()
+check_agent = Check_Agent()
+response_agent = Response_Agent()
+planner_agent = Planner_Agent()
+
+isComplete = False
+chat_history = ""
+
+helper_anwser = "Hello, can you tell me your trip details and constraints so I can give you great recomendations?"
+user_input = input("Helper: " + helper_anwser + "\nUser: ")
+
+def send_message(user_input, chat_history):
+    isComplete = False
+    helper_anwser = ""
+
+    _input_gather = gather_agent.format_prompt(input=user_input, history=chat_history)
+    parsed_result_gather = gather_agent.get_parsed_result(_input_gather)
+
+    _input_check = check_agent.format_prompt(input=parsed_result_gather)
+    isComplete = check_agent.get_parsed_result(_input_check)
+
+    if isComplete == False:
+        _input_response = response_agent.format_prompt(input=parsed_result_gather)
+        helper_anwser = response_agent.get_parsed_result(_input_response)
+
+    return isComplete, helper_anwser, parsed_result_gather
+
+def get_itenerary(parsed_result_gather):
+    _input_planner = planner_agent.format_prompt(parsed_result_gather)
+    return planner_agent.get_itenerary(_input_planner)
+
+    
+
+while isComplete == False:
+    isComplete, helper_anwser, parsed_result_gather = send_message(user_input, chat_history)
+
+    if isComplete == False:
+        chat_history += "User: " + user_input + "\nHelper: " + helper_anwser + "\n"
+        user_input = input("Helper: " + helper_anwser + "\nUser: ")
+        
+
+print(parsed_result_gather)
+print(get_itenerary(parsed_result_gather))
+
+_input_places = planner_agent.format_instructions_places(parsed_result_gather)
+parsed_result_places = planner_agent.get_places_from_itenerary(_input_places)
+print(planner_agent.get_itenerary(_input_planner))

requirements.txt

@@ -0,0 +1,7 @@
+openai==0.27.2
+openapi-python-client==0.13.4
+openapi-schema-pydantic==1.2.4
+chromadb==0.3.26
+langchain==0.0.201
+googlemaps==4.10.0
+plotly==5.15.0