Merge branch 'main' into dev/backend

# Conflicts:
#	be_repo/modules/job_recommendation_system.py
#	be_repo/modules/recommendation_generator.py
#	be_repo/modules/retrieval_engine.py
#	be_repo/modules/view.py

Author: Linchen-Xu

.github/workflows/ci_be.yml

@@ -62,10 +62,14 @@ jobs:
         run: |
           sed -i '/<!-- Pytest Coverage Comment:Begin -->/,/<!-- Pytest Coverage Comment:End -->/c\<!-- Pytest Coverage Comment:Begin -->\n\${{ steps.coverageComment.outputs.coverageHtml }}\n<!-- Pytest Coverage Comment:End -->' ../README.md
 
+      - name: Debug current branch
+        run: |
+          echo "head ref: ${{ github.head_ref }} "
+          echo "ref name: ${{ github.ref_name }} "
+
       - name: Commit & Push changes to Readme
-        uses: actions-js/push@master
+        uses: ad-m/github-push-action@master
         with:
-          branch: |
-            ${{ github.ref_name == 'main' && 'dev/backend' || github.ref_name.startsWith('be/') && github.ref_name || 'dev/backend' }}
+          branch: ${{ github.head_ref || github.ref_name }}
           message: Update coverage on Readme
           github_token: ${{ secrets.GITHUB_TOKEN }}

be_repo/app.py

@@ -9,6 +9,7 @@
 from configs.database import get_resume_database, get_user_database
 from graphs.qa_graph import create_graph
 from modules.evaluator import evaluate_resume, evaluate_resume_with_jd
+from modules.job_recommendation_system import job_recommend
 from modules.langgraph_qa import get_answer_from_langgraph
 from modules.upload import upload_parse_resume
 
@@ -159,9 +160,17 @@ def ask_question():
         return jsonify({"error": "No user ID provided."}), 400
     if not question:
         return jsonify({"error": "No question provided."}), 400
+    # Load resume from database
+    resume = resume_collection.find_one({"user_id": user_id})
+    if not resume:
+        return jsonify({"error": "No resume found for this user."}), 404
+
+    resume_text = resume.get('resume_text', '')
+    if not resume_text:
+        return jsonify({"error": "Resume text is empty."}), 400
 
     # Get answer using LangGraph
-    response = get_answer_from_langgraph(qa_graph, resume_collection, user_state_collection, user_id, question)
+    response = get_answer_from_langgraph(qa_graph, resume_text, user_state_collection, user_id, question)
 
     return jsonify({"response": response}), 200
 
@@ -202,11 +211,43 @@ def interview_question_suggestion():
     if not user_id:
         return jsonify({"error": "No user ID provided."}), 400
 
+    # Load resume from database
+    resume = resume_collection.find_one({"user_id": user_id})
+    if not resume:
+        return jsonify({"error": "No resume found for this user."}), 404
+
+    resume_text = resume.get('resume_text', '')
+    if not resume_text:
+        return jsonify({"error": "Resume text is empty."}), 400
+
     # Get answer using LangGraph
-    response = get_answer_from_langgraph(qa_graph, resume_collection, user_state_collection, user_id, prompt)
+    response = get_answer_from_langgraph(qa_graph, resume_text, user_state_collection, user_id, prompt)
 
     return jsonify({"response": response}), 200
 
 
+@app.route('/suggest/jobs', methods=['POST', 'OPTIONS'])
+def job_suggestion():
+    if request.method == 'OPTIONS':
+        return jsonify({'status': 'OK'}), 200
+
+    user_id = request.form.get('user_id')
+
+    if not user_id:
+        return jsonify({"error": "No user ID provided."}), 400
+
+    # Load resume from database
+    resume = resume_collection.find_one({"user_id": user_id})
+    if not resume:
+        return jsonify({"error": "No resume found for this user."}), 404
+
+    # Get answer using LangGraph
+    resume_text = resume.get('resume_text', '')
+    if not resume_text:
+        return jsonify({"error": "Resume text is empty."}), 400
+
+    return jsonify({"response": job_recommend(resume_text, user_id)}), 200
+
+
 if __name__ == '__main__':
     app.run(host='0.0.0.0', debug=True, port=5000)

be_repo/modules/job_recommendation_system.py

@@ -1,26 +1,23 @@
 # job_recommendation_system.py
 
-from neo4j_model import Neo4jModel
-from resume_processor import ResumeProcessor
-from retrieval_engine import RetrievalEngine
-from recommendation_generator import RecommendationGenerator
-from view import CLIView
+from .neo4j_model import Neo4jModel
+from .resume_processor import ResumeProcessor
+from .retrieval_engine import RetrievalEngine
+from .recommendation_generator import RecommendationGenerator
+from .view import CLIView
+import logging
 import sys
 
