Update app.py

app.py

@@ -1,530 +1,131 @@
 import json
 import logging
-import os
 from datetime import datetime
-from typing import Dict, List, Optional, Any, Tuple
-from dataclasses import dataclass, field
-
-import openai
+from typing import Dict, List, Optional, Any
 import gradio as gr
+import openai
 
-# Set up logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(),
-        logging.FileHandler('loss_dog.log')
-    ]
-)
+# Configure logging
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# System Prompts
-CONVERSATION_PROMPT = '''
-<?xml version="1.0" encoding="UTF-8"?>
-<system_prompt>
-    <assistant_identity>
-        <name>LOSS DOG</name>
-        <role>Digital Profile Assistant</role>
-        <purpose>To help users build comprehensive professional and digital presence profiles through natural, comfortable conversation</purpose>
-    </assistant_identity>
-
-    <core_personality>
-        <traits>
-            <trait>Friendly and approachable</trait>
-            <trait>Attentive listener</trait>
-            <trait>Professionally insightful</trait>
-            <trait>Respectful of boundaries</trait>
-            <trait>Naturally curious</trait>
-        </traits>
-        <voice_characteristics>
-            <characteristic>Warm and encouraging</characteristic>
-            <characteristic>Clear and professional</characteristic>
-            <characteristic>Adaptable to user's style</characteristic>
-        </voice_characteristics>
-    </core_personality>
-
-    <information_categories>
-        <category name="professional_background">
-            <fields>
-                <field>Current role and responsibilities</field>
-                <field>Career history and progression</field>
-                <field>Notable achievements</field>
-                <field>Professional goals</field>
-            </fields>
-            <approach>
-                <step>Begin with current role</step>
-                <step>Explore career journey naturally</step>
-                <step>Discuss achievements organically</step>
-                <step>Note specific metrics when shared</step>
-            </approach>
-        </category>
-
-        <category name="education_training">
-            <fields>
-                <field>Formal education</field>
-                <field>Certifications</field>
-                <field>Specialized training</field>
-                <field>Continuous learning</field>
-            </fields>
-            <data_points>
-                <point>Institution names</point>
-                <point>Degree details</point>
-                <point>Time periods</point>
-                <point>Special achievements</point>
-            </data_points>
-        </category>
-
-        <category name="skills_expertise">
-            <fields>
-                <field>Technical skills</field>
-                <field>Soft skills</field>
-                <field>Tools and technologies</field>
-                <field>Domain expertise</field>
-            </fields>
-            <metrics>
-                <metric>Proficiency levels</metric>
-                <metric>Years of experience</metric>
-                <metric>Project applications</metric>
-            </metrics>
-        </category>
-
-        <category name="digital_presence">
-            <fields>
-                <field>Social media impact</field>
-                <field>Content creation</field>
-                <field>Community engagement</field>
-                <field>Digital assets</field>
-            </fields>
-            <metrics>
-                <metric>Follower counts</metric>
-                <metric>Engagement rates</metric>
-                <metric>Content reach</metric>
-                <metric>Portfolio value</metric>
-            </metrics>
-        </category>
-
-        <category name="projects_contributions">
-            <fields>
-                <field>Major projects</field>
-                <field>Open source contributions</field>
-                <field>Creative works</field>
-                <field>Impact metrics</field>
-            </fields>
-            <data_collection>
-                <point>Project descriptions</point>
-                <point>Role and responsibilities</point>
-                <point>Technologies used</point>
-                <point>Measurable outcomes</point>
-            </data_collection>
-        </category>
-    </information_categories>
-
-    <conversation_strategies>
-        <engagement_patterns>
-            <pattern type="initial_contact">
-                <approach>Open with friendly, professional greeting</approach>
-                <focus>Establish comfortable rapport</focus>
-                <goal>Begin natural information gathering</goal>
-            </pattern>
-            
-            <pattern type="information_gathering">
-                <approach>Use natural conversation flow</approach>
-                <focus>Follow user's narrative</focus>
-                <goal>Collect relevant details organically</goal>
-            </pattern>
-
-            <pattern type="follow_up">
-                <approach>Ask relevant, contextual questions</approach>
-                <focus>Deepen understanding of shared information</focus>
-                <goal>Gather additional context and details</goal>
-            </pattern>
-        </engagement_patterns>
-
-        <response_handling>
-            <scenario type="shared_information">
-                <action>Acknowledge and validate</action>
-                <action>Note key points</action>
-                <action>Ask natural follow-up if appropriate</action>
-            </scenario>
-
-            <scenario type="hesitation">
-                <action>Respect boundaries</action>
-                <action>Shift to comfortable topics</action>
-                <action>Leave door open for later sharing</action>
-            </scenario>
-
-            <scenario type="completion">
-                <action>Summarize collected information</action>
-                <action>Verify accuracy</action>
-                <action>Transition smoothly to next topic</action>
-            </scenario>
-        </response_handling>
-    </conversation_strategies>
-
-    <output_guidelines>
-        <quality_standards>
-            <standard>Professional language</standard>
-            <standard>Accurate representation</standard>
-            <standard>Structured organization</standard>
-            <standard>Clear categorization</standard>
-        </quality_standards>
-    </output_guidelines>
-
-    <ethics_guidelines>
-        <principle>Respect user privacy</principle>
-        <principle>Never pressure for information</principle>
-        <principle>Maintain professional boundaries</principle>
-        <principle>Ensure data accuracy</principle>
-    </ethics_guidelines>
-</system_prompt>
-'''
-
-EXTRACTION_PROMPT = '''
-<?xml version="1.0" encoding="UTF-8"?>
-<system_prompt>
-    <assistant_identity>
-        <name>LOSS DOG - Information Processor</name>
-        <role>Conversation Analyzer and Information Extractor</role>
-        <purpose>Process conversation history to extract and structure professional profile information</purpose>
-    </assistant_identity>
-
-    <task_description>
-        Your task is to analyze the provided conversation history and extract structured profile information:
-        1. Process natural conversation into structured data
-        2. Identify and categorize relevant information
-        3. Make intelligent inferences when appropriate
-        4. Maintain high accuracy and data quality
-        5. Handle messy or non-linear conversation flows
-    </task_description>
-
-    <extraction_guidelines>
-        <primary_objective>
-            Convert conversation data into clean, structured JSON that matches these categories:
-            - personal_info (name, contact, location)
-            - education (degree, institution, field, dates)
-            - work_experience (title, company, duration, responsibilities)
-            - skills (technical, soft_skills, tools)
-            - achievements (awards, publications, projects)
-            - digital_presence (social_media, content_creation, community_impact)
-        </primary_objective>
-
-        <processing_rules>
-            <rule>Focus on factual information over casual conversation</rule>
-            <rule>Handle partial or incomplete information gracefully</rule>
-            <rule>Use context to resolve ambiguities</rule>
-            <rule>Track confidence levels for all extracted data</rule>
-            <rule>Mark any inferred information clearly</rule>
-            <rule>Maintain source context for future reference</rule>
-        </processing_rules>
-
-        <data_handling>
-            <instruction>For each piece of extracted information, provide:
-                - Category classification
-                - Confidence score (0.0-1.0)
-                - Source context (relevant conversation snippet)
-                - List of any inferred fields
-                - Structured data in appropriate format
-            </instruction>
-        </data_handling>
-    </extraction_guidelines>
-
-    <output_format>
-        <format_rules>
-            <rule>Return JSON object with categorized sections</rule>
-            <rule>Include confidence scores (0.0-1.0) for each section</rule>
-            <rule>Mark inferred information with "inferred": true</rule>
-            <rule>Include source context for traceability</rule>
-            <rule>Use consistent date formats (YYYY-MM-DD where possible)</rule>
-        </format_rules>
-
-        <structure>
-            {
-                "category_name": {
-                    "data": {
-                        // Structured data specific to category
-                    },
-                    "confidence": float,
-                    "source_context": string,
-                    "inferred_fields": [string],
-                    "metadata": {
-                        // Additional category-specific metadata
-                    }
-                }
-            }
-        </structure>
-    </output_format>
-
-    <quality_controls>
-        <validations>
-            <validation>Check date consistency and sequences</validation>
-            <validation>Verify logical relationships between entries</validation>
-            <validation>Ensure required fields are present or marked missing</validation>
-            <validation>Confirm confidence scores are justified</validation>
-        </validations>
-
-        <error_handling>
-            <case>Handle conflicting information by preferring most recent/confident</case>
-            <case>Mark ambiguous information with multiple possible interpretations</case>
-            <case>Skip unverifiable information rather than making weak inferences</case>
-        </error_handling>
-    </quality_controls>
-</system_prompt>
-'''
-
-@dataclass
-class ProfileSection:
-    """Represents a section of the professional profile with structured data."""
-    category: str
-    data: Dict[str, Any]
-    confidence: float
-    source_context: str
-    inferred_fields: List[str] = field(default_factory=list)
-    last_updated: datetime = field(default_factory=datetime.now)
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-@dataclass
-class ConversationState:
-    """Tracks the state of the information gathering conversation."""
-    collected_sections: Dict[str, ProfileSection] = field(default_factory=dict)
-    missing_information: List[str] = field(default_factory=list)
-    conversation_history: List[Dict[str, str]] = field(default_factory=list)
-    completion_status: Dict[str, float] = field(default_factory=dict)
-    current_focus: Optional[str] = None
-    extraction_history: List[Dict[str, Any]] = field(default_factory=list)
+# System prompts
+CONVERSATION_PROMPT = """You are LOSS DOG, a professional profile builder. Your goal is to have natural conversations
+with users to gather information about their professional background across 9 categories:
+
+1. Work History & Experience
+2. Salary & Compensation
+3. Skills & Certifications
+4. Education & Learning
+5. Personal Branding & Online Presence
+6. Achievements & Awards
+7. Social Proof & Networking
+8. Project Contributions & Leadership
+9. Work Performance & Impact Metrics
+
+Be friendly and conversational. Ask follow-up questions naturally. When appropriate, guide users to share more details
+but respect their boundaries. Once you believe you have gathered sufficient information (or if the user indicates they
+have nothing more to share), let them know they can click 'Generate Profile' to proceed.
+"""
+
+EXTRACTION_PROMPT = """You are LOSS DOG's data processing system. Analyze the provided conversation and extract
+structured information into the following categories:
+
+1. Work History & Experience: Job titles, companies, industries, locations, adaptability, promotions
+2. Salary & Compensation: Base salary, bonuses, equity, benefits (if shared)
+3. Skills & Certifications: Technical skills, languages, certifications, licenses
+4. Education & Learning: Degrees, institutions, courses, research
+5. Personal Branding: Online presence, portfolio, blockchain projects, social media
+6. Achievements & Awards: Industry recognition, hackathons, creative projects
+7. Social Proof: Mentors, references, memberships, conferences
+8. Project Contributions: Major projects, open-source, patents, impact
+9. Performance Metrics: KPIs, revenue impact, growth metrics
+
+Format the output as clean, structured JSON. Include confidence scores for each extracted piece of information.
+Mark any inferred information clearly."""
 
 class ProfileBuilder:
-    """
-    Core class for building professional profiles through conversation and extraction.
-    Implements two-phase approach:
-    1. Interactive conversation for information gathering
-    2. Structured information extraction and processing
-    """
-    
     def __init__(self):
-        """Initialize the ProfileBuilder with default settings."""
-        self.state = ConversationState()
-        self.required_sections = {
-            "personal_info": ["name", "contact", "location"],
-            "education": ["degree", "institution", "field", "dates"],
-            "work_experience": ["title", "company", "duration", "responsibilities"],
-            "skills": ["technical", "soft_skills", "tools"],
-            "achievements": ["awards", "publications", "projects"],
-            "digital_presence": ["platforms", "metrics", "content"]
-        }
-        self._api_key: Optional[str] = None
-        self._setup_logging()
+        self.conversation_history = []
+        self.api_key = None
+    
+    async def process_message(self, message: str, api_key: str) -> Dict[str, Any]:
+        """Process a user message through conversation phase."""
+        try:
+            if not self.api_key:
+                self.api_key = api_key
+                openai.api_key = api_key
 
-    def _setup_logging(self) -> None:
-        """Configure logging for the profile builder."""
-        self.logger = logging.getLogger(__name__)
-        handler = logging.FileHandler('profile_builder.log')
-        handler.setFormatter(logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        ))
-        self.logger.addHandler(handler)
-        self.logger.setLevel(logging.INFO)
+            # Add message to history
+            self.conversation_history.append({"role": "user", "content": message})
+            
+            # Get AI response
+            response = await openai.ChatCompletion.acreate(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": CONVERSATION_PROMPT},
+                    *self.conversation_history
+                ],
+                temperature=0.7
+            )
+            
+            ai_message = response.choices[0].message.content
+            self.conversation_history.append({"role": "assistant", "content": ai_message})
+            
+            return {"response": ai_message}
 
