Deploying PDF Version v12

app.py

@@ -1,16 +1,6 @@
 import os
 import tempfile
-
-os.environ["CHAINLIT_CONFIG_DIR"] = tempfile.gettempdir()
-
 import logging
-
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-logger.debug("Starting application")
-
-
 from typing import List
 
 from langchain.embeddings import OpenAIEmbeddings
@@ -21,148 +11,155 @@ from langchain.document_loaders import PyPDFLoader
 from langchain.chat_models import ChatOpenAI
 from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
 from langchain.schema import Document
-from langchain.memory import ChatMessageHistory, ConversationBufferMemory
+from langchain.memory import ConversationBufferMemory
 
 import chainlit as cl
 from chainlit.types import AskFileResponse
 
-text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Set Chainlit config directory
+os.environ["CHAINLIT_CONFIG_DIR"] = tempfile.gettempdir()
 
-system_template = """Use the following pieces of context to answer the users question.
+# App configuration
+APP_CONFIG = {
+    "model_name": "gpt-4o",
+    "temperature": 0,
+    "chunk_size": 4000,
+    "chunk_overlap": 200,
+    "max_file_size_mb": 50,
+    "max_output_tokens": 4096,
+    "embedding_model": "text-embedding-3-large"  # Updated to use the most capable embedding model
+}
+
+# Initialize text splitter
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=APP_CONFIG["chunk_size"], 
+    chunk_overlap=APP_CONFIG["chunk_overlap"]
+)
+
+# System template
+system_template = """You are GPT-4o, an advanced AI model with multimodal capabilities and high intelligence. Use the following pieces of context to answer the user's question.
 If you don't know the answer, just say that you don't know, don't try to make up an answer.
 ALWAYS return a "SOURCES" part in your answer.
 The "SOURCES" part should be a reference to the source of the document from which you got your answer.
 
-And if the user greets with greetings like Hi, hello, How are you, etc reply accordingly as well.
+If the user greets with phrases like Hi, hello, How are you, etc., reply accordingly as well.
 
 Example of your response should be:
 
 The answer is foo
 SOURCES: xyz
 
