Spaces:

jzou19950715
/

Newco_information_extraction_agent

Sleeping

App Files Files Community

jzou19950715 commited on Feb 5

Commit

210eb9d

verified ·

1 Parent(s): d3c9017

Update app.py

Browse files

Files changed (1) hide show

app.py +514 -535

app.py CHANGED Viewed

@@ -5,429 +5,531 @@ from datetime import datetime
 from typing import Dict, List, Optional, Any, Tuple
 from dataclasses import dataclass, field
-import openai  # We'll use the official openai package
 import gradio as gr
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
     handlers=[
         logging.StreamHandler(),
-        logging.FileHandler('app.log')
     ]
 )
 logger = logging.getLogger(__name__)
-SYSTEM_PROMPT = """
-You are LOSS DOG, a Career and Education Information Extraction Assistant, designed to help users craft a compelling
-and well-structured resume by extracting and organizing key details from conversations.
-Core Capabilities:
-- Proactively ask users about their career history, education, skills, certifications, projects, and achievements.
-- Guide users through a step-by-step process to ensure all essential resume details are collected.
-- Offer suggestions to improve clarity and impact based on best resume-building practices.
-- Maintain a friendly, engaging, and professional tone to encourage users to share relevant information.
-- Structure extracted data into well-organized resume sections.
-Your goal is to make resume-building effortless by asking the right questions, extracting key information,
-and presenting it in a clear, professional format.
-"""
 @dataclass
-class ExtractedInfo:
-    """Structure for storing extracted information relevant to building a resume."""
-    text: str
     category: str
     confidence: float
-    timestamp: datetime = field(default_factory=datetime.now)
     metadata: Dict[str, Any] = field(default_factory=dict)
 @dataclass
 class ConversationState:
-    """Tracks the conversation state and progress regarding extracted resume info."""
-    extracted_items: List[ExtractedInfo] = field(default_factory=list)
-    categories_covered: List[str] = field(default_factory=list)
     current_focus: Optional[str] = None
-    completion_percentage: float = 0.0
-    last_error: Optional[str] = None
-    last_update: datetime = field(default_factory=datetime.now)
-    def add_extracted_info(self, info: ExtractedInfo) -> None:
-        """Add new extracted information and update state accordingly."""
-        self.extracted_items.append(info)
-        if info.category not in self.categories_covered:
-            self.categories_covered.append(info.category)
-        self.last_update = datetime.now()
-class InformationExtractor:
-    """
-    Core class for handling information extraction from user messages to build a structured resume.
-    Attributes:
-        conversation_history: A list of dictionaries storing each message and its role (user/assistant).
-        state: An instance of ConversationState, which tracks the extraction progress and items.
-        extraction_categories: A list of main categories we want to extract for building the resume.
     """
-    def __init__(self) -> None:
-        """Initialize the InformationExtractor with default settings."""
-        self.conversation_history: List[Dict[str, str]] = []
         self.state = ConversationState()
-        self.extraction_categories = [
-            "personal_info",
-            "education",
-            "work_experience",
-            "skills",
-            "achievements"
-        ]
-        # We'll store the API key in a protected variable to re-use as needed
         self._api_key: Optional[str] = None
-    def _validate_api_key(self, api_key: str) -> bool:
-        """
-        Validate the OpenAI API key format.
-        Args:
-            api_key: The user's OpenAI API key.
-        Returns:
-            True if the API key is valid, raises ValueError otherwise.
-        """
-        if not api_key.strip():
-            raise ValueError("API key cannot be empty.")
-        if not api_key.startswith("sk-"):
-            raise ValueError("Invalid API key format. It must start with 'sk-'.")
-        return True
     def _initialize_client(self, api_key: str) -> None:
-        """
-        Initialize openai with the given API key. Uses error handling to catch any issue.
-        Args:
-            api_key: The user's OpenAI API key.
-        """
         try:
-            if self._validate_api_key(api_key):
-                openai.api_key = api_key
-                self._api_key = api_key
         except Exception as e:
-            logger.error(f"Error initializing OpenAI client: {str(e)}")
             raise