-def main():
-
-    # Redirect standard output to a file
-    sys.stdout = open('output.log', 'w')
-
-    # Your code here
-    print("Lots of output")
-
-
+def job_recommend(resume_text, user_id):
     # Setup Logging
-    import logging
     logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
     logger = logging.getLogger(__name__)
-    
+
+    # Get Resume Input from User
+    if not resume_text.strip():
+        logger.error(f'No resume text provided, user_id: {user_id}.')
+        return 'Error: No resume text provided.'
+
     # Neo4j Connection Details
     NEO4J_URI = "neo4j+ssc://7bf5a48e.databases.neo4j.io"  # Replace with your Neo4j URI
     NEO4J_USERNAME = "neo4j"             # Replace with your Neo4j username
@@ -32,44 +29,28 @@ def main():
         username=NEO4J_USERNAME,
         password=NEO4J_PASSWORD
     )
-    
+
     node_label = "JTitle"  # Adjust as needed; could be dynamic based on user input or other criteria
 
     # Initialize Controller Components
     resume_processor = ResumeProcessor()
     retrieval_engine = RetrievalEngine(resume_processor, neo4j_model)
     recommendation_generator = RecommendationGenerator()
-    
+
     # Initialize View
     view = CLIView()
-    
-    # Get Resume Input from User
-    resume_text = view.get_resume_input()
-    
-    if not resume_text.strip():
-        logger.error("No resume text provided.")
-        print("Error: No resume text provided.")
-        return
-    
-    # Perform Mixed Retrieval for 'JD' Node Label
+
+    # Perform Mixed Retrieval
     similar_docs, graph_results = retrieval_engine.perform_mixed_retrieval(resume_text, node_label=node_label)
-    
+
     if not similar_docs and not graph_results:
-        print("No job recommendations found based on your resume.")
-        return
-    
+        return 'No job recommendations found based on your resume.'
+
     # Generate Recommendations
     try:
         recommendations = recommendation_generator.generate_recommendations(similar_docs, graph_results)
     except Exception as e:
-        print("Error: Failed to generate job recommendations.")
-        return
-    
-    # Display Recommendations
-    view.display_recommendations(recommendations)
+        return 'Error: Failed to generate job recommendations.'
 
-    # Close the file
-    sys.stdout.close()
-
-if __name__ == "__main__":
-    main()
+    # Display Recommendations
+    return view.display_recommendations(recommendations)

be_repo/modules/langgraph_qa.py

@@ -1,27 +1,24 @@
-def get_answer_from_langgraph(qa_graph, resume_collection, user_state_collection, user_id, question):
-    resume = resume_collection.find_one({"user_id": user_id})
+def get_answer_from_langgraph(qa_graph, resume_text, user_state_collection, user_id, question):
     user_state = user_state_collection.find_one({"user_id": user_id})
-    resume_text = resume.get('resume_text', '')
-    state = user_state.get('state', '')
     thread_id = user_state.get('thread_id', '')
 
     config = {"configurable": {"thread_id": user_id + thread_id}}
 
     # If state is 0, send resume to LLM first
