Update app.py

app.py

@@ -1,20 +1,19 @@
-
-
-
-
 import gradio as gr
 import weaviate
 from weaviate.embedded import EmbeddedOptions
 import os
-from openai import OpenAI
+from openai import AsyncOpenAI
 from dotenv import load_dotenv
 import textwrap
+import asyncio
+import aiohttp
+from functools import wraps
 
 # Load environment variables
 load_dotenv()
 
-# Set up OpenAI client
-openai_client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
+# Set up AsyncOpenAI client
+openai_client = AsyncOpenAI(api_key=os.getenv('OPENAI_API_KEY'))
 
 # Connect to Weaviate
 client = weaviate.Client(
@@ -28,35 +27,47 @@ client = weaviate.Client(
 # Get the collection name from environment variable
 COLLECTION_NAME = os.getenv('WEAVIATE_COLLECTION_NAME')
 
-def get_embedding(text):
-    response = openai_client.embeddings.create(
+# Async-compatible caching decorator
+def async_lru_cache(maxsize=128):
+    cache = {}
+
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            key = str(args) + str(kwargs)
+            if key not in cache:
+                if len(cache) >= maxsize:
+                    cache.pop(next(iter(cache)))
+                cache[key] = await func(*args, **kwargs)
+            return cache[key]
+        return wrapper
+    return decorator
+
+@async_lru_cache(maxsize=1000)
+async def get_embedding(text):
+    response = await openai_client.embeddings.create(
         input=text,
         model="text-embedding-3-large"
     )
     return response.data[0].embedding
 
-def search_multimodal(query: str, limit: int = 30, alpha: float = 0.6):
-    query_vector = get_embedding(query)
+async def search_multimodal(query: str, limit: int = 30, alpha: float = 0.6):
+    query_vector = await get_embedding(query)
     
     try:
-        response = (
-            client.query
-            .get(COLLECTION_NAME, ["content_type", "url", "source_document", "page_number",
-                                   "paragraph_number", "text", "image_path", "description", "table_content"])
-            .with_hybrid(
-                query=query,
-                vector=query_vector,
-                alpha=alpha
-            )
+        response = await asyncio.to_thread(
+            client.query.get(COLLECTION_NAME, ["content_type", "url", "source_document", "page_number",
+                                               "paragraph_number", "text", "image_path", "description", "table_content"])
+            .with_hybrid(query=query, vector=query_vector, alpha=alpha)
             .with_limit(limit)
-            .do()
+            .do
         )
         return response['data']['Get'][COLLECTION_NAME]
     except Exception as e:
         print(f"An error occurred during the search: {str(e)}")
         return []
 
-def generate_response(query: str, context: str) -> str:
+async def generate_response(query: str, context: str) -> str:
     prompt = f"""
 You are an AI assistant with extensive expertise in the semiconductor industry. Your knowledge spans a wide range of companies, technologies, and products, including but not limited to: System-on-Chip (SoC) designs, Field-Programmable Gate Arrays (FPGAs), Microcontrollers, Integrated Circuits (ICs), semiconductor manufacturing processes, and emerging technologies like quantum computing and neuromorphic chips.
 Use the following context, your vast knowledge, and the user's question to generate an accurate, comprehensive, and insightful answer. While formulating your response, follow these steps internally:
@@ -83,7 +94,7 @@ User Question: {query}
 Based on the above context and your extensive knowledge of the semiconductor industry, provide your detailed, accurate, and grounded response below. Remember, only include information you're confident is correct, and clearly state any uncertainties: 
     """
 
-    response = openai_client.chat.completions.create(
+    response = await openai_client.chat.completions.create(
         model="gpt-4o",
         messages=[
             {"role": "system", "content": "You are an expert Semi Conductor industry analyst"},
@@ -94,19 +105,22 @@ Based on the above context and your extensive knowledge of the semiconductor ind
 
     return response.choices[0].message.content
 
-def esg_analysis(user_query: str):
-    search_results = search_multimodal(user_query)
+def process_search_result(item):
+    if item['content_type'] == 'text':
+        return f"Text from {item['source_document']} (Page {item['page_number']}, Paragraph {item['paragraph_number']}): {item['text']}\n\n"
+    elif item['content_type'] == 'image':
+        return f"Image Description from {item['source_document']} (Page {item['page_number']}, Path: {item['image_path']}): {item['description']}\n\n"
+    elif item['content_type'] == 'table':
+        return f"Table Description from {item['source_document']} (Page {item['page_number']}): {item['description']}\n\n"
+    return ""
+
+async def esg_analysis(user_query: str):
+    search_results = await search_multimodal(user_query)
     
-    context = ""
-    for item in search_results:
-        if item['content_type'] == 'text':
-            context += f"Text from {item['source_document']} (Page {item['page_number']}, Paragraph {item['paragraph_number']}): {item['text']}\n\n"
-        elif item['content_type'] == 'image':
-            context += f"Image Description from {item['source_document']} (Page {item['page_number']}, Path: {item['image_path']}): {item['description']}\n\n"
-        elif item['content_type'] == 'table':
-            context += f"Table Description from {item['source_document']} (Page {item['page_number']}): {item['description']}\n\n"
-
-    response = generate_response(user_query, context)
+    context_parts = await asyncio.gather(*[asyncio.to_thread(process_search_result, item) for item in search_results])
+    context = "".join(context_parts)
+    
+    response = await generate_response(user_query, context)
 
     sources = []
     for item in search_results[:5]:  # Limit to top 5 sources
@@ -126,8 +140,8 @@ def esg_analysis(user_query: str):
 def wrap_text(text, width=120):
     return textwrap.fill(text, width=width)
 
-def gradio_interface(user_question):
-    ai_response, sources = esg_analysis(user_question)
+async def gradio_interface(user_question):
+    ai_response, sources = await esg_analysis(user_question)
     
     # Format AI response
     formatted_response = f"""
@@ -152,7 +166,7 @@ def gradio_interface(user_question):
     return formatted_response, source_text
 
 iface = gr.Interface(
-    fn=gradio_interface,
+    fn=lambda user_question: asyncio.run(gradio_interface(user_question)),
     inputs=gr.Textbox(lines=2, placeholder="Enter your question about the semiconductor industry..."),
     outputs=[
         gr.Markdown(label="AI Response"),
@@ -164,4 +178,4 @@ iface = gr.Interface(
 )
 
 if __name__ == "__main__":
-    iface.launch(server_name="0.0.0.0", server_port=7860)
+    iface.launch(server_name="0.0.0.0", server_port=7860, share=True)