Upload folder using huggingface_hub

.env

@@ -0,0 +1,4 @@
+OPENAI_API_KEY='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'
+GMAPS_API_KEY='AIzaSyDXCm-fwucr6R93CHa9Bb4j5qArup5D4kY'
+GOOGLE_MAPS_API_KEY='AIzaSyDXCm-fwucr6R93CHa9Bb4j5qArup5D4kY'
+NEO4J_PASSWORD=222

README.md

@@ -1,12 +1,6 @@
 ---
-title: Webapp
-emoji: 🐠
-colorFrom: yellow
-colorTo: blue
+title: webapp
+app_file: llm.py
 sdk: gradio
 sdk_version: 4.7.1
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api.py

@@ -0,0 +1,36 @@
+from fastapi import FastAPI
+import pandas as pd
+from typing import List
+
+from fastapi import FastAPI, HTTPException
+import os
+from services.location_services import LocationDataHandler
+
+app = FastAPI()
+
+# Initialize your LocationDataHandler
+data_file = 'address.json'
+df = pd.read_json(data_file).drop('embeddings_specialization', axis=1).dropna().reset_index().drop('index', axis=1)
+handler = LocationDataHandler(df)
+
+app = FastAPI()
+
+@app.get("/data")
+async def read_data():
+    return df.to_dict(orient='records')
+
+
+@app.get("/filter_by_address")
+async def api_filter_by_address(address: str, max_distance_km: float = 30):
+    try:
+        filtered_df = handler.filter_by_address(address, max_distance_km)
+        if filtered_df is not None:
+            return filtered_df.to_dict(orient='records')
+        else:
+            raise HTTPException(status_code=404, detail="No locations found within the specified distance")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# To run the server:
+# uvicorn your_file_name:app --reload

get_data.rest

@@ -0,0 +1 @@
+GET http://localhost:8000/filter_by_address?address=phileo+damansara

llm.py

