you.com, tavily, and perplexity is working in the helper functions.

app.py

@@ -46,7 +46,6 @@ if submit_button:
             # Save answers and state to session state
             st.session_state['answer_a'] = answer_a
             st.session_state['answer_b'] = answer_b
-            # st.session_state['selected_model'] = selected_model
             st.session_state['question'] = question
             st.session_state['results_displayed'] = True
         else:

helpers.py

@@ -0,0 +1,154 @@
+import requests
+from dotenv import load_dotenv
+import os
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Get API keys from environment variables
+YOU_COM_API_KEY = os.getenv('YOU_API_KEY')
+TAVILY_API_KEY = os.getenv('TAVILY_API_KEY')
+PERPLEXITY_API_KEY = os.getenv('PPLX_API_KEY')
+BRAVE_API_KEY = os.getenv('BRAVESEARCH_API_KEY')
+
+def query_you_com(query):
+    headers = {"X-API-Key": YOU_COM_API_KEY}
+    params = {"query": query}
+    try:
+        response = requests.get(
+            "https://api.ydc-index.io/rag",  # Verify the correctness of the API endpoint
+            params=params,
+            headers=headers,
+        )
+        response.raise_for_status()  # Raises an HTTPError if the response code was unsuccessful
+        return response.json()
+    except requests.exceptions.HTTPError as http_err:
+        return f"HTTP error occurred: {http_err}"
+    except Exception as err:
+        return f"An error occurred: {err}"
+
+
+def query_tavily(query):
+    payload = {
+        "api_key": TAVILY_API_KEY,
+        "query": query,
+        "search_depth": "basic",
+        "include_answer": True,
+        "include_images": False,
+        "include_raw_content": False,
+        "max_results": 1,
+        "include_domains": [],
+        "exclude_domains": []
+    }
+    response = requests.post("https://api.tavily.com/search", json=payload)
+    if response.status_code == 200:
+        return response.json()
+    else:
+        return f"Request failed with status code: {response.status_code}"
+
+def query_perplexity(query):
+    url = 'https://api.perplexity.ai/chat/completions'
+    headers = {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+        'Authorization': f'Bearer {PERPLEXITY_API_KEY}'
+    }
+    data = {
+        "model": "llama-3-sonar-large-32k-online",
+        "stream": False,
+        "max_tokens": 1024,
+        "frequency_penalty": 1,
+        "temperature": 0.0,
+        "messages": [
+            {
+                "role": "system", 
+                "content": "Be precise and concise in your responses."
+            },
+            {
+                "role": "user",
+                "content": query
+            }
+        ]
+    }
+    response = requests.post(url, headers=headers, json=data)
+    if response.status_code == 200:
+        result = response.json()
+        return result['choices'][0]['message']['content']
+    else:
+        return f"Request failed with status code: {response.status_code}"
+
+# def query_brave(query):
+#     headers = {"X-API-Key": BRAVE_API_KEY}
+#     params = {
+#         "q": query,
+#         "count": 1,
+#         "summary": True
+#     }
+#     response = requests.get("https://api.search.brave.com/res/v1/web/search", params=params, headers=headers)
+#     if response.status_code == 200:
+#         return response.json().get("summary", "No summary available.")
+#     else:
+#         return f"Request failed with status code: {response}"
+    
+
+# def brave_search_summarization(query):
+#     # Endpoint for web search with summary
+#     web_search_url = "https://api.search.brave.com/res/v1/web/search"
+#     summarizer_url = "https://api.search.brave.com/res/v1/summarizer/search"
+    
+#     # Headers for the requests
+#     headers = {
+#         "Accept": "application/json",
+#         "Accept-Encoding": "gzip",
+#         "X-Subscription-Token": BRAVE_API_KEY
+#     }
+    
+#     # Parameters for the initial web search request
+#     web_search_params = {
+#         "q": query,
+#         "summary": 1
+#     }
+    
+#     # Make the initial request to the web search endpoint
+#     web_search_response = requests.get(web_search_url, headers=headers, params=web_search_params)
+    
+#     # Check if the request was successful
+#     if web_search_response.status_code != 200:
+#         raise Exception(f"Web search request failed with status code {web_search_response.status_code}")
+    
+#     web_search_data = web_search_response.json()
+    
+#     # Extract the summarizer key from the response
+#     summarizer_key = web_search_data.get('summarizer', {}).get('key')
+#     if not summarizer_key:
+#         raise Exception("No summarizer key found in the web search response")
+    
+#     # Parameters for the summarizer request
+#     summarizer_params = {
+#         "key": summarizer_key,
+#         "entity_info": 1
+#     }
+    
+#     # Make the request to the summarizer endpoint
+#     summarizer_response = requests.get(summarizer_url, headers=headers, params=summarizer_params)
+    
+#     # Check if the request was successful
+#     if summarizer_response.status_code != 200:
+#         raise Exception(f"Summarizer request failed with status code {summarizer_response.status_code}")
+    
+#     summarizer_data = summarizer_response.json()
+    
+#     # Return the summarized content
+#     return summarizer_data
+
+def ProcessQuestion(question, model):
+    if model == "You.com":
+        return query_you_com(question)
+    elif model == "Tavily.com":
+        return query_tavily(question)
+    elif model == "Perplexity.ai":
+        return query_perplexity(question)
+    elif model == "Brave.com":
+        return query_brave(question)
+    else:
+        return "Model not supported"

test_func.py

@@ -0,0 +1,24 @@
+from helpers import query_you_com, query_tavily, query_perplexity #, brave_search_summarization,
+
+def test_queries():
+    test_query = "How is the weather in Palo Alto, CA?"
+
+    print("Testing You.com API:")
+    # you_com_result = query_you_com(test_query)
+    you_com_result = query_you_com(test_query)
+    print(you_com_result['answer'])
+
+    print("\nTesting Tavily.com API:")
+    tavily_result = query_tavily(test_query)
+    print(tavily_result['answer'])
+
+    print("\nTesting Perplexity.ai API:")
+    perplexity_result = query_perplexity(test_query)
+    print(perplexity_result)
+
+    # print("\nTesting Brave.com API:")
+    # brave_result = brave_search_summarization(test_query)
+    # print(brave_result)
+
+if __name__ == "__main__":
+    test_queries()