fix imports

.env_example

@@ -1,3 +1,5 @@
 REDIS_KEY = ''
 OPENAI_API_KEY = ''
-HUGGINGFACEHUB_API_TOKEN = ''
+HUGGINGFACEHUB_API_TOKEN = ''
+REDIS_HOST = ''
+REDIS_PORT = ''

.pre-commit-config.yaml

@@ -0,0 +1,24 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+  - repo: https://github.com/psf/black
+    rev: 22.10.0
+    hooks:
+      - id: black
+        args: ["--line-length=118"]
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        name: isort (python)
+        args: ["--profile", "black", "--filter-files"]
+  - repo: https://github.com/pycqa/flake8
+    rev: 6.0.0
+    hooks:
+    -   id: flake8
+        args: ["--max-line-length=118", "--ignore=E501,E266,E203,W503"]

app.py

@@ -1,124 +1,121 @@
-import streamlit as st
-from sentence_transformers import SentenceTransformer
-from redis.commands.search.query import Query
+import os
+
+import numpy as np
 import redis
-from langchain.prompts import PromptTemplate
+import streamlit as st
+from dotenv import load_dotenv
 from langchain import HuggingFaceHub
 from langchain.chains import LLMChain
-from langchain.memory import ConversationBufferMemory
 from langchain.chat_models import ChatOpenAI
-from langchain.callbacks.base import BaseCallbackHandler
-import os
-from dotenv import load_dotenv
-import numpy as np
-
-load_dotenv()
-redis_key = os.getenv('REDIS_KEY')
-HUGGINGFACEHUB_API_TOKEN = os.getenv('HUGGINGFACEHUB_API_TOKEN')
-repo_id = 'tiiuae/falcon-7b-instruct'
-
-class StreamHandler(BaseCallbackHandler):
-    def __init__(self, container, initial_text="", display_method='markdown'):
-        self.container = container
-        self.text = initial_text
-        self.display_method = display_method
-
-    def on_llm_new_token(self, token: str, **kwargs) -> None:
-        self.text += token + " "
-        display_function = getattr(self.container, self.display_method, None)
-        if display_function is not None:
-            display_function(self.text)
-        else:
-            raise ValueError(f"Invalid display_method: {self.display_method}")
-        
-
-st.title('My Amazon shopping buddy 🏷️')
-st.caption('🤖 Powered by Falcon Open Source AI model')
-
-#connect to redis database
-@st.cache_resource()
-def redis_connect():
-  redis_conn = redis.Redis(
-    host='redis-12882.c259.us-central1-2.gce.cloud.redislabs.com',
-    port=12882,
-    password=redis_key)
-  return redis_conn
-
-redis_conn = redis_connect()
-
-#the encoding keywords chain
-@st.cache_resource()
-def encode_keywords_chain():
-    falcon_llm_1 = HuggingFaceHub(repo_id = repo_id, model_kwargs={'temperature':0.1,'max_new_tokens':500},huggingfacehub_api_token=HUGGINGFACEHUB_API_TOKEN)
-    prompt = PromptTemplate(
-        input_variables=["product_description"],
-        template="Create comma seperated product keywords to perform a query on a amazon dataset for this user input: {product_description}",
-    )
-    chain = LLMChain(llm=falcon_llm_1, prompt=prompt)
-    return chain
-chain = encode_keywords_chain()
-#the present products chain
-
-@st.cache_resource()
-def present_products_chain():
-    template = """You are a salesman. Be kind, detailed and nice.  take the given context and Present the given queried search result in a nice way as answer to the user_msg. dont ask questions back or freestyle and invent followup conversation! 
-    {chat_history}
-    user:{user_msg}
-    Chatbot:"""
-    prompt = PromptTemplate(
-        input_variables=["chat_history", "user_msg"],
-        template=template
-    )
-    memory = ConversationBufferMemory(memory_key="chat_history")
-    llm_chain = LLMChain(
-        llm = ChatOpenAI(openai_api_key=os.getenv('OPENAI_API_KEY'),temperature=0.8,model='gpt-3.5-turbo'),
-        prompt=prompt,
-        verbose=False,
-        memory=memory,
-    )
-    return llm_chain
- 
-
-
-llm_chain = present_products_chain()
-
-@st.cache_resource()
-def embedding_model():
-    embedding_model = SentenceTransformer('sentence-transformers/all-distilroberta-v1')
-    return embedding_model
-
-embedding_model = embedding_model()
-
-if "messages" not in st.session_state:
-    st.session_state["messages"] = [{"role": "assistant", "content": "Hey im your online shopping buddy, how can i help you today?"}]
-for msg in st.session_state["messages"]:
-    st.chat_message(msg["role"]).write(msg["content"])
-
-prompt = st.chat_input(key="user_input" )
-
-if prompt:
-    st.session_state["messages"].append({"role": "user", "content": prompt})
-    st.chat_message('user').write(prompt)
-    st.session_state.disabled = True
-    keywords = chain.run(prompt)
-    #vectorize the query
-    query_vector = embedding_model.encode(keywords)
-    query_vector = np.array(query_vector).astype(np.float32).tobytes()
-    #prepare the query
-    ITEM_KEYWORD_EMBEDDING_FIELD = 'item_vector'
-    topK=5
-    q = Query(f'*=>[KNN {topK} @{ITEM_KEYWORD_EMBEDDING_FIELD} $vec_param AS vector_score]').sort_by('vector_score').paging(0,topK).return_fields('vector_score','item_name','item_id','item_keywords').dialect(2)
-    params_dict = {"vec_param": query_vector}
-    #Execute the query
-    results = redis_conn.ft().search(q, query_params = params_dict)
-
-    full_result_string = ''
-    for product in results.docs:
-        full_result_string += product.item_name + ' ' + product.item_keywords  + "\n\n\n"
-
-    result = llm_chain.predict(user_msg=f"{full_result_string} ---\n\n {prompt}")
-    st.session_state.messages.append({"role": "assistant", "content": result})
-    st.chat_message('assistant').write(result)
-
+from langchain.memory import ConversationBufferMemory
+from langchain.prompts import PromptTemplate
+from redis.commands.search.query import Query
+from sentence_transformers import SentenceTransformer
 
+from constants import (
+    EMBEDDING_MODEL_NAME,
+    FALCON_MAX_TOKENS,
+    FALCON_REPO_ID,
+    FALCON_TEMPERATURE,
+    OPENAI_MODEL_NAME,
+    OPENAI_TEMPERATURE,
+    TEMPLATE_1,
+    TEMPLATE_2,
+)
+from database import create_redis
 
+load_dotenv()
+HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+ITEM_KEYWORD_EMBEDDING = "item_vector"
+TOPK = 5
+
+
+def main():
+    # connect to redis database
+    @st.cache_resource()
+    def connect_to_redis():
+        pool = create_redis()
+        return redis.Redis(connection_pool=pool)
+
+    # the encoding keywords chain
+    @st.cache_resource()
+    def encode_keywords_chain():
+        falcon_llm_1 = HuggingFaceHub(
+            repo_id=FALCON_REPO_ID,
+            model_kwargs={"temperature": FALCON_TEMPERATURE, "max_new_tokens": FALCON_MAX_TOKENS},
+            huggingfacehub_api_token=HUGGINGFACEHUB_API_TOKEN,
+        )
+        prompt = PromptTemplate(
+            input_variables=["product_description"],
+            template=TEMPLATE_1,
+        )
+        chain = LLMChain(llm=falcon_llm_1, prompt=prompt)
+        return chain
+
+    # the present products chain
+    @st.cache_resource()
+    def present_products_chain():
+        template = TEMPLATE_2
+        prompt = PromptTemplate(input_variables=["chat_history", "user_msg"], template=template)
+        memory = ConversationBufferMemory(memory_key="chat_history")
+        llm_chain = LLMChain(
+            llm=ChatOpenAI(
+                openai_api_key=os.getenv("OPENAI_API_KEY"), temperature=OPENAI_TEMPERATURE, model=OPENAI_MODEL_NAME
+            ),
+            prompt=prompt,
+            verbose=False,
+            memory=memory,
+        )
+        return llm_chain
+
+    @st.cache_resource()
+    def instance_embedding_model():
+        embedding_model = SentenceTransformer(EMBEDDING_MODEL_NAME)
+        return embedding_model
+
+    st.title("My Amazon shopping buddy 🏷️")
+    st.caption("🤖 Powered by Falcon Open Source AI model")
+    redis_conn = connect_to_redis()
+    keywords_chain = encode_keywords_chain()
+    chat_chain = present_products_chain()
+    embedding_model = instance_embedding_model()
+
+    if "messages" not in st.session_state:
+        st.session_state["messages"] = [
+            {"role": "assistant", "content": "Hey im your online shopping buddy, how can i help you today?"}
+        ]
+    for msg in st.session_state["messages"]:
+        st.chat_message(msg["role"]).write(msg["content"])
+
+    prompt = st.chat_input(key="user_input")
+
+    if prompt:
+        st.session_state["messages"].append({"role": "user", "content": prompt})
+        st.chat_message("user").write(prompt)
+        st.session_state.disabled = True
+        keywords = keywords_chain.run(prompt)
+        # vectorize the query
+        query_vector = embedding_model.encode(keywords)
+        query_vector_bytes = np.array(query_vector).astype(np.float32).tobytes()
+        # prepare the query
+
+        q = (
+            Query(f"*=>[KNN {TOPK} @{ITEM_KEYWORD_EMBEDDING} $vec_param AS vector_score]")
+            .sort_by("vector_score")
+            .paging(0, TOPK)
+            .return_fields("vector_score", "item_name", "item_id", "item_keywords")
+            .dialect(2)
+        )
+        params_dict = {"vec_param": query_vector_bytes}
+        # Execute the query
+        results = redis_conn.ft().search(q, query_params=params_dict)
+        result_output = ""
+        for product in results.docs:
+            result_output += f"product_name:{product.item_name}, product_description:{product.item_keywords} \n"
+        result = chat_chain.predict(user_msg=f"{result_output}\n{prompt}")
+        st.session_state.messages.append({"role": "assistant", "content": result})
+        st.chat_message("assistant").write(result)
+
+
+if __name__ == "__main__":
+    main()

constants.py

@@ -0,0 +1,14 @@
+FALCON_REPO_ID = "tiiuae/falcon-7b-instruct"
+FALCON_TEMPERATURE = 0.1
+FALCON_MAX_TOKENS = 500
+
+OPENAI_MODEL_NAME = "gpt-3.5-turbo"
+OPENAI_TEMPERATURE = 0.8
+
+EMBEDDING_MODEL_NAME = "sentence-transformers/all-distilroberta-v1"
+
+TEMPLATE_1 = "Create comma seperated product keywords to perform a query on a amazon dataset for this user input: {product_description}"
+TEMPLATE_2 = """You are a salesman.Present the given product results in a nice way as answer to the user_msg. Dont ask questions back,
+    {chat_history}
+    user:{user_msg}
+    Chatbot:"""

database.py

@@ -1,13 +1,16 @@
-import redis
 import os
+
+import redis
 from dotenv import load_dotenv
 
 load_dotenv()
-redis_key = os.getenv('REDIS_KEY')
-
 
 
-redis_conn = redis.Redis(
-  host='redis-12882.c259.us-central1-2.gce.cloud.redislabs.com',
-  port=12882,
-  password=redis_key)
+def create_redis():
+    return redis.ConnectionPool(
+        host=os.getenv("REDIS_HOST"),
+        port=os.getenv("REDIS_PORT"),
+        password=os.getenv("REDIS_KEY"),
+        db=0,
+        decode_responses=True,
+    )

preprocess.py

@@ -1,48 +1,44 @@
-from langchain.embeddings import OpenAIEmbeddings
-from sentence_transformers import SentenceTransformer
-import os
-import pandas as pd
 import numpy as np
-from dotenv import load_dotenv
-from database import redis_conn
-from utilities import create_flat_index, load_vectors
-
+import pandas as pd
+import redis
+from sentence_transformers import SentenceTransformer
 
+from database import create_redis
+from utils import create_flat_index, load_vectors
 
-#set maximum length for text fields
+pool = create_redis()
+redis_conn = redis.Redis(connection_pool=pool)
+# set maximum length for text fields
 MAX_TEXT_LENGTH = 512
+TEXT_EMBEDDING_DIMENSION = 768
+NUMBER_PRODUCTS = 10000
+
 
-def auto_truncate(text:str):
+def auto_truncate(text: str):
     return text[0:MAX_TEXT_LENGTH]
 
-data = pd.read_csv('product_data.csv',converters={'bullet_point':auto_truncate,'item_keywords':auto_truncate,'item_name':auto_truncate})
-data['primary_key'] = data['item_id'] + '-' + data['domain_name']
-data.drop(columns=['item_id','domain_name'],inplace=True)
-data['item_keywords'].replace('',np.nan,inplace=True)
-data.dropna(subset=['item_keywords'],inplace=True)
+
+data = pd.read_csv(
+    "product_data.csv",
+    converters={"bullet_point": auto_truncate, "item_keywords": auto_truncate, "item_name": auto_truncate},
+)
+data["primary_key"] = data["item_id"] + "-" + data["domain_name"]
+data.drop(columns=["item_id", "domain_name"], inplace=True)
+data["item_keywords"].replace("", np.nan, inplace=True)
+data.dropna(subset=["item_keywords"], inplace=True)
 data.reset_index(drop=True, inplace=True)
-data_metadata = data.head(500).to_dict(orient='index')
+data_metadata = data.head(10000).to_dict(orient="index")
 
-#generating embeddings (vectors) for the item keywords
-embedding_model = SentenceTransformer('sentence-transformers/all-distilroberta-v1')
+# generating embeddings (vectors) for the item keywords
+embedding_model = SentenceTransformer("sentence-transformers/all-distilroberta-v1")
 # embedding_model = OpenAIEmbeddings(openai_api_key=openai_api_key)
 
-#get the item keywords attribute for each product and encode them into vector embeddings
-item_keywords = [data_metadata[i]['item_keywords'] for i in data_metadata.keys()]
+# get the item keywords attribute for each product and encode them into vector embeddings
+item_keywords = [data_metadata[i]["item_keywords"] for i in data_metadata.keys()]
 item_keywords_vectors = [embedding_model.encode(item) for item in item_keywords]
 
-TEXT_EMBEDDING_DIMENSION=768
-NUMBER_PRODUCTS=500
-
-print ('Loading and Indexing + ' +  str(NUMBER_PRODUCTS) + ' products')
-#flush all data
+# flush all data
 redis_conn.flushall()
-#create flat index & load vectors
-create_flat_index(redis_conn,NUMBER_PRODUCTS,TEXT_EMBEDDING_DIMENSION,'COSINE')
-load_vectors(redis_conn,data_metadata,item_keywords_vectors)
-
-
-
-
-
-
+# create flat index & load vectors
+create_flat_index(redis_conn, NUMBER_PRODUCTS, TEXT_EMBEDDING_DIMENSION, "COSINE")
+load_vectors(redis_conn, data_metadata, item_keywords_vectors)

utilities.py

@@ -1,32 +0,0 @@
-from redis import Redis
-from redis.commands.search.field import VectorField
-from redis.commands.search.field import TextField
-from redis.commands.search.field import TagField
-from redis.commands.search.result import Result
-import numpy as np
-
-def load_vectors(client:Redis, product_metadata, vector_dict):
-    p = client.pipeline(transaction=False)
-    for index in product_metadata.keys():    
-        #hash key
-        key='product:'+ str(index)+ ':' + product_metadata[index]['primary_key']
-        
-        #hash values
-        item_metadata = product_metadata[index]
-        item_keywords_vector = np.array(vector_dict[index], dtype=np.float32).tobytes()
-        item_metadata['item_vector']=item_keywords_vector
-        
-        # HSET
-        p.hset(key,mapping=item_metadata)
-            
-    p.execute()
-
-def create_flat_index (redis_conn, number_of_vectors, vector_dimensions=512, distance_metric='L2'):
-    redis_conn.ft().create_index([
-        VectorField('item_vector', "FLAT", {"TYPE": "FLOAT32", "DIM": vector_dimensions, "DISTANCE_METRIC": distance_metric, "INITIAL_CAP": number_of_vectors, "BLOCK_SIZE":number_of_vectors }),
-        TagField("product_type"),
-        TextField("item_name"),
-        TextField("item_keywords"),
-        TagField("country")        
-    ])
-

utils.py

@@ -0,0 +1,38 @@
+import numpy as np
+from redis import Redis
+from redis.commands.search.field import TagField, TextField, VectorField
+
+
+def load_vectors(client: Redis, product_metadata, vector_dict):
+    p = client.pipeline(transaction=False)
+    for index in product_metadata.keys():
+        # hash key
+        key = "product:" + str(index) + ":" + product_metadata[index]["primary_key"]
+        # hash values
+        item_metadata = product_metadata[index]
+        item_keywords_vector = np.array(vector_dict[index], dtype=np.float32).tobytes()
+        item_metadata["item_vector"] = item_keywords_vector
+        p.hset(key, mapping=item_metadata)
+    p.execute()
+
+
+def create_flat_index(redis_conn, number_of_vectors, vector_dimensions=512, distance_metric="L2"):
+    redis_conn.ft().create_index(
+        [
+            VectorField(
+                "item_vector",
+                "FLAT",
+                {
+                    "TYPE": "FLOAT32",
+                    "DIM": vector_dimensions,
+                    "DISTANCE_METRIC": distance_metric,
+                    "INITIAL_CAP": number_of_vectors,
+                    "BLOCK_SIZE": number_of_vectors,
+                },
+            ),
+            TagField("product_type"),
+            TextField("item_name"),
+            TextField("item_keywords"),
+            TagField("country"),
+        ]
+    )