Rename app.py to Backend.py

app.py → Backend.py

@@ -21,8 +21,8 @@ import tempfile
 import os
 from langchain.llms import OpenAI  # Import the OpenAI class
 from langchain.chat_models import ChatOpenAI  # Import ChatOpenAI
-from langchain.agents import create_chat_conversational_react_description_agent
 from langchain.memory import ConversationBufferMemory
+from langchain.agents import create_openai_tools_agent, AgentExecutor
 
 
 
@@ -196,180 +196,29 @@ def initialize_qa_system(_vector_store):
             api_key=os.environ.get('OPENAI_API_KEY'),
         )
 
-        memory = ConversationBufferMemory(memory_key="chat_history")  # Initialize memory
+        # Define the prompt template
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are a helpful assistant"),
+            MessagesPlaceholder(variable_name="chat_history"),   
 
-        # Create the conversational agent
-        qa_pipeline = create_chat_conversational_react_description_agent(
-            llm=llm,
-            tools=[
-                Tool(
-                    name="Search",
-                    func=_vector_store.as_retriever(search_kwargs={"k": 2}).get_relevant_documents,
-                    description="useful for when you need to answer questions about the documents you have been uploaded. Input should be a fully formed question.",
-                )
-            ],
-            verbose=True,
-            memory=memory,
-        )
-        return qa_pipeline
+            ("human", "{input}"),
+        ])
+
+        # Define the tools
+        tools = [
+            Tool(
+                name="Search",
+                func=_vector_store.as_retriever(search_kwargs={"k": 2}).get_relevant_documents,
+                description="useful for when you need to answer questions about the documents you have been uploaded. Input should be a fully formed question.",
+            )
+        ]
+
+        # Create the agent and executor
+        agent = create_openai_tools_agent(llm=llm, tools=tools, prompt=prompt)
+        agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=ConversationBufferMemory(memory_key="chat_history"))
+
+        return agent_executor  # Return the agent executor
     except Exception as e:
         st.error(f"Error initializing QA system: {e}")
         return None
         
-# Streamlit App Interface (app.py)
-def main():
-    st.title("**SYNAPTYX - RFP Analysis Agent**")
-    st.markdown("<h3 style='color: #1E3A8A;'>Upload RFP documents, provide a URL, search, and get intelligent answers.</h3>", unsafe_allow_html=True)
-
-    # Database Initialization
-    database = "rfp_agent.db"
-    conn = create_connection(database)
-    if conn is not None:
-        create_tables(conn)
-    else:
-        st.error("Error! Cannot create the database connection.")
-
-    # Dashboard Overview Tab
-    st.sidebar.markdown("<h2 style='color: #1E3A8A;'>Dashboard Overview</h2>", unsafe_allow_html=True)
-    if conn is not None:
-        try:
-            cursor = conn.cursor()
-            cursor.execute("SELECT COUNT(*) FROM documents")
-            total_documents = cursor.fetchone()[0]
-
-            cursor.execute("SELECT COUNT(*) FROM queries")
-            total_queries = cursor.fetchone()[0]
-
-            st.sidebar.write(f"Total Documents: {total_documents}")
-            st.sidebar.write(f"Total Queries: {total_queries}")
-        except Exception as e:
-            st.error(f"Error retrieving dashboard data: {e}")
-
-    # Sidebar Knowledge Base Tab
-    st.sidebar.markdown("<h2 style='color: #1E3A8A;'>Knowledge Base</h2>", unsafe_allow_html=True)
-    st.sidebar.markdown("<p style='color: #1E3A8A;'>View and select documents for search.</p>", unsafe_allow_html=True)
-
-    # Retrieve Documents from Database
-    if conn is not None:
-        try:
-            cursor = conn.cursor()
-            cursor.execute("SELECT id, name FROM documents")
-            documents_in_db = cursor.fetchall()
-
-            if documents_in_db:
-                # Use st.multiselect instead of st.selectbox
-                selected_doc_ids = st.sidebar.multiselect(  
-                    "Select documents to include in the search:",
-                    options=[doc[0] for doc in documents_in_db],
-                    format_func=lambda doc_id: next(doc[1] for doc in documents_in_db if doc[0] == doc_id),
-                    default=[doc[0] for doc in documents_in_db]  # Select all documents by default
-                )
-
-                if selected_doc_ids:
-                    selected_documents = []
-                    selected_doc_names = [] # Also keep track of the document names
-                    for doc_id in selected_doc_ids:
-                        cursor.execute("SELECT content, name FROM documents WHERE id = ?", (doc_id,))
-                        result = cursor.fetchone()
-                        selected_documents.append(result[0])
-                        selected_doc_names.append(result[1]) # Add the name to the list
-
-                    # Initialize FAISS and Store Embeddings for Selected Documents
-                    embeddings = get_embeddings_model()
-                    if embeddings:
-                        vector_store = initialize_faiss(embeddings, selected_documents, selected_doc_names) # Use selected_doc_names here
-                        if vector_store:
-                            st.sidebar.success("Embeddings for selected documents stored successfully.", icon="📁")
-
-                            # Initialize QA System for Selected Documents
-                            qa_system = initialize_qa_system(vector_store)
-                            if qa_system:
-                                 # Query Input
-                                user_query = st.text_input("Enter your query about the RFPs:", placeholder="e.g., What are the evaluation criteria?", label_visibility='visible')
-                                if user_query:
-                                    st.markdown("<p style='color: #1E3A8A;'>Retrieving answer...</p>", unsafe_allow_html=True)
-                                    try:
-                                        response, source_documents = qa_system.run(query=user_query, return_source_documents=True)
-                                        response = qa_system.run(query=user_query, return_source_documents=True)
-                                        st.markdown("<h4 style='color: #1E3A8A;'>Answer:</h4>", unsafe_allow_html=True)
-                                        st.write(response["result"])  # Access the answer text
-                                        st.write(response["source_documents"])  # Access the source documents
-                                        
-                                    
-
-                                        # Store Query and Response in Database
-                                        with conn:
-                                            for doc in source_documents:
-                                                source_name = doc.metadata["source"]
-                                                document_id = conn.execute("SELECT id FROM documents WHERE name = ?", (source_name,)).fetchone()
-                                                if document_id:
-                                                    conn.execute("INSERT INTO queries (query, response, document_id) VALUES (?, ?, ?)", (user_query, response, document_id[0]))
-
-                                        # Display Source Information
-                                        st.markdown("<h4 style='color: #1E3A8A;'>Sources:</h4>", unsafe_allow_html=True)
-                                        for doc in source_documents:
-                                            source_name = doc.metadata["source"]
-                                            matched_text = doc.page_content
-                                            st.write(f"- Source Document: {source_name}")
-                                            # Display the matching text with highlighting
-                                            for idx, page_content in enumerate(document_pages[document_names.index(source_name)]):
-                                                if matched_text in page_content:
-                                                    highlighted_content = re.sub(re.escape(matched_text), f"<mark>{matched_text}</mark>", page_content)
-                                                    st.write(f"  - Page {idx + 1}: {highlighted_content}")
-
-                                    except Exception as e:
-                                        st.error(f"Error generating response: {e}")
-        except Exception as e:
-            st.error(f"Error retrieving documents from database: {e}")
-
-    # Document Upload Section
-    st.markdown("<h2 style='color: #1E3A8A;'>Upload RFP Documents</h2>", unsafe_allow_html=True)
-    uploaded_documents = st.file_uploader("Upload PDF documents", type="pdf", accept_multiple_files=True)
-    if uploaded_documents:
-        st.write(f"Uploaded {len(uploaded_documents)} documents.")
-        all_texts, document_names, document_pages = upload_and_parse_documents(uploaded_documents)
-        if all_texts:
-            # Store Documents in Database
-            if conn is not None:
-                try:
-                    with conn:
-                        for doc, doc_name in zip(all_texts, document_names):
-                            conn.execute("INSERT INTO documents (name, content) VALUES (?, ?)", (doc_name, doc))
-                    st.success("Documents uploaded and parsed successfully.", icon="✅")
-                except Exception as e:
-                    st.error(f"Error saving documents to database: {e}")
-
-    # URL Input Section
-    st.markdown("<h2 style='color: #1E3A8A;'>Or Provide a URL</h2>", unsafe_allow_html=True)
-    url = st.text_input("Enter the URL of a PDF document:")
-    if url:
-        all_texts, document_name = parse_pdf_from_url(url)
-        if all_texts:
-            # Store Document in Database
-            if conn is not None:
-                try:
-                    with conn:
-                        for doc in all_texts:
-                            conn.execute("INSERT INTO documents (name, content) VALUES (?, ?)", (document_name, doc))
-                    st.success("Document from URL uploaded and parsed successfully.", icon="✅")
-                except Exception as e:
-                    st.error(f"Error saving document from URL to database: {e}")
-
-    # Google Drive Integration Section
-    st.markdown("<h2 style='color: #1E3A8A;'>Or Fetch from Google Drive</h2>", unsafe_allow_html=True)
-    gdrive_file_id = st.text_input("Enter the Google Drive File ID:")
-    if gdrive_file_id:
-        all_texts, document_name = parse_pdf_from_google_drive(gdrive_file_id)
-        if all_texts:
-            # Store Document in Database
-            if conn is not None:
-                try:
-                    with conn:
-                        for doc in all_texts:
-                            conn.execute("INSERT INTO documents (name, content) VALUES (?, ?)", (document_name, doc))
-                    st.success("Document from Google Drive uploaded and parsed successfully.", icon="✅")
-                except Exception as e:
-                    st.error(f"Error saving document from Google Drive to database: {e}")
-
-if __name__ == "__main__":
-    main()