-    def _add_to_history(self, role: str, content: str) -> None:
-        """
-        Add a message to the conversation history with a timestamp.
-        Args:
-            role: Either 'user' or 'assistant' to denote who sent the message.
-            content: The message content.
-        """
-        self.conversation_history.append({
-            "role": role,
-            "content": content,
-            "timestamp": datetime.now().isoformat()
-        })
-    def _get_ai_response(self, retries: int = 3) -> str:
-        """
-        Get an AI response from OpenAI's ChatCompletion endpoint.
-        Args:
-            retries: Number of times to retry upon failure.
-        Returns:
-            The text content of the AI's reply.
-        """
-        if not self._api_key:
-            raise ValueError("OpenAI client not initialized (API key missing).")
-        for attempt in range(retries):
-            try:
-                # We use a context manager for the create call
-                with openai.ChatCompletion.create(
-                    model="gpt-4o-mini",  # or "gpt-4" or any other available model
-                    messages=[
-                        {"role": "system", "content": SYSTEM_PROMPT},
-                        *[{"role": msg["role"], "content": msg["content"]} for msg in self.conversation_history]
-                    ],
-                    temperature=0.7,
-                    max_tokens=2000
-                ) as response:
-                    return response["choices"][0]["message"]["content"]
-            except Exception as e:
-                logger.warning(f"Attempt {attempt + 1} failed: {str(e)}")
-                if attempt == retries - 1:
-                    raise Exception(f"Failed after {retries} attempts: {str(e)}")
-        return ""
-    def _extract_resume_information(self, text: str) -> List[ExtractedInfo]:
-        """
-        Extract structured career and education-related information from the given text.
-        Args:
-            text: The combined user and AI text from which to extract relevant info.
-        Returns:
-            A list of ExtractedInfo objects with the extracted details.
-        """
-        if not self._api_key:
-            raise ValueError("OpenAI client not initialized (API key missing).")
-        # We'll ask GPT to produce JSON with extracted items
-        extraction_prompt = f"""
-        Analyze the following text and extract relevant information for resume building.
-        Focus on these key categories: {', '.join(self.extraction_categories)}.
-        For each piece of extracted data, output a JSON structure with:
-        {{
-            "extracted_items": [
-                {{
-                    "text": "...",
-                    "category": "...",
-                    "confidence": 0.0,
-                    "metadata": {{ ... }}
-                }},
-                ...
             ]
-        }}
-        Text to analyze: {text}
-        """
-        try:
-            with openai.ChatCompletion.create(
-                model="gpt-4o-mini",
-                messages=[
-                    {"role": "system", "content": SYSTEM_PROMPT},
-                    {"role": "user", "content": extraction_prompt}
-                ],
                 temperature=0.3,
-                max_tokens=1000
-            ) as response:
-                raw_content = response["choices"][0]["message"]["content"]
-            # Now parse the content
-            analysis = json.loads(raw_content)
-            extracted_items = []
-            # This line must NOT be truncated or it will cause a syntax error
-            for item in analysis.get("extracted_items", []):
-                new_info = ExtractedInfo(
-                    text=item.get("text", ""),
-                    category=item.get("category", "misc"),
-                    confidence=float(item.get("confidence", 0.0)),
-                    metadata=item.get("metadata", {})
                 )
-                extracted_items.append(new_info)
-            return extracted_items
-        except json.JSONDecodeError as e:
-            logger.error(f"Error parsing extraction response: {str(e)}")
-            return []
         except Exception as e:
-            logger.error(f"Error during information extraction: {str(e)}")
-            return []
-    def _update_completion_status(self) -> None:
-        """
-        Update completion status based on categories covered and confidence levels.
-        """
-        total_categories = len(self.extraction_categories)
-        covered_categories = len(self.state.categories_covered)
-        base_completion = (covered_categories / total_categories) * 100 if total_categories > 0 else 0
-        if self.state.extracted_items:
-            avg_confidence = sum(item.confidence for item in self.state.extracted_items) / len(self.state.extracted_items)
-            adjusted_completion = base_completion * avg_confidence
-        else:
-            adjusted_completion = 0.0
-        # Cap at 100%
-        self.state.completion_percentage = min(adjusted_completion, 100.0)
-    def process_message(self, message: str, api_key: str) -> Dict[str, Any]:
-        """
-        Process a user message:
-            1. Initialize OpenAI if needed,
-            2. Add user message to history,
-            3. Get AI response,
-            4. Extract resume information,
-            5. Update the conversation state,
-            6. Return structured data.
-        Args:
-            message: The user's chat input.
-            api_key: The user's OpenAI API key.
-        Returns:
-            A dictionary with AI response, extracted info, and updated completion status.
-        """
-        # Always return a dictionary so that the UI can parse it
         try:
-            if not message.strip():
-                # Return placeholders if message is empty
-                return {
-                    "response": "Please enter a message.",
-                    "extracted_info": [],
-                    "completion_status": {
-                        "percentage": self.state.completion_percentage,
-                        "categories_covered": self.state.categories_covered,
-                        "current_focus": self.state.current_focus
-                    },
-                    "analysis_text": "No new information extracted.",
-                    "history_message": "(No change in history)"
-                }
-            # Initialize the client if not done yet
-            if not self._api_key:
-                self._initialize_client(api_key)
-            # Add user message to conversation history
-            self._add_to_history("user", message)
-            ai_response = self._get_ai_response()
-            self._add_to_history("assistant", ai_response)
-            # Extract new info from the full conversation
-            new_info = self._extract_resume_information(text=message + "\n" + ai_response)
-            # Update the conversation state
-            for info_item in new_info:
-                self.state.add_extracted_info(info_item)
             self._update_completion_status()
             return {
                 "response": ai_response,
-                "extracted_info": [
-                    {
-                        "text": info.text,
-                        "category": info.category,
-                        "confidence": info.confidence
                     }
-                    for info in new_info
-                ],
-                "completion_status": {
-                    "percentage": self.state.completion_percentage,
-                    "categories_covered": self.state.categories_covered,
-                    "current_focus": self.state.current_focus
                 },
-                "analysis_text": (
-                    "Successfully extracted new information."
-                    if new_info else
-                    "No new information extracted."
-                ),
-                "history_message": f"Added user message '{message}' and assistant response to history."
             }
         except Exception as e:
-            error_msg = f"Error processing message: {str(e)}"
-            logger.error(error_msg)
-            self.state.last_error = error_msg
             return {
-                "response": "",
-                "extracted_info": [],
-                "completion_status": {
-                    "percentage": self.state.completion_percentage,
-                    "categories_covered": self.state.categories_covered,
-                    "current_focus": self.state.current_focus
-                },
-                "analysis_text": error_msg,
-                "history_message": "(Processing failed)"
             }
-    def generate_output(self) -> Dict[str, Any]:
-        """
-        Generate structured JSON output containing all extracted information,
-        store it in a file, and return the file name and content.
-        Returns:
-            A dict with fields: filename, content, and status.
-        """
         try:
-            categorized_info = {}
-            for category in self.extraction_categories:
-                items_in_cat = [
-                    {
-                        "text": item.text,
-                        "confidence": item.confidence,
-                        "timestamp": item.timestamp.isoformat(),
-                        "metadata": item.metadata
                     }
-                    for item in self.state.extracted_items
-                    if item.category == category
-                ]
-                if items_in_cat:
-                    categorized_info[category] = items_in_cat
-            output = {
-                "extracted_information": categorized_info,
-                "analysis_summary": {
-                    "total_items": len(self.state.extracted_items),
-                    "categories_covered": self.state.categories_covered,
-                    "completion_percentage": self.state.completion_percentage
                 },
                 "metadata": {
                     "generated_at": datetime.now().isoformat(),
-                    "conversation_length": len(self.conversation_history),
-                    "version": "2.0"
                 }
             }
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            filename = f"extracted_info_{timestamp}.json"
-            # Use a context manager for safe file operations
             with open(filename, 'w', encoding='utf-8') as f:
-                json.dump(output, f, indent=2, ensure_ascii=False)
             return {
                 "filename": filename,
-                "content": output,
                 "status": "success"
             }
         except Exception as e:
-            error_msg = f"Error generating output: {str(e)}"
-            logger.error(error_msg)
             return {
-                "error": error_msg,
                 "status": "error"
             }
 def create_gradio_interface() -> gr.Blocks:
-    """
-    Create the Gradio interface for the InformationExtractor.
-    Returns:
-        The gradio Blocks application interface object.
-    """
-    extractor = InformationExtractor()
-    css = """
-    .container { max-width: 900px; margin: auto; }
-    .message { padding: 1rem; margin: 0.5rem 0; border-radius: 0.5rem; }
-    .info-panel { background: #f5f5f5; padding: 1rem; border-radius: 0.5rem; }
-    .status-badge {
-        display: inline-block;
-        padding: 0.25rem 0.5rem;
-        border-radius: 0.25rem;
-        margin: 0.25rem;
-        background: #e0e0e0;
-    }
-    .extraction-highlight {
-        background: #e8f4f8;
-        border-left: 4px solid #4a90e2;
-        padding: 0.5rem;
-        margin: 0.5rem 0;
-    }
-    """
-    with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🔍 Information Extraction Assistant\n")
         with gr.Row():
             with gr.Column(scale=2):
                 api_key = gr.Textbox(
@@ -435,212 +537,89 @@ def create_gradio_interface() -> gr.Blocks:
                     type="password",
                     placeholder="Enter your OpenAI API key (sk-...)"
                 )
                 chatbot = gr.Chatbot(
                     label="Conversation",
-                    value=[],
                     height=400
                 )
                 with gr.Row():
                     msg = gr.Textbox(
                         label="Message",
-                        placeholder="Type your message here..."
                     )
