Add validation prompt template, test and agent

.gitignore

@@ -0,0 +1,2 @@
+venv
+__pycache__

agents/agent.py

@@ -0,0 +1,77 @@
+import openai
+import logging
+import time
+from templates.validation import ValidationTemplate  # Adjust the import path as necessary
+from langchain.chat_models  import ChatOpenAI
+from langchain.chains import LLMChain, SequentialChain
+
+logging.basicConfig(level=logging.INFO)
+
+class Agent:
+    def __init__(
+        self,
+        openai_api_key,
+        model="gpt-3.5-turbo",
+        temperature=0,
+        debug=True,
+    ):
+        self.logger = logging.getLogger(__name__)
+        if debug:
+            self.logger.setLevel(logging.DEBUG)
+        else:
+            self.logger.setLevel(logging.INFO)
+        
+        self._openai_key = openai_api_key
+
+        # Initialize ChatOpenAI with the provided OpenAI API key and model details
+        self.chat_model = ChatOpenAI(model=model, temperature=temperature, openai_api_key=self._openai_key)
+        # Initialize the ValidationTemplate
+        self.validation_prompt = ValidationTemplate()
+        # Setup the validation chain using the LLMChain and SequentialChain
+        self.validation_chain = self._set_up_validation_chain(debug)
+
+    def _set_up_validation_chain(self, debug=True):
+        # Make validation agent chain using LLMChain
+        validation_agent = LLMChain(
+            llm=self.chat_model,
+            prompt=self.validation_prompt.chat_prompt,
+            output_parser=self.validation_prompt.parser,
+            output_key="validation_output",
+            verbose=debug,
+        )
+        
+        # Add validation agent to sequential chain
+        overall_chain = SequentialChain(
+            chains=[validation_agent],
+            input_variables=["query", "format_instructions"],
+            output_variables=["validation_output"],
+            verbose=debug,
+        )
+
+        return overall_chain
+
+    def validate_travel(self, query):
+        self.logger.info("Validating query: %s", query)
+        t1 = time.time()
+        
+        self.logger.info(
+            "Calling validation (model is {}) on user input".format(
+                self.chat_model.model_name
+            )
+        )
+
+
+        # Call the validation chain with the query and format instructions
+        validation_result = self.validation_chain.run(
+            {
+                "query": query,
+                "format_instructions": self.validation_prompt.parser.get_format_instructions(),
+            }
+        )
+
+        # Extract the result from the validation output
+        validation_output = validation_result["validation_output"].dict()
+        t2 = time.time()
+        self.logger.debug("Time to validate request: %.2f seconds", t2 - t1)
+
+        return validation_output

app.py

@@ -31,8 +31,11 @@ if 'end_date' not in st.session_state:
 with st.sidebar:
     st.header('Enter Your Travel Details')
 