@@ -0,0 +1,121 @@
+from pydantic.v1 import BaseModel, Field
+from langchain.tools import tool
+import requests
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
+from langchain.schema.agent import AgentFinish
+from langchain.schema.runnable import RunnablePassthrough
+from langchain.agents import AgentExecutor
+from langchain.schema.output_parser import StrOutputParser
+from langchain.schema.runnable import RunnableMap
+from langchain.prompts import MessagesPlaceholder
+from langchain.tools.render import format_tool_to_openai_function
+from langchain.agents.format_scratchpad import format_to_openai_functions
+from langchain.memory import ConversationBufferMemory
+from dotenv import load_dotenv, find_dotenv
+import openai
+import os 
+import gradio as gr
+
+
+
+_ = load_dotenv(find_dotenv()) # read local .env file
+openai.api_key = os.environ['OPENAI_API_KEY']
+model_name = 'gpt-4-1106-preview'
+model = ChatOpenAI(temperature=0, model='gpt-4-1106-preview')
+output_parser = StrOutputParser()
+
+
+def invoke_llm(query, context, template):
+    prompt = ChatPromptTemplate.from_template(template)
+    chain = prompt | model | output_parser
+    return chain.invoke({"query": query, "context": context})
+
+
+class SearchInput(BaseModel):
+    medical_condition: str = Field(..., description="The medical condition to base the search on.")
+    address: str = Field(..., description="The address or location to consider for proximity in the search.")
+
+@tool(args_schema=SearchInput)
+def search_healthcare_professionals(medical_condition: str, address: str) -> str:
+    """
+    Search for healthcare professionals details based on their relevance to a specified medical condition 
+    and proximity to a given address. Results are approximate and based on available data.
+    """
+    BASE_URL = "http://localhost:8000/filter_by_address"
+    
+    # Parameters for the request
+    params = {
+        'address': address,
+    }
+
+    response = requests.get(BASE_URL, params=params)
+
+    if response.status_code == 200:
+        results = response.json()
+    else:
+        raise Exception(f"API Request failed with status code: {response.status_code}")
+
+    # Part 2: Use LLM
+    template = """ You are a medical expert and have been provided with a list of healthcare professionals 
+    along with their details including title, name, specialization, experience, 
+    company, address, and distance. The data is as follows:
+    
+    {context}
+
+    Query: I am seeking healthcare professionals who specialize in {query}. Based
+    on the provided data, please rank these professionals according to the relevance
+    of their specialization to the medical condition and their distance as mentioned
+    in the data. Provide a ranked tabular comparison, including their title, name,
+    specialization, experience, company, address, and distance."""
+    
+    context = "Results from the database (within 10km):\n{df}".format(df=results)
+    
+    results = invoke_llm(query=medical_condition, context=context, template=template)
+    return results
+
+
+system_message = (
+"""You are a helpful and professional assistant for Whitecoat360, a pharmacy service operating in Malaysia. 
+Your role is to assist users in finding and scheduling appointments with the most suitable pharmacists and nutritionists. 
+Start by asking users about their specific medical concerns or if they have a general health inquiry. 
+Use this information, along with their specific location, to employ the 'search_healthcare_professionals' function 
+for identifying the right specialists. Once an appropriate specialist is found, guide the users through the appointment setting process. 
+Remember, your assistance should focus on logistical support based on user needs and location; 
+avoid providing medical advice or consultations."""
+)
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", system_message),
+    MessagesPlaceholder(variable_name="chat_history"),
+    ("user", "{input}"),
+    MessagesPlaceholder(variable_name="agent_scratchpad")
+])
+
+tools = [search_healthcare_professionals]
+functions = [format_tool_to_openai_function(f) for f in tools]
+
+chat_model = ChatOpenAI(temperature=0, model='gpt-4-1106-preview').bind(functions=functions)
+agent_chain = RunnablePassthrough.assign(
+    agent_scratchpad = lambda x: format_to_openai_functions(x["intermediate_steps"])
+) | prompt | chat_model | OpenAIFunctionsAgentOutputParser()
+
+
+def predict(message, history):
+    gradio_memory = ConversationBufferMemory(return_messages=True, memory_key="chat_history")
+    
+    for human, ai in history:        
+        gradio_memory.save_context({"input": human}, {"output": ai})
+    gradio_agent_executor = AgentExecutor(agent=agent_chain, tools=tools, verbose=False, memory=gradio_memory)
+    gpt_response = gradio_agent_executor.invoke({"input": message})
+    return gpt_response['output']
+
+
+gr.ChatInterface(predict).launch(share=True)
+
+# print(search_healthcare_professionals({"medical_condition":"fever", "address":"phileo"}))
+
+# Implementation of the search logic goes here
+# res = pharma_search(df, medical_condition, address)
+# return res

requirements.txt