-                    submit = gr.Button("Send", variant="primary")
-                with gr.Row():
-                    clear = gr.Button("Clear Chat")
-                    generate = gr.Button("Generate Report", variant="secondary")
             with gr.Column(scale=1):
-                with gr.Group():
-                    gr.Markdown("### Extraction Progress")
-                    progress = gr.Slider(
-                        label="Completion",
-                        minimum=0,
-                        maximum=100,
-                        value=0,
-                        interactive=False
-                    )
-                    categories_covered = gr.JSON(label="Categories Covered", value={})
-                    current_focus = gr.Textbox(
-                        label="Current Focus",
-                        value="Not started",
-                        interactive=False
-                    )
-                with gr.Tabs() as result_tabs:
-                    with gr.Tab("Extracted Information"):
-                        extracted_info = gr.JSON(label="Extracted Details", value={})
-                    with gr.Tab("Download"):
-                        file_output = gr.File(label="Download Report")
-                    with gr.Tab("Analysis"):
-                        analysis_text = gr.Markdown("Analysis will appear here after processing.")
-        def format_extraction_summary(extracted_items_list: List[Dict[str, Any]]) -> str:
-            """
-            Utility function to format extracted data for user-friendly display.
-            Args:
-                extracted_items_list: List of dictionaries with 'category', 'confidence', and 'text'.
-            Returns:
-                A string summary of the extracted items.
-            """
-            if not extracted_items_list:
-                return "No information extracted yet."
-            lines = ["### Recently Extracted Information"]
-            for itm in extracted_items_list:
-                lines.append(
-                    f"- **{itm['category']}** ({itm['confidence']*100:.1f}% confidence)\n"
-                    f"  {itm['text']}"
-                )
-            return "\n".join(lines)
-        def process_message(user_input: str, history: List[Dict[str, str]], key: str) -> Tuple[Any, float, Dict[str, Any], str, str]:
-            """
-            Event handler to process a user message. Returns a 5-element tuple matching the
-            outputs: (new_chat_history, progress_value, categories_json, focus_text, analysis_message).
-            Args:
-                user_input: The current user message.
-                history: The existing chat history.
-                key: The user's OpenAI API key.
-            Returns:
-                A tuple with updated chatbot messages, progress, categories_covered, current_focus, and analysis text.
-            """
-            result = extractor.process_message(user_input, key)
-            # Update chat history: append the user message + assistant response
-            history.append({"role": "user", "content": user_input})
-            history.append({"role": "assistant", "content": result["response"]})
-            # Update progress
-            prog_val = result["completion_status"]["percentage"]
-            cat_cov = {"categories": result["completion_status"]["categories_covered"]}
-            focus_val = result["completion_status"]["current_focus"] or "Not specified"
-            # If we have newly extracted info, let's show it
-            extract_list = result.get("extracted_info", [])
-            if extract_list:
-                analysis = format_extraction_summary(extract_list)
-            else:
-                analysis = result["analysis_text"]
-            return history, prog_val, cat_cov, focus_val, analysis
-        def generate_report() -> Tuple[Optional[str], Dict[str, Any], str, str]:
-            """
-            Generate a JSON report of extracted resume info.
-            Returns:
-                A tuple of: (filename, extracted_json, focus_message, analysis_text).
-            """
-            gen_result = extractor.generate_output()
-            if gen_result["status"] == "success":
-                filename = gen_result["filename"]
-                content = gen_result["content"]
-                # Summarize categories, etc. for user
-                content_preview = {
-                    "summary": content["analysis_summary"],
-                    "categories": list(content["extracted_information"].keys()),
-                    "total_items": len(content["extracted_information"])
-                }
-                # Flatten everything for a final analysis string
-                flat_items = []
-                for cat_key, cat_items in content["extracted_information"].items():
-                    for item_data in cat_items:
-                        flat_items.append({
-                            "category": cat_key,
-                            "confidence": item_data["confidence"],
-                            "text": item_data["text"]
-                        })
-                final_analysis = format_extraction_summary(flat_items)
-                return filename, content_preview, "Report generated successfully!", final_analysis
-            else:
-                return None, {"error": gen_result["error"]}, "Error generating report.", "No analysis."
-        def clear_interface() -> Tuple[List[Dict[str, str]], float, Dict[str, Any], str, Dict[str, Any], None, str, str]:
-            """
-            Reset all UI components to their initial state.
-            Returns:
-                A tuple specifying the reset states of:
-                - Chatbot
-                - Progress
-                - Categories
-                - Current Focus
-                - Extracted Info
-                - File Output
-                - Analysis
-                - Message Box
-            """
-            # Re-instantiate the extractor to clear its internal state
-            global extractor
-            extractor = InformationExtractor()
-            return [], 0.0, {"categories": []}, "Not started", {}, None, "Ready to start new extraction.", ""
         # Bind events
         msg.submit(
-            fn=process_message,
             inputs=[msg, chatbot, api_key],
-            outputs=[chatbot, progress, categories_covered, current_focus, analysis_text]
-        ).then(lambda: "", None, msg)
-        submit.click(
-            fn=process_message,
             inputs=[msg, chatbot, api_key],
-            outputs=[chatbot, progress, categories_covered, current_focus, analysis_text]
         ).then(lambda: "", None, msg)
