Update app.py

app.py

@@ -1,75 +1,92 @@
 import os
-import streamlit as st
-from openai import OpenAI
+from getpass import getpass
+import gradio as gr
+import random
+import time
+
+pinecone_api_key = os.getenv("PINECONE_API_KEY") or getpass("Enter your Pinecone API Key: ")
+openai_api_key = os.getenv("OPENAI_API_KEY") or getpass("Enter your OpenAI API Key: ")
+
 from llama_index.node_parser import SemanticSplitterNodeParser
 from llama_index.embeddings import OpenAIEmbedding
 from llama_index.ingestion import IngestionPipeline
+
+# This will be the model we use both for Node parsing and for vectorization
+embed_model = OpenAIEmbedding(api_key=openai_api_key)
+
+# Define the initial pipeline
+pipeline = IngestionPipeline(
+    transformations=[
+        SemanticSplitterNodeParser(
+            buffer_size=1,
+            breakpoint_percentile_threshold=95,
+            embed_model=embed_model,
+        ),
+        embed_model,
+    ],
+)
+
 from pinecone.grpc import PineconeGRPC
 from pinecone import ServerlessSpec
-from llama_index.vector_stores import PineconeVectorStore
-from llama_index import VectorStoreIndex
-from llama_index.retrievers import VectorIndexRetriever
-from llama_index.query_engine import RetrieverQueryEngine
 
-# Set OpenAI API key from environment variables
-openai_api_key = os.getenv("OPENAI_API_KEY")
-pinecone_api_key = os.getenv("PINECONE_API_KEY")
-index_name = os.getenv("INDEX_NAME")
-
-# Initialize OpenAI client
-client = OpenAI(api_key=openai_api_key)
+from llama_index.vector_stores import PineconeVectorStore
 
 # Initialize connection to Pinecone
 pc = PineconeGRPC(api_key=pinecone_api_key)
+index_name = "anualreport"
 
 # Initialize your index
-if index_name not in pc.list_indexes():
-    spec = ServerlessSpec(replicas=1, pod_type="p1")
-    pc.create_index(name=index_name, dimension=1536, spec=spec)
-
 pinecone_index = pc.Index(index_name)
 
 # Initialize VectorStore
 vector_store = PineconeVectorStore(pinecone_index=pinecone_index)
+
 pinecone_index.describe_index_stats()
 
-# Initialize vector index and retriever
+from llama_index import VectorStoreIndex
+from llama_index.retrievers import VectorIndexRetriever
+
+# Set the OpenAI API key if not already set
+if not os.getenv('OPENAI_API_KEY'):
+    os.environ['OPENAI_API_KEY'] = openai_api_key
+
+# Instantiate VectorStoreIndex object from our vector_store object
 vector_index = VectorStoreIndex.from_vector_store(vector_store=vector_store)
+
+# Grab 5 search results
 retriever = VectorIndexRetriever(index=vector_index, similarity_top_k=5)
-query_engine = RetrieverQueryEngine(retriever=retriever)
 
-# Set up LlamaIndex embedding model and pipeline
-embed_model = OpenAIEmbedding(api_key=openai_api_key)
-pipeline = IngestionPipeline(
-    transformations=[
-        SemanticSplitterNodeParser(buffer_size=1, breakpoint_percentile_threshold=95, embed_model=embed_model),
-        embed_model,
-    ],
-)
+from llama_index.query_engine import RetrieverQueryEngine
+
+# Pass in your retriever from above, which is configured to return the top 5 results
+query_engine = RetrieverQueryEngine(retriever=retriever)
 
-def query_annual_report(query):
+def query_anual_report(query):
     response = query_engine.query(query)
     return response.response
 
-# Streamlit app setup
-st.title("ChatGPT-like Clone with Pinecone Integration")
+# Define the chat functions
+def user(user_message, history):
+    return "", history + [[user_message, None]]
 
-# Initialize chat history
-if "messages" not in st.session_state:
-    st.session_state.messages = []
+def bot(history):
+    bot_message = query_anual_report(history[-1][0])
+    history[-1][1] = ""
+    for character in bot_message:
+        history[-1][1] += character
+        time.sleep(0.01)  # Reduced sleep time to make response appear faster
+        yield history
 
-# Display chat messages from history
-for message in st.session_state.messages:
-    with st.chat_message(message["role"]):
-        st.markdown(message["content"])
+# Define Gradio Blocks interface
+with gr.Blocks() as demo:
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox()
+    clear = gr.Button("Clear")
 
-# Accept user input
-if prompt := st.chat_input("What is up?"):
-    st.session_state.messages.append({"role": "user", "content": prompt})
-    with st.chat_message("user"):
-        st.markdown(prompt)
+    msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+        bot, chatbot, chatbot
+    )
+    clear.click(lambda: None, None, chatbot, queue=False)
 
-    with st.chat_message("assistant"):
-        response = query_annual_report(prompt)
-        st.markdown(response)
-    st.session_state.messages.append({"role": "assistant", "content": response})
+if __name__ == "__main__":
+    demo.launch()