From CVs to Graphs: Structuring Talent Data with Gemini and Neo4j

(Person)-[:HAS_SKILL]->(Skill)
(Person)-[:HAS_POSITION]->(Position)-[:AT_COMPANY]->(Company)
(Position)-[:WORKED_ON]->(Project)-[:FOR_CLIENT]->(Company)

# --- Gemini Parsing Function ---
def parse_cv_with_gemini(cv_text):
    """Sends CV text to Gemini API and requests structured JSON output."""
    if not cv_text:
        logging.warning("CV text is empty, skipping Gemini parsing.")
        return None

    # ** IMPORTANT: Craft a detailed prompt requesting the specific JSON structure **
    # This prompt needs refinement based on testing with your actual CVs.
    prompt = f"""
    Parse the following CV text and extract the information into a JSON object.
    The JSON object should strictly follow this structure:

    {{
      "name": "Full Name",
      "email": "email @ address",
      "phone": "+1234567890",
      "linkedin_url": "Optional LinkedIn Profile URL",
      "github_url": "Optional GitHub Profile URL",
      "profile_summary": "A brief summary or objective statement from the CV.",
      "skills": ["Skill 1", "Skill 2", "Technology 3"],
      "experience": [
        {{
          "title": "Job Title",
          "company": "Company Name",
          "start_date": "YYYY-MM or textual description like 'Jan 2020'",
          "end_date": "YYYY-MM, 'Present', or textual description",
          "responsibilities": [
            "Responsibility description 1.",
            "Responsibility description 2."
          ],
          // *** Crucial flags ***
          "is_past_experience": true, // true if this job was BEFORE {COMPANY_NAME}, false otherwise
          "client_name": "Client Company Name OR null" // If the company is {COMPANY_NAME} AND the description mentions working FOR a specific client, put the client's name here. Otherwise null.
        }}
        // ... more experience objects
      ],
      "education": [
        {{
          "university": "University Name",
          "degree": "Degree Name (e.g., BSc Computer Science)",
          "field_of_study": "Field (e.g., Software Engineering)", // Optional refinement
          "start_date": "YYYY or textual description",
          "end_date": "YYYY, 'Expected Grad YYYY', or textual description"
        }}
        // ... more education objects
      ],
      "languages": [
        {{
          "language": "Language Name",
          "level": "Proficiency Level (e.g., Native, Fluent, A2, Basic)"
        }}
        // ... more language objects
      ]
    }}

    **Instructions & Clarifications:**
    - Identify the main current employer as "{COMPANY_NAME}". Any experience listed *before* the start date of the first role at "{COMPANY_NAME}" should have "is_past_experience": true. Roles *at* "{COMPANY_NAME}" should have "is_past_experience": false.
    - For roles at "{COMPANY_NAME}", if the responsibilities clearly state the work was *for* another company (e.g., "Developed a system for Client X", "Project for Client Y"), extract "Client X" or "Client Y" into the "client_name" field for that specific experience entry. Otherwise, "client_name" should be null.
    - Extract dates as accurately as possible. If exact YYYY-MM is not available, use the text provided (e.g., "Summer 2023"). Use "Present" for ongoing roles.
    - Consolidate skills into a single list of strings.
    - Extract languages and their proficiency levels.
    - Ensure the entire output is ONLY the JSON object, nothing else before or after.

    **CV Text:**
    --- START CV TEXT ---
    {cv_text}
    --- END CV TEXT ---

    **JSON Output:**
    """

    try:
        logging.info("Sending request to Gemini API...")
        # Use generate_content with generation_config for JSON mode if available/preferred
        # response = model.generate_content(prompt, generation_config=genai.types.GenerationConfig(response_mime_type="application/json"))
        # Or simpler method:
        response = model.generate_content(prompt)

        # Clean potential markdown code fences json ... 
        cleaned_response_text = re.sub(r'^json\s*|\s*$', '', response.text.strip(), flags=re.MULTILINE)

        logging.info("Received response from Gemini.")
        # print("Gemini Raw Response Text:", cleaned_response_text) # Debugging

        # Parse the JSON response
        parsed_json = json.loads(cleaned_response_text)
        logging.info("Successfully parsed JSON response from Gemini.")
        return parsed_json

    except json.JSONDecodeError as json_err:
        logging.error(f"Failed to decode JSON from Gemini response: {json_err}")
        logging.error(f"Gemini raw response was:\n{response.text[:500]}...") # Log partial response
        return None
    except Exception as e:
        logging.error(f"Error during Gemini API call or processing: {e}", exc_info=True)
        # Log response text if available and exception happened after getting response
        if 'response' in locals() and hasattr(response, 'text'):
             logging.error(f"Gemini raw response text was:\n{response.text[:500]}...")
        return None