-        generate.click(
-            fn=generate_report,
-            outputs=[file_output, extracted_info, current_focus, analysis_text]
-        )
-        clear.click(
-            fn=clear_interface,
-            outputs=[
-                chatbot,
-                progress,
-                categories_covered,
-                current_focus,
-                extracted_info,
-                file_output,
-                analysis_text,
-                msg
-            ]
         )
     return demo
-def main() -> None:
-    """
-    Main function to launch the Gradio application on port 7860, with share=True.
-    """
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
-    demo_app = create_gradio_interface()
-    try:
-        demo_app.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=True,
-            show_api=False
-        )
-    except Exception as e:
-        logger.error(f"Application failed to start: {str(e)}")
 if __name__ == "__main__":
-    main()

 from typing import Dict, List, Optional, Any, Tuple
 from dataclasses import dataclass, field
+import openai
 import gradio as gr
+# 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')
     ]
 )
 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)
+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()
+    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)
     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
+    async def _extract_information(self) -> Dict[str, ProfileSection]:
+        """Extract structured information from the conversation history."""
+        try:
+            # Prepare conversation context
+            conversation_text = "\n".join(
+                f"{msg['role']}: {msg['content']}"
+                for msg in self.state.conversation_history
+            )
+            messages = [
+                {"role": "system", "content": EXTRACTION_PROMPT},
+                {"role": "user", "content": f"Extract professional profile information from this conversation:\n\n{conversation_text}"}
             ]
+            response = await openai.ChatCompletion.acreate(
+                model="gpt-4",
+                messages=messages,
                 temperature=0.3,
+                max_tokens=2000
+            )
+            # 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})
+            # 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:
+            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()
                 },
                 "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
                 }
             }
+            # Save profile 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)
+            self.logger.info(f"Generated profile saved to {filename}")
             return {
+                "profile": profile,
                 "filename": filename,
                 "status": "success"
             }
         except Exception as e:
+            self.logger.error(f"Error generating profile: {str(e)}")
             return {
+                "error": str(e),
                 "status": "error"
             }
 def create_gradio_interface() -> gr.Blocks:
+    """Create the Gradio interface for the profile builder."""
+    builder = ProfileBuilder()
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🐕 LOSS DOG - Professional Profile Builder")
         with gr.Row():
             with gr.Column(scale=2):
                 api_key = gr.Textbox(
                     type="password",
                     placeholder="Enter your OpenAI API key (sk-...)"
                 )
                 chatbot = gr.Chatbot(
                     label="Conversation",
                     height=400
                 )
                 with gr.Row():
                     msg = gr.Textbox(
                         label="Message",
+                        placeholder="Chat with LOSS DOG..."
                     )
+                    send = gr.Button("Send", variant="primary")
             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")
+                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]:
+            if not message.strip():
+                return history, None, None, None
+            result = await builder.process_message(message, key)
+            if "error" in result:
+                return history, None, None, {"error": result["error"]}
+            history = history + [[message, result["response"]]]
+            return (
+                history,
+                result["extracted_sections"],
+                result["completion_status"],
+                result["missing_information"]
+            )
+        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
         # 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
+        send.click(
+            on_message,
             inputs=[msg, chatbot, api_key],
+            outputs=[chatbot, extracted_info, completion, missing]
         ).then(lambda: "", None, msg)
+        generate_btn.click(
+            on_generate,
+            outputs=[profile_output, download_btn]
         )
     return demo
 if __name__ == "__main__":
+    demo = create_gradio_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )