done

enhancer_agent.py

@@ -19,11 +19,10 @@ def enhancer_agent(profile_data, evaluation_feedback, target_role):
     profile_sections = [
         "Headline",
         "Summary/About",
-        "Current Position/Experience",
+        "Experience",  # Changed from "Current Position/Experience" to "Experience"
         "Education",
         "Skills",
         "Certifications",
-
         "Recommendations",
     ]
 
@@ -83,6 +82,8 @@ Explanation:
                 temperature=0.3
             )
             agent_response = chat_completion.choices[0].message.content.strip()
+            # Clean markdown formatting from GPT-OSS response
+            agent_response = agent_response.replace('**', '').replace('*', '')
         except Exception as e:
             st.error(f"❌ Groq API Error: {str(e)}")
             if "organization_restricted" in str(e):
@@ -117,7 +118,8 @@ Explanation:
         else:
             positions_list = []
 
-        current_position = positions_list[0] if positions_list else '-'
+        # Get ALL positions, not just current one
+        all_positions = positions_list if positions_list else ['-']
 
         if isinstance(certifications_data, dict):
             certifications_list = certifications_data.get('certificationHistory', [])
@@ -129,9 +131,10 @@ Explanation:
 
         if isinstance(educations_data, dict):
             educations_list = educations_data.get('educationHistory', [])
-            education = educations_list[0] if educations_list else '-'
+            # Get ALL education entries, not just the first one
+            all_education = educations_list if educations_list else ['-']
         else:
-            education = '-'
+            all_education = ['-']
 
         if isinstance(recommendations_data, dict):
             recommendations_count = recommendations_data.get('recommendationsCount', 0)