-    def _initialize_client(self, api_key: str) -> None:
-        """Initialize OpenAI client with API key."""
-        try:
-            if not api_key.startswith("sk-"):
-                raise ValueError("Invalid API key format")
-            self._api_key = api_key
-            openai.api_key = api_key
-            self.logger.info("OpenAI client initialized successfully")
         except Exception as e:
-            self.logger.error(f"Failed to initialize OpenAI client: {str(e)}")
-            raise
+            logger.error(f"Error processing message: {str(e)}")
+            return {"error": str(e)}
 
-    async def _extract_information(self) -> Dict[str, ProfileSection]:
-        """Extract structured information from the conversation history."""
+    async def generate_profile(self) -> Dict[str, Any]:
+        """Process conversation history into structured profile."""
         try:
-            # Prepare conversation context
+            # Convert conversation history to text
             conversation_text = "\n".join(
                 f"{msg['role']}: {msg['content']}"
-                for msg in self.state.conversation_history
+                for msg in self.conversation_history
             )
 
-            messages = [
-                {"role": "system", "content": EXTRACTION_PROMPT},
-                {"role": "user", "content": f"Extract professional profile information from this conversation:\n\n{conversation_text}"}
-            ]
-
+            # Extract structured information
             response = await openai.ChatCompletion.acreate(
                 model="gpt-4o-mini",
-                messages=messages,
-                temperature=0.3,
-                max_tokens=2000
+                messages=[
+                    {"role": "system", "content": EXTRACTION_PROMPT},
+                    {"role": "user", "content": f"Extract profile information from this conversation:\n\n{conversation_text}"}
+                ],
+                temperature=0.3
             )
 
-            # Parse and validate the response
-            extracted_data = self._parse_extraction_response(response.choices[0].message.content)
-            
-            # Convert to ProfileSection objects
-            sections = {}
-            for category, data in extracted_data.items():
-                sections[category] = ProfileSection(
-                    category=category,
-                    data=data.get("data", {}),
-                    confidence=data.get("confidence", 0.0),
-                    source_context=data.get("source_context", ""),
-                    inferred_fields=data.get("inferred_fields", []),
-                    metadata=data.get("metadata", {})
-                )
-
-            # Log extraction results
-            self.logger.info(f"Successfully extracted information for {len(sections)} sections")
-            return sections
-
-        except Exception as e:
-            self.logger.error(f"Error in extraction phase: {str(e)}")
-            raise
-
-    def _parse_extraction_response(self, response_text: str) -> Dict[str, Any]:
-        """Parse and validate the extraction response."""
-        try:
-            extracted_data = json.loads(response_text)
-            self._validate_extracted_data(extracted_data)
-            return extracted_data
-        except json.JSONDecodeError as e:
-            self.logger.error(f"Failed to parse extraction response: {str(e)}")
-            return {}
-        except Exception as e:
-            self.logger.error(f"Error processing extraction response: {str(e)}")
-            return {}
-
-    def _validate_extracted_data(self, data: Dict[str, Any]) -> None:
-        """Validate the structure and content of extracted data."""
-        required_keys = ["data", "confidence", "source_context"]
-        for category, section in data.items():
-            missing_keys = [key for key in required_keys if key not in section]
-            if missing_keys:
-                self.logger.warning(f"Missing required keys {missing_keys} in category {category}")
-                raise ValueError(f"Invalid data structure for category {category}")
-
-    def _update_completion_status(self) -> None:
-        """Update the completion status based on collected information."""
-        status = {}
-        for section, required_fields in self.required_sections.items():
-            if section in self.state.collected_sections:
-                profile_section = self.state.collected_sections[section]
-                fields_present = sum(
-                    1 for field in required_fields 
-                    if field in profile_section.data
-                )
-                confidence_factor = profile_section.confidence
-                status[section] = (fields_present / len(required_fields)) * confidence_factor
-            else:
-                status[section] = 0.0
-        
-        self.state.completion_status = status
-        self.logger.info(f"Updated completion status: {status}")
-
-    def _get_missing_information(self) -> List[str]:
-        """Identify missing required information."""
-        missing = []
-        for section, required_fields in self.required_sections.items():
-            if section not in self.state.collected_sections:
-                missing.extend([f"{section}.{field}" for field in required_fields])
-            else:
-                profile_section = self.state.collected_sections[section]
-                missing.extend([
-                    f"{section}.{field}" 
-                    for field in required_fields 
-                    if field not in profile_section.data
-                ])
-        return missing
-
-    async def process_message(self, message: str, api_key: str) -> Dict[str, Any]:
-        """Process a user message through both conversation and extraction phases."""
-        if not self._api_key:
-            self._initialize_client(api_key)
-
-        try:
-            # Phase 1: Conversation
-            self.state.conversation_history.append({"role": "user", "content": message})
-            ai_response = await self._get_conversation_response(message)
-            self.state.conversation_history.append({"role": "assistant", "content": ai_response})
+            # Parse the structured response
+            profile_data = json.loads(response.choices[0].message.content)
 
