inital_mvp

adjuster_dashboard.py

@@ -0,0 +1,81 @@
+import gradio as gr
+from utils import get_mock_claims
+
+class AdjusterDashboard:
+    def __init__(self):
+        self.claims = get_mock_claims()
+
+    def get_claims_data(self):
+        """Formats claims for the dataframe."""
+        return [[c["id"], c["submitter"], c["date"], c["vehicle"], c["status"], c["ai_analysis"]["fraud_risk"], c["ai_analysis"].get("adjuster_classification", "Junior Adjuster")] for c in self.claims]
+
+    def get_claim_details(self, evt: gr.SelectData):
+        """
+        Returns details for a selected claim.
+        Args:
+            evt: The selection event from the dataframe.
+        """
+        # Get the row index selected
+        index = evt.index[0]
+        if index < len(self.claims):
+            claim = self.claims[index]
+            analysis = claim["ai_analysis"]
+            
+            details_md = f"""
+            ### Claim Details: {claim['id']}
+            **Submitter:** {claim['submitter']}
+            **Vehicle:** {claim['vehicle']}
+            **Date:** {claim['date']}
+            
+            ---
+            ### AI Analysis
+            *   **Damage Estimate:** {analysis['damage_estimate']}
+            *   **Fraud Risk:** {analysis['fraud_risk']}
+            *   **Adjuster Classification:** {analysis.get('adjuster_classification', 'Junior Adjuster')}
+            *   **Recommendation:** {analysis['recommendation']}
+            
+            **Summary:**
+            {analysis['summary']}
+            """
+            return details_md, gr.update(interactive=True), gr.update(interactive=True)
+        return "Select a claim to view details.", gr.update(interactive=False), gr.update(interactive=False)
+
+    def add_claim(self, claim_data):
+        """
+        Adds a new claim to the dashboard.
+        Args:
+            claim_data (dict): Extracted claim data.
+        """
+        import datetime
+        new_id = f"CLM-{1000 + len(self.claims) + 1}"
+        new_claim = {
+            "id": new_id,
+            "submitter": claim_data.get("submitter", "Anonymous"),
+            "date": datetime.date.today().strftime("%Y-%m-%d"),
+            "vehicle": claim_data.get("vehicle", "Unknown"),
+            "status": "New",
+            "ai_analysis": {
+                "damage_estimate": claim_data.get("damage_estimate", "N/A"),
+                "fraud_risk": claim_data.get("fraud_risk", "Unknown"),
+                "adjuster_classification": claim_data.get("adjuster_classification", "Junior Adjuster"),
+                "recommendation": claim_data.get("recommendation", "Review"),
+                "summary": claim_data.get("summary", "")
+            }
+        }
+        self.claims.append(new_claim)
+        return self.get_claims_data()
+
+    def approve_claim(self, claim_details_text):
+        # Extract ID from text (simple parsing for MVP)
+        try:
+            claim_id = claim_details_text.split("Claim Details: ")[1].split("\n")[0].strip()
+            return f"Claim {claim_id} Approved. Payment processing initiated."
+        except:
+            return "Error approving claim."
+
+    def escalate_claim(self, claim_details_text):
+        try:
+            claim_id = claim_details_text.split("Claim Details: ")[1].split("\n")[0].strip()
+            return f"Claim {claim_id} Escalated to SIU for investigation."
+        except:
+            return "Error escalating claim."

app.py