-    # Destination input
-    destination = st.text_input('Destination', help='Enter the destination for your trip.')
+    # Start location input
+    start_location = st.text_input('From', help='Enter the starting location for your trip.')
+
+    # End location input
+    end_location = st.text_input('To', help='Enter the final location for your trip.')
 
     # Create the start date input widget
     start_date = st.date_input(
@@ -93,10 +96,11 @@ with st.sidebar:
 # Main page layout
 st.header('Your Itinerary')
 if submit:
-    if destination and attractions and start_date and end_date:
+    if start_location and end_location and attractions and start_date and end_date:
         # The function to generate the itinerary would go here.
         # The following lines are placeholders to show the captured inputs.
-        st.write('Destination:', destination)
+        st.write('From:', start_location)
+        st.write('To:', end_location)
         st.write('Travel Dates:', st.session_state['start_date'], 'to', st.session_state['end_date'])
         st.write('Attractions:', attractions)
         st.write('Budget:', budget)

config.py

@@ -11,12 +11,18 @@ def load_secrets():
     google_maps_key = os.getenv("GOOGLE_MAPS_API_KEY")
     google_palm_key = os.getenv("GOOGLE_PALM_API_KEY")
 
-    # Make sure to check if keys were successfully loaded and handle accordingly
-    if not open_ai_key or not google_maps_key or not google_palm_key:
-        raise Exception("API keys not found. Ensure .env file is set up correctly for local development or secrets are set for deployment.")
-
-    return {
+    # Collect all keys in a dictionary
+    secrets = {
         "OPENAI_API_KEY": open_ai_key,
         "GOOGLE_MAPS_API_KEY": google_maps_key,
         "GOOGLE_PALM_API_KEY": google_palm_key,
     }
+
+    # Check if any of the keys are missing
+    missing_keys = [key for key, value in secrets.items() if not value]
+    if missing_keys:
+        missing_keys_str = ", ".join(missing_keys)
+        raise Exception(f"Missing API keys: {missing_keys_str}. Ensure .env file is set up correctly.")
+
+    return secrets
+

requirements.txt

@@ -1,15 +1,14 @@
 streamlit
-requests>=2.26.0
-pandas>=1.3.5
-folium>=0.14.0
-streamlit-folium>=0.4.0
-python-dotenv>=1.0.0
-httpx>=0.21.1
+requests
+folium
+streamlit-folium
+python-dotenv
+httpx
 langchain
 python-dotenv
 openai
 folium
 google-generativeai
-geopandas>=0.13.2
+geopandas
 tiktoken 
 duckduckgo-search

templates/validation.py

@@ -0,0 +1,59 @@
+from langchain.prompts import (
+    ChatPromptTemplate,
+    SystemMessagePromptTemplate,
+    HumanMessagePromptTemplate,
+)
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field
+
+# Validation schema
+class Validation(BaseModel):
+    plan_is_valid: str = Field(description="This field is 'yes' if the plan is feasible, 'no' otherwise")
+    updated_request: str = Field(description="Your update to the plan")
+
+class ValidationTemplate:
+    def __init__(self):
+        self.system_template = """
+      You are a travel agent who helps users make exciting travel plans.
+
+      The user's request will be denoted by four hashtags. Determine if the user's
+      request is reasonable and achievable within the constraints they set.
+
+      A valid request should contain the following:
+      - A start and end location
+      - A trip duration that is reasonable given the start and end location
+      - Some other details, like the user's interests and/or preferred mode of transport
+
+      Any request that contains potentially harmful activities is not valid, regardless of what
+      other details are provided.
+
+      If the request is not valid, set
+      plan_is_valid = 'no' and use your travel expertise to update the request to make it valid,
+      keeping your revised request shorter than 100 words.
+
+      If the request seems reasonable, then set plan_is_valid = 'yes' and
+      don't revise the request.
+
+      {format_instructions}
+    """
+
+        self.human_template = """
+      ####{query}####
+    """
+
+        self.parser = PydanticOutputParser(pydantic_object=Validation)
+
+        self.system_message_prompt = SystemMessagePromptTemplate.from_template(
+            self.system_template,
+            partial_variables={
+                "format_instructions": self.parser.get_format_instructions()
+            },
+        )
+        self.human_message_prompt = HumanMessagePromptTemplate.from_template(
+            self.human_template, 
+            input_variables=["query"]
+        )
+
+        self.chat_prompt = ChatPromptTemplate.from_messages(
+            [self.system_message_prompt, self.human_message_prompt]
+        )

tests/agent/test_agent.py

@@ -0,0 +1,65 @@
+import unittest
+from config import load_secrets # Update this path to match the actual location
+from agents.agent import Agent  # Update this path to match the actual location
+
+DEBUG = True
+
+class TestAgentMethods(unittest.TestCase):
+
+    def assert_secrets(self, secrets_dict):
+        assert secrets_dict["OPENAI_API_KEY"] is not None
+        assert secrets_dict["GOOGLE_MAPS_API_KEY"] is not None
+        assert secrets_dict["GOOGLE_PALM_API_KEY"] is not None
+
+
+    def setUp(self):
+        self.debug = DEBUG
+        secrets = load_secrets()
+        self.assert_secrets(secrets)
+
+        # Assuming you only need the OPENAI_API_KEY for this test
+        self.agent = Agent(
+            openai_api_key=secrets["OPENAI_API_KEY"],
+            debug=self.debug,
+        )
+
+    # @unittest.skipIf(DEBUG, "Skipping this test while debugging other tests")
+    def test_validation_chain(self):
+        validation_chain = self.agent._set_up_validation_chain(debug=self.debug)
+
+        # not a reasonable request
+        q1 = "fly to the moon"
+        q1_res = validation_chain(
+            {
+                "query": q1,
+                "format_instructions": self.agent.validation_prompt.parser.get_format_instructions(),
+            }
+        )
+        q1_out = q1_res["validation_output"].dict()
+        self.assertEqual(q1_out["plan_is_valid"], "no")
+
+        # not a reasonable request
+        q2 = "1 day road trip from Chicago to Brazilia"
+        q2_res = validation_chain(
+            {
+                "query": q2,
+                "format_instructions": self.agent.validation_prompt.parser.get_format_instructions(),
+            }
+        )
+        q2_out = q2_res["validation_output"].dict()
+        self.assertEqual(q2_out["plan_is_valid"], "no")
+
+        # a reasonable request
+        q3 = "1 week road trip from Chicago to Mexico city"
+        q3_res = validation_chain(
+            {
+                "query": q3,
+                "format_instructions": self.agent.validation_prompt.parser.get_format_instructions(),
+            }
+        )
+        q3_out = q3_res["validation_output"].dict()
+        self.assertEqual(q3_out["plan_is_valid"], "yes")
+
+
+if __name__ == "__main__":
+    unittest.main()