-            # Phase 2: Information Extraction
-            extracted_sections = await self._extract_information()
-            
-            # Update state with new information
-            self.state.collected_sections.update(extracted_sections)
-            self._update_completion_status()
-            
-            # Track extraction history
-            self.state.extraction_history.append({
-                "timestamp": datetime.now().isoformat(),
-                "sections_extracted": list(extracted_sections.keys())
-            })
-
-            return {
-                "response": ai_response,
-                "extracted_sections": {
-                    category: {
-                        "data": section.data,
-                        "confidence": section.confidence,
-                        "inferred_fields": section.inferred_fields
-                    }
-                    for category, section in extracted_sections.items()
-                },
-                "completion_status": self.state.completion_status,
-                "missing_information": self._get_missing_information()
-            }
-
-        except Exception as e:
-            self.logger.error(f"Error processing message: {str(e)}")
-            return {
-                "error": str(e),
-                "completion_status": self.state.completion_status
-            }
-
-    def generate_profile(self) -> Dict[str, Any]:
-        """Generate the final structured profile with all collected information."""
-        try:
+            # Add metadata
             profile = {
-                "profile_data": {
-                    category: {
-                        "data": section.data,
-                        "confidence": section.confidence,
-                        "inferred_fields": section.inferred_fields,
-                        "metadata": section.metadata
-                    }
-                    for category, section in self.state.collected_sections.items()
-                },
+                "profile_data": profile_data,
                 "metadata": {
                     "generated_at": datetime.now().isoformat(),
-                    "completion_status": self.state.completion_status,
-                    "missing_information": self._get_missing_information(),
-                    "conversation_length": len(self.state.conversation_history),
-                    "extraction_history": self.state.extraction_history
+                    "conversation_length": len(self.conversation_history)
                 }
             }
 
-            # Save profile to file
+            # Save to file
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             filename = f"profile_{timestamp}.json"
             with open(filename, 'w', encoding='utf-8') as f:
-                json.dump(profile, f, indent=2, ensure_ascii=False)
+                json.dump(profile, f, indent=2)
 
-            self.logger.info(f"Generated profile saved to {filename}")
             return {
                 "profile": profile,
-                "filename": filename,
-                "status": "success"
+                "filename": filename
             }
 
         except Exception as e:
-            self.logger.error(f"Error generating profile: {str(e)}")
-            return {
-                "error": str(e),
-                "status": "error"
-            }
+            logger.error(f"Error generating profile: {str(e)}")
+            return {"error": str(e)}
 
-def create_gradio_interface() -> gr.Blocks:
-    """Create the Gradio interface for the profile builder."""
+def create_gradio_interface():
+    """Create the Gradio interface."""
     builder = ProfileBuilder()
 
     with gr.Blocks(theme=gr.themes.Soft()) as demo:
@@ -535,78 +136,53 @@ def create_gradio_interface() -> gr.Blocks:
                 api_key = gr.Textbox(
                     label="OpenAI API Key",
                     type="password",
-                    placeholder="Enter your OpenAI API key (sk-...)"
+                    placeholder="Enter your OpenAI API key"
                 )
                 
-                chatbot = gr.Chatbot(
-                    label="Conversation",
-                    height=400
-                )
+                chatbot = gr.Chatbot(label="Conversation")
                 
                 with gr.Row():
                     msg = gr.Textbox(
                         label="Message",
                         placeholder="Chat with LOSS DOG..."
                     )
-                    send = gr.Button("Send", variant="primary")
+                    send = gr.Button("Send")
 
             with gr.Column(scale=1):
-                with gr.Tabs():
-                    with gr.Tab("Extracted Info"):
-                        extracted_info = gr.JSON(
-                            label="Extracted Information",
-                            show_label=True
-                        )
-                    with gr.Tab("Progress"):
-                        completion = gr.JSON(
-                            label="Completion Status",
-                            show_label=True
-                        )
-                        missing = gr.JSON(
-                            label="Missing Information",
-                            show_label=True
-                        )
-
-                generate_btn = gr.Button("Generate Profile", variant="secondary")
+                generate_btn = gr.Button("Generate Profile")
                 profile_output = gr.JSON(label="Generated Profile")
                 download_btn = gr.File(label="Download Profile")
 
         # Event handlers
-        async def on_message(message: str, history: List[List[str]], key: str) -> Tuple[Any, Any, Any, Any]:
+        async def on_message(message: str, history: List[List[str]], key: str):
             if not message.strip():
-                return history, None, None, None
+                return history, None
 
             result = await builder.process_message(message, key)
             
             if "error" in result:
-                return history, None, None, {"error": result["error"]}
+                return history, {"error": result["error"]}
 
             history = history + [[message, result["response"]]]
-            
-            return (
-                history,
-                result["extracted_sections"],
-                result["completion_status"],
-                result["missing_information"]
-            )
+            return history, None
 
-        def on_generate() -> Tuple[Dict[str, Any], str]:
-            result = builder.generate_profile()
-            if result["status"] == "success":
-                return result["profile"], result["filename"]
-            return {"error": result["error"]}, None
+        async def on_generate():
+            result = await builder.generate_profile()
+            if "error" in result:
+                return {"error": result["error"]}, None
+            return result["profile"], result["filename"]
 
         # Bind events
         msg.submit(
             on_message,
             inputs=[msg, chatbot, api_key],
-            outputs=[chatbot, extracted_info, completion, missing]
-        ).then(lambda: "", None, msg)  # Clear message box after sending
+            outputs=[chatbot, profile_output]
+        ).then(lambda: "", None, msg)
         
         send.click(
             on_message,
             inputs=[msg, chatbot, api_key],
-            outputs=[chatbot, extracted_info, completion, missing]
+            outputs=[chatbot, profile_output]
         ).then(lambda: "", None, msg)
         
         generate_btn.click(
@@ -618,8 +194,4 @@ def create_gradio_interface() -> gr.Blocks:
 
 if __name__ == "__main__":
     demo = create_gradio_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860)