@@ -143,8 +146,8 @@ Explanation:
         parsed_data = {
             'Headline': person.get('headline', '-') or '-',
             'Summary/About': summary,
-            'Current Position/Experience': current_position,
-            'Education': education,
+            'Experience': all_positions,  # Changed from current_position to all_positions
+            'Education': all_education,   # Changed from single education to all_education  
             'Skills': skills_list,
             'Certifications': certifications_list,
             'Recommendations': recommendations_count,
@@ -181,58 +184,64 @@ Explanation:
             if not value or value == '-' or (isinstance(value, list) and not any(value)):
                 st.markdown("_This section is currently missing or incomplete._")
             else:
-                if key == "Current Position/Experience" and isinstance(value, dict):
-                    position = value
-                    start_end_date = position.get('startEndDate', {})
-                    start_date = start_end_date.get('start')
-                    end_date = start_end_date.get('end')
-
-                    if isinstance(start_date, dict):
-                        start_month = start_date.get('month', '-')
-                        start_year = start_date.get('year', '-')
-                    else:
-                        start_month = '-'
-                        start_year = '-'
-
-                    if isinstance(end_date, dict):
-                        end_month = end_date.get('month', '-')
-                        end_year = end_date.get('year', '-')
-                    else:
-                        end_month = 'Present'  
-                        end_year = ''
-
-                    duration = f"{start_month}/{start_year} - {end_month}/{end_year}".strip()
-                    if duration == "-/- - Present/":
-                        duration = "Present"
-
-                    position_details = f"**Title:** {position.get('title', '-')}\n\n" \
-                                       f"**Company Name:** {position.get('companyName', '-')}\n\n" \
-                                       f"**Duration:** {duration}\n\n" \
-                                       f"**Description:**\n{position.get('description', '-')}"
-                    st.markdown(position_details)
-
-                elif key == "Education" and isinstance(value, dict):
-                    education = value
-                    start_end_date = education.get('startEndDate', {})
-                    start_date = start_end_date.get('start')
-                    end_date = start_end_date.get('end')
-
-                    if isinstance(start_date, dict):
-                        start_year = start_date.get('year', '-')
-                    else:
-                        start_year = '-'
-
-                    if isinstance(end_date, dict):
-                        end_year = end_date.get('year', '-')
-                    else:
-                        end_year = '-'
-
-                    duration = f"{start_year} - {end_year}".strip()
-                    education_details = f"**School Name:** {education.get('schoolName', '-')}\n\n" \
-                                        f"**Degree Name:** {education.get('degreeName', '-')}\n\n" \
-                                        f"**Field of Study:** {education.get('fieldOfStudy', '-')}\n\n" \
-                                        f"**Duration:** {duration}"
-                    st.markdown(education_details)
+                if key == "Experience" and isinstance(value, list) and value != ['-']:
+                    # Display all experience entries
+                    for i, position in enumerate(value):
+                        st.markdown(f"### Experience {i+1}")
+                        start_end_date = position.get('startEndDate', {})
+                        start_date = start_end_date.get('start')
+                        end_date = start_end_date.get('end')
+
+                        if isinstance(start_date, dict):
+                            start_month = start_date.get('month', '-')
+                            start_year = start_date.get('year', '-')
+                        else:
+                            start_month = '-'
+                            start_year = '-'
+
+                        if isinstance(end_date, dict):
+                            end_month = end_date.get('month', '-')
+                            end_year = end_date.get('year', '-')
+                        else:
+                            end_month = 'Present'  
+                            end_year = ''
+
+                        duration = f"{start_month}/{start_year} - {end_month}/{end_year}".strip()
+                        if duration == "-/- - Present/":
+                            duration = "Present"
+
+                        position_details = f"**Title:** {position.get('title', '-')}\n\n" \
+                                           f"**Company Name:** {position.get('companyName', '-')}\n\n" \
+                                           f"**Duration:** {duration}\n\n" \
+                                           f"**Description:**\n{position.get('description', '-')}"
+                        st.markdown(position_details)
+                        st.markdown("---")  # Separator between experiences
+
+                elif key == "Education" and isinstance(value, list) and value != ['-']:
+                    # Display all education entries
+                    for i, education in enumerate(value):
+                        st.markdown(f"### Education {i+1}")
+                        start_end_date = education.get('startEndDate', {})
+                        start_date = start_end_date.get('start')
+                        end_date = start_end_date.get('end')
+
+                        if isinstance(start_date, dict):
+                            start_year = start_date.get('year', '-')
+                        else:
+                            start_year = '-'
+
+                        if isinstance(end_date, dict):
+                            end_year = end_date.get('year', '-')
+                        else:
+                            end_year = '-'
+
+                        duration = f"{start_year} - {end_year}".strip()
+                        education_details = f"**School Name:** {education.get('schoolName', '-')}\n\n" \
+                                            f"**Degree Name:** {education.get('degreeName', '-')}\n\n" \
+                                            f"**Field of Study:** {education.get('fieldOfStudy', '-')}\n\n" \
+                                            f"**Duration:** {duration}"
+                        st.markdown(education_details)
+                        st.markdown("---")  # Separator between education entries
 
                 elif key == "Skills" and isinstance(value, list):
                     st.markdown("\n".join([f"- {skill}" for skill in value]))
@@ -273,6 +282,8 @@ Enhanced Evaluation Feedback:
                     temperature=0.3
                 )
                 enhanced_feedback = chat_completion.choices[0].message.content.strip()
+                # Clean markdown formatting from GPT-OSS response
+                enhanced_feedback = enhanced_feedback.replace('**', '').replace('*', '')
                 return enhanced_feedback
             except Exception as e:
                 st.error(f"❌ Groq API Error: {str(e)}")
@@ -298,9 +309,12 @@ Enhanced Evaluation Feedback:
 
         for key in profile_sections:
             current_content = parsed_profile.get(key, '-')
-            if key == "Current Position/Experience" and isinstance(current_content, dict):
-                position = current_content
-                current_content_str = f"Title: {position.get('title', '-')}\nCompany Name: {position.get('companyName', '-')}\nDescription: {position.get('description', '-')}"
+            if key == "Experience" and isinstance(current_content, list) and current_content != ['-']:
+                # Handle multiple experience entries
+                experience_strs = []
+                for position in current_content:
+                    experience_strs.append(f"Title: {position.get('title', '-')}\nCompany Name: {position.get('companyName', '-')}\nDescription: {position.get('description', '-')}")
+                current_content_str = "\n\n".join(experience_strs)
                 recommendation, explanation = get_section_recommendation_and_explanation(key, current_content_str)
             elif isinstance(current_content, list) and current_content != ['-']:
                 current_content_str = ", ".join(current_content)
@@ -354,12 +368,14 @@ Enhanced Evaluation Feedback:
                 profile_context = ""
                 for key, value in parsed_profile.items():
                     if value != '-' and value:
-                        if key == "Current Position/Experience" and isinstance(value, dict):
-                            position = value
-                            position_details = f"Title: {position.get('title', '-')}\n" \
-                                               f"Company Name: {position.get('companyName', '-')}\n" \
-                                               f"Description: {position.get('description', '-')}"
-                            profile_context += f"\n{key}:\n{position_details}"
+                        if key == "Experience" and isinstance(value, list) and value != ['-']:
+                            experience_details = []
+                            for position in value:
+                                position_detail = f"Title: {position.get('title', '-')}\n" \
+                                                 f"Company Name: {position.get('companyName', '-')}\n" \
+                                                 f"Description: {position.get('description', '-')}"
+                                experience_details.append(position_detail)
+                            profile_context += f"\n{key}:\n" + "\n\n".join(experience_details)
                         elif isinstance(value, list):
                             profile_context += f"\n{key}:\n{', '.join(value)}"
                         elif isinstance(value, int):
@@ -388,6 +404,8 @@ User's current profile data:
                 )
 
                 agent_response = chat_completion.choices[0].message.content.strip()
+                # Clean markdown formatting from GPT-OSS response
+                agent_response = agent_response.replace('**', '').replace('*', '')
                 st.session_state['conversation_history'].append({'role': 'assistant', 'content': agent_response})
 
                 display_conversation()

evaluator_agent.py

@@ -40,7 +40,10 @@ def evaluate_linkedin_profile(profile_data):
             max_tokens=30000,
             temperature=0.5
         )
-        return completion.choices[0].message.content
+        # Clean markdown formatting from GPT-OSS response
+        content = completion.choices[0].message.content
+        content = content.replace('**', '').replace('*', '')  # Remove markdown formatting
+        return content
     except Exception as e:
         st.error(f"❌ Groq API Error: {str(e)}")
         if "organization_restricted" in str(e):

linkedin_scraper.py

@@ -15,8 +15,18 @@ class LinkedInScraper:
     """
     
     def __init__(self):
-        self.api_url = "https://api-f1db6c.stack.tryrelevance.com/latest/studios/11116e42-9be9-4837-8753-c46a80458318/trigger_webhook"
-        self.project_id = "f56ec267-8285-4bef-b8ab-4dce36204e5d"
+        # Primary API (original)
+        self.primary_api = {
+            "url": "https://api-f1db6c.stack.tryrelevance.com/latest/studios/11116e42-9be9-4837-8753-c46a80458318/trigger_webhook",
+            "project_id": "f56ec267-8285-4bef-b8ab-4dce36204e5d"
+        }
+        
+        # Fallback API (new account)
+        self.fallback_api = {
+            "url": "https://api-f1db6c.stack.tryrelevance.com/latest/studios/a1a00cf9-4102-4d76-99e5-8ce9b922b51c/trigger_webhook",
+            "project_id": "e5f9ef92-aa24-4626-a145-3fb746186504"
+        }
+        
         self.headers = {
             "Content-Type": "application/json"
         }
@@ -34,39 +44,22 @@ class LinkedInScraper:
         except:
             return False
     
-    def scrape_profile(self, linkedin_url: str) -> Dict[str, Any]:
+    def _try_api(self, api_config: Dict[str, str], linkedin_url: str, api_name: str) -> Dict[str, Any]:
         """