@@ -0,0 +1,170 @@
+import gradio as gr
+from claims_agent import ClaimsIntakeAgent
+from adjuster_dashboard import AdjusterDashboard
+from utils import extract_claim_data
+from PIL import Image
+
+# Initialize Agents and Dashboard
+intake_agent = ClaimsIntakeAgent()
+dashboard = AdjusterDashboard()
+
+# --- Claims Intake View Functions ---
+import time
+
+# --- Claims Intake View Functions ---
+def intake_chat(message, image, file, progress=gr.Progress()):
+    # Yield status updates to the output box directly
+    yield "🔄 **Initializing AI Agent...**"
+    progress(0.1, desc="Initializing AI Agent...")
+    time.sleep(0.5) # Simulate init time
+    
+    yield "🔍 **Analyzing Image & Documents...**"
+    progress(0.3, desc="Analyzing Image & Documents...")
+    # If file is provided, it comes as a filepath
+    response = intake_agent.process_claim(message, image, file)
+    
+    yield "💾 **Syncing with Adjuster Dashboard...**"
+    progress(0.7, desc="Syncing with Adjuster Dashboard...")
+    # Sync with Dashboard
+    if response and "Error" not in response:
+        try:
+            claim_data = extract_claim_data(response)
+            # Update the dashboard data
+            # Note: In a real app with concurrent users, this needs better state management.
+            # Here we update the global dashboard object.
+            dashboard.add_claim(claim_data)
+        except Exception as e:
+            print(f"Error syncing to dashboard: {e}")
+            
+    progress(1.0, desc="Assessment Complete!")
+    yield response
+
+# --- Adjuster Auth Functions ---
+def check_password(password):
+    if password == "password":
+        return gr.update(visible=False), gr.update(visible=True)
+    return gr.update(visible=True), gr.update(visible=False)
+
+# --- UI Construction ---
+custom_css = """
+#main_container {
+    max-width: 1000px;
+    margin: 0 auto;
+    padding: 20px;
+    background-color: white;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    border-radius: 10px;
+    margin-top: 20px;
+}
+body {
+    background-color: #f0f2f5;
+}
+h1 {
+    text-align: center;
+    color: #2c3e50;
+    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+}
+"""
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="slate"), title="EMA Claims MVP", css=custom_css) as demo:
+    with gr.Column(elem_id="main_container"):
+        gr.Markdown("# 🛡️ EMA Claims MVP")
+        
+        with gr.Tabs():
+            # Tab 1: Customer View (Claims Intake)
+            with gr.Tab("🚗 Claims Intake (Customer)"):
+                gr.Markdown("### Report an Accident")
+                gr.Markdown("Upload a photo of the damage and any relevant documents (PDF/Doc). Our AI will assess it immediately.")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        image_input = gr.Image(type="pil", label="Upload Damage Photo")
+                        file_input = gr.File(label="Upload Documents (PDF/Doc)", file_types=[".pdf", ".docx", ".txt"])
+                        msg_input = gr.Textbox(placeholder="Describe the accident...", label="Description")
+                        submit_btn = gr.Button("Submit Claim", variant="primary")
+                    
+                    with gr.Column(scale=1):
+                        chat_output = gr.Markdown(label="AI Assessment")
+                
+                # We need to update the claims table if it's visible, but since it's in another tab, 
+                # we can rely on the global dashboard object being updated. 
+                # However, Gradio components need an event to refresh.
+                # For MVP, we'll just update the global list. The table in the other tab won't auto-refresh 
+                # without a trigger, but we can add a "Refresh" button or make the table update on tab select (harder in simple Blocks).
+                # Let's add a "Refresh" button to the dashboard.
+                
+                submit_btn.click(
+                    fn=intake_chat,
+                    inputs=[msg_input, image_input, file_input], 
+                    outputs=[chat_output],
+                    show_progress=True
+                )
+
+            # Tab 2: Adjuster View (Dashboard)
+            with gr.Tab("👨‍💼 Adjuster Dashboard (Internal)"):
+                
+                # Login State
+                with gr.Group(visible=True) as login_group:
+                    gr.Markdown("### Internal Access Only")
+                    password_input = gr.Textbox(label="Password", type="password")
+                    login_btn = gr.Button("Login")
+                
+                # Dashboard Content (Hidden by default)
+                with gr.Group(visible=False) as dashboard_group:
+                    gr.Markdown("### Incoming Claims Queue")
+                    refresh_btn = gr.Button("Refresh List", size="sm")
+                    
+                    with gr.Row():
+                        with gr.Column(scale=2):
+                            # Dataframe for claims list
+                            claims_df = gr.Dataframe(
+                                headers=["ID", "Submitter", "Date", "Vehicle", "Status", "Fraud Risk", "Classification"],
+                                value=dashboard.get_claims_data, # Pass method to call on load/refresh
+                                interactive=False,
+                                label="Active Claims",
+                                elem_id="claims_table"
+                            )
+                        
+                        with gr.Column(scale=1):
+                            # Details Panel
+                            details_panel = gr.Markdown("Select a claim to view details.", label="Claim Analysis")
+                            with gr.Row():
+                                approve_btn = gr.Button("Approve Payment", variant="primary", interactive=False)
+                                escalate_btn = gr.Button("Escalate to SIU", variant="stop", interactive=False)
+                            
+                            action_output = gr.Label(label="Action Status")
+
+                    # Interactions
+                    claims_df.select(
+                        fn=dashboard.get_claim_details,
+                        inputs=None,
+                        outputs=[details_panel, approve_btn, escalate_btn]
+                    )
+                    
+                    approve_btn.click(
+                        fn=dashboard.approve_claim,
+                        inputs=[details_panel],
+                        outputs=[action_output]
+                    )
+                    
+                    escalate_btn.click(
+                        fn=dashboard.escalate_claim,
+                        inputs=[details_panel],
+                        outputs=[action_output]
+                    )
+                    
+                    refresh_btn.click(
+                        fn=lambda: dashboard.get_claims_data(),
+                        inputs=None,
+                        outputs=[claims_df]
+                    )
+
+                login_btn.click(
+                    fn=check_password,
+                    inputs=[password_input],
+                    outputs=[login_group, dashboard_group]
+                )
+
+if __name__ == "__main__":
+    demo.queue()
+    demo.launch()

claims_agent.py

@@ -0,0 +1,79 @@
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+from PIL import Image
+
+load_dotenv()
+
+class ClaimsIntakeAgent:
+    def __init__(self):
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            print("Warning: GEMINI_API_KEY not found in environment variables.")
+        else:
+            genai.configure(api_key=api_key)
+            self.model = genai.GenerativeModel('gemini-2.5-flash')
+
+    def process_claim(self, user_input, image=None, document_path=None):
+        """
+        Processes a user claim report.
+        Args:
+            user_input (str): The user's description of the accident.
+            image (PIL.Image): Optional image of the damage.
+            document_path (str): Optional path to a uploaded document (PDF/Doc).
+        Returns:
+            str: The agent's response.
+        """
+        if not hasattr(self, 'model'):
+             return "Error: Gemini API key not configured. Please check your .env file."
+
+        from utils import convert_doc_to_markdown
+        doc_content = ""
+        if document_path:
+            doc_content = convert_doc_to_markdown(document_path)
+            doc_content = f"\n\n**Uploaded Document Content:**\n{doc_content}\n"
+
+        prompt = f"""
+        You are an AI assistant for an auto insurance company. Your goal is to help users report vehicle claims and provide a preliminary assessment for the back-office.
+        Analyze the user's input, any provided images, and any uploaded document content.
+        
+        If an image is provided, estimate the damage severity and cost (in GBP) based on visual inspection.
+        Extract vehicle information if possible.
+        Analyze the text and documents for consistency and potential fraud indicators.
+        
+        **Uploaded Document Content:**
+        {doc_content}
+        
+        Return a structured response in the following format:
+        
+        **Claim Assessment**
+        *   **Submitter Name:** [Name if found in text/docs, else 'Anonymous']
+        *   **Vehicle:** [Vehicle Make/Model/Year if identifiable, else 'Unknown']
+        *   **Damage Severity:** [Minor/Moderate/Severe]
+        *   **Estimated Repair Cost:** [Amount in £]
+        *   **Fraud Risk:** [Low/Medium/High] - [Brief reason]
+        *   **Adjuster Classification:** [Junior Adjuster/Senior Adjuster] (Route complex/high-risk/high-value >£5000 claims to Senior)
+        *   **Policy Check:** Coverage appears valid (Simulated).
+        *   **Summary:** [Concise summary of the incident and findings]
+        *   **Next Steps:** [Brief instruction to user]
+        
+        If no image is provided, ask the user to upload one for a better assessment, but still acknowledge the report.
+        """
+        
+        try:
+            inputs = [prompt, user_input]
+            if image:
+                inputs.append(image)
+            
+            response = self.model.generate_content(inputs)
+            return response.text
+        except Exception as e:
+            return f"Error processing claim: {str(e)}"
+
+    def analyze_document(self, file_path):
+        """
+        Analyzes an uploaded document (PDF/Image) for claim info.
+        For MVP, this handles images primarily, but could be expanded for PDFs.
+        """
+        # Placeholder for document analysis logic using Gemini
+        return "Document received. Analysis feature is in beta (MVP)."

test_agent.py

@@ -0,0 +1,19 @@
+from claims_agent import ClaimsIntakeAgent
+import os
+
+def test_agent():
+    print("Testing ClaimsIntakeAgent...")
+    agent = ClaimsIntakeAgent()
+    
+    # Check if API key is set
+    if not os.getenv("GEMINI_API_KEY") or os.getenv("GEMINI_API_KEY") == "your_api_key_here":
+        print("Skipping live API test: GEMINI_API_KEY not set.")
+        return
+
+    # Test with text only
+    response = agent.process_claim("I scratched my bumper backing into a pole.")
+    print("\nResponse to text input:")
+    print(response)
+
+if __name__ == "__main__":
+    test_agent()

test_doc_conversion.py

@@ -0,0 +1,25 @@
+from utils import convert_doc_to_markdown
+import os
+
+def test_conversion():
+    # Create a dummy text file to test conversion (since we don't have a PDF handy easily without downloading)
+    # MarkItDown handles text files too.
+    dummy_file = "test_doc.txt"
+    with open(dummy_file, "w") as f:
+        f.write("This is a test document for claims processing.\nRepair estimate: £500.\n")
+    
+    print(f"Testing conversion of {dummy_file}...")
+    content = convert_doc_to_markdown(dummy_file)
+    print("Converted Content:")
+    print(content)
+    
+    if "Repair estimate: £500" in content:
+        print("SUCCESS: Content extracted correctly.")
+    else:
+        print("FAILURE: Content not extracted.")
+
+    # Clean up
+    os.remove(dummy_file)
+
+if __name__ == "__main__":
+    test_conversion()

utils.py

@@ -0,0 +1,129 @@
+import base64
+from io import BytesIO
+from PIL import Image
+from markitdown import MarkItDown
+
+def encode_image_to_base64(image):
+    """Encodes a PIL Image to a base64 string."""
+    if isinstance(image, str):
+        # If it's a file path
+        with open(image, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode('utf-8')
+    elif isinstance(image, Image.Image):
+        buffered = BytesIO()
+        image.save(buffered, format="JPEG")
+        return base64.b64encode(buffered.getvalue()).decode('utf-8')
+    return None
+
+def convert_doc_to_markdown(file_path):
+    """Converts a document (PDF, Docx, etc.) to markdown."""
+    if not file_path:
+        return ""
+    try:
+        md = MarkItDown()
+        result = md.convert(file_path)
+        return result.text_content
+    except Exception as e:
+        return f"Error converting document: {str(e)}"
+
+def get_mock_claims():
+    """Returns a list of mock claims for the dashboard."""
+    return [
+        {
+            "id": "CLM-1001",
+            "submitter": "John Doe",
+            "date": "2023-10-25",
+            "vehicle": "2018 Toyota Camry",
+            "status": "New",
+            "ai_analysis": {
+                "damage_estimate": "£820",
+                "fraud_risk": "Low",
+                "adjuster_classification": "Junior Adjuster",
+                "recommendation": "Auto-approve payment",
+                "summary": "Minor rear bumper damage. Policy active. No suspicious indicators."
+            }
+        },
+        {
+            "id": "CLM-1002",
+            "submitter": "Jane Smith",
+            "date": "2023-10-24",
+            "vehicle": "2022 Tesla Model 3",
+            "status": "Under Review",
+            "ai_analysis": {
+                "damage_estimate": "£15,000",
+                "fraud_risk": "High",
+                "adjuster_classification": "Senior Adjuster",
+                "recommendation": "Escalate to SIU",
+                "summary": "Severe front-end collision. Multiple vehicles involved. Discrepancy in accident location report."
+            }
+        },
+        {
+            "id": "CLM-1003",
+            "submitter": "Robert Brown",
+            "date": "2023-10-26",
+            "vehicle": "2015 Ford Focus",
+            "status": "New",
+            "ai_analysis": {
+                "damage_estimate": "£1,200",
+                "fraud_risk": "Low",
+                "adjuster_classification": "Junior Adjuster",
+                "recommendation": "Review Further",
+                "summary": "Side panel scratch and dent. consistent with description. Higher than average repair cost for model."
+            }
+        }
+    ]
+
+def extract_claim_data(text):
+    """
+    Extracts structured data from the AI's markdown response.
+    Returns a dictionary with keys: vehicle, damage_estimate, fraud_risk, adjuster_classification, summary, recommendation.
+    """
+    import re
+    data = {
+        "submitter": "Anonymous",
+        "vehicle": "Unknown",
+        "damage_estimate": "N/A",
+        "fraud_risk": "Unknown",
+        "adjuster_classification": "Junior Adjuster",
+        "recommendation": "Review",
+        "summary": "Auto-generated summary from intake."
+    }
+    
+    # Simple regex extraction based on the prompt format
+    # *   **Submitter Name:** [Name]
+    name_match = re.search(r"\*\*Submitter Name:\*\*\s*(.*)", text)
+    if name_match:
+        data["submitter"] = name_match.group(1).strip()
+
+    # *   **Vehicle:** [Vehicle Make/Model/Year if identifiable, else 'Unknown']
+    vehicle_match = re.search(r"\*\*Vehicle:\*\*\s*(.*)", text)
+    if vehicle_match:
+        data["vehicle"] = vehicle_match.group(1).strip()
+
+    estimate_match = re.search(r"\*\*Estimated Repair Cost:\*\*\s*(.*)", text)
+    if estimate_match:
+        data["damage_estimate"] = estimate_match.group(1).strip()
+
+    fraud_match = re.search(r"\*\*Fraud Risk:\*\*\s*(.*)", text)
+    if fraud_match:
+        data["fraud_risk"] = fraud_match.group(1).strip()
+
+    class_match = re.search(r"\*\*Adjuster Classification:\*\*\s*(.*)", text)
+    if class_match:
+        data["adjuster_classification"] = class_match.group(1).strip()
+        
+    summary_match = re.search(r"\*\*Summary:\*\*\s*(.*)", text)
+    if summary_match:
+        data["summary"] = summary_match.group(1).strip()
+    else:
+        # Fallback: use the first few lines or the whole text if summary not found explicitly
+        data["summary"] = text[:200] + "..."
+
+    # Infer recommendation based on classification/risk if not explicitly parsed (or add prompt for it)
+    # For now, let's look for "Next Steps" or just default based on risk
+    if "High" in data["fraud_risk"]:
+        data["recommendation"] = "Escalate to SIU"
+    elif "Low" in data["fraud_risk"] and "Junior" in data["adjuster_classification"]:
+        data["recommendation"] = "Auto-approve payment"
+    
+    return data