Merge branch 'DEV' of https://github.com/neo4j-labs/llm-graph-builder into add-show-graph

Author: prakriti-solankey

README.md

@@ -114,7 +114,7 @@ KNN_MIN_SCORE = ""\
 https://github.com/neo4j-labs/llm-graph-builder/assets/121786590/b725a503-6ade-46d2-9e70-61d57443c311
 
 ## Links
- The Public [ Google cloud Run URL](https://devfrontend-dcavk67s4a-uc.a.run.app/).
+ The Public [ Google cloud Run URL](https://staging-frontend-dcavk67s4a-uc.a.run.app/).
  [Workspace URL](https://workspace-preview.neo4j.io/workspace)
 
 

backend/score.py

@@ -57,16 +57,17 @@ async def create_source_knowledge_graph_url(
     uri=Form(None),
     userName=Form(None),
     password=Form(None),
-    source_url=Form(),
+    source_url=Form(None),
     database=Form(None),
     aws_access_key_id=Form(None),
     aws_secret_access_key=Form(None),
     max_limit=Form(5),
     query_source=Form(None),
+    wiki_query=Form(None),
     model=Form(None)
 ):
     return create_source_node_graph_url(
-        uri, userName, password, source_url, model, database, aws_access_key_id, aws_secret_access_key
+        uri, userName, password, model, source_url, database, wiki_query, aws_access_key_id, aws_secret_access_key
     )
 
 
@@ -126,6 +127,17 @@ async def extract_knowledge_graph_from_file(
             wiki_query=wiki_query,
             max_sources=max_sources,
         )
+    elif wiki_query:
+         return await asyncio.to_thread(
+            extract_graph_from_file,
+            uri,
+            userName,
+            password,
+            model,
+            database,
+            wiki_query=wiki_query
+        )
+            
     else:
         return {"job_status": "Failure", "error": "No file found"}
 
@@ -161,8 +173,8 @@ async def chat_bot(uri=Form(None),
                           userName=Form(None),
                           password=Form(None),
                           question=Form(None),
-                          model=Form(None)):
-    result = await asyncio.to_thread(QA_RAG,uri=uri,userName=userName,password=password,model_version=model,question=question)
+                          session_id=Form(None)):
+    result = await asyncio.to_thread(QA_RAG,uri=uri,userName=userName,password=password,question=question,session_id=session_id)
     return result
 
 @app.post("/connect")

backend/src/QA_integration.py

@@ -7,58 +7,95 @@
 from langchain_openai import ChatOpenAI
 from langchain_openai import OpenAIEmbeddings
 import logging
+from langchain_community.chat_message_histories import Neo4jChatMessageHistory
+import asyncio
 load_dotenv()
 
 openai_api_key = os.environ.get('OPENAI_API_KEY')
+model_version='gpt-4-0125-preview'
 
 def vector_embed_results(qa,question):
     vector_res={}
     try:
-        # question ="What do you know about machine learning"
         result = qa({"query": question})
-        vector_res['result']=result["result"]
+        vector_res['result']=result.get("result")
         list_source_docs=[]
         for i in result["source_documents"]:
             list_source_docs.append(i.metadata['source'])
             vector_res['source']=list_source_docs
     except Exception as e:
       error_message = str(e)
       logging.exception(f'Exception in vector embedding in QA component:{error_message}')
-      raise Exception(error_message)
+    #   raise Exception(error_message)
 
     return vector_res
 
-def cypher_results(graph,question,model_version):
+def cypher_results(graph,question):
     cypher_res={}
     try:
         graph.refresh_schema()
         cypher_chain = GraphCypherQAChain.from_llm(
             graph=graph,
-            # cypher_llm=ChatOpenAI(temperature=0, model="gpt-4"),
             cypher_llm=ChatOpenAI(temperature=0, model=model_version),
             qa_llm=ChatOpenAI(temperature=0, model=model_version),
             validate_cypher=True, # Validate relationship directions
             verbose=True,
             top_k=2
         )
-
-        cypher_res=cypher_chain.invoke({"query": question})
+        try:
+            cypher_res=cypher_chain.invoke({"query": question})
+        except:
+            cypher_res={}
 
     except Exception as e:
       error_message = str(e)
       logging.exception(f'Exception in CypherQAChain in QA component:{error_message}')
-      raise Exception(error_message)
+    #   raise Exception(error_message)
 
     return cypher_res
 
+def save_chat_history(uri,userName,password,session_id,user_message,ai_message):
+    try:
+        history = Neo4jChatMessageHistory(
+        url=uri,
+        username=userName,
+        password=password,
+        session_id=session_id
+        )
+        history.add_user_message(user_message)
+        history.add_ai_message(ai_message)
+        logging.info(f'Successfully saved chat history')
+    except Exception as e:
+        error_message = str(e)
+        logging.exception(f'Exception in saving chat history:{error_message}')
+        # raise Exception(error_message)
+    
 
+def get_chat_history(llm,uri,userName,password,session_id):
+    try:
+        history = Neo4jChatMessageHistory(
+        url=uri,
+        username=userName,
+        password=password,
+        session_id=session_id
+        )
+        chat_history=history.messages
 
-def QA_RAG(uri,userName,password,model_version,question):
+        if len(chat_history)==0:
+            return ""
+        condense_template = f"""Given the following earlier conversation , Summarise the chat history.Make sure to include all the relevant information.
+            Chat History:
+            {chat_history}"""
+        chat_summary=llm.predict(condense_template)
+        return chat_summary
+    except Exception as e:
+        error_message = str(e)
+        logging.exception(f'Exception in retrieving chat history:{error_message}')
+        # raise Exception(error_message)
+        return ''
+
+def QA_RAG(uri,userName,password,question,session_id):
     try:
-        if model_version=='OpenAI GPT 3.5':
-            model_version='gpt-3.5-turbo'
-        elif model_version=='OpenAI GPT 4':
-            model_version='gpt-4-0125-preview'
         retrieval_query="""
         MATCH (node)-[:PART_OF]->(d:Document)
         WITH d, apoc.text.join(collect(node.text),"\n----\n") as text, avg(score) as score
@@ -77,7 +114,7 @@ def QA_RAG(uri,userName,password,model_version,question):
         llm = ChatOpenAI(model= model_version, temperature=0)
 
         qa = RetrievalQA.from_chain_type(
-            llm=llm, chain_type="stuff", retriever=neo_db.as_retriever(search_kwargs={"score_threshold": 0.5}), return_source_documents=True
+            llm=llm, chain_type="stuff", retriever=neo_db.as_retriever(search_kwargs={'k': 3,"score_threshold": 0.5}), return_source_documents=True
         )
 
         graph = Neo4jGraph(
@@ -86,24 +123,39 @@ def QA_RAG(uri,userName,password,model_version,question):
             password=password
         )
         vector_res=vector_embed_results(qa,question)
+        print('Response from Vector embeddings')
         print(vector_res)
-        cypher_res= cypher_results(graph,question,model_version)
+        cypher_res= cypher_results(graph,question)
+        print('Response from CypherQAChain')
         print(cypher_res)
+
+        chat_summary=get_chat_history(llm,uri,userName,password,session_id)
+
         final_prompt = f"""You are a helpful question-answering agent. Your task is to analyze
         and synthesize information from two sources: the top result from a similarity search
-        (unstructured information) and relevant data from a graph database (structured information).
+        (unstructured information) and relevant data from a graph database (structured information). 
+        If structured information fails to find an answer then use the answer from unstructured information 
+        and vice versa. I only want a straightforward answer without mentioning from which source you got the answer. You are also receiving 
+        a chat history of the earlier conversation. You should be able to understand the context from the chat history and answer the question.
         Given the user's query: {question}, provide a meaningful and efficient answer based
         on the insights derived from the following data:
+        chat_summary:{chat_summary}
         Structured information: {cypher_res.get('result','')}.
         Unstructured information: {vector_res.get('result','')}.
 
-        If structured information fails to find an answer then use the answer from unstructured information and vice versa. I only want a straightforward answer without mentioning from which source you got the answer.
         """
         print(final_prompt)
         response = llm.predict(final_prompt)
-        res={"message":response,"user":"chatbot"}
+        ai_message=response
+        user_message=question
+        save_chat_history(uri,userName,password,session_id,user_message,ai_message)
+
+        res={"session_id":session_id,"message":response,"user":"chatbot"}
         return res
     except Exception as e:
       error_message = str(e)
       logging.exception(f'Exception in in QA component:{error_message}')
-      raise Exception(error_message)
+    #   raise Exception(error_message)
+      return {"session_id":session_id,"message":"Something went wrong","user":"chatbot"}
+
+