-        Scrape a LinkedIn profile using the API
-        
-        Args:
-            linkedin_url (str): LinkedIn profile URL
-            
-        Returns:
-            Dict containing profile data or error information
+        Try scraping with a specific API configuration
         """
-        
-        # Validate URL
-        if not self.is_valid_linkedin_url(linkedin_url):
-            return {
-                "success": False,
-                "error": "Invalid LinkedIn URL format",
-                "url": linkedin_url
-            }
-        
         try:
-            # Prepare request
             payload = {"url": linkedin_url}
-            full_url = f"{self.api_url}?project={self.project_id}"
+            full_url = f"{api_config['url']}?project={api_config['project_id']}"
             
-            print(f"[SCRAPING] LinkedIn profile: {linkedin_url}")
+            print(f"[{api_name}] Trying to scrape: {linkedin_url}")
             start_time = time.time()
             
-            # Make API request
             response = requests.post(
                 full_url,
                 headers=self.headers,
                 data=json.dumps(payload),
-                timeout=60  # 60 second timeout
+                timeout=60
             )
             
             end_time = time.time()
@@ -75,11 +68,15 @@ class LinkedInScraper:
             if response.status_code == 200:
                 data = response.json()
                 
-                # Check if data was successfully scraped
+                # Handle different response formats from different APIs
+                profile_data = None
                 if 'linkedin_full_data' in data:
                     profile_data = data['linkedin_full_data']
-                    
-                    print(f"[SUCCESS] Scraped profile in {duration}s")
+                elif 'data' in data:
+                    profile_data = data['data']
+                
+                if profile_data:
+                    print(f"[{api_name}] SUCCESS in {duration}s")
                     print(f"   Name: {profile_data.get('full_name', 'N/A')}")
                     print(f"   Headline: {profile_data.get('headline', 'N/A')}")
                     print(f"   Location: {profile_data.get('location', 'N/A')}")
@@ -88,19 +85,20 @@ class LinkedInScraper:
                         "success": True,
                         "data": profile_data,
                         "scrape_time": duration,
-                        "url": linkedin_url
+                        "url": linkedin_url,
+                        "api_used": api_name
                     }
                 else:
                     return {
                         "success": False,
-                        "error": "No profile data returned from API",
+                        "error": f"{api_name}: No profile data returned",
                         "raw_response": data,
                         "url": linkedin_url
                     }
             else:
                 return {
                     "success": False,
-                    "error": f"API request failed with status {response.status_code}",
+                    "error": f"{api_name}: API returned status {response.status_code}",
                     "response_text": response.text,
                     "url": linkedin_url
                 }
@@ -108,27 +106,60 @@ class LinkedInScraper:
         except requests.exceptions.Timeout:
             return {
                 "success": False,
-                "error": "Request timed out after 60 seconds",
-                "url": linkedin_url
-            }
-        except requests.exceptions.RequestException as e:
-            return {
-                "success": False,
-                "error": f"Request failed: {str(e)}",
+                "error": f"{api_name}: Request timed out after 60 seconds",
                 "url": linkedin_url
             }
-        except json.JSONDecodeError as e:
+        except Exception as e:
             return {
                 "success": False,
-                "error": f"Failed to parse API response: {str(e)}",
+                "error": f"{api_name}: {str(e)}",
                 "url": linkedin_url
             }
-        except Exception as e:
+
+    def scrape_profile(self, linkedin_url: str) -> Dict[str, Any]:
+        """
+        Scrape a LinkedIn profile using primary API with fallback
+        
+        Args:
+            linkedin_url (str): LinkedIn profile URL
+            
+        Returns:
+            Dict containing profile data or error information
+        """
+        
+        # Validate URL
+        if not self.is_valid_linkedin_url(linkedin_url):
             return {
                 "success": False,
-                "error": f"Unexpected error: {str(e)}",
+                "error": "Invalid LinkedIn URL format",
                 "url": linkedin_url
             }
+        
+        print(f"[SCRAPING] LinkedIn profile: {linkedin_url}")
+        
+        # Try primary API first
+        result = self._try_api(self.primary_api, linkedin_url, "PRIMARY")
+        
+        if result["success"]:
+            return result
+        
+        print(f"[FALLBACK] Primary API failed: {result['error']}")
+        print(f"[FALLBACK] Trying secondary API...")
+        
+        # Try fallback API
+        result = self._try_api(self.fallback_api, linkedin_url, "FALLBACK")
+        
+        if result["success"]:
+            return result
+        
+        # Both APIs failed
+        print(f"[FAILED] Both APIs failed!")
+        return {
+            "success": False,
+            "error": "Both primary and fallback APIs failed",
+            "primary_error": result.get('error', 'Unknown error'),
+            "url": linkedin_url
+        }
     
     def extract_key_info(self, profile_data: Dict[str, Any]) -> Dict[str, Any]:
         """

new_resume.py

@@ -13,22 +13,52 @@ def generate_latex_resume(personal_info, education_list, experience_list, skills
     """Generate clean LaTeX code for resume"""
     
     def clean_text(text):
-        """Clean text for LaTeX - simple and effective"""
+        """Clean text for LaTeX - PRODUCTION READY VERSION"""
         if not text:
             return ""
-        # Handle common problematic characters
-        text = str(text)
-        text = text.replace('&', ' and ')
-        text = text.replace('%', '\\%')
+        
+        text = str(text).strip()
+        
+        # Handle special LaTeX characters in EXACT correct order
+        text = text.replace('\\', '\\textbackslash{}')  # MUST be first!
+        text = text.replace('{', '\\{')
+        text = text.replace('}', '\\}')
         text = text.replace('$', '\\$')
+        text = text.replace('&', '\\&')
+        text = text.replace('%', '\\%')
         text = text.replace('#', '\\#')
+        text = text.replace('^', '\\textasciicircum{}')
         text = text.replace('_', '\\_')
-        text = text.replace('{', '\\{')
-        text = text.replace('}', '\\}')
-        # Remove problematic Unicode
-        text = text.replace('\u202f', ' ')
-        text = text.replace('\u2013', '-')
-        text = text.replace('\u2014', '-')
+        text = text.replace('~', '\\textasciitilde{}')
+        
+        # Handle quotes properly for LaTeX
+        text = text.replace('"', "''")
+        text = text.replace('`', "'")  # Prevent backtick issues
+        
+        # Fix common Unicode characters that break LaTeX
+        unicode_fixes = {
+            '\u202f': ' ',      # Narrow no-break space
+            '\u2013': '--',     # En dash
+            '\u2014': '---',    # Em dash
+            '\u2019': "'",      # Right single quotation mark
+            '\u201c': '``',     # Left double quotation mark
+            '\u201d': "''",     # Right double quotation mark
+            '\u2026': '...',    # Horizontal ellipsis
+            '\u00a0': ' ',      # Non-breaking space
+            '\u2010': '-',      # Hyphen
+            '\u2011': '-',      # Non-breaking hyphen
+            '\u2012': '-',      # Figure dash
+        }
+        
+        for unicode_char, replacement in unicode_fixes.items():
+            text = text.replace(unicode_char, replacement)
+        
+        # Convert to ASCII to remove any remaining problematic characters
+        text = text.encode('ascii', 'ignore').decode('ascii')
+        
+        # Final cleanup - remove multiple spaces and trim
+        text = ' '.join(text.split())
+        
         return text
     
     # Get clean data
@@ -328,88 +358,98 @@ def parse_uploaded_resume(uploaded_file):
         return None, f"Error parsing file: {str(e)}"
 
 def structure_resume_content(raw_content):
-    """Use AI to structure raw resume content into organized sections"""
+    """Use AI to structure raw resume content into organized sections - IMPROVED VERSION"""
     try:
         client = Groq(api_key=Config.GROQ_API_KEY)
         
-        prompt = f"""
-You are an AI assistant that extracts and structures resume information from raw text.
-Parse the following resume content and extract information into a structured format.
+        prompt = f"""Extract information from this resume and return ONLY a JSON object:
 
-Raw Resume Content:
 {raw_content}
 
-Please extract and return the information in this exact JSON format:
+Return exactly this structure with real data from the resume:
 {{
-    "personal_info": {{
-        "full_name": "extracted name",
-        "email": "extracted email",
-        "phone": "extracted phone",
-        "address": "extracted address",
-        "summary": "extracted professional summary or objective"
-    }},
-    "experience": [
-        {{
-            "job_title": "position title",
-            "company": "company name",
-            "location": "work location",
-            "start_date": "start date",
-            "end_date": "end date or Present",
-            "responsibilities": ["responsibility 1", "responsibility 2", "responsibility 3"]
-        }}
-    ],
-    "education": [
-        {{
-            "degree": "degree name",
-            "university": "university name",
-            "location": "university location",
-            "graduation_date": "graduation date",
-            "gpa": "GPA if mentioned"
-        }}
-    ],
-    "skills": ["skill1", "skill2", "skill3"],
-    "certifications": ["cert1", "cert2"],
-    "projects": [
-        {{
-            "project_name": "project name",
-            "description": "project description"
-        }}
-    ],
-    "languages": ["language1", "language2"],
-    "hobbies": ["hobby1", "hobby2"]
+  "personal_info": {{
+    "full_name": "",
+    "email": "",
+    "phone": "",
+    "address": "",
+    "summary": ""
+  }},
+  "experience": [
+    {{
+      "job_title": "",
+      "company": "",
+      "start_date": "",
+      "end_date": "",
+      "responsibilities": []
+    }}
+  ],
+  "education": [
+    {{
+      "degree": "",
+      "institution": "",
+      "graduation_year": "",
+      "field": ""
+    }}
+  ],
+  "skills": [],
+  "projects": [],
+  "certifications": []
 }}
 
-Important:
-- If any section is not found, use empty arrays [] or empty strings ""
-- Extract actual content, don't make up information
-- For responsibilities, extract bullet points or key achievements
-- Keep the exact JSON format
-"""
+Rules:
+- Return ONLY valid JSON, no markdown or explanations
+- Use empty string "" for missing text fields
+- Use empty array [] for missing list fields
+- Extract real data only, don't invent anything"""
 
         response = client.chat.completions.create(
-            messages=[{"role": "user", "content": prompt}],
+            messages=[
+                {"role": "system", "content": "Extract resume data and return only valid JSON. No explanations, no markdown formatting."},
+                {"role": "user", "content": prompt}
+            ],
             model="openai/gpt-oss-120b",
-            temperature=0.1
+            temperature=0.0,
+            max_tokens=1500
         )
         
-        # Parse the JSON response
-        import json
-        response_content = response.choices[0].message.content.strip()
+        # Clean response
+        content = response.choices[0].message.content.strip()
+        content = content.replace('```json', '').replace('```', '').strip()
         
-        # Try to extract JSON from the response (in case there's extra text)
-        json_start = response_content.find('{')
-        json_end = response_content.rfind('}') + 1
+        # Remove markdown formatting that GPT-OSS sometimes adds
+        content = content.replace('**', '')  # Remove bold formatting
+        content = content.replace('*', '')   # Remove italic formatting
         
-        if json_start != -1 and json_end != -1:
-            json_content = response_content[json_start:json_end]
-            structured_data = json.loads(json_content)
-            return structured_data
-        else:
-            raise ValueError("No valid JSON found in response")
+        # Parse JSON
+        import json
+        data = json.loads(content)
+        return data
         
+    except json.JSONDecodeError as e:
+        st.error(f"JSON parsing error: {str(e)}")
+        st.error("AI returned invalid JSON format")
+        return create_empty_resume_structure()
     except Exception as e:
-        st.error(f"Error structuring content: {str(e)}")
-        return None
+        st.error(f"Extraction error: {str(e)}")
+        return create_empty_resume_structure()
+
+def create_empty_resume_structure():
+    """Create empty resume structure for fallback"""
+    return {
+        "personal_info": {
+            "full_name": "",
+            "email": "",
+            "phone": "",
+            "address": "",
+            "summary": ""
+        },
+        "experience": [],
+        "education": [],
+        "skills": [],
+        "projects": [],
+        "certifications": []
+    }
 
 def enhance_resume_with_ai(structured_data, target_role):
     """Use AI to enhance the structured resume data for the target role"""
@@ -451,6 +491,9 @@ Enhancement guidelines:
         
         response_content = response.choices[0].message.content.strip()
         
+        # Clean markdown formatting from response
+        response_content = response_content.replace('**', '').replace('*', '')
+        
         # Extract enhanced data and summary
         if "ENHANCED_DATA:" in response_content and "ENHANCEMENT_SUMMARY:" in response_content:
             data_part = response_content.split("ENHANCED_DATA:")[1].split("ENHANCEMENT_SUMMARY:")[0].strip()
@@ -556,6 +599,12 @@ def display_editable_resume_data(structured_data):
             st.markdown(f"**Project #{i+1}**")
             proj_data = existing_projects[i] if i < len(existing_projects) else {}
             
+            # Handle case where project data might be a string instead of dict
+            if isinstance(proj_data, str):
+                proj_data = {'project_name': proj_data, 'description': ''}
+            elif not isinstance(proj_data, dict):
+                proj_data = {'project_name': '', 'description': ''}
+            
             project = {
                 'project_name': st.text_input(f"Project Name #{i+1}", value=proj_data.get('project_name', ''), key=f"edit_proj_name_{i}"),
                 'description': st.text_area(f"Project Description #{i+1}", value=proj_data.get('description', ''), key=f"edit_proj_desc_{i}")