total restructure

app.py

@@ -3,13 +3,16 @@
 """
 
 import json
+import random
 import concurrent.futures
 
 import streamlit as st
 
+from backend import paired_critique
+
 from utils.process_doc import parse_docx, parse_pdf
-from backend import process_cv, process_job_posting
-from utils.gpt import test_api_key
+from utils.gpt import test_api_key, gpt_stream_response_chat_history
+from utils.format import extract_json, generate_markdown_report
 
 st.set_page_config(layout="wide")
 
@@ -21,7 +24,7 @@ with st.sidebar:
     )
 
 if "state" not in st.session_state:
-    st.session_state.state = {"formatted": False}
+    st.session_state.state = {"successful_report_flag": True, "paired_report": {}}
 
 STATE = st.session_state.state
 
@@ -38,93 +41,152 @@ cv_upload_box = st.file_uploader(
 )
 job_posting_upload_box = st.text_area(
     "Job Description Upload Box",
+    value="""Job description
+As a Data Scientist at Meta, you will shape the future of people-facing and business-facing products we build across our entire family of applications (Facebook, Instagram, Messenger, WhatsApp, Oculus). By applying your technical skills, analytical mindset, and product intuition to one of the richest data sets in the world, you will help define the experiences we build for billions of people and hundreds of millions of businesses around the world. You will collaborate on a wide array of product and business problems with a diverse set of cross-functional partners across Product, Engineering, Research, Data Engineering, Marketing, Sales, Finance and others. You will use data and analysis to identify and solve product development’s biggest challenges. You will influence product strategy and investment decisions with data, be focused on impact, and collaborate with other teams. By joining Meta, you will become part of a world-class analytics community dedicated to skill development and career growth in analytics and beyond.Product leadership: You will use data to shape product development, quantify new opportunities, identify upcoming challenges, and ensure the products we build bring value to people, businesses, and Meta. You will help your partner teams prioritize what to build, set goals, and understand their product’s ecosystem.Analytics: You will guide teams using data and insights. You will focus on developing hypotheses and employ a diverse toolkit of rigorous analytical approaches, different methodologies, frameworks, and technical approaches to test them.Communication and influence: You won’t simply present data, but tell data-driven stories. You will convince and influence your partners using clear insights and recommendations. You will build credibility through structure and clarity, and be a trusted strategic partner.
+
+Data Scientist, Product Analytics Responsibilities:
+
+Work with large and complex data sets to solve a wide array of challenging problems using different analytical and statistical approaches.
+Apply technical expertise with quantitative analysis, experimentation, data mining, and the presentation of data to develop strategies for our products that serve billions of people and hundreds of millions of businesses.
+Identify and measure success of product efforts through goal setting, forecasting, and monitoring of key product metrics to understand trends.
+Define, understand, and test opportunities and levers to improve the product, and drive roadmaps through your insights and recommendations.
+Partner with Product, Engineering, and cross-functional teams to inform, influence, support, and execute product strategy and investment decisions.
+
+Minimum Qualifications:
+
+A minimum of 6 years of work experience in analytics (minimum of 4 years with a Ph.D.).
+Bachelor's degree in Mathematics, Statistics, a relevant technical field, or equivalent practical experience.
+Experience with data querying languages (e.g. SQL), scripting languages (e.g. Python), and/or statistical/mathematical software (e.g. R).
+
+Preferred Qualifications:
+
+Masters or Ph.D. Degree in a quantitative field.
+
+About Meta:
+
+Meta builds technologies that help people connect, find communities, and grow businesses. When Facebook launched in 2004, it changed the way people connect. Apps like Messenger, Instagram and WhatsApp further empowered billions around the world. Now, Meta is moving beyond 2D screens toward immersive experiences like augmented and virtual reality to help build the next evolution in social technology. People who choose to build their careers by building with us at Meta help shape a future that will take us beyond what digital connection makes possible today—beyond the constraints of screens, the limits of distance, and even the rules of physics.
+
+Individual compensation is determined by skills, qualifications, experience, and location. Compensation details listed in this posting reflect the base hourly rate, monthly rate, or annual salary only, and do not include bonus, equity or sales incentives, if applicable. In addition to base compensation, Meta offers benefits. Learn more about benefits at Meta.""",
     placeholder="Copy and Paste a job post you are interested in. Make sure to include the full post! More information is better.",
     help="In this box, please dump text content for a job description you are interested in. This could easily be setup to work directly with a webpage (we'd simply need to scrape said page) however I do not want to do that on HF spaces.",
 )
 
 if cv_upload_box and job_posting_upload_box != "":
+    STATE["job_posting"] = job_posting_upload_box
 
-    process_files = st.button("Process Files", type="primary")
-
-    if process_files:
-        if test_api_key(COHERE_API_KEY):
-
-            # Process our two uploaded files into state variables
-            STATE["job_posting"] = job_posting_upload_box
+    cv_filetype = cv_upload_box.name.split(".")[-1]
+    cv_file_contents = cv_upload_box.getvalue()
 
-            cv_filetype = cv_upload_box.name.split(".")[-1]
-            cv_file_contents = cv_upload_box.getvalue()
-
-            STATE["cv"] = (
-                parse_docx(cv_file_contents)
-                if cv_filetype == "docx"
-                else parse_pdf(cv_file_contents)
-            )
+    STATE["cv"] = (
+        parse_docx(cv_file_contents)
+        if cv_filetype == "docx"
+        else parse_pdf(cv_file_contents)
+    )
+    cv_critique, practice_interview, general_cv_critique = st.tabs(
+        ["Role Specific CV Critique", "Practice Interview", "General CV Critique"]
+    )
 
-            # Now, use Cohere to get structured output for both cv and job_posting
+    with cv_critique:
+        produce_report = st.button("Produce Suitability Report")
+        if produce_report:
 
-            # Making these calls in parallel
+            # Make 3 calls in parallel
             with concurrent.futures.ThreadPoolExecutor() as executor:
+                future1 = executor.submit(
+                    paired_critique,
+                    STATE["cv"],
+                    STATE["job_posting"],
+                    "basic",
+                    COHERE_API_KEY,
+                )
 
-                future1 = executor.submit(process_cv, STATE["cv"], COHERE_API_KEY)
                 future2 = executor.submit(
-                    process_job_posting, STATE["job_posting"], COHERE_API_KEY
+                    paired_critique,
+                    STATE["cv"],
+                    STATE["job_posting"],
+                    "general",
+                    COHERE_API_KEY,
                 )
 
-                cv_json_text = future1.result()
-                job_posting_json_text = future2.result()
-
-            cv_json_text = (
-                "{" + cv_json_text.lstrip().lstrip("{").rstrip().rstrip("}") + "}"
-            )
-            job_posting_json_text = (
-                "{"
-                + job_posting_json_text.lstrip().lstrip("{").rstrip().rstrip("}")
-                + "}"
-            )
-            try:
-                STATE["cv_json"] = json.loads(cv_json_text)
-            except json.JSONDecodeError as e:
-                print(
-                    f"Error parsing JSON Output for CV: {e}. Response content: {cv_json_text}"
+                future3 = executor.submit(
+                    paired_critique,
+                    STATE["cv"],
+                    STATE["job_posting"],
+                    "specific",
+                    COHERE_API_KEY,
                 )
-                STATE["cv_json"] = {"name": "Failed"}
 
-            try:
-                STATE["job_posting_json"] = json.loads(job_posting_json_text)
+                basic_details_out = future1.result()
+                general_details_out = future2.result()
+                specific_details_out = future3.result()
 
-            except json.JSONDecodeError as e:
-                print(
-                    f"Error parsing JSON Output for Job Posting: {e}. Response content: {job_posting_json_text}"
-                )
-                STATE["job_posting_json"] = {"companyName": "Failed"}
+            # merge the outputs
+            resultsDict = {}
+            for jsonText in [
+                basic_details_out,
+                general_details_out,
+                specific_details_out,
+            ]:
+                valid_json_flag, output_report_json = extract_json(jsonText)
 
-            STATE["formatted"] = True
-        else:
-            st.error(
-                "You entered an invalid Cohere API Key. Please enter a valid API key in the sidebar."
-            )
+                if not valid_json_flag:
+                    STATE["successful_report_flag"] = False
 
-    # Now, we can work with this !
-    if STATE["formatted"]:
-        lcol, rcol = st.columns((0.5, 0.5))
-        with lcol:
-            st.download_button(
-                label="Download Job Posting JSON",
-                data=json.dumps(STATE["job_posting_json"], indent=4),
-                file_name=f"job_posting_formatted_{STATE['job_posting_json']['companyName']}.json",
-                mime="application/json",
-                use_container_width=True,
-            )
-        with rcol:
-            st.download_button(
-                label="Download CV JSON",
-                data=json.dumps(STATE["cv_json"], indent=4),
-                file_name=f"cv_formatted_{STATE['cv_json']['name']}.json",
-                mime="application/json",
-                use_container_width=True,
+                resultsDict.update(output_report_json)
+
+            STATE["paired_report"] = resultsDict
+
+        if STATE["successful_report_flag"] and STATE["paired_report"]:
+
+            paired_report = STATE["paired_report"]
+
+            name = paired_report.get("personName", "MissingPersonName")
+            job_title = paired_report.get("jobTitle", "MissingTitle")
+            company_name = paired_report.get("companyName", "MissingCompany")
+
+            with cv_critique:
+                st.markdown(generate_markdown_report(STATE["paired_report"]))
+
+                st.download_button(
+                    label="Download Report JSON",
+                    data=json.dumps(STATE["paired_report"], indent=4),
+                    file_name=f"{name}_{job_title}_{company_name}.json",
+                    mime="application/json",
+                    use_container_width=True,
+                )
+
+    # Streaming Chatbot !!!
+    with practice_interview:
+        initial_questions = [
+            "What do you think is the biggest reason you're unsuitable for the role?",
+            "Why are you interested in this role specifically?",
+            "What do you know about the company?",
+        ]
+
+        if "messages" not in st.session_state:
+            st.session_state["messages"] = [
+                {"role": "assistant", "message": random.choice(initial_questions)}
+            ]
+
+        # Populate the chat with historic messages
+        for msg in st.session_state.messages:
+            st.chat_message(msg["role"]).write(msg["message"])
+
+        if prompt := st.chat_input():
+            st.session_state.messages.append({"role": "user", "message": prompt})
+            st.chat_message("user").write(prompt)
+
+            assistant_message = st.chat_message("assistant")
+
+            response = assistant_message.write_stream(
+                gpt_stream_response_chat_history(
+                    st.session_state.messages,
+                    background_info={
+                        "cv": STATE["cv"],
+                        "job_posting": STATE["job_posting"],
+                    },
+                    api_key=COHERE_API_KEY,
+                )
             )
 
-        cv_critique, practice_interview, general_cv_critique = st.tabs(
-            ["Role Specific CV Critique", "Practice Interview", "General CV Critique"]
-        )
+            st.session_state.messages.append({"role": "assistant", "message": response})

backend.py

@@ -1,31 +1,31 @@
 from utils.prompts import (
-    cv_extract_prompt,
-    cv_format,
-    job_posting_extract_prompt,
-    job_posting_format,
+    basic_details_extraction_prompt,
+    general_skils_extraction_prompt,
+    specific_skills_comparison_prompt,
 )
 
 from utils.gpt import gpt_response
 
+prompt_mapping = {
+    "basic": basic_details_extraction_prompt,
+    "general": general_skils_extraction_prompt,
+    "specific": specific_skills_comparison_prompt,
+}
 
-def process_cv(cv_contents: str, API_KEY: str) -> str:
+
+def paired_critique(
+    cv_contents: str, job_post_contents: str, response_type: str, API_KEY: str
+) -> str:
     """Process CV contents, using Cohere"""
 
-    prompt = cv_extract_prompt.replace("<input-cv>", cv_contents)
+    # First, get the prompt from the prompt dict
+    prompt = prompt_mapping.get(response_type)
 
-    response = gpt_response(
-        prompt=prompt,
-        api_key=API_KEY,
+    # Now, populate with the contents of the CV and job posting
+    prompt = prompt.replace("<cv>", cv_contents).replace(
+        "<job-posting>", job_post_contents
     )
 
-    return response
-
-
-def process_job_posting(job_post_contents: str, API_KEY: str) -> str:
-    """Process a job posting, using Cohere"""
-
-    prompt = job_posting_extract_prompt.replace("<job-posting>", job_post_contents)
-
     response = gpt_response(
         prompt=prompt,
         api_key=API_KEY,
@@ -38,4 +38,10 @@ if __name__ == "__main__":
     with open("sample_data/meta_job.txt", "r") as file:
         post_contents = file.read()
 
-    output = process_job_posting(post_contents)
+    with open("sample_data/example_cv.txt", "r") as file:
+        cv_contents = file.read()
+
+    COHERE_API_KEY = ""
+
+    output = paired_critique(post_contents, cv_contents, "specific", COHERE_API_KEY)
+    print(output)

utils/format.py

@@ -0,0 +1,142 @@
+import json
+
+
+def extract_json(input_string: str) -> dict:
+    """String to Json function"""
+
+    # First, ensure we remove json wrapper
+    input_string = input_string.replace("```json", "```").replace("```", "")
+
+    # Now, ensure we have stripped everything so it is just json
+    input_string_formatted = input_string.lstrip("{").rstrip("}")
+
+    # Ensure we do not have the weird \_ behaviour that models sometimes include
+    input_string_formatted = input_string_formatted.replace("\_", "_")
+
+    try:
+        return True, json.loads(input_string_formatted)
+
+    except json.JSONDecodeError as e:
+        print(f"Error parsing JSON Output: {input_string}. Error: {e}")
+        return False, {}
+
+
+def generate_markdown_report(data):
+    # Header
+    report = f"# CV Analysis Report\n\n"
+    report += f"**Name:** {data.get('personName', 'Unknown')}  \n"
+    report += f"**Job:** {data.get('jobTitle', 'N/A')} at {data.get('companyName', 'N/A')}  \n"
+    report += (
+        f"**Job Description:** {data.get('jobDesc', 'No description available.')}\n\n"
+    )
+    report += "---\n\n"
+    report += "## Key Findings\n\n"
+
+    experiences = data.get("experience", [])
+    if experiences:
+
+        report += "### Experience\n\n"
+        report += (
+            "| Job Posting Requirement | CV Details | Explanation | Impact Score |\n"
+        )
+        report += (
+            "| ----------------------- | ---------- | ----------- | -------------- |\n"
+        )
+        for exp in experiences:
+            report += f"| {exp.get('jobPostingDetails', 'N/A')} | {exp.get('cvDetails', 'N/A')} | {exp.get('explanation', '')} | **{exp.get('severityScore', 0)}** |\n"
+        report += "\n"
+
+    education = data.get("education", [])
+    if education:
+        report += "### Education\n\n"
+        report += (
+            "| Job Posting Requirement | CV Details | Explanation | Impact Score |\n"
+        )
+        report += (
+            "| ----------------------- | ---------- | ----------- | -------------- |\n"
+        )
+        for edu in education:
+            report += f"| {edu.get('jobPostingDetails', 'N/A')} | {edu.get('cvDetails', 'N/A')} | {edu.get('explanation', '')} | **{edu.get('severityScore', 0)}** |\n"
+        report += "\n"
+
+    responsibilities = data.get("responsibilities", [])
+    if responsibilities:
+        report += "### Responsibilities\n\n"
+        report += (
+            "| Job Posting Requirement | CV Details | Explanation | Impact Score |\n"
+        )
+        report += (
+            "| ----------------------- | ---------- | ----------- | -------------- |\n"
+        )
+        for resp in responsibilities:
+            report += f"| {resp.get('jobPostingDetails', 'N/A')} | {resp.get('cvDetails', 'N/A')} | {resp.get('explanation', '')} | **{resp.get('severityScore', 0)}** |\n"
+        report += "\n"
+
+    languages = data.get("languages", [])
+    if languages:
+        report += "### Languages\n\n"
+        report += (
+            "| Job Posting Requirement | CV Details | Explanation | Impact Score |\n"
+        )
+        report += (
+            "| ----------------------- | ---------- | ----------- | -------------- |\n"
+        )
+        for lang in languages:
+            report += f"| {lang.get('jobPostingDetails', 'N/A')} | {lang.get('cvDetails', 'N/A')} | {lang.get('explanation', '')} | **{lang.get('severityScore', 0)}** |\n"
+        report += "\n"
+
+    # Tools
+    tools = data.get("tools", [])
+    if tools:
+        report += "### Tools\n\n"
+        report += (
+            "| Job Posting Requirement | CV Details | Explanation | Impact Score |\n"
+        )
+        report += (
+            "| ----------------------- | ---------- | ----------- | -------------- |\n"
+        )
+        for tool in tools:
+            report += f"| {tool.get('jobPostingDetails', 'N/A')} | {tool.get('cvDetails', 'N/A')} | {tool.get('explanation', '')} | **{tool.get('severityScore', 0)}** |\n"
+        report += "\n"
+
+    # Closing
+    report += "---\n"
+
+    return report
+
+
+def format_chat_history_cohere(chat_history: list, background_info: dict) -> list:
+    """Takes streamlit chat history, and converts to cohere format"""
+
+    # Could use cohere to track history, maybe for the future
+    new_output = [
+        {
+            "role": "USER",
+            "message": f"Hi there! Here is my CV! {background_info['cv']}.\n\n I'd like you to act as a senior technical recruiter, recruiting for a role at a specific company. I want you to ask highly specific questions about the role, and critique my CV and its' suitability for the role. Please also ask general interview questions.",
+        },
+        {
+            "role": "CHATBOT",
+            "message": f"Thanks. Can you send me the job posting?",
+        },
+        {
+            "role": "USER",
+            "message": f"Here is the job posting: {background_info['job_posting']}",
+        },
+    ]
+
+    for item in chat_history:
+        new_output.append(
+            {
+                "role": "USER" if item["role"] == "user" else "CHATBOT",
+                "message": item["message"],
+            }
+        )
+
+    return new_output
+
+
+if __name__ == "__main__":
+    example_json = """
+
+"""
+    extract_json(example_json)

utils/gpt.py

@@ -1,4 +1,5 @@
 import cohere
+from utils.format import format_chat_history_cohere
 
 
 def test_api_key(api_key: str):
@@ -14,6 +15,23 @@ def test_api_key(api_key: str):
         return False
 
 
+def gpt_stream_response_chat_history(chat_history, background_info, api_key):
+    """Get response from Cohere and stream response"""
+    co = cohere.Client(
+        api_key=api_key,
+    )
+
+    cohere_history = format_chat_history_cohere(chat_history, background_info)
+
+    stream = co.chat_stream(
+        chat_history=cohere_history[:-1], message=cohere_history[-1]["message"]
+    )
+
+    for event in stream:
+        if event.event_type == "text-generation":
+            yield event.text
+
+
 def gpt_stream_response(prompt: str, api_key: str):
     """Get response from Cohere and stream response"""
 

utils/prompts.py

@@ -1,124 +1,159 @@
-# NOTE: The _format variables may be useful for testing the beta of Cohere's structured output endpoints.
-
-cv_format = {
-    "type": "object",
-    "required": [
-        "name",
-        "roles",
-        "projects",
-        "languages",
-        "packages",
-        "tools",
-        "qualifications",
-        "responsibilities",
-    ],
-    "properties": {
-        "name": {"type": "string"},
-        "roles": {"type": "list"},
-        "projects": {"type": "list"},
-        "languages": {"type": "list"},
-        "packages": {"type": "list"},
-        "tools": {"type": "list"},
-        "qualifications": {"type": "list"},
-        "responsibilities": {"type": "list"},
-    },
+basic_details_extraction_prompt = """
+You are an expert at understanding how suitable a given CV is for a given job posting. 
+You will focus on evaluating the candidates experience quality
+
+**Goal**
+To summarize the information provided in a clear form
+
+**Job Posting**
+Here are the Job Posting contents: 
+<job-posting>
+
+**CV**
+Here are the CV contents: 
+<cv>
+
+**Output Format**
+
+You will produce a json, summarizing the input data. 
+
+Here is the overall structure of your output: 
+{
+    "jobTitle": str,
+    "companyName": str,
+    "personName": str,
+    "jobDesc": str
 }
 
+* jobTitle: at most 5 words giving role title
+* companyName: name of company in job posting
+* personName: name of person who submitted CV (if no name, put Example Name)
+* jobDesc: a short description of the job 
+
+Respond only with a json, wrapped in ```json.
 
-cv_extract_prompt = """
-You are an expert at extracting information from CVs
+If you wish to leave a field blank in a given json, use "". You must never use null as this will be loaded using json.loads! 
+
+Now respond with your professional, concise, answer. 
+"""
+
+general_skils_extraction_prompt = """
+You are an expert at understanding how suitable a given CV is for a given job posting. 
+You will focus on evaluating the candidates experience quality
 
 **Goal**
-For a given CV, you must extract structured information and present it to the user in json form
+To evaluate the candidate, against the job posting, given set criteria
 
-**Input**
-<input-cv>
+**Job Posting**
+Here are the Job Posting contents: 
+<job-posting>
+
+**CV**
+Here are the CV contents: 
+<cv>
 
 **Output Format**
-You will respond with a json object, in the form given. 
-You will ensure that you are concise.
+You will produce a json, summarizing the candidates suitability. 
+The fields will all be lists, each item in those lists will be a dictionary with 4 keys. 
 
+That required form is
 {
-    "name": ,
-    "roles": [],
-    "projects": [],
-    "languages": [],
-    "packages": [],
-    "tools": [],
-    "qualifications": [] ,
-    "responsibilities": [],
+    "jobPostingDetails": str,
+    "cvDetails": str,
+    "explanation": str,
+    "SeverityScore": float
 }
 
-**Guidance**
+* SeverityScore is between 0 and 10, marking how much of a critical miss the given thing is.
+* Explanation will contain a brief explanation of what the problem was 
+
+For instance
+(3 Years using R, No Mention of R, Missing Language Experience, 4)
+
+Here is the overall structure of your output: 
+{
+    "experience": [],
+    "education": [],
+    "responsibilities": []
+}
 
-- languages: programming languages mentioned in the CV. Each should be tagged with a number between 1 and 5. 5 suggests they must be fully fluent, 1 suggests they may have some experience. If the CV does not indicate the level of required experience, approximate it, and if no information at all is given put 3 
-- packages: specific packages mentioned in the CV. Each package should be tagged with a number between 1 and 5, 5 suggesting fully fluent and 1 suggesting just tried it once. Use your best judgement to gauge the individual's level of understanding.
-- tools: a list of other tools the individual has experience with
-- qualifications: of form [{"type": , "grade": ,"location": }] where type is the qualification type identified. Available Education Levels are: bsc,msc,phd. grade should be the grade achieved (number between 0 and 100. Make relevant conversions, if no number is given, assume 60). location is the location of where the education was taken.
-- responsibilities: an extensive list of the responsibilities demonstrated in the CV. 
+* experience should look at the desired experiences in the job posting. For each experience listed, it should be understood if the user's CV showed that trait. 
+* education should compare required / desired education levels with the user's CV's education levels
+* responsibilities refers to the list of responsibilities in the job posting, which should each be compared with the user's CV
 
-You will now respond clearly, only responding with the desired json output. 
+Respond only with a json, wrapped in ```json.
+
+If you wish to leave a field blank in a given json, use "". You must never use null as this will be loaded using json.loads! 
+
+Now respond with your professional, concise, answer. 
 """
 
-job_posting_format = {
-    "type": "object",
-    "required": [
-        "companyName",
-        "roleShortDesc",
-        "roleLongDesc",
-        "requiredExperience",
-        "languages",
-        "packages",
-        "tools",
-        "qualifications",
-        "responsibilities",
-    ],
-    "properties": {
-        "name": {"type": "string"},
-        "roleShortDesc": {"type": "string"},
-        "roleLongDesc": {"type": "string"},
-        "requiredExperience": {"type": "list"},
-        "languages": {"type": "list"},
-        "packages": {"type": "list"},
-        "tools": {"type": "list"},
-        "qualifications": {"type": "list"},
-        "responsibilities": {"type": "list"},
-    },
-}
 
-job_posting_extract_prompt = """
-You are an expert at extracting information from job postings
+specific_skills_comparison_prompt = """
+You are an expert at understanding how suitable a given CV is for a given job posting. 
+You will focus on evaluating the candidates experience quality
 
 **Goal**
-For a given job posting, you must extract structured information and present it to the user
+To evaluate the candidate, against the job posting, given set criteria
 
-**Input**
+**Job Posting**
+Here are the Job Posting contents: 
 <job-posting>
 
+**CV**
+Here are the CV contents: 
+<cv>
+
 **Output Format**
-You will respond with a json object, in the form given. 
-You will ensure that you are concise.
 
+You will produce a json, summarizing the candidates suitability. 
+The fields will all be lists, each item in those lists will be a dictionary with 4 keys. 
+
+That required form is
+{
+    "jobPostingDetails": str,
+    "cvDetails": str,
+    "explanation": str,
+    "SeverityScore": float
+}
+
+* SeverityScore is between 0 and 10, marking how much of a critical miss the given thing is.
+* Explanation will contain a brief explanation of what the problem was 
+
+For instance this could look like: (3 Years using R, No Mention of R, Missing Language Experience, 4)
+
+Here is the overall structure of your output: 
 {
-    "companyName": ,
-    "roleShortDesc": ,
-    "roleLongDesc": ,
-    "requiredExperience": [],
     "languages": [],
     "packages": [],
-    "tools": [],
-    "qualifications": [] ,
-    "responsibilities": [],
+    "tools": []
 }
 
-**Guidance**
-- roleShortDesc should be one sentence only
-- requiredExperience: a standaredized list of items, each item should be at most one short sentence
-- languages: programming languages mentioned in the post. Each should be tagged with a number between 1 and 5. 5 suggests they must be fully fluent, 1 suggests they may have some experience. If the job does not indicate the level of required experience, put 3 
-- packages: specific packages mentioned in the post. Each package should be tagged with a number between 1 and 5, 5 suggesting fully fluent and 1 suggesting just tried it once. If no level is given, assume level 3
-- tools: a list of other tools that would be useful to know
-- qualifications: of form [{"type": , "strictness": }] where type is the qualification type identified, and strictness is your approximation of how strict the job posting suggests the requirement is. 1 being not strict at all, 5 being absolute necessity. Available Education Levels are: bsc,msc,phd.  
-- responsibilities: an extensive list of the responsibilities given in the advert. 
+* languages should compare either programming, or regular language, requirements
+* packages refers specifically to packages of programming languages. Leave blank if job posting gives no details on specific packages.
+* tools refers to specific tools referenced in the job posting, leave blank if job posting gives no details on tools.
+
+Be incredibly careful that you do not confuse the content of the CV with the content of the Job Posting. 
+
+Respond only with a json, wrapped in ```json.
+
+You must never use null as this will be loaded using json.loads! If there is nothing relevant, leave the list empty. If a field is missing from the dictionary of 4, then just put "".
+
+Now respond with your professional, concise, answer. 
+"""
+
+interviewer_prompt = """
+**Goal**
+You are an interviewer, and will carry out a natural interview
+
+**Background Information**
+The user has the following CV:
+<cv>
+
+The user is interested in the following job: 
+<job-posting>
+
+You will act like an interviewer for that job, critiquing the user's CV and asking them questions. Follow the conversation naturally. 
 
-You will now respond clearly, only responding with the desired json output. 
+Ask either STAR reasoning, or technical questions, based on the job posting, or general job title.
 """