Update app.py

app.py

@@ -1,212 +1,161 @@
 import gradio as gr
-import pdfplumber
 import os
-from langchain.schema import Document
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_community.embeddings import OpenAIEmbeddings
-from langchain.vectorstores import Pinecone
-import pinecone
-import pandas as pd
-import time
-from pinecone.grpc import PineconeGRPC as Pinecone
-from pinecone import ServerlessSpec
-from langchain_pinecone import PineconeVectorStore
-from datetime import datetime
-import os
-from langchain.document_loaders import PyPDFLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.embeddings.openai import OpenAIEmbeddings
-from langchain.vectorstores import Pinecone
-from typing import TypedDict,List
-from langgraph.graph import StateGraph
-from langgraph.prebuilt import ToolNode
-from langchain.schema import Document
-from langchain.prompts import PromptTemplate
-from langchain.tools import Tool
-from langchain.llms import OpenAI
-
-# OpenAI API key
-openai_api_key = os.getenv("OPENAI_API_KEY")
-# Embedding using OpenAI
-embeddings = OpenAIEmbeddings(api_key=openai_api_key)
-
-# Initialize Pinecone with PineconeGRPC
-from pinecone import Pinecone
-pc = Pinecone(api_key=os.environ['PINECONE_API_KEY'])
-# Define index name and parameters
-index_name = "italy-kg"
-vectorstore = PineconeVectorStore(index_name=index_name, embedding=embeddings)
-
-
-
-
-
-
-llm=OpenAI(temperature=0,openai_api_key=openai_api_key)
-
-
-# Tool functions
-def search_vector_db(query: str, k: int = 3) -> List[Document]:
-    docs = vectorstore.similarity_search(query, k=k)
-    return docs
-
-def expand_query(query: str) -> str:
-    return query
-
-def summarize_context(context: str) -> str:
-    prompt = PromptTemplate(template="""Summarize the following Context to provide a concise overview: {context}""")
-    summary = llm(prompt.format(context=context))
-    return summary.strip()
-
-def generate_response(context: str, query: str) -> str:
-    prompt = PromptTemplate(template="""Question: {question}\nContext: {context}\nAnswer:""")
-    formatted_prompt = prompt.format(context=context, question=query)
-    response = llm(formatted_prompt)
-    return response.strip()
-
-# Tool objects
-expand_tool = Tool(
-    name="Expand Query",
-    func=expand_query,
-    description="Enhance the query with additional terms or context"
+import logging
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_openai import ChatOpenAI
+from langchain_community.graphs import Neo4jGraph
+from typing import List, Tuple
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.runnables import (
+    RunnableBranch,
+    RunnableLambda,
+    RunnablePassthrough,
+    RunnableParallel,
 )
+from langchain_core.prompts.prompt import PromptTemplate
 
-summarize_tool = Tool(
-    name="Summarize Context",
-    func=summarize_context,
-    description="Summarize the context to provide a concise overview"
+# Setup Neo4j
+graph = Neo4jGraph(
+    url="neo4j+s://6457770f.databases.neo4j.io",
+    username="neo4j",
+    password="Z10duoPkKCtENuOukw3eIlvl0xJWKtrVSr-_hGX1LQ4"
 )
 
-search_tool = Tool(
-    name="Search Vector Database",
-    func=search_vector_db,
-    description="Search the vector database for relevant information"
+# Define entity extraction and retrieval functions
+class Entities(BaseModel):
+    names: List[str] = Field(
+        ..., description="All the person, organization, or business entities that appear in the text"
+    )
+
+entity_prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are extracting organization and person entities from the text."),
+    ("human", "Use the given format to extract information from the following input: {question}"),
+])
+
+chat_model = ChatOpenAI(temperature=0, model_name="gpt-4o", api_key="YOUR_OPENAI_API_KEY")
+entity_chain = entity_prompt | chat_model.with_structured_output(Entities)
+
+def remove_lucene_chars(input: str) -> str:
+    return input.translate(str.maketrans({
+        "\\": r"\\", "+": r"\+", "-": r"\-", "&": r"\&", "|": r"\|", "!": r"\!",
+        "(": r"\(", ")": r"\)", "{": r"\{", "}": r"\}", "[": r"\[", "]": r"\]",
+        "^": r"\^", "~": r"\~", "*": r"\*", "?": r"\?", ":": r"\:", '"': r'\"',
+        ";": r"\;", " ": r"\ "
+    }))
+
+def generate_full_text_query(input: str) -> str:
+    full_text_query = ""
+    words = [el for el in remove_lucene_chars(input).split() if el]
+    for word in words[:-1]:
+        full_text_query += f" {word}~2 AND"
+    full_text_query += f" {words[-1]}~2"
+    return full_text_query.strip()
+
+def structured_retriever(question: str) -> str:
+    result = ""
+    entities = entity_chain.invoke({"question": question})
+    for entity in entities.names:
+        response = graph.query(
+            """CALL db.index.fulltext.queryNodes('entity', $query, {limit:2})
+            YIELD node,score
+            CALL {
+              WITH node
+              MATCH (node)-[r:!MENTIONS]->(neighbor)
+              RETURN node.id + ' - ' + type(r) + ' -> ' + neighbor.id AS output
+              UNION ALL
+              WITH node
+              MATCH (node)<-[r:!MENTIONS]-(neighbor)
+              RETURN neighbor.id + ' - ' + type(r) + ' -> ' +  node.id AS output
+            }
+            RETURN output LIMIT 50
+            """,
+            {"query": generate_full_text_query(entity)},
+        )
+        result += "\n".join([el['output'] for el in response])
+    return result
+
+def retriever_neo4j(question: str):
+    structured_data = structured_retriever(question)
+    logging.debug(f"Structured data: {structured_data}")
+    return structured_data
+
+# Setup for condensing the follow-up questions
+_template = """Given the following conversation and a follow-up question, rephrase the follow-up question to be a standalone question,
+in its original language.
+Chat History:
+{chat_history}
+Follow Up Input: {question}
+Standalone question:"""
+
+CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
+
+def _format_chat_history(chat_history: list[tuple[str, str]]) -> list:
+    buffer = []
+    for human, ai in chat_history:
+        buffer.append(HumanMessage(content=human))
+        buffer.append(AIMessage(content=ai))
+    return buffer
+
+_search_query = RunnableBranch(
+    (
+        RunnableLambda(lambda x: bool(x.get("chat_history"))).with_config(
+            run_name="HasChatHistoryCheck"
+        ),
+        RunnablePassthrough.assign(
+            chat_history=lambda x: _format_chat_history(x["chat_history"])
+        )
+        | CONDENSE_QUESTION_PROMPT
+        | ChatOpenAI(temperature=0, api_key=os.environ['OPENAI_API_KEY'])
+        | StrOutputParser(),
+    ),
+    RunnableLambda(lambda x: x["question"]),
 )
 
-generate_tool = Tool(
-    name="Generate Response",
-    func=generate_response,
-    description="Generate a response based on the context and query"
+# Define the QA prompt template
+template = """As an expert concierge known for being helpful and a renowned guide for Birmingham, Alabama, I assist visitors in discovering the best that the city has to offer. I also assist the visitors about various sports and activities. Given today's sunny and bright weather on {current_date}, I am well-equipped to provide valuable insights and recommendations without revealing specific locations. I draw upon my extensive knowledge of the area, including perennial events and historical context.
+In light of this, how can I assist you today? Feel free to ask any questions or seek recommendations for your day in Birmingham. If there's anything specific you'd like to know or experience, please share, and I'll be glad to help. Remember, keep the question concise for a quick, short, crisp, and accurate response.
+"It was my pleasure!"
+{context}
+Question: {question}
+Helpful Answer:"""
+
+qa_prompt = ChatPromptTemplate.from_template(template)
+
+# Define the chain for Neo4j-based retrieval and response generation
+chain_neo4j = (
+    RunnableParallel(
+        {
+            "context": _search_query | retriever_neo4j,
+            "question": RunnablePassthrough(),
+        }
+    )
+    | qa_prompt
+    | chat_model
+    | StrOutputParser()
 )
 
-# State for the graph
-class State(TypedDict):
-    question: str
-    context: List[Document]
-    response: str
-    expanded_query: str
-    summarized_context: str
-
-# Workflow node definitions
-def expand(state: State) -> State:
-    state["expanded_query"] = expand_tool.func(state["question"])  # Expand the query
-    return state
-
-def search(state: State) -> State:
-    results = search_tool.func(state["expanded_query"])  # Search using the expanded query
-    state["context"] = results
-    print(f"Retrieved Documents: {[doc.page_content[:100] for doc in results]}")
-    return state
-
-def summarize(state: State) -> State:
-    context = " ".join(doc.page_content for doc in state["context"]) if state["context"] else ""
-    state["summarized_context"] = summarize_tool.func(context)
-    print(f"Summarized Context: {state['summarized_context']}")
-    return state
-
-def generate(state: State) -> State:
-    response = generate_tool.func(state["summarized_context"], state["question"])
-    state["response"] = response
-    print(f"Generated Response: {state['response']}")
-    return state
-
-# Workflow graph
-workflow = StateGraph(State)
-
-workflow.add_node("expand", expand)
-workflow.add_node("search", search)
-workflow.add_node("summarize", summarize)
-workflow.add_node("generate", generate)
-
-workflow.set_entry_point("expand")
-workflow.add_edge("expand", "search")
-workflow.add_edge("search", "summarize")
-workflow.add_edge("summarize", "generate")
-workflow.set_finish_point("generate")
-
-graph = workflow.compile()
-
-# Function to run the graph
-def run_graph(question: str):
-    result = graph.invoke({"question": question})
-    return result["response"]
-
-# Function to clear the input and response
-def clear_inputs():
-    return "", ""  # Return empty strings for both the query input and response output
-
-# Create a global list to store uploaded document records
-uploaded_documents = []
-
-
-
-# Function to process PDF, extract text, split it into chunks, and upload to the vector DB
-def process_pdf(pdf_file, uploaded_documents):
-    if pdf_file is None:
-        return uploaded_documents, "No PDF file uploaded."
-    
-    # Open the PDF file and extract text page by page
-    with pdfplumber.open(pdf_file.name) as pdf:
-        chunks = []
-        for page_num, page in enumerate(pdf.pages, start=1):
-            text = page.extract_text()
-            if text:
-                # Split the text into chunks and attach page number metadata to each chunk
-                text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
-                page_chunks = text_splitter.split_text(text)
-                for chunk in page_chunks:
-                    # Create a Document with the page number as metadata
-                    document = Document(page_content=chunk, metadata={"page_number": page_num})
-                    chunks.append(document)
-
-    # Embed and upload the chunks into the vector database
-    chunk_ids = vectorstore.add_documents(chunks)
-    
-    # Update the upload history
-    document_record = {
-        "Document Name": pdf_file.name,
-        "Upload Time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        "Chunks": len(chunks),
-        "Pinecone Index": index_name
-    }
+# Define the function to get the response
+def get_response(question):
+    try:
+        return chain_neo4j.invoke({"question": question})
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Define the function to clear input and output
+def clear_fields():
+    return "", ""
+
+# Create the Gradio Blocks interface
+with gr.Blocks() as demo:
+    question_input = gr.Textbox(label="Ask a Question", placeholder="Type your question here...")
+    response_output = gr.Textbox(label="Response", placeholder="The response will appear here...", interactive=False)
+    get_response_btn = gr.Button("Get Response")
+    clean_btn = gr.Button("Clean")
     
-    # Add the record to the global list
-    uploaded_documents.append(document_record)
-
-    # Convert the list of dictionaries into a list of lists for the dataframe
-    table_data = [[doc["Document Name"], doc["Upload Time"], doc["Chunks"], doc["Pinecone Index"]] for doc in uploaded_documents]
-
-    return table_data, f"Uploaded {len(chunks)} chunks to the vector database with page numbers included as metadata."
-
-
-
-# Gradio Interface
-with gr.Blocks() as demo:    
-          
-    with gr.Row():         
-        with gr.Column():
-            response_output = gr.Textbox(label="Response:", lines=10, max_lines=10)
-            query_input = gr.Textbox(label="Enter your query:")
-            with gr.Row():
-                query_button = gr.Button("Get Response")
-                clear_button = gr.Button("Clear")  # New Clear button
-            query_button.click(fn=run_graph, inputs=query_input, outputs=response_output)
-            clear_button.click(fn=clear_inputs, inputs=[], outputs=[query_input, response_output])  # Clear both input and output
-        with gr.Column():    
-            file_input = gr.File(label="Upload PDF", file_types=[".pdf"])
-            document_table = gr.Dataframe(headers=["Document Name", "Upload Time", "Chunks", "Pinecone Index"], interactive=False)
-            output_textbox = gr.Textbox(label="Result")
-            process_button = gr.Button("Process PDF and Upload")
-            process_button.click(fn=process_pdf, inputs=[file_input, gr.State([])], outputs=[document_table, output_textbox])
+    get_response_btn.click(fn=get_response, inputs=question_input, outputs=response_output)
+    clean_btn.click(fn=clear_fields, inputs=[], outputs=[question_input, response_output])
 
+# Launch the Gradio interface
 demo.launch(show_error=True)