agent_modern.py

#!/usr/bin/env python3
"""
Modern LinkedIn Profile Analyzer Agent
Uses advanced AI and modern scraping techniques to analyze LinkedIn profiles.
No external API dependencies - fully self-contained.
"""

import os
import json
from typing import Dict, Any
from langchain import hub
from langchain.agents import create_react_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate
from dotenv import load_dotenv

# Import our modern scraping tools
from scraper_modern import scraper_tool
from linkedin_url import linkedin_url

# Load environment variables
load_dotenv()

# Set LangSmith API key for tracing (optional)
if os.environ.get("LANGSMITH_API_KEY"):
    os.environ["LANGCHAIN_TRACING_V2"] = "true"
    os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"

class ModernLinkedInAgent:
    """
    Modern LinkedIn Profile Analyzer using AI and advanced scraping
    """
    
    def __init__(self, model: str = "gpt-4", temperature: float = 0.1):
        """Initialize the agent with specified model and temperature"""
        self.llm = ChatOpenAI(temperature=temperature, model_name=model)
        self.tools = [linkedin_url, scraper_tool]
        
        # Create the ReAct agent
        react_prompt = hub.pull("hwchase17/react")
        self.agent = create_react_agent(
            llm=self.llm, 
            tools=self.tools, 
            prompt=react_prompt
        )
        self.agent_executor = AgentExecutor(
            agent=self.agent, 
            tools=self.tools, 
            verbose=True,
            max_iterations=5,
            handle_parsing_errors=True
        )
    
    def analyze_profile(self, name: str) -> Dict[str, Any]:
        """
        Analyze a LinkedIn profile and generate insights
        
        Args:
            name: Full name of the person to analyze
            
        Returns:
            Dictionary with analysis results
        """
        
        # Enhanced prompt for better results
        prompt = f"""
You are an expert LinkedIn profile analyzer. Your task is to find and analyze the LinkedIn profile for "{name}".

Follow these steps:
1. First, use the linkedin_url tool to find the LinkedIn profile URL for "{name}"
2. Then, use the Modern LinkedIn Scraper tool to extract profile data from the URL
3. Analyze the extracted data and generate insights

Your final output must be a valid JSON object with these exact keys:
- "summary": A professional 2-3 sentence summary highlighting key career aspects
- "interesting_facts": An array of exactly 2 interesting facts about the person
- "profile_pic_url": The profile picture URL (if available)
- "full_name": The person's full name as found on LinkedIn
- "headline": Their current professional headline

Important guidelines:
- Base your analysis only on the actual scraped data
- If scraping fails, acknowledge this in your response
- Keep facts professional and relevant
- Ensure the JSON is properly formatted
- Do not make up information not found in the profile

Begin your analysis now.
"""
        
        try:
            # Execute the agent
            result = self.agent_executor.invoke({"input": prompt})
            output = result.get("output", "")
            
            # Try to parse the output as JSON
            return self._parse_agent_output(output, name)
            
        except Exception as e:
            return self._create_error_response(str(e), name)
    
    def _parse_agent_output(self, output: str, name: str) -> Dict[str, Any]:
        """Parse and validate agent output"""
        
        if not output or not output.strip():
            return self._create_error_response("Agent returned empty response", name)
        
        # Try to extract JSON from the output
        json_start = output.find('{')
        json_end = output.rfind('}') + 1
        
        if json_start >= 0 and json_end > json_start:
            json_str = output[json_start:json_end]
            try:
                parsed_data = json.loads(json_str)
                return self._validate_and_clean_response(parsed_data, name)
            except json.JSONDecodeError:
                pass
        
        # If no valid JSON found, create structured response from text
        return self._create_structured_response_from_text(output, name)
    
    def _validate_and_clean_response(self, data: Dict, name: str) -> Dict[str, Any]:
        """Validate and clean the parsed response"""
        
        # Ensure required fields exist
        cleaned = {
            "full_name": data.get("full_name", name),
            "headline": data.get("headline", "LinkedIn Professional"),
            "summary": data.get("summary", "Profile analysis completed"),
            "interesting_facts": data.get("interesting_facts", ["Analysis completed successfully"]),
            "profile_pic_url": data.get("profile_pic_url", "")
        }
        
        # Ensure interesting_facts is a list
        if not isinstance(cleaned["interesting_facts"], list):
            cleaned["interesting_facts"] = [str(cleaned["interesting_facts"])]
        
        # Limit to 2 facts
        if len(cleaned["interesting_facts"]) > 2:
            cleaned["interesting_facts"] = cleaned["interesting_facts"][:2]
        elif len(cleaned["interesting_facts"]) < 2:
            cleaned["interesting_facts"].append("Professional with LinkedIn presence")
        
        return cleaned
    
    def _create_structured_response_from_text(self, text: str, name: str) -> Dict[str, Any]:
        """Create structured response from unstructured text"""
        
        return {
            "full_name": name,
            "headline": "LinkedIn Professional",
            "summary": text[:200] + "..." if len(text) > 200 else text,
            "interesting_facts": [
                "Profile information extracted successfully",
                "Analysis completed using modern scraping techniques"
            ],
            "profile_pic_url": ""
        }
    
    def _create_error_response(self, error_msg: str, name: str) -> Dict[str, Any]:
        """Create error response in expected format"""
        
        return {
            "full_name": name,
            "headline": "Profile Analysis Error",
            "summary": f"Unable to analyze profile: {error_msg}",
            "interesting_facts": [
                "Profile may be private or require authentication",
                "Try again later or check the profile URL manually"
            ],
            "profile_pic_url": "",
            "error": error_msg
        }

# Global agent instance
_agent = ModernLinkedInAgent()

def generate_profile_summary_and_facts_single_step(name: str) -> str:
    """
    Generate LinkedIn profile analysis for a given name
    
    Args:
        name: Full name of the person to analyze
        
    Returns:
        JSON string with analysis results
    """
    result = _agent.analyze_profile(name)
    return json.dumps(result, indent=2)

def analyze_linkedin_profile(name: str, model: str = "gpt-4") -> Dict[str, Any]:
    """
    Analyze LinkedIn profile and return structured data
    
    Args:
        name: Full name of the person to analyze
        model: AI model to use for analysis
        
    Returns:
        Dictionary with analysis results
    """
    agent = ModernLinkedInAgent(model=model)
    return agent.analyze_profile(name)

# Example usage and testing
if __name__ == "__main__":
    print("🤖 Modern LinkedIn Profile Analyzer")
    print("=" * 40)
    
    # Interactive mode
    while True:
        name = input("\nEnter full name (or 'quit' to exit): ").strip()
        
        if name.lower() in ['quit', 'exit', 'q']:
            print("👋 Goodbye!")
            break
            
        if not name:
            print("❌ Please enter a valid name")
            continue
        
        print(f"\n🔍 Analyzing profile for: {name}")
        print("⏳ This may take a moment...")
        
        try:
            result = generate_profile_summary_and_facts_single_step(name)
            print("\n📊 Analysis Results:")
            print(result)
        except Exception as e:
            print(f"\n❌ Error: {e}")
        
        print("\n" + "="*50)