-
 Begin!
 ----------------
 {summaries}"""
+
+# Create prompt template
 messages = [
     SystemMessagePromptTemplate.from_template(system_template),
-    HumanMessagePromptTemplate.from_template("{question}"),
+    HumanMessagePromptTemplate.from_template("{question}")
 ]
 prompt = ChatPromptTemplate.from_messages(messages)
-chain_type_kwargs = {"prompt": prompt}
-
-
-def process_file(file: AskFileResponse):
-    import tempfile
 
-    with tempfile.NamedTemporaryFile(mode="w", delete=False) as tempfile:
-        with open(tempfile.name, "wb") as f:
-            f.write(file.content)
-
-    pypdf_loader = PyPDFLoader(tempfile.name)
-    texts = pypdf_loader.load_and_split()
-    texts = [text.page_content for text in texts]
-    return texts
+def process_file(file: AskFileResponse) -> List[str]:
+    """Process uploaded PDF file and return list of text chunks."""
+    with tempfile.NamedTemporaryFile(mode="wb", delete=False, suffix=".pdf") as temp_file:
+        temp_file.write(file.content)
+        temp_file_path = temp_file.name
 
+    loader = PyPDFLoader(temp_file_path)
+    pages = loader.load_and_split()
+    texts = text_splitter.split_documents(pages)
+    return [text.page_content for text in texts]
 
 @cl.on_chat_start
 async def start():
-    await cl.Message("Welcome! Chat session started. You can now ask questions about the uploaded PDF.").send()
+    """Initialize chat session and process uploaded PDF."""
+    await cl.Message(f"Welcome! Chat session started using {APP_CONFIG['model_name']} for text generation and {APP_CONFIG['embedding_model']} for embeddings. This combination provides state-of-the-art performance for both English and non-English tasks. You can now ask questions about the uploaded PDF.").send()
     
-    files = None
+    files = await cl.AskFileMessage(
+        content="Please upload a PDF file to begin!",
+        accept=["application/pdf"],
+        max_size_mb=APP_CONFIG["max_file_size_mb"],
+        timeout=180,
+    ).send()
 
-    # Wait for the user to upload a file
-    while files == None:
-        files = await cl.AskFileMessage(
-            content="Please upload a PDF file to begin!",
-            accept=["application/pdf"],
-            max_size_mb=20,
-            timeout=180,
-        ).send()
+    if not files:
+        await cl.Message("No file uploaded. Please try again.").send()
+        return
 
     file = files[0]
-
-    msg = cl.Message(
-        content=f"Processing `{file.name}`...", disable_human_feedback=True
-    )
+    msg = cl.Message(content=f"Processing `{file.name}`...", disable_human_feedback=True)
     await msg.send()
 
-    # load the file
-    texts = process_file(file)
-
-    print(texts[0])
-
-    # Create a metadata for each chunk
-    metadatas = [{"source": f"{i}-pl"} for i in range(len(texts))]
-
-    # Create a Chroma vector store
-    embeddings = OpenAIEmbeddings()
-    docsearch = await cl.make_async(Chroma.from_texts)(
-        texts, embeddings, metadatas=metadatas
-    )
-
-    message_history = ChatMessageHistory()
-
-    memory = ConversationBufferMemory(
-        memory_key="chat_history",
-        output_key="answer",
-        chat_memory=message_history,
-        return_messages=True,
-    )
-
-    # Create a chain that uses the Chroma vector store
-    chain = ConversationalRetrievalChain.from_llm(
-        ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0, streaming=True),
-        chain_type="stuff",
-        retriever=docsearch.as_retriever(),
-        memory=memory,
-        return_source_documents=True,
-    )
-
-    # Let the user know that the system is ready
-    msg.content = f"Processing `{file.name}` done. You can now ask questions!"
-    await msg.update()
-
-    cl.user_session.set("chain", chain)
+    try:
+        texts = process_file(file)
+        metadatas = [{"source": f"{i}-pl"} for i in range(len(texts))]
+
+        embeddings = OpenAIEmbeddings(model=APP_CONFIG["embedding_model"])
+        docsearch = await cl.make_async(Chroma.from_texts)(texts, embeddings, metadatas=metadatas)
+
+        memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            output_key="answer",
+            return_messages=True,
+        )
+
+        chain = ConversationalRetrievalChain.from_llm(
+            ChatOpenAI(
+                model_name=APP_CONFIG["model_name"],
+                temperature=APP_CONFIG["temperature"],
+                max_tokens=APP_CONFIG["max_output_tokens"],
+                streaming=True
+            ),
+            chain_type="stuff",
+            retriever=docsearch.as_retriever(),
+            memory=memory,
+            return_source_documents=True,
+            combine_docs_chain_kwargs={"prompt": prompt}
+        )
+
+        cl.user_session.set("chain", chain)
+        msg.content = f"Processing `{file.name}` done. You can now ask questions!"
+        await msg.update()
 
-logger.debug("Defining main function")
+    except Exception as e:
+        error_msg = f"An error occurred while processing the file: {str(e)}"
+        logger.error(error_msg)
+        await cl.Message(content=error_msg).send()
 
 @cl.on_message
 async def main(message: cl.Message):
-    debug_info = f"""
-    Debug Info:
-    Message type: {type(message)}
-    Message: {message}
-    Message content: {message.content}
-    Message dir: {dir(message)}
-    """
-    print(debug_info)
-    
+    """Handle user messages and generate responses."""
     try:
-        chain = cl.user_session.get("chain")  # type: ConversationalRetrievalChain
+        chain = cl.user_session.get("chain")
         cb = cl.AsyncLangchainCallbackHandler()
         
         res = await chain.acall(message.content, callbacks=[cb])
         answer = res["answer"]
-        source_documents = res["source_documents"]  # type: List[Document]
+        source_documents = res["source_documents"]
+        
+        text_elements = []
+        for source_idx, source_doc in enumerate(source_documents):
+            source_name = f"source_{source_idx}"
+            text_elements.append(cl.Text(content=source_doc.page_content, name=source_name))
         
-        text_elements = []  # type: List[cl.Text]
-        if source_documents:
-            for source_idx, source_doc in enumerate(source_documents):
-                source_name = f"source_{source_idx}"
-                text_elements.append(
-                    cl.Text(content=source_doc.page_content, name=source_name)
-                )
-            
-            source_names = [text_el.name for text_el in text_elements]
-            if source_names:
-                answer += f"\nSources: {', '.join(source_names)}"
-            else:
-                answer += "\nNo sources found"
+        source_names = [text_el.name for text_el in text_elements]
+        if source_names:
+            answer += f"\nSources: {', '.join(source_names)}"
+        else:
+            answer += "\nNo sources found"
         
         await cl.Message(content=answer, elements=text_elements).send()
     
     except Exception as e:
-        error_message = f"An error occurred: {str(e)}\n\n{debug_info}"
-        print(error_message)
-        await cl.Message(content=error_message).send()
+        error_msg = f"An error occurred: {str(e)}"
+        logger.error(error_msg)
+        await cl.Message(content=error_msg).send()
+
+if __name__ == "__main__":
+    logger.info(f"Starting Chainlit application with model: {APP_CONFIG['model_name']} and embedding model: {APP_CONFIG['embedding_model']}")
+    cl.run()