initial commit+

Spacefile

@@ -0,0 +1,2 @@
+sdk: gradio
+app_file: app.py

app.py

@@ -1,63 +1,32 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
+import chainlit as cl
+from chainlit.input_widget import TextInput
+from rag import RAGModel
+import os
+import nest_asyncio
+nest_asyncio.apply()
+
+
+# Initialize RAG model
+rag_model = RAGModel(openai_api_key=os.getenv("OPENAI_API_KEY"))
+
+@cl.on_message
+async def main(message):
+    result = rag_model.query(message.content)
+    print(result)
+    await cl.Message(result).send()
+
+# @cl.application
+# def app():
+#     cl.TextInput(label="Enter your query", on_submit=handle_message)
+
+@cl.on_chat_start
+async def start():
+#def on_chat_start():
+    msg=cl.Message(content="Firing up the research info bot...")
+    await msg.send()
+    msg.content= "Hi, welcome to research info bot. What is your query?"
+    await msg.update()
 
 if __name__ == "__main__":
-    demo.launch()
+    cl.run()    
+

chainlit.md

@@ -0,0 +1,14 @@
+# Welcome to Chainlit! 🚀🤖
+
+Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.
+
+## Useful Links 🔗
+
+- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
+- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/k73SQ3FyUh) to ask questions, share your projects, and connect with other developers! 💬
+
+We can't wait to see what you create with Chainlit! Happy coding! 💻😊
+
+## Welcome screen
+
+To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.

rag.py

@@ -0,0 +1,91 @@
+from datasets import load_dataset
+from langchain_community.document_loaders.csv_loader import CSVLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import CacheBackedEmbeddings
+from langchain.storage import LocalFileStore
+from langchain_community.vectorstores import FAISS
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI
+from langchain_openai import OpenAIEmbeddings
+from langchain_core.runnables.passthrough import RunnablePassthrough
+from langchain_core.runnables.base import RunnableSequence
+
+
+class RAGModel:
+    def __init__(self, openai_api_key):
+        #openai_api_key = os.getenv("OPENAI_API_KEY")
+        # Load dataset
+        dataset = load_dataset('csv', data_files='imdb.csv')
+        dataset_dict = dataset
+        imdb_csv = dataset_dict["train"].to_csv('imdb.csv')
+
+        # Load documents
+        loader = CSVLoader(file_path="imdb.csv")
+        data = loader.load()
+
+        # Split documents into chunks
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+        chunked_documents = text_splitter.split_documents(data)
+
+        # Create embeddings
+        self.embeddings = OpenAIEmbeddings(model="text-embedding-ada-002", openai_api_key=openai_api_key)
+        text_documents = [str(doc) for doc in chunked_documents]
+
+        # Create cache-backed embeddings
+        self.store = LocalFileStore("./cache/")
+        self.embedder = CacheBackedEmbeddings.from_bytes_store(
+            self.embeddings, self.store, namespace=self.embeddings.model
+        )
+
+        # Load and split documents again for FAISS
+        documents = loader.load()
+        text_splitter = RecursiveCharacterTextSplitter()
+        docs = text_splitter.split_documents(documents)
+
+        # Create vector store using FAISS
+        self.vector_store = FAISS.from_documents(docs, self.embedder)
+        self.vector_store.save_local("faiss_index")
+
+        # Create retriever
+        self.retriever = self.vector_store.as_retriever()
+
+        # Create chat model
+        self.chat_model = ChatOpenAI(model="gpt-4", temperature=0, openai_api_key=openai_api_key)
+
+        # Create parser
+        self.parser = StrOutputParser()
+
+        # Create prompt template
+        messages = "Answer the {question} based on the following context: {context}"
+        self.prompt_template = ChatPromptTemplate.from_template(messages)
+        
+
+    def query(self, question):
+        # Retrieve similar documents
+        embedding_query = self.embeddings.embed_query(question)
+        similar_documents = self.vector_store.similarity_search_by_vector(embedding_query)
+
+        # Create context from retrieved documents
+        context = "\n".join([doc.page_content for doc in similar_documents])
+
+        # Format prompt
+        prompt = self.prompt_template.format(context=context, question=question)
+        
+#        print(context)
+        # Get response from chat model
+#        response = self.chat_model(prompt)
+        # Parse response
+#        result = self.parser.parse(response)
+        
+    #    chain = prompt=prompt | self.chat_model | parser=self.parser
+     #   result = chain.invoke()    
+        dict_context = {"question": question} 
+        #chain = ({"context": context,"question":Runnab
+        chain =({"context": lambda x: context,"question": RunnablePassthrough()}          
+                  | self.prompt_template
+                 | self.chat_model
+                  | self.parser)
+        #
+        result = chain.invoke(question)
+        return result

requirements.txt

@@ -1 +1,21 @@
-huggingface_hub==0.22.2
+chainlit
+transformers
+datasets
+langchain
+langchain.text_splitter 
+langchain_community.document_loaders.csv_loader
+langchain.embeddings
+langchain.storage
+langchain_community.vectorstores
+langchain_community.document_loaders
+langchain_text_splitters
+langchain_core.runnables.base
+langchain_core.runnables.passthrough
+langchain_core.output_parsers
+langchain_core.prompts
+langchain_openai
+torch
+faiss-cpu
+openai
+librosa
+nest_asyncio