Update app.py

app.py

@@ -30,365 +30,573 @@ Core Traits:  #25
 - Maintains context throughout the conversation  #30
 """  #31
   #32
-# Profile structure configuration  #33
-PROFILE_STRUCTURE = {  #34
-    "profile_overview": {  #35
-        "required_fields": ["current_status", "career_summary"],  #36
-        "optional_fields": ["key_highlights", "skills_and_expertise"],  #37
-        "allow_custom_fields": True,  #38
-        "weight": 0.2  #39
-    },  #40
-    "education": {  #41
-        "required_fields": ["institution", "program"],  #42
-        "optional_fields": ["metrics", "experiences", "achievements"],  #43
-        "allow_custom_fields": True,  #44
-        "weight": 0.25,  #45
-        "subsections": ["current", "history", "highlights"]  #46
-    },  #47
-    "professional": {  #48
-        "required_fields": ["role", "organization"],  #49
-        "optional_fields": ["metrics", "achievements", "impact"],  #50
-        "allow_custom_fields": True,  #51
-        "weight": 0.25,  #52
-        "subsections": ["current", "history", "highlights"]  #53
-    },  #54
-    "achievements_and_impacts": {  #55
-        "required_fields": [],  #56
-        "optional_fields": ["recognition", "certifications", "contributions"],  #57
-        "allow_custom_fields": True,  #58
-        "weight": 0.3  #59
-    }  #60
-}  #61
-  #62
-@dataclass  #63
-class ConversationState:  #64
-    """Track the state of the conversation and profile completion."""  #65
-    sections_completed: List[str] = None  #66
-    sections_partial: List[str] = None  #67
-    current_section: Optional[str] = None  #68
-    completion_percentage: float = 0.0  #69
-    last_error: Optional[str] = None  #70
+@dataclass  #33
+class ConversationState:  #34
+    """Track the state of the conversation and profile completion."""  #35
+    sections_completed: List[str] = None  #36
+    sections_partial: List[str] = None  #37
+    current_section: Optional[str] = None  #38
+    completion_percentage: float = 0.0  #39
+    last_error: Optional[str] = None  #40
+  #41
+    def __post_init__(self):  #42
+        self.sections_completed = []  #43
+        self.sections_partial = []  #44
+  #45
+class ProfileAnalyzer:  #46
+    """Analyzes and structures conversation data flexibly."""  #47
+  #48
+    @staticmethod  #49
+    def analyze_content(text: str) -> Dict[str, Any]:  #50
+        """Extract key information from text."""  #51
+        analysis = {  #52
+            "categories": [],  #53
+            "metrics": {},  #54
+            "experiences": [],  #55
+            "achievements": [],  #56
+            "skills": []  #57
+        }  #58
+        return analysis  #59
+  #60
+    @staticmethod  #61
+    def clean_data(data: Dict[str, Any]) -> Dict[str, Any]:  #62
+        """Clean and validate extracted data."""  #63
+        def clean_value(v):  #64
+            if isinstance(v, dict):  #65
+                return {k: clean_value(val) for k, val in v.items() if val not in (None, "", [], {})}  #66
+            if isinstance(v, list):  #67
+                return [clean_value(item) for item in v if item not in (None, "", [], {})]  #68
+            return v  #69
+        return clean_value(data)  #70
   #71
-    def __post_init__(self):  #72
-        self.sections_completed = []  #73
-        self.sections_partial = []  #74
-  #75
-class ProfileValidator:  #76
-    """Validate and structure profile data."""  #77
-      #78
-    @staticmethod  #79
-    def validate_section(section_data: Dict[str, Any], section_config: Dict[str, Any]) -> Tuple[bool, List[str]]:  #80
-        """Validate a section against its configuration."""  #81
-        errors = []  #82
-        is_valid = True  #83
-          #84
-        # Check required fields  #85
-        for field in section_config.get("required_fields", []):  #86
-            if field not in section_data or not section_data[field]:  #87
-                errors.append(f"Missing required field: {field}")  #88
-                is_valid = False  #89
-          #90
-        return is_valid, errors  #91
+class EducationCareerCollector:  #72
+    """Main collector class for handling career and education information."""  #73
+  #74
+    def __init__(self):  #75
+        self.conversation_history = []  #76
+        self.client = None  #77
+        self.state = ConversationState()  #78
+        self.analyzer = ProfileAnalyzer()  #79
+  #80
+    def process_message(self, message: str, api_key: str) -> Dict[str, Any]:  #81
+        """Process a user message and return AI response with enhanced error handling."""  #82
+        try:  #83
+            if not message.strip():  #84
+                raise ValueError("Message cannot be empty")  #85
+  #86
+            if not api_key.strip().startswith('sk-'):  #87
+                raise ValueError("Invalid API key format")  #88
+  #89
+            if not self.client:  #90
+                self.client = OpenAI(api_key=api_key)  #91
   #92
-    @staticmethod  #93
-    def clean_section_data(data: Dict[str, Any], config: Dict[str, Any]) -> Dict[str, Any]:  #94
-        """Clean and validate section data."""  #95
-        cleaned = {}  #96
-          #97
-        # Handle required fields  #98
-        for field in config.get("required_fields", []):  #99
-            cleaned[field] = data.get(field) or "Not provided"  #100
-          #101
-        # Handle optional fields  #102
-        for field in config.get("optional_fields", []):  #103
-            if field in data and data[field]:  #104
-                cleaned[field] = data[field]  #105
-          #106
-        return cleaned  #107
-  #108
-class EducationCareerCollector:  #109
-    """Main collector class for handling career and education information."""  #110
-      #111
-    def __init__(self):  #112
-        self.conversation_history = []  #113
-        self.client = None  #114
-        self.state = ConversationState()  #115
-        self.validator = ProfileValidator()  #116
-          #117
-    def process_message(self, message: str, api_key: str) -> Dict[str, Any]:  #118
-        """Process a user message and return AI response."""  #119
-        try:  #120
-            if not message.strip():  #121
-                raise ValueError("Message cannot be empty")  #122
-                  #123
-            if not api_key.strip().startswith('sk-'):  #124
-                raise ValueError("Invalid API key format")  #125
-                  #126
-            if not self.client:  #127
-                self.client = OpenAI(api_key=api_key)  #128
-              #129
-            # Add message to history  #130
-            self.conversation_history.append({"role": "user", "content": message})  #131
-              #132
-            # Get AI response  #133
-            response = self.client.chat.completions.create(  #134
-                model="gpt-4",  #135
-                messages=[  #136
-                    {"role": "system", "content": SYSTEM_PROMPT},  #137
-                    *self.conversation_history  #138
-                ],  #139
-                temperature=0.7  #140
-            )  #141
-              #142
-            # Process response  #143
-            ai_message = response.choices[0].message.content  #144
-            self.conversation_history.append({"role": "assistant", "content": ai_message})  #145
-              #146
-            # Update state  #147
-            self._update_conversation_state()  #148
-              #149
-            return {  #150
-                "content": ai_message,  #151
-                "type": "success",  #152
-                "completion_status": self.get_completion_status()  #153
-            }  #154
-              #155
-        except Exception as e:  #156
-            error_msg = f"Error processing message: {str(e)}"  #157
-            logger.error(error_msg)  #158
-            self.state.last_error = error_msg  #159
-            return {  #160
-                "content": error_msg,  #161
-                "type": "error",  #162
-                "completion_status": self.get_completion_status()  #163
-            }  #164
-  #165
-    def _update_conversation_state(self):  #166
-        """Update internal conversation state."""  #167
-        try:  #168
-            # Create analysis prompt  #169
-            analysis_prompt = """  #170
-            Analyze our conversation and identify:  #171
-            1. Which sections have been fully covered?  #172
-            2. Which sections have been partially covered?  #173
-            3. What is the current topic of discussion?  #174
-              #175
-            Respond in JSON format:  #176
-            {  #177
-                "sections_completed": [],  #178
-                "sections_partial": [],  #179
-                "current_section": "",  #180
-                "completion_percentage": 0.0  #181
-            }  #182
-            """  #183
-              #184
-            # Get analysis from AI  #185
-            response = self.client.chat.completions.create(  #186
-                model="gpt-4",  #187
-                messages=[  #188
-                    {"role": "system", "content": SYSTEM_PROMPT},  #189
-                    *self.conversation_history,  #190
-                    {"role": "user", "content": analysis_prompt}  #191
-                ],  #192
-                temperature=0.3  #193
-            )  #194
-              #195
-            # Update state  #196
-            analysis = json.loads(response.choices[0].message.content)  #197
-            self.state.sections_completed = analysis.get("sections_completed", [])  #198
-            self.state.sections_partial = analysis.get("sections_partial", [])  #199
-            self.state.current_section = analysis.get("current_section")  #200
-            self.state.completion_percentage = analysis.get("completion_percentage", 0.0)  #201
-              #202
-        except Exception as e:  #203
-            logger.error(f"Error updating conversation state: {str(e)}")  #204
-  #205
-    def generate_json(self, api_key: str) -> Tuple[Optional[str], str]:  #206
-        """Generate profile JSON from conversation."""  #207
-        try:  #208
-            if not self.client:  #209
-                self.client = OpenAI(api_key=api_key)  #210
-  #211
-            # First pass: Analysis  #212
-            analysis_prompt = """  #213
-            Analyze our conversation and extract:  #214
-            1. Key themes and topics  #215
-            2. Quantitative metrics  #216
-            3. Qualitative achievements  #217
-            4. Timeline points  #218
-            5. Skills and competencies  #219
-              #220
-            Format as JSON.  #221
-            """  #222
-              #223
-            analysis_response = self.client.chat.completions.create(  #224
-                model="gpt-4",  #225
-                messages=[  #226
-                    {"role": "system", "content": SYSTEM_PROMPT},  #227
-                    *self.conversation_history,  #228
-                    {"role": "user", "content": analysis_prompt}  #229
-                ],  #230
-                temperature=0.7  #231
-            )  #232
-              #233
-            analysis = json.loads(analysis_response.choices[0].message.content)  #234
-              #235
-            # Second pass: Generate JSON  #236
-            json_prompt = f"""  #237
-            Based on our conversation and this analysis: {json.dumps(analysis, indent=2)}  #238
-              #239
-            Create a comprehensive profile following the PROFILE_STRUCTURE format.  #240
-            Include both quantitative and qualitative elements.  #241
-            """  #242
-              #243
-            json_response = self.client.chat.completions.create(  #244
-                model="gpt-4",  #245
-                messages=[  #246
-                    {"role": "system", "content": SYSTEM_PROMPT},  #247
-                    *self.conversation_history,  #248
-                    {"role": "user", "content": json_prompt}  #249
-                ],  #250
-                temperature=0.5  #251
-            )  #252
-  #253
-            # Process and validate JSON  #254
-            profile_data = json.loads(json_response.choices[0].message.content)  #255
-              #256
-            # Validate and clean sections  #257
-            for section, data in profile_data.items():  #258
-                if section in PROFILE_STRUCTURE:  #259
-                    _, errors = self.validator.validate_section(  #260
-                        data, PROFILE_STRUCTURE[section]  #261
-                    )  #262
-                    if errors:  #263
-                        logger.warning(f"Validation errors in {section}: {errors}")  #264
-                        profile_data[section] = self.validator.clean_section_data(  #265
-                            data, PROFILE_STRUCTURE[section]  #266
-                        )  #267
-  #268
-            # Add metadata  #269
-            profile_data["metadata"] = {  #270
-                "generated_at": datetime.now().isoformat(),  #271
-                "version": "2.0",  #272
-                "completion_metrics": {  #273
-                    "overall_score": self.state.completion_percentage,  #274
-                    "sections_completed": self.state.sections_completed,  #275
-                    "sections_partial": self.state.sections_partial  #276
-                }  #277
-            }  #278
-              #279
-            # Save file  #280
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")  #281
-            filename = f"career_education_profile_{timestamp}.json"  #282
-              #283
-            with open(filename, 'w') as f:  #284
-                json.dump(profile_data, f, indent=2)  #285
-                  #286
-            return (filename, json.dumps(profile_data, indent=2))  #287
-  #288
-        except Exception as e:  #289
-            logger.error(f"Error generating JSON: {str(e)}")  #290
-            return (None, json.dumps(self._create_error_json(str(e)), indent=2))  #291
-  #292
-    def _create_error_json(self, error_msg: str) -> Dict[str, Any]:  #293
-        """Create error JSON structure."""  #294
-        return {  #295
-            "error": error_msg,  #296
-            "metadata": {  #297
+            # Add message to conversation history  #93
+            self.conversation_history.append({  #94
+                "role": "user",   #95
+                "content": message,  #96
+                "timestamp": datetime.now().isoformat()  #97
+            })  #98
+  #99
+            # Get AI response with retry mechanism  #100
+            max_retries = 3  #101
+            last_error = None  #102
+  #103
+            for attempt in range(max_retries):  #104
+                try:  #105
+                    response = self.client.chat.completions.create(  #106
+                        model="gpt-4",  #107
+                        messages=[  #108
+                            {"role": "system", "content": SYSTEM_PROMPT},  #109
+                            *[{  #110
+                                "role": msg["role"],   #111
+                                "content": msg["content"]  #112
+                            } for msg in self.conversation_history]  #113
+                        ],  #114
+                        temperature=0.7,  #115
+                        max_tokens=1000  #116
+                    )  #117
+                    break  #118
+                except Exception as e:  #119
+                    last_error = str(e)  #120
+                    if attempt == max_retries - 1:  #121
+                        raise Exception(f"Failed after {max_retries} attempts: {last_error}")  #122
+                    logger.warning(f"Attempt {attempt + 1} failed: {last_error}")  #123
+                    continue  #124
+  #125
+            # Process response  #126
+            ai_message = response.choices[0].message.content  #127
+            self.conversation_history.append({  #128
+                "role": "assistant",   #129
+                "content": ai_message,  #130
+                "timestamp": datetime.now().isoformat()  #131
+            })  #132
+  #133
+            # Analyze response and update state  #134
+            self._update_conversation_state(ai_message)  #135
+  #136
+            return {  #137
+                "content": ai_message,  #138
+                "type": "success",  #139
+                "completion_status": self.get_completion_status(),  #140
+                "timestamp": datetime.now().isoformat()  #141
+            }  #142
+  #143
+        except Exception as e:  #144
+            error_msg = f"Error processing message: {str(e)}"  #145
+            logger.error(error_msg)  #146
+            self.state.last_error = error_msg  #147
+            return {  #148
+                "content": error_msg,  #149
+                "type": "error",  #150
+                "completion_status": self.get_completion_status(),  #151
+                "timestamp": datetime.now().isoformat()  #152
+            }  #153
+def _update_conversation_state(self, ai_message: str) -> None:  #154
+        """Update the conversation state based on AI response."""  #155
+        try:  #156
+            # Create analysis prompt  #157
+            analysis_prompt = """  #158
+            Review our conversation and identify:  #159
+            1. What topics or aspects of their journey were discussed?  #160
+            2. What areas need more exploration?  #161
+            3. What's the current focus of discussion?  #162
+            
+            Response format:
+            {
+                "topics_discussed": [],
+                "areas_needing_exploration": [],
+                "current_focus": "",
+                "completion_estimate": 0.0
+            }
+            """  #163
+            
+            # Get analysis from AI  #164
+            response = self.client.chat.completions.create(  #165
+                model="gpt-4",  #166
+                messages=[  #167
+                    {"role": "system", "content": SYSTEM_PROMPT},  #168
+                    *self.conversation_history,  #169
+                    {"role": "user", "content": analysis_prompt}  #170
+                ],  #171
+                temperature=0.3  #172
+            )  #173
+            
+            # Process analysis  #174
+            try:  #175
+                analysis = json.loads(response.choices[0].message.content)  #176
+                
+                # Update state based on analysis  #177
+                self.state.sections_completed = analysis.get("topics_discussed", [])  #178
+                self.state.sections_partial = analysis.get("areas_needing_exploration", [])  #179
+                self.state.current_section = analysis.get("current_focus")  #180
+                self.state.completion_percentage = analysis.get("completion_estimate", 0.0)  #181
+                
+            except json.JSONDecodeError as e:  #182
+                logger.error(f"Error parsing analysis JSON: {str(e)}")  #183
+                # Set default values on error  #184
+                self.state.completion_percentage = max(  #185
+                    self.state.completion_percentage,   #186
+                    len(self.conversation_history) * 5.0  # Rough estimate based on message count  #187
+                )  #188
+                
+        except Exception as e:  #189
+            logger.error(f"Error updating conversation state: {str(e)}")  #190
+            # State remains unchanged on error  #191
+            
+    def get_completion_status(self) -> Dict[str, Any]:  #192
+        """Get current completion status with rich context."""  #193
+        status = {  #194
+            "completion_percentage": self.state.completion_percentage,  #195
+            "topics_covered": self.state.sections_completed,  #196
+            "topics_in_progress": self.state.sections_partial,  #197
+            "current_focus": self.state.current_section,  #198
+            "conversation_length": len(self.conversation_history),  #199
+            "last_update": datetime.now().isoformat(),  #200
+            "needs_attention": [  #201
+                topic for topic in self.state.sections_partial   #202
+                if topic not in self.state.sections_completed  #203
+            ],  #204
+            "status_summary": self._generate_status_summary()  #205
+        }  #206
+        
+        if self.state.last_error:  #207
+            status["last_error"] = self.state.last_error  #208
+            
+        return status  #209
+        
+    def _generate_status_summary(self) -> str:  #210
+        """Generate a human-readable summary of the conversation status."""  #211
+        if not self.conversation_history:  #212
+            return "Ready to start the conversation."  #213
+            
+        summary_parts = []  #214
+        
+        # Add completion status  #215
+        if self.state.completion_percentage > 0:  #216
+            summary_parts.append(  #217
+                f"Conversation is approximately {self.state.completion_percentage:.1f}% complete"  #218
+            )  #219
+            
+        # Add covered topics  #220
+        if self.state.sections_completed:  #221
+            topics = ", ".join(self.state.sections_completed)  #222
+            summary_parts.append(f"We've discussed: {topics}")  #223
+            
+        # Add current focus  #224
+        if self.state.current_section:  #225
+            summary_parts.append(  #226
+                f"Currently focusing on: {self.state.current_section}"  #227
+            )  #228
+            
+        # Add next steps if any  #229
+        if self.state.sections_partial:  #230
+            topics = ", ".join(self.state.sections_partial)  #231
+            summary_parts.append(f"Topics to explore further: {topics}")  #232
+            
+        return " | ".join(summary_parts) if summary_parts else "Conversation in progress."  #233
+        
+    def generate_json(self, api_key: str) -> Tuple[Optional[str], str]:  #234
+        """Generate a JSON profile from the conversation history."""  #235
+        try:  #236
+            if not self.client:  #237
+                self.client = OpenAI(api_key=api_key)  #238
+                
+            # Analysis prompt focused on understanding the conversation  #239
+            analysis_prompt = """  #240
+            Review our conversation and create a JSON structure that captures the person's journey.  #241
+            Focus on what was actually discussed, not fitting into predetermined categories.  #242
+            Include:  #243
+            1. Any experiences or achievements shared  #244
+            2. Skills or competencies demonstrated  #245
+            3. Timeline or progression points mentioned  #246
+            4. Notable metrics or outcomes  #247
+            5. Personal growth or learning moments  #248
+            
+            Structure the JSON naturally around the topics they shared.  #249
+            """  #250
+# Get initial analysis of conversation content  #251
+            analysis_response = self.client.chat.completions.create(  #252
+                model="gpt-4",  #253
+                messages=[  #254
+                    {"role": "system", "content": SYSTEM_PROMPT},  #255
+                    *self.conversation_history,  #256
+                    {"role": "user", "content": analysis_prompt}  #257
+                ],  #258
+                temperature=0.7  #259
+            )  #260
+            
+            # Parse the initial analysis  #261
+            analysis = json.loads(analysis_response.choices[0].message.content)  #262
+            
+            # Generate structured profile based on analysis  #263
+            profile_prompt = f"""  #264
+            Based on our conversation, create a detailed profile JSON.  #265
+            Use this analysis as a guide: {json.dumps(analysis, indent=2)}  #266
+            
+            Important guidelines:  #267
+            - Create sections based on what was actually discussed  #268
+            - Include both quantitative and qualitative information  #269
+            - Preserve the context and significance of experiences  #270
+            - Maintain natural flow and connections between topics  #271
+            - Use descriptive section names that reflect the conversation  #272
+            """  #273
+            
+            # Generate the profile JSON  #274
+            profile_response = self.client.chat.completions.create(  #275
+                model="gpt-4",  #276
+                messages=[  #277
+                    {"role": "system", "content": SYSTEM_PROMPT},  #278
+                    *self.conversation_history,  #279
+                    {"role": "user", "content": profile_prompt}  #280
+                ],  #281
+                temperature=0.5  #282
+            )  #283
+            
+            # Parse and clean the profile data  #284
+            profile_data = json.loads(profile_response.choices[0].message.content)  #285
+            
+            # Clean the data  #286
+            def clean_dict(d):  #287
+                if isinstance(d, dict):  #288
+                    return {k: clean_dict(v) for k, v in d.items()   #289
+                            if v not in (None, "", [], {}, "N/A", "None")}  #290
+                if isinstance(d, list):  #291
+                    return [clean_dict(item) for item in d   #292
+                            if item not in (None, "", [], {}, "N/A", "None")]  #293
+                return d  #294
+            
+            profile_data = clean_dict(profile_data)  #295
+            
+            # Add metadata  #296
+            profile_data["metadata"] = {  #297
                 "generated_at": datetime.now().isoformat(),  #298
                 "version": "2.0",  #299
-                "error_occurred": True  #300
-            }  #301
-        }  #302
-  #303
-    def get_completion_status(self) -> Dict[str, Any]:  #304
-        """Get current completion status."""  #305
-        return {  #306
-            "completion_percentage": self.state.completion_percentage,  #307
-            "sections_completed": self.state.sections_completed,  #308
-            "sections_partial": self.state.sections_partial,  #309
-            "current_section": self.state.current_section,  #310
-            "sections_remaining": [  #311
-                section for section in PROFILE_STRUCTURE.keys()  #312
-                if section not in self.state.sections_completed  #313
-                and section not in self.state.sections_partial  #314
-            ]  #315
-        }  #316
-  #317
-def create_education_career_interface():  #318
-    """Create Gradio interface."""  #319
-    collector = EducationCareerCollector()  #320
-  #321
-    css = """  #322
-    .message { font-size: 16px; }  #323
-    .alert { padding: 12px; margin: 8px 0; border-radius: 4px; }  #324
-    .alert-info { background-color: #e8f4f8; border-left: 4px solid #4a90e2; }  #325
-    .alert-error { background-color: #fde8e8; border-left: 4px solid #f56565; }  #326
-    """  #327
-  #328
-    with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:  #329
-        gr.Markdown("""  #330
-        # 🐕 LOSS DOG - Profile Builder  #331
-        Share your career and education journey naturally.  #332
-        """)  #333
-          #334
-        with gr.Row():  #335
-            with gr.Column(scale=2):  #336
-                api_key = gr.Textbox(  #337
-                    label="OpenAI API Key",  #338
-                    type="password",  #339
-                    placeholder="Enter your OpenAI API key"  #340
-                )  #341
-                  #342
-                status_msg = gr.Markdown(  #343
-                    "Ready to start!",  #344
-                    elem_classes=["alert", "alert-info"]  #345
-                )  #346
-                  #347
-                chatbot = gr.Chatbot(  #348
-                    height=400,  #349
-                    show_label=False  #350
-                )  #351
-                  #352
-                with gr.Row():  #353
-                    msg = gr.Textbox(  #354
-                        label="Your message",  #355
-                        placeholder="Tell me about your journey..."  #356
-                    )  #357
-                    submit = gr.Button("Send")  #358
-                    generate = gr.Button("Generate Profile")  #359
-  #360
-            with gr.Column(scale=1):  #361
-                progress_info = gr.Markdown("### Profile Progress")  #362
-                json_preview = gr.JSON(label="Profile Preview")  #363
-                output_file = gr.File(label="Download Profile")  #364
-  #365
-        def process_message(message, history, key):  #366
-            if not message.strip():  #367
-                return history, "Please enter a message."  #368
-              #369
-            result = collector.process_message(message, key)  #370
-            history.append((message, result["content"]))  #371
-              #372
-            status = f"Completion: {result['completion_status']['completion_percentage']}%"  #373
-            return history, status  #374
-  #375
-        def generate_profile(key):  #376
-            filename, json_content = collector.generate_json(key)  #377
-            if filename:  #378
-                return (filename, json.loads(json_content))  #379
-            return (None, json.loads(json_content))  #380
-  #381
-        msg.submit(process_message, [msg, chatbot, api_key], [chatbot, status_msg])  #382
-        submit.click(process_message, [msg, chatbot, api_key], [chatbot, status_msg])  #383
-        generate.click(generate_profile, [api_key], [output_file, json_preview])  #384
-  #385
-    return demo  #386
-  #387
-if __name__ == "__main__":  #388
-    demo = create_education_career_interface()  #389
-    demo.launch(  #390
-        server_name="0.0.0.0",  #391
-        server_port=7860,  #392
-        share=True  #393
-    )  #394
+                "generation_metrics": {  #300
+                    "conversation_length": len(self.conversation_history),  #301
+                    "topics_covered": self.state.sections_completed,  #302
+                    "completion_percentage": self.state.completion_percentage  #303
+                }  #304
+            }  #305
+            
+            # Save to file  #306
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")  #307
+            filename = f"career_education_profile_{timestamp}.json"  #308
+            
+            try:  #309
+                with open(filename, 'w', encoding='utf-8') as f:  #310
+                    json.dump(profile_data, f, indent=2, ensure_ascii=False)  #311
+                return (filename, json.dumps(profile_data, indent=2, ensure_ascii=False))  #312
+            except Exception as e:  #313
+                logger.error(f"Error saving profile to file: {str(e)}")  #314
+                return (None, json.dumps(profile_data, indent=2, ensure_ascii=False))  #315
+                
+        except Exception as e:  #316
+            error_msg = f"Error generating profile: {str(e)}"  #317
+            logger.error(error_msg)  #318
+            error_json = {  #319
+                "error": error_msg,  #320
+                "metadata": {  #321
+                    "generated_at": datetime.now().isoformat(),  #322
+                    "error_occurred": True  #323
+                }  #324
+            }  #325
+            return (None, json.dumps(error_json, indent=2))  #326
+            
+def create_education_career_interface():  #327
+    """Create Gradio interface for the education and career collector."""  #328
+    collector = EducationCareerCollector()  #329
+    
+    css = """  #330
+    .message { font-size: 16px; margin: 8px 0; }  #331
+    .system-message { color: #444; font-style: italic; }  #332
+    .user-message { color: #000; font-weight: 500; }  #333
+    .alert {  #334
+        padding: 12px;  #335
+        margin: 8px 0;  #336
+        border-radius: 4px;  #337
+    }  #338
+    .alert-info {  #339
+        background-color: #e8f4f8;  #340
+        border-left: 4px solid #4a90e2;  #341
+    }  #342
+    .alert-error {  #343
+        background-color: #fde8e8;  #344
+        border-left: 4px solid #f56565;  #345
+    }  #346
+    .alert-success {  #347
+        background-color: #e8f8e8;  #348
+        border-left: 4px solid #48bb78;  #349
+    }  #350
+    """  #351
+    
+    with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:  #352
+        gr.Markdown("""  #353
+        # 🐕 LOSS DOG - Profile Builder  #354
+        
+        Share your career and education journey naturally.  #355
+        Tell your story in your own way - we'll capture what matters to you.  #356
+        """)  #357
+        
+        with gr.Row():  #358
+            with gr.Column(scale=2):  #359
+                # API Key Input  #360
+                api_key = gr.Textbox(  #361
+                    label="OpenAI API Key",  #362
+                    type="password",  #363
+                    placeholder="Enter your OpenAI API key (sk-...)",  #364
+                    info="Your API key from platform.openai.com"  #365
+                )  #366
+                
+                # Status Messages  #367
+                status_msg = gr.Markdown(  #368
+                    "Ready to start! Share your journey...",  #369
+                    elem_classes=["alert", "alert-info"]  #370
+                )  #371
+                
+                # Chat Interface  #372
+                chatbot = gr.Chatbot(  #373
+                    height=400,  #374
+                    show_label=False,  #375
+                    elem_classes=["message"]  #376
+                )  #377
+                
+                # Message Input  #378
+                with gr.Row():  #379
+                    msg = gr.Textbox(  #380
+                        label="Your message",  #381
+                        placeholder="Tell me about your journey...",  #382
+                        show_label=False,  #383
+                        scale=4  #384
+                    )  #385
+                    submit = gr.Button("Send", variant="primary", scale=1)  #386
+                
+                # Action Buttons  #387
+                with gr.Row():  #388
+                    clear = gr.Button("🗑️ Clear Chat", scale=1)  #389
+                    generate = gr.Button("📄 Generate Profile", scale=2)  #390
+with gr.Column(scale=1):  #391
+                # Progress Information  #392
+                progress_info = gr.Markdown(  #393
+                    "### Profile Progress\nStart sharing your story!",  #394
+                    elem_classes=["alert", "alert-info"]  #395
+                )  #396
+                
+                # Profile Preview  #397
+                with gr.Tab("Preview"):  #398
+                    json_preview = gr.JSON(  #399
+                        label="Profile Preview",  #400
+                        show_label=True  #401
+                    )  #402
+                
+                # Download Section  #403
+                with gr.Tab("Download"):  #404
+                    output_file = gr.File(  #405
+                        label="Download Profile"  #406
+                    )  #407
+                    
+                # Tips and Guidelines  #408
+                with gr.Accordion("💡 Tips", open=False):  #409
+                    gr.Markdown("""  #410
+                    ### Share Your Story Naturally  #411
+                    
+                    - Tell us about experiences that matter to you  #412
+                    - Include both achievements and challenges  #413
+                    - Share numbers when they're meaningful  #414
+                    - Describe your growth and learning  #415
+                    - Talk about what makes your journey unique  #416
+                    """)  #417
+        
+        def process_message(message: str, history: list, key: str) -> tuple:  #418
+            """Process user message and update interface."""  #419
+            if not message.strip():  #420
+                return history, "Please enter a message."  #421
+            
+            try:  #422
+                # Process the message  #423
+                result = collector.process_message(message, key)  #424
+                
+                # Update chat history  #425
+                history.append((message, result["content"]))  #426
+                
+                # Generate status message  #427
+                status = f"""Progress: {result['completion_status']['completion_percentage']:.1f}%  #428
+                        | Topics covered: {len(result['completion_status']['topics_covered'])}"""  #429
+                
+                return history, status  #430
+                
+            except Exception as e:  #431
+                error_msg = f"Error: {str(e)}"  #432
+                logger.error(error_msg)  #433
+                return history, error_msg  #434
+        
+        def generate_profile(key: str) -> tuple:  #435
+            """Generate and return profile JSON."""  #436
+            try:  #437
+                filename, json_content = collector.generate_json(key)  #438
+                if filename:  #439
+                    return (  #440
+                        filename,   #441
+                        json.loads(json_content),   #442
+                        "Profile generated successfully! 🎉"  #443
+                    )  #444
+                return (  #445
+                    None,   #446
+                    json.loads(json_content),   #447
+                    "Profile generated but couldn't save file."  #448
+                )  #449
+            except Exception as e:  #450
+                error_msg = f"Error generating profile: {str(e)}"  #451
+                logger.error(error_msg)  #452
+                return None, {"error": error_msg}, error_msg  #453
+        
+        def clear_interface() -> tuple:  #454
+            """Reset the interface state."""  #455
+            return (  #456
+                [],  # Clear chat history  #457
+                "Ready to start! Share your journey...",  # Reset status  #458
+                "### Profile Progress\nStart sharing your story!",  # Reset progress  #459
+                None,  # Clear JSON preview  #460
+                None  # Clear file output  #461
+            )  #462
+        
+        def update_progress(history: list) -> str:  #463
+            """Update progress information based on conversation."""  #464
+            if not history:  #465
+                return "### Profile Progress\nStart sharing your story!"  #466
+            
+            # Get completion status  #467
+            status = collector.get_completion_status()  #468
+            
+            # Format progress message  #469
+            progress_md = f"""### Profile Progress: {status['completion_percentage']:.1f}%\n\n"""  #470
+            
+            if status['topics_covered']:  #471
+                progress_md += "✅ **Discussed:**\n"  #472
+                for topic in status['topics_covered']:  #473
+                    progress_md += f"- {topic}\n"  #474
+            
+            if status['topics_in_progress']:  #475
+                progress_md += "\n📝 **Currently exploring:**\n"  #476
+                for topic in status['topics_in_progress']:  #477
+                    progress_md += f"- {topic}\n"  #478
+            
+            if status.get('needs_attention'):  #479
+                progress_md += "\n❗ **Consider discussing:**\n"  #480
+                for topic in status['needs_attention']:  #481
+                    progress_md += f"- {topic}\n"  #482
+            
+            return progress_md  #483
+        
+        # Event Handlers  #484
+        msg.submit(  #485
+            process_message,   #486
+            [msg, chatbot, api_key],   #487
+            [chatbot, status_msg]  #488
+        ).then(  #489
+            update_progress,   #490
+            chatbot,   #491
+            progress_info  #492
+        ).then(  #493
+            lambda: "",   #494
+            None,   #495
+            msg  #496
+        )  #497
+        
+        submit.click(  #498
+            process_message,   #499
+            [msg, chatbot, api_key],   #500
+[msg, chatbot, api_key],  #501
+            [chatbot, status_msg]  #502
+        ).then(  #503
+            update_progress,  #504
+            chatbot,  #505
+            progress_info  #506
+        ).then(  #507
+            lambda: "",  #508
+            None,  #509
+            msg  #510
+        )  #511
+        
+        generate.click(  #512
+            generate_profile,  #513
+            [api_key],  #514
+            [output_file, json_preview, status_msg]  #515
+        )  #516
+        
+        clear.click(  #517
+            clear_interface,  #518
+            None,  #519
+            [chatbot, status_msg, progress_info, json_preview, output_file]  #520
+        )  #521
+    
+    return demo  #522
+
+if __name__ == "__main__":  #523
+    demo = create_education_career_interface()  #524
+    demo.launch(  #525
+        server_name="0.0.0.0",  #526
+        server_port=7860,  #527
+        share=True,  #528
+        enable_queue=True,  #529
+        show_error=True  #530
+    )  #531