@@ -0,0 +1,117 @@
+# This file may be used to create an environment using:
+# $ conda create --name <env> --file <this file>
+# platform: linux-64
+_libgcc_mutex=0.1=main
+_openmp_mutex=5.1=1_gnu
+aiofiles=23.2.1=pypi_0
+aiohttp=3.9.1=pypi_0
+aiosignal=1.3.1=pypi_0
+altair=5.2.0=pypi_0
+annotated-types=0.6.0=pypi_0
+anyio=3.7.1=pypi_0
+argcomplete=1.12.3=pypi_0
+async-timeout=4.0.3=pypi_0
+attrs=23.1.0=pypi_0
+bzip2=1.0.8=h7b6447c_0
+ca-certificates=2023.08.22=h06a4308_0
+certifi=2023.11.17=pypi_0
+charset-normalizer=3.3.2=pypi_0
+click=8.1.7=pypi_0
+colorama=0.4.6=pypi_0
+contourpy=1.2.0=pypi_0
+cycler=0.12.1=pypi_0
+dataclasses-json=0.6.3=pypi_0
+distro=1.8.0=pypi_0
+exceptiongroup=1.2.0=pypi_0
+fastapi=0.104.1=pypi_0
+ffmpy=0.3.1=pypi_0
+filelock=3.13.1=pypi_0
+fonttools=4.45.1=pypi_0
+frozenlist=1.4.0=pypi_0
+fsspec=2023.10.0=pypi_0
+future=0.18.3=pypi_0
+geographiclib=2.0=pypi_0
+geopy=2.4.1=pypi_0
+gradio=4.7.1=pypi_0
+gradio-client=0.7.0=pypi_0
+greenlet=3.0.1=pypi_0
+h11=0.14.0=pypi_0
+httpcore=1.0.2=pypi_0
+httpx=0.25.2=pypi_0
+huggingface-hub=0.19.4=pypi_0
+idna=3.6=pypi_0
+importlib-resources=6.1.1=pypi_0
+jinja2=3.1.2=pypi_0
+jsonpatch=1.33=pypi_0
+jsonpointer=2.4=pypi_0
+jsonschema=4.20.0=pypi_0
+jsonschema-specifications=2023.11.1=pypi_0
+kiwisolver=1.4.5=pypi_0
+langchain=0.0.342=pypi_0
+langchain-core=0.0.7=pypi_0
+langsmith=0.0.67=pypi_0
+ld_impl_linux-64=2.38=h1181459_1
+libffi=3.4.4=h6a678d5_0
+libgcc-ng=11.2.0=h1234567_1
+libgomp=11.2.0=h1234567_1
+libstdcxx-ng=11.2.0=h1234567_1
+libuuid=1.41.5=h5eee18b_0
+markdown-it-py=3.0.0=pypi_0
+markupsafe=2.1.3=pypi_0
+marshmallow=3.20.1=pypi_0
+matplotlib=3.8.2=pypi_0
+mdurl=0.1.2=pypi_0
+multidict=6.0.4=pypi_0
+mypy-extensions=1.0.0=pypi_0
+ncurses=6.4=h6a678d5_0
+numpy=1.26.2=pypi_0
+openai=1.3.6=pypi_0
+openssl=3.0.12=h7f8727e_0
+orjson=3.9.10=pypi_0
+packaging=23.2=pypi_0
+pandas=2.1.3=pypi_0
+pillow=10.1.0=pypi_0
+pip=23.3.1=py310h06a4308_0
+pydantic=2.5.2=pypi_0
+pydantic-core=2.14.5=pypi_0
+pydub=0.25.1=pypi_0
+pygments=2.17.2=pypi_0
+pyparsing=3.1.1=pypi_0
+python=3.10.13=h955ad1f_0
+python-dateutil=2.8.2=pypi_0
+python-dotenv=1.0.0=pypi_0
+python-multipart=0.0.6=pypi_0
+pytz=2023.3.post1=pypi_0
+pyyaml=6.0.1=pypi_0
+readline=8.2=h5eee18b_0
+referencing=0.31.0=pypi_0
+requests=2.31.0=pypi_0
+requests-toolbelt=0.9.1=pypi_0
+rich=13.7.0=pypi_0
+rpds-py=0.13.1=pypi_0
+semantic-version=2.10.0=pypi_0
+setuptools=68.0.0=py310h06a4308_0
+shellingham=1.5.4=pypi_0
+six=1.16.0=pypi_0
+sniffio=1.3.0=pypi_0
+sqlalchemy=2.0.23=pypi_0
+sqlite=3.41.2=h5eee18b_0
+starlette=0.27.0=pypi_0
+tabulate=0.8.10=pypi_0
+tenacity=8.2.3=pypi_0
+tk=8.6.12=h1ccaba5_0
+tomlkit=0.12.0=pypi_0
+toolz=0.12.0=pypi_0
+tqdm=4.66.1=pypi_0
+typer=0.9.0=pypi_0
+typing-extensions=4.8.0=pypi_0
+typing-inspect=0.9.0=pypi_0
+tzdata=2023.3=pypi_0
+tzlocal=2.1=pypi_0
+urllib3=2.1.0=pypi_0
+uvicorn=0.24.0.post1=pypi_0
+websockets=11.0.3=pypi_0
+wheel=0.41.2=py310h06a4308_0
+xz=5.4.2=h5eee18b_0
+yarl=1.9.3=pypi_0
+zlib=1.2.13=h5eee18b_0

services/location_services.py