-    if state == '0':
-        events = qa_graph.stream(
-            {"messages": [("user", resume_text)]}, config, stream_mode="values"
-        )
-        # Update state to 1
-        new_state = {
-            "user_id": user_id,
-            "state": '1',
-            "thread_id": thread_id
-        }
-        user_state_collection.replace_one({"user_id": user_id}, new_state, upsert=True)
-        for event in events:
-            if event["messages"][-1].type == "ai":
-                print('User ask for the first time!')
+    # if state == '0':
+    events = qa_graph.stream(
+        {"messages": [("user", resume_text)]}, config, stream_mode="values"
+    )
+    # Update state to 1
+    new_state = {
+        "user_id": user_id,
+        "state": '1',
+        "thread_id": thread_id
+    }
+    user_state_collection.replace_one({"user_id": user_id}, new_state, upsert=True)
+    for event in events:
+        if event["messages"][-1].type == "ai":
+            print('User ask for the first time!')
     # Then send the question
     events = qa_graph.stream(
         {"messages": [("user", question)]}, config, stream_mode="values"

be_repo/modules/retrieval_engine.py

@@ -1,12 +1,10 @@
 # retrieval_engine.py
 
-from langchain_neo4j import GraphCypherQAChain
-from langchain_openai import ChatOpenAI
-from langchain.chains.retrieval import create_retrieval_chain 
 from langchain.chains.combine_documents import create_stuff_documents_chain
-from configs.openai_key import get_openai_api_key  # New import
+from langchain.chains.retrieval import create_retrieval_chain
 from langchain.prompts import PromptTemplate
 
+
 class RetrievalEngine:
     def __init__(self, resume_processor, neo4j_model):
         """
@@ -21,15 +19,18 @@ def __init__(self, resume_processor, neo4j_model):
 
         # Initialize Language Model (already initialized in Neo4jModel)
         self.llm = self.neo4j_model.llm
-        
+
         # Initialize GraphCypherQAChain (already initialized in Neo4jModel)
         self.graph_chain = self.neo4j_model.get_graph_chain()
 
         # Define the PromptTemplate with 'context' as input variable
-        template="""
-            You are an assistant that matches resumes to relevant job descriptions.
+        prompt = PromptTemplate(
+            template="""
+            You are an expert Cypher query writer for a Neo4j graph database.
 
-            Given the user's resume, find the most relevant job descriptions.
+            Given the user's question, generate an efficient Cypher query that:
+            - extract entities and relationships from the following resume. 
+            - Focus solely on the resume content.
 
             **Entities to Extract:**
             - **Education (Edu):** Details about degrees, fields of study, institutions, start and end years, GPA.
@@ -39,19 +40,29 @@ def __init__(self, resume_processor, neo4j_model):
             - **Certifications (Cert):** Certification names, issuing organizations, expiration dates.
             - **Soft Skills (SSkill):** Non-technical skills like leadership, communication.
 
+            **Relationships to Identify:**
+            - **UTILIZES_SKILL:** A Work Experience (WE) node utilizes a Skill (Skill) node.
+            - **USES_TECH:** A Project (Proj) node uses a Skill (Skill) node as a technology.
+            - **REL_TO (Proj to Skill):** A Project (Proj) node is related to a Skill (Skill) node.
+            - **REL_TO (Skill to Skill):** A Skill (Skill) node is similar to another Skill (Skill) node.
+
             **Resume:**
             \"\"\"
             {context}
             \"\"\"
-            """
-        
-        self.prompt_template = PromptTemplate(
-            template=template,
+            """,
             input_variables=["input"]
         )
 
         # Create a documents chain
-        self.combine_docs_chain = create_stuff_documents_chain(self.llm, self.prompt_template)
+        self.combine_docs_chain = create_stuff_documents_chain(self.llm, prompt=prompt)
+
+        # Initialize Retrieval Chain
+        # Default node_label is 'JD'; can be adjusted as needed
+        self.retrieval_chain = create_retrieval_chain(
+            self.neo4j_model.get_retriever(node_label="JD"),
+            self.combine_docs_chain
+        )
 
     def perform_mixed_retrieval(self, resume_text, node_label="JD"):
         """
@@ -66,38 +77,30 @@ def perform_mixed_retrieval(self, resume_text, node_label="JD"):
         """
         # Process resume into a Document
         doc = self.resume_processor.process_resume(resume_text)
-        
+
         if not doc:
             return [], {}
-        
+
         # Store the Document in the appropriate vector store
         self.neo4j_model.store_documents([doc], node_label=node_label)
-        
+
         # Access the schema property correctly
         schema = self.neo4j_model.graph.get_schema
 
-        # Get the retriever for the given node label
-        retriever = self.neo4j_model.get_retriever(node_label=node_label)
-
-        # Create the retrieval chain with the retriever and the combine_docs_chain
-        retrieval_chain = create_retrieval_chain(
-            retriever,
-            self.combine_docs_chain
-        )
-
         # Perform vector similarity search
-        similar_docs_result = retrieval_chain.invoke({"input": resume_text})  # Corrected to 'context'
+        similar_docs_result = self.retrieval_chain.invoke({"input": resume_text})  # Corrected to 'context'
         similar_docs = similar_docs_result.get("output", [])
         print("similar_docs_result:", similar_docs_result)
         print("Keys in similar_docs_result:", similar_docs_result.keys())
-        
+
         for doc in similar_docs:
             print("Document Metadata:", doc.metadata)
 
-        query = f"Based on the following resume, recommend relevant job positions: {resume_text}"
+        query = (f"Based on the following resume, recommend relevant job positions based on skills and experience, "
+                 f"while ignoring the location: {resume_text}")
         graph_response = self.graph_chain.invoke({"query": query, "schema": schema})
         # After graph query
         print("Graph Response:")
         print(graph_response)
-       
-        return similar_docs, graph_response
+
+        return similar_docs, graph_response

be_repo/modules/view.py

@@ -28,8 +28,8 @@ def display_recommendations(self, recommendations):
         Display job recommendations to the user.
         """
         if not recommendations:
-            print("No job recommendations found based on your resume.")
-            return
-        print("\nRecommended Jobs for You:")
+            return 'No job recommendations found based on your resume.'
+        res = '\nRecommended Jobs for You:\n'
         for idx, job in enumerate(recommendations, start=1):
-            print(f"{idx}. {job}")
+            res += f'{idx}. {job}\n'
+        return res