@@ -0,0 +1,125 @@
+import os
+import pandas as pd
+from dotenv import load_dotenv
+import requests
+from geopy.distance import geodesic
+
+load_dotenv()
+
+def find_place(input_text, api_key):
+    # Define the base URL and parameters for the request
+    base_url = "https://maps.googleapis.com/maps/api/place/findplacefromtext/json"
+    params = {
+        "fields": "formatted_address,name,rating,opening_hours,geometry",
+        "input": input_text,
+        "inputtype": "textquery",
+        "key": api_key  # Replace with your actual API key
+    }
+
+    # Make the GET request
+    response = requests.get(base_url, params=params)
+
+    # Check if the request was successful
+    if response.status_code == 200:
+        # Return the response content (JSON)
+        return response.json()
+    else:
+        # Return an error message if the request failed
+        return f"Request failed with status code: {response.status_code}"
+    
+    
+
+def get_zip_code(address):
+    base_url = "https://maps.googleapis.com/maps/api/geocode/json"
+    params = {
+        "address": address,
+        "key": "AIzaSyDXCm-fwucr6R93CHa9Bb4j5qArup5D4kY"
+    }
+    response = requests.get(base_url, params=params)
+    if response.status_code == 200:
+        data = response.json()
+        if data['status'] == 'OK':
+            # Extract the postal code from the address components
+            for component in data['results'][0]['address_components']:
+                if 'postal_code' in component['types']:
+                    return component['long_name']
+            return None
+        else:
+            return f"API request returned status: {data['status']}"
+    else:
+        return f"Request failed with status code: {response.status_code}"
+
+
+def get_distances_for_multiple_destinations(origin, destinations, api_key):
+    destinations_param = '|'.join(destinations)
+
+    base_url = "https://maps.googleapis.com/maps/api/distancematrix/json"
+    params = {
+        "origins": origin,
+        "destinations": destinations_param,
+        "key": api_key
+    }
+
+    response = requests.get(base_url, params=params)
+    if response.status_code == 200:
+        data = response.json()
+        if data['status'] == 'OK':
+            results = []
+            for element in data['rows'][0]['elements']:
+                if element['status'] == 'OK':
+                    distance = element['distance']['text']
+                    results.append(distance)
+                else:
+                    results.append("Distance calculation failed")
+            return results
+        else:
+            return ["API request returned error: " + data['status']]
+    else:
+        return [f"Request failed with status code: {response.status_code}"]
+
+class LocationDataHandler:
+    def __init__(self, data_frame):
+        # self.data_file = data_file
+        self.api_key = os.getenv('GOOGLE_MAPS_API_KEY')
+        self.data_frame = data_frame
+
+    def get_latlong_from_address(self, address):
+        try:
+            result = find_place(address, self.api_key)
+            lat = result['candidates'][0]['geometry']['location']['lat']
+            lng = result['candidates'][0]['geometry']['location']['lng']
+            return lat, lng
+        except Exception as e:
+            print(f"Error retrieving location for {address}: {e}")
+            return None
+
+    def calculate_distance(self, ref_point, latitude, longitude):
+        try:
+            location = (latitude, longitude)
+            return geodesic(ref_point, location).kilometers
+        except Exception as e:
+            print(f"Error calculating distance: {e}")
+            return None
+
+    def filter_by_address(self, address, max_distance_km=30):
+        ref_point = self.get_latlong_from_address(address)
+        if not ref_point:
+            return None
+        
+        def distance_calculation(row):
+            return self.calculate_distance(ref_point, row['Latitude'], row['Longitude'])
+
+        # Calculate distance for each row
+        self.data_frame['Distance'] = self.data_frame.apply(distance_calculation, axis=1)
+
+        # Select top 10 within the maximum distance
+        df = self.data_frame[self.data_frame['Distance'] <= max_distance_km].sort_values(by='Distance').head(10).reset_index(drop=True)
+
+        # Calculate Actual Distance Using GMaps API
+        destinations = df.apply(lambda row: f"{row['Latitude']},{row['Longitude']}", axis=1).tolist()
+        distances = get_distances_for_multiple_destinations(f"{ref_point[0]},{ref_point[1]}", destinations, self.api_key)
+
+        # Add the distances back to the DataFrame
+        df['Distance'] = distances
+
+        return df