first commit

.dockerignore

@@ -0,0 +1,93 @@
+extra.md
+scraped_files.md
+scrape.py
+
+# Git
+.git
+.gitignore
+.gitattributes
+
+
+# CI
+.codeclimate.yml
+.travis.yml
+.taskcluster.yml
+
+# Docker
+docker-compose.yml
+Dockerfile
+.docker
+.dockerignore
+
+# Byte-compiled / optimized / DLL files
+**/__pycache__/
+**/*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Virtual environment
+.env
+.venv/
+venv/
+
+# PyCharm
+.idea
+
+# Python mode for VIM
+.ropeproject
+**/.ropeproject
+
+# Vim swap files
+**/*.swp
+
+# VS Code
+.vscode/

.env.example

@@ -0,0 +1,7 @@
+# API Keys
+GOOGLE_API_KEY=your_google_api_key_here
+
+# App Settings
+DATABASE_URL=sqlite:///./disputes.db
+API_URL=http://localhost:8000
+DEBUG=True

.gitignore

@@ -0,0 +1,178 @@
+extra.md
+scraped_files.md
+scrape.py
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENV PYTHONPATH=/app
+
+CMD ["python", "app/entrypoint.py"]

README.md

@@ -1,11 +1,33 @@
----
-title: AI Financial Dispute Automation
-emoji: 👁
-colorFrom: red
-colorTo: yellow
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Banking Dispute Resolution System
+
+A prototype system for handling banking disputes with AI-powered insights and priority assignment.
+
+## Features
+
+- AI-powered dispute analysis and priority assignment
+- Streamlit-based user interface for customer service representatives
+- FastAPI backend with SQLite database
+- Deployed on Hugging Face Spaces
+
+## Setup
+
+1. Clone this repository
+2. Install dependencies: \pip install -r requirements.txt\
+3. Set up environment variables (see \.env.example\)
+4. Run the application: \python app/entrypoint.py\
+
+## Docker
+
+To run with Docker:
+
+\\\
+docker build -t banking-disputes .
+docker run -p 8501:8501 -p 8000:8000 banking-disputes
+\\\
+
+## Development
+
+All code is in the \pp\ directory:
+- \pi/\ - FastAPI backend
+- \i/\ - AI services using Langchain and Gemini
+- \rontend/\ - Streamlit UI components

Space.yaml

@@ -0,0 +1,6 @@
+title: Banking Dispute Resolution System
+emoji: ??
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false

app/ai/dispute_analyzer.py

@@ -0,0 +1,151 @@
+# app/ai/dispute_analyzer.py
+from typing import Dict, Any, List, Tuple
+import json
+from datetime import datetime, timedelta
+
+from app.ai.langchain_service import DisputeAIService
+from app.core.ai_config import ai_settings
+
+
+class DisputeAnalyzer:
+    """Class for analyzing banking disputes using AI and rule-based approaches"""
+
+    def __init__(self):
+        self.ai_service = DisputeAIService()
+
+    def analyze_dispute(self, dispute_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Comprehensive analysis of a dispute combining AI and rule-based approaches
+
+        Returns:
+            Dict with analysis results including priority, risk score, insights,
+            recommended actions, etc.
+        """
+        # Get AI analysis
+        ai_analysis = self.ai_service.analyze_dispute(dispute_data)
+
+        # Add rule-based risk scoring
+        risk_score, risk_factors = self._calculate_risk_score(dispute_data)
+
+        # Add recommended next actions
+        recommended_actions = self._generate_recommended_actions(
+            dispute_data, ai_analysis, risk_score
+        )
+
+        # Combine all analysis
+        return {
+            **ai_analysis,
+            "risk_score": risk_score,
+            "risk_factors": risk_factors,
+            "recommended_actions": recommended_actions,
+            "sla_target": self._calculate_sla_target(
+                dispute_data, ai_analysis["priority"]
+            ),
+            "similar_cases_count": 0,  # Placeholder for future implementation
+        }
+
+    def _calculate_risk_score(
+        self, dispute_data: Dict[str, Any]
+    ) -> Tuple[float, List[str]]:
+        """Calculate a risk score (0-100) based on dispute characteristics"""
+        risk_factors = []
+        score = 50
+
+        # Transaction amount risk
+        amount = dispute_data.get("transaction_amount", 0)
+        if amount > 10000:
+            score += 25
+            risk_factors.append("High transaction amount (>$10k)")
+        elif amount > 5000:
+            score += 15
+            risk_factors.append("Medium-high transaction amount (>$5k)")
+        elif amount > 1000:
+            score += 5
+            risk_factors.append("Moderate transaction amount (>$1k)")
+
+        # Customer history risk
+        previous_disputes = dispute_data.get("previous_disputes_count", 0)
+        if previous_disputes > 5:
+            score += 20
+            risk_factors.append("Frequent disputer (>5 disputes)")
+        elif previous_disputes > 2:
+            score += 10
+            risk_factors.append("Multiple previous disputes (>2)")
+
+        # Account age risk
+        account_age = dispute_data.get("customer_account_age_days", 0)
+        if account_age < 30:
+            score += 15
+            risk_factors.append("New account (<30 days)")
+        elif account_age < 365:
+            score += 5
+            risk_factors.append("Relatively new account (<1 year)")
+
+        # Category risk
+        category = dispute_data.get("category", "").lower()
+        if "fraud" in category:
+            score += 30
+            risk_factors.append("Fraud-related category")
+        elif "unauthorized" in category:
+            score += 20
+            risk_factors.append("Unauthorized transaction")
+
+        # Document status
+        if not dispute_data.get("has_supporting_documents"):
+            score += 10
+            risk_factors.append("Missing supporting documents")
+
+        # Cap score between 0-100
+        score = max(0, min(100, score))
+
+        return round(score, 2), risk_factors
+
+    def _generate_recommended_actions(
+        self,
+        dispute_data: Dict[str, Any],
+        ai_analysis: Dict[str, Any],
+        risk_score: float,
+    ) -> List[str]:
+        """Generate recommended actions based on analysis results"""
+        actions = []
+
+        # High priority actions
+        if ai_analysis["priority"] >= 4:
+            actions.extend(
+                [
+                    "Escalate to senior analyst",
+                    "Request urgent documentation",
+                    "Initiate fraud investigation",
+                ]
+            )
+
+        # Medium priority actions
+        elif ai_analysis["priority"] >= 3:
+            actions.extend(
+                [
+                    "Schedule customer interview",
+                    "Verify transaction details with merchant",
+                    "Review account history",
+                ]
+            )
+
+        # General actions based on risk
+        if risk_score > 70:
+            actions.append("Flag account for enhanced monitoring")
+        if risk_score > 80:
+            actions.append("Notify compliance department")
+
+        # Add AI recommendations
+        actions.extend(ai_analysis.get("probable_solutions", []))
+
+        return list(set(actions))[:5]  # Return top 5 unique actions
+
+    def _calculate_sla_target(
+        self, dispute_data: Dict[str, Any], priority: int
+    ) -> datetime:
+        """Calculate SLA target date based on priority"""
+        base_date = datetime.utcnow()
+
+        sla_days = {1: 14, 2: 10, 3: 7, 4: 3, 5: 1}
+
+        return base_date + timedelta(days=sla_days.get(priority, 14))

app/ai/langchain_service.py

@@ -0,0 +1,132 @@
+# app/ai/langchain_service.py
+from langchain_google_genai import ChatGoogleGenerativeAI
+import os
+from typing import Dict, Any, List
+import json
+
+from app.ai.schemas.priority_schema import PrioritySchema
+from app.ai.schemas.insights_schema import InsightsSchema
+from app.core.ai_config import ai_settings
+
+
+class DisputeAIService:
+    """Service for AI-powered dispute analysis using Langchain and Gemini"""
+
+    def __init__(self):
+        self.llm = ChatGoogleGenerativeAI(
+            model=ai_settings.GEMINI_MODEL,
+            temperature=ai_settings.TEMPERATURE,
+            max_tokens=ai_settings.MAX_TOKENS,
+            timeout=None,
+            max_retries=ai_settings.MAX_RETRIES,
+            # google_api_key=os.environ.get("GOOGLE_API_KEY", ai_settings.GOOGLE_API_KEY),
+            google_api_key="AIzaSyBeC3D_rxPbaLyQjgeqCB3PZRQL7kT4mrE",
+        )
+
+    def analyze_dispute(self, dispute_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Analyze a dispute and return AI-generated insights
+
+        Returns:
+            Dict with priority, insights, followup_questions,
+            probable_solutions, and possible_reasons
+        """
+        # Get structured output for priority
+        priority_model = self.llm.with_structured_output(PrioritySchema)
+        priority_result = priority_model.invoke(
+            self._build_priority_prompt(dispute_data)
+        )
+
+        print(self._build_priority_prompt(dispute_data))
+        print(type(priority_result))
+        print(priority_result)
+
+        # Get structured output for insights
+        insights_model = self.llm.with_structured_output(InsightsSchema)
+        insights_result = insights_model.invoke(
+            self._build_insights_prompt(dispute_data)
+        )
+
+        print(self._build_insights_prompt(dispute_data))
+        print(type(insights_result))
+        print(insights_result)
+
+        # Combine results
+        return {
+            "priority": (
+                priority_result.priority_level if priority_result.priority_level else 0
+            ),
+            "priority_reason": (
+                priority_result.priority_reason
+                if priority_result.priority_reason
+                else ""
+            ),
+            "insights": insights_result.insights if insights_result.insights else "",
+            "followup_questions": (
+                insights_result.followup_questions
+                if insights_result.followup_questions
+                else ""
+            ),
+            "probable_solutions": (
+                insights_result.probable_solutions
+                if insights_result.probable_solutions
+                else ""
+            ),
+            "possible_reasons": (
+                insights_result.possible_reasons
+                if insights_result.possible_reasons
+                else ""
+            ),
+            "risk_score": (
+                insights_result.risk_score if insights_result.risk_score else 0
+            ),
+            "risk_factors": (
+                insights_result.risk_factors if insights_result.risk_factors else ""
+            ),
+        }
+
+    def _build_priority_prompt(self, dispute_data: Dict[str, Any]) -> str:
+        """Create prompt for priority assignment"""
+        return f"""
+        You are a banking dispute resolution expert. Analyze this dispute and assign a priority level.
+        
+        Customer profile:
+        - Customer name: {dispute_data.get('customer_name')}
+        - Customer type: {dispute_data.get('customer_type')}
+        - Previous disputes: {dispute_data.get('previous_disputes_count')}
+        - Account age (days): {dispute_data.get('customer_account_age_days')}
+        
+        Dispute details:
+        - Transaction amount: ${dispute_data.get('transaction_amount')}
+        - Description: {dispute_data.get('dispute_description')}
+        - Category: {dispute_data.get('category')}
+        - Has supporting documents: {dispute_data.get('has_supporting_documents')}
+        
+        Based on this information, assign a priority level (1-5) where:
+        1 = Very Low, 2 = Low, 3 = Medium, 4 = High, 5 = Critical
+        
+        Provide the priority level and a brief explanation for this decision.
+        """
+
+    def _build_insights_prompt(self, dispute_data: Dict[str, Any]) -> str:
+        """Create prompt for generating insights"""
+        return f"""
+        You are a banking dispute resolution expert. Analyze this dispute and provide insights.
+        
+        Customer profile:
+        - Customer name: {dispute_data.get('customer_name')}
+        - Customer type: {dispute_data.get('customer_type')}
+        - Previous disputes: {dispute_data.get('previous_disputes_count')}
+        
+        Dispute details:
+        - Transaction amount: ${dispute_data.get('transaction_amount')}
+        - Description: {dispute_data.get('dispute_description')}
+        - Category: {dispute_data.get('category')}
+        - Transaction date: {dispute_data.get('transaction_date')}
+        
+        Provide:
+        1. Key insights about this dispute
+        2. Follow-up questions to ask the customer
+        3. Probable solutions to resolve this dispute
+        4. Possible underlying reasons for this dispute
+        """

app/ai/prompts/dispute_insights.py

@@ -0,0 +1,29 @@
+from typing import Dict, Any
+
+# app/ai/prompts/dispute_insights.py
+def get_insights_prompt_template(dispute_data: Dict[str, Any]) -> str:
+    return f"""
+    As a senior dispute analyst, provide detailed insights for this case:
+    
+    Customer Background:
+    - Member since: {dispute_data.get('customer_account_age_days')} days
+    - Past disputes: {dispute_data.get('previous_disputes_count')}
+    - Account type: {dispute_data.get('customer_type')}
+    
+    Transaction Details:
+    - Date: {dispute_data.get('transaction_date')}
+    - Merchant: {dispute_data.get('merchant_name')}
+    - Amount: ${dispute_data.get('transaction_amount')}
+    - Description: {dispute_data.get('dispute_description')}
+    
+    Analysis Requirements:
+    1. Identify 3 key patterns or anomalies
+    2. List 5 relevant follow-up questions for the customer
+    3. Suggest 3 probable resolution paths
+    4. Highlight 2-3 potential systemic issues
+    
+    Format Requirements:
+    - Use bullet points for each section
+    - Avoid markdown formatting
+    - Keep responses concise and actionable
+    """

app/ai/prompts/dispute_priority.py

@@ -0,0 +1,30 @@
+from typing import Dict, Any
+# app/ai/prompts/dispute_priority.py
+def get_priority_prompt_template(dispute_data: Dict[str, Any]) -> str:
+    return f"""
+    You are a banking dispute resolution expert. Analyze this dispute and assign a priority level.
+    
+    Customer Profile:
+    - Name: {dispute_data.get('customer_name')}
+    - Type: {dispute_data.get('customer_type')}
+    - Previous Disputes: {dispute_data.get('previous_disputes_count')}
+    - Account Age: {dispute_data.get('customer_account_age_days')} days
+    
+    Dispute Details:
+    - Amount: ${dispute_data.get('transaction_amount')}
+    - Category: {dispute_data.get('category')}
+    - Description: {dispute_data.get('dispute_description')}
+    - Documents Available: {'Yes' if dispute_data.get('has_supporting_documents') else 'No'}
+    
+    Priority Guidelines:
+    1 (Very Low) - Routine inquiry, low amount, established customer
+    2 (Low) - Minor discrepancy, medium amount
+    3 (Medium) - Significant amount, unclear details
+    4 (High) - Potential fraud indicators, large amount
+    5 (Critical) - Clear fraud pattern, VIP customer, legal implications
+    
+    Required Output:
+    - Priority level (1-5 integer)
+    - Concise reason for priority assignment
+    - Key risk factors identified
+    """

app/ai/prompts/followup_questions.py

@@ -0,0 +1,20 @@
+from typing import Dict, Any
+# app/ai/prompts/followup_questions.py
+def get_followup_prompt_template(dispute_data: Dict[str, Any]) -> str:
+    return f"""
+    Generate targeted follow-up questions for this dispute:
+    
+    Context:
+    - Customer: {dispute_data.get('customer_name')}
+    - Transaction ID: {dispute_data.get('transaction_id')}
+    - Dispute Type: {dispute_data.get('category')}
+    
+    Current Information:
+    {dispute_data.get('dispute_description')}
+    
+    Requirements:
+    - Generate 5-7 specific questions
+    - Prioritize questions that help verify transaction legitimacy
+    - Include questions about timeline, location, and verification methods
+    - Phrase questions in neutral, non-accusatory language
+    """

app/ai/schemas/insights_schema.py

@@ -0,0 +1,30 @@
+# app/ai/schemas/insights_schema.py
+from typing import List
+from pydantic import BaseModel, Field
+
+
+class InsightsSchema(BaseModel):
+    """Schema for dispute insights"""
+
+    insights: str = Field(description="Detailed insights regarding the dispute")
+    followup_questions: List[str] = Field(
+        description="List of relevant follow-up questions to gather more information"
+    )
+    probable_solutions: List[str] = Field(
+        description="Potential solutions to address the dispute"
+    )
+    possible_reasons: List[str] = Field(
+        description="Possible reasons that might have caused the dispute"
+    )
+
+    risk_score: float = Field(
+        description="Risk score for the dispute from 0 (lowest) to 10 (highest)"
+    )
+
+    risk_factors: List[str] = Field(
+        description="3 Factors contributing to the calculated risk score, if low risk, keep empty"
+    )
+
+
+
+

app/ai/schemas/priority_schema.py

@@ -0,0 +1,12 @@
+# app/ai/schemas/priority_schema.py
+from pydantic import BaseModel, Field
+from typing import Literal, Optional
+
+class PrioritySchema(BaseModel):
+    """Schema for priority assignment"""
+    priority_level: int = Field(
+        description="Priority level from 1 (lowest) to 10 (highest)"
+    )
+    priority_reason: str = Field(
+        description="Explanation for the assigned priority level"
+    )

app/api/database.py

@@ -0,0 +1,140 @@
+# app/api/database.py
+from datetime import datetime
+from app.core.config import settings
+from sqlalchemy import (
+    create_engine,
+    Column,
+    Integer,
+    String,
+    Float,
+    ForeignKey,
+    Text,
+    DateTime,
+    Boolean,
+    case,
+    func,
+)
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship, Session
+from sqlalchemy import event
+from sqlite3 import Connection as SQLite3Connection
+import uuid
+
+# Create SQLite engine
+SQLALCHEMY_DATABASE_URL = settings.DATABASE_URL
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
+)
+
+# Create session
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+
+# Database Models
+class Customer(Base):
+    __tablename__ = "customers"
+
+    id = Column(String, primary_key=True, index=True)
+    name = Column(String, index=True)
+    email = Column(String, unique=True, index=True)
+    account_type = Column(String)  # e.g., "Individual", "Business"
+    dispute_count = Column(Integer, default=0)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    # Relationship
+    disputes = relationship("Dispute", back_populates="customer")
+
+
+class Dispute(Base):
+    __tablename__ = "disputes"
+
+    id = Column(String, primary_key=True, index=True)
+    customer_id = Column(String, ForeignKey("customers.id"))
+    transaction_id = Column(String, index=True)
+    merchant_name = Column(String)
+    amount = Column(Float)
+    description = Column(Text)
+    category = Column(String, index=True)  # e.g., "Unauthorized", "Duplicate"
+    status = Column(String, default="Open")  # "Open", "Under Review", "Resolved"
+    priority = Column(Integer, nullable=True)  # 1-5, with 5 being highest priority
+    created_at = Column(DateTime, default=datetime.utcnow)
+    resolved_at = Column(DateTime, nullable=True)
+
+    # Relationship
+    customer = relationship("Customer", back_populates="disputes")
+    notes = relationship("DisputeNote", back_populates="dispute")
+    ai_insights = relationship(
+        "DisputeInsight", back_populates="dispute", uselist=False
+    )
+
+
+class DisputeNote(Base):
+    __tablename__ = "dispute_notes"
+
+    id = Column(String, primary_key=True, index=True)
+    dispute_id = Column(String, ForeignKey("disputes.id"))
+    content = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    # Relationship
+    dispute = relationship("Dispute", back_populates="notes")
+
+
+
+class DisputeInsight(Base):
+    """SQLAlchemy model for dispute insights"""
+
+    __tablename__ = "dispute_insights"
+    __table_args__ = {"extend_existing": True}  # Allows redefining table options
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    dispute_id = Column(
+        String, ForeignKey("disputes.id", ondelete="CASCADE"), nullable=False
+    )
+
+    # Core insight fields
+    insights = Column(String, nullable=False)
+    followup_questions = Column(String, nullable=False)
+    probable_solutions = Column(String, nullable=False)
+    possible_reasons = Column(String, nullable=False)
+
+    # Risk assessment
+    risk_score = Column(Float, nullable=False)
+    risk_factors = Column(String, nullable=False)
+
+    # Priority fields (from your existing model)
+    priority_level = Column(Integer, nullable=False)
+    priority_reason = Column(String, nullable=False)
+
+    # Metadata
+    created_at = Column(DateTime, server_default=func.now())
+    updated_at = Column(DateTime, onupdate=func.now())
+
+    # Relationship
+    dispute = relationship("Dispute", back_populates="ai_insights")
+
+    def __repr__(self):
+        return f"<DisputeInsight(id={self.id}, dispute_id={self.dispute_id})>"
+
+
+# Create all tables
+Base.metadata.create_all(bind=engine)
+
+
+# Add this event listener
+@event.listens_for(engine, "connect")
+def set_sqlite_pragma(dbapi_connection, connection_record):
+    if isinstance(dbapi_connection, SQLite3Connection):
+        cursor = dbapi_connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.close()
+
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/api/models.py

@@ -0,0 +1,171 @@
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field, EmailStr, ConfigDict
+
+# Customer Models
+class CustomerBase(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    name: str
+    email: EmailStr
+    account_type: str = "Individual"
+
+class CustomerCreate(CustomerBase):
+    pass
+
+class Customer(CustomerBase):
+    id: str
+    dispute_count: int = 0
+    created_at: datetime
+    
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+
+# Dispute Models
+class DisputeBase(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    customer_id: str
+    transaction_id: str
+    merchant_name: str
+    amount: float
+    description: str
+    category: str
+
+class DisputeCreate(DisputeBase):
+    pass
+
+class DisputeUpdate(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    status: Optional[str] = None
+    priority: Optional[int] = None
+    description: Optional[str] = None
+
+class Dispute(DisputeBase):
+    id: str
+    status: str
+    priority: Optional[int] = None
+    created_at: datetime
+    resolved_at: Optional[datetime] = None
+    
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+
+class DisputeWithCustomer(Dispute):
+    customer: Customer
+    
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+
+# Note Models
+class NoteCreate(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    content: str
+    dispute_id: str
+
+class Note(NoteCreate):
+    id: str
+    created_at: datetime
+    
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+
+# AI Insight Models
+class FollowupQuestion(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    question: str
+
+class ProbableSolution(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    solution: str
+    confidence: Optional[float] = None
+
+class PossibleReason(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    reason: str
+    confidence: Optional[float] = None
+
+class InsightCreate(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    dispute_id: str
+    priority_level: int
+    priority_reason: str
+    insights: str
+    followup_questions: List[str]
+    probable_solutions: List[str]
+    possible_reasons: List[str]
+
+class Insight(InsightCreate):
+    id: str
+    created_at: datetime
+    
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+
+# AI Analysis Request/Response
+class DisputeAnalysisResponse(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    dispute_id: str
+    analysis: Dict[str, Any]
+
+class DashboardMetrics(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    total_disputes: int
+    high_priority_count: int
+    pending_count: int
+    resolved_today: Optional[int] = None 
+    disputes_by_category: Dict[str, int] = {}
+    disputes_by_status: Dict[str, int] = {}
+    disputes_by_priority: Dict[str, int] = {}
+    average_resolution_time: Optional[str] = None
+
+class Insights(BaseModel):
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+    
+    id: str
+    dispute_id: str
+    insights: str = Field(description="Detailed insights regarding the dispute")
+    followup_questions: List[str] = Field(
+        description="List of relevant follow-up questions to gather more information"
+    )
+    probable_solutions: List[str] = Field(
+        description="Potential solutions to address the dispute"
+    )
+    possible_reasons: List[str] = Field(
+        description="Possible reasons that might have caused the dispute"
+    )
+    risk_score: float = Field(
+        description="Risk score for the dispute from 0 (lowest) to 10 (highest)"
+    )
+    risk_factors: List[str] = Field(
+        description="Factors contributing to the calculated risk score, if low risk, keep empty"
+    )
+    priority_level: int
+    priority_reason: str
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+class InsightsCreate(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    
+    insights: str = Field(description="Detailed insights regarding the dispute")
+    followup_questions: List[str] = Field(
+        description="List of relevant follow-up questions to gather more information"
+    )
+    probable_solutions: List[str] = Field(
+        description="Potential solutions to address the dispute"
+    )
+    possible_reasons: List[str] = Field(
+        description="Possible reasons that might have caused the dispute"
+    )
+    risk_score: float = Field(
+        description="Risk score for the dispute from 0 (lowest) to 10 (highest)"
+    )
+    risk_factors: List[str] = Field(
+        description="Factors contributing to the calculated risk score, if low risk, keep empty"
+    )
+    priority_level: int
+    priority_reason: str

app/api/routes/customers.py

@@ -0,0 +1,181 @@
+# app/api/routes/customers.py
+import uuid
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app.api.database import get_db, Customer
+from app.api.models import Dispute as DisputeModel
+from app.api.database import Dispute as DbDispute
+from app.api.models import CustomerCreate, Customer as CustomerModel
+
+router = APIRouter()
+
+
+@router.post("/", response_model=CustomerModel, status_code=201)
+async def create_customer(customer: CustomerCreate, db: Session = Depends(get_db)):
+    """Create a new customer"""
+    # Check if customer with this email already exists
+    db_customer = db.query(Customer).filter(Customer.email == customer.email).first()
+    if db_customer:
+        raise HTTPException(status_code=400, detail="Email already registered")
+
+    # Create new customer
+    new_customer = Customer(
+        id=str(uuid.uuid4()),
+        name=customer.name,
+        email=customer.email,
+        account_type=customer.account_type,
+    )
+
+    # Add to database
+    db.add(new_customer)
+    db.commit()
+    db.refresh(new_customer)
+
+    # Convert to Pydantic model
+    return CustomerModel.model_validate(new_customer.__dict__)
+
+
+@router.get("/", response_model=List[CustomerModel])
+async def get_customers(
+    db: Session = Depends(get_db),
+    skip: int = 0,
+    limit: int = 100,
+    account_type: str = None,
+):
+    """Get all customers with optional filtering"""
+    query = db.query(Customer)
+
+    # Apply filters
+    if account_type:
+        query = query.filter(Customer.account_type == account_type)
+
+    # Apply pagination
+    customers = query.offset(skip).limit(limit).all()
+
+    # Convert to Pydantic models
+    return [CustomerModel.model_validate(customer.__dict__) for customer in customers]
+
+
+@router.get("/{customer_id}", response_model=CustomerModel)
+async def get_customer(customer_id: str, db: Session = Depends(get_db)):
+    """Get a specific customer"""
+    customer = db.query(Customer).filter(Customer.id == customer_id).first()
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+
+    # Convert to Pydantic model
+    return CustomerModel.model_validate(customer.__dict__)
+
+
+@router.get("/{customer_id}/disputes", response_model=List[DisputeModel])
+async def get_customer_disputes(
+    customer_id: str,
+    db: Session = Depends(get_db),
+    skip: int = 0,
+    limit: int = 100,
+    status: Optional[str] = None,
+):
+    """Get all disputes for a specific customer with filtering"""
+    try:
+        # Check if customer exists
+        customer = db.query(Customer).filter(Customer.id == customer_id).first()
+        if not customer:
+            raise HTTPException(status_code=404, detail="Customer not found")
+
+        # Build query
+        query = db.query(DbDispute).filter(DbDispute.customer_id == customer_id)
+
+        # Apply status filter if provided
+        if status:
+            valid_statuses = ["Open", "Under Review", "Resolved"]
+            if status not in valid_statuses:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Invalid status. Must be one of: {', '.join(valid_statuses)}",
+                )
+            query = query.filter(DbDispute.status == status)
+
+        # Apply sorting and pagination
+        query = query.order_by(DbDispute.created_at.desc())
+
+        # Validate pagination parameters
+        if skip < 0:
+            skip = 0
+        if limit <= 0:
+            limit = 100
+        elif limit > 500:
+            limit = 500
+
+        disputes = query.offset(skip).limit(limit).all()
+
+        # Convert to Pydantic models
+        return [DisputeModel.model_validate(dispute.__dict__) for dispute in disputes]
+    except HTTPException as e:
+        raise e  # Re-raise HTTPExceptions
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        import traceback
+
+        print(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Internal Server Error: {str(e)}")
+
+
+@router.put("/{customer_id}", response_model=CustomerModel)
+async def update_customer(
+    customer_id: str, customer_update: CustomerCreate, db: Session = Depends(get_db)
+):
+    """Update a customer"""
+    customer = db.query(Customer).filter(Customer.id == customer_id).first()
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+
+    # Check if email is being changed and if it's already in use
+    if customer_update.email != customer.email:
+        existing_customer = (
+            db.query(Customer).filter(Customer.email == customer_update.email).first()
+        )
+        if existing_customer:
+            raise HTTPException(status_code=400, detail="Email already registered")
+
+    # Update fields
+    customer.name = customer_update.name
+    customer.email = customer_update.email
+    customer.account_type = customer_update.account_type
+
+    db.commit()
+    db.refresh(customer)
+
+    # Convert to Pydantic model
+    return CustomerModel.model_validate(customer.__dict__)
+
+
+@router.delete("/{customer_id}", response_model=dict)
+async def delete_customer(customer_id: str, db: Session = Depends(get_db)):
+    """Delete a customer with option to cascade delete disputes"""
+    customer = db.query(Customer).filter(Customer.id == customer_id).first()
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+
+    # Check if customer has disputes
+    disputes = db.query(DbDispute).filter(DbDispute.customer_id == customer_id).all()
+
+    if disputes:
+        # Inform user of existing disputes that block deletion
+        dispute_count = len(disputes)
+        raise HTTPException(
+            status_code=400,
+            detail=f"Cannot delete customer with existing disputes. The customer has {dispute_count} disputes.",
+        )
+
+    try:
+        # Delete the customer
+        db.delete(customer)
+        db.commit()
+        return {"message": "Customer deleted successfully"}
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=500, detail=f"Failed to delete customer: {str(e)}"
+        )

app/api/routes/disputes.py

@@ -0,0 +1,505 @@
+# app/api/routes/disputes.py
+import uuid
+from typing import List, Optional
+from datetime import datetime
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from sqlalchemy import case
+import json
+from app.api.database import get_db, Dispute, Customer, DisputeNote, DisputeInsight
+from app.api.models import (
+    DisputeCreate,
+    Dispute as DisputeModel,
+    DisputeUpdate,
+    DisputeWithCustomer,
+    DisputeAnalysisResponse,
+)
+from app.ai.langchain_service import DisputeAIService
+
+router = APIRouter()
+
+
+# Dependency for AI service
+def get_ai_service():
+    return DisputeAIService()
+
+
+@router.post("/", response_model=DisputeModel, status_code=201)
+async def create_dispute(
+    dispute: DisputeCreate,
+    db: Session = Depends(get_db),
+):
+    """Create a new dispute"""
+    # Check if customer exists
+    customer = db.query(Customer).filter(Customer.id == dispute.customer_id).first()
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+
+    # Create new dispute with all required fields from DisputeCreate model
+    new_dispute = Dispute(
+        id=str(uuid.uuid4()),
+        customer_id=dispute.customer_id,
+        transaction_id=dispute.transaction_id,
+        merchant_name=dispute.merchant_name,
+        amount=dispute.amount,
+        description=dispute.description,
+        category=dispute.category,
+        status="Open",
+        priority=None,
+        created_at=datetime.utcnow(),
+        resolved_at=None,
+    )
+
+    # Increment customer dispute count
+    customer.dispute_count += 1
+
+    # Add to database
+    db.add(new_dispute)
+    db.commit()
+    db.refresh(new_dispute)
+
+    # Convert to Pydantic model
+    return DisputeModel.model_validate(new_dispute.__dict__, strict=False)
+
+
+@router.get(
+    "/",
+    response_model=List[DisputeModel],
+)
+async def get_disputes(
+    db: Session = Depends(get_db),
+    skip: int = 0,
+    limit: int = 100,
+    status: Optional[str] = None,
+    priority: Optional[int] = None,
+    category: Optional[str] = None,
+    priority_sort: bool = Query(True, description="Sort by priority (high to low)"),
+    date_sort: str = Query("desc", description="Sort by date ('asc' or 'desc')"),
+):
+    """Get all disputes with improved filtering and sorting"""
+    query = db.query(Dispute)
+
+    # Apply filters
+    if status:
+        valid_statuses = ["Open", "Under Review", "Resolved"]
+        if status not in valid_statuses:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid status filter. Must be one of: {', '.join(valid_statuses)}",
+            )
+        query = query.filter(Dispute.status == status)
+
+    if priority:
+        if not 1 <= priority <= 5:
+            raise HTTPException(
+                status_code=400, detail="Priority filter must be between 1 and 5"
+            )
+        query = query.filter(Dispute.priority == priority)
+
+    if category:
+        query = query.filter(Dispute.category == category)
+
+    # Apply sorting
+    if priority_sort:
+        # Sort by priority descending (nulls last)
+        query = query.order_by(
+            case({None: 0}, value=Dispute.priority, else_=Dispute.priority).desc()
+        )
+
+    # Apply date sorting
+    if date_sort.lower() == "asc":
+        query = query.order_by(Dispute.created_at.asc())
+    else:
+        query = query.order_by(Dispute.created_at.desc())
+
+    # Apply pagination with validation
+    if skip < 0:
+        skip = 0
+    if limit <= 0:
+        limit = 100
+    elif limit > 500:  # Set a reasonable maximum
+        limit = 500
+
+    # Execute query with pagination
+    try:
+        disputes = query.offset(skip).limit(limit).all()
+        # Convert to Pydantic models
+        return [DisputeModel.model_validate(dispute.__dict__) for dispute in disputes]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Database query error: {str(e)}")
+
+
+@router.get("/{dispute_id}", response_model=DisputeWithCustomer)
+async def get_dispute(dispute_id: str, db: Session = Depends(get_db)):
+    """Get a specific dispute with customer details"""
+    dispute = db.query(Dispute).filter(Dispute.id == dispute_id).first()
+    if not dispute:
+        raise HTTPException(status_code=404, detail="Dispute not found")
+
+    # Get the customer
+    customer = db.query(Customer).filter(Customer.id == dispute.customer_id).first()
+
+    # Prepare the result dict
+    result = dispute.__dict__.copy()
+    result["customer"] = customer.__dict__ if customer else None
+
+    # Convert to Pydantic model
+    return DisputeWithCustomer.model_validate(result)
+
+
+@router.put("/{dispute_id}", response_model=DisputeModel)
+async def update_dispute(
+    dispute_id: str, dispute_update: DisputeUpdate, db: Session = Depends(get_db)
+):
+    """Update a dispute"""
+    dispute = db.query(Dispute).filter(Dispute.id == dispute_id).first()
+    if not dispute:
+        raise HTTPException(status_code=404, detail="Dispute not found")
+
+    # Check if any fields are provided
+    update_data = dispute_update.model_dump(exclude_unset=True)
+    if not update_data:
+        raise HTTPException(status_code=400, detail="No valid fields to update")
+
+    # Update fields with validation
+    if dispute_update.status is not None:
+        # Validate status
+        valid_statuses = ["Open", "Under Review", "Resolved"]
+        if dispute_update.status not in valid_statuses:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid status. Must be one of: {', '.join(valid_statuses)}",
+            )
+
+        dispute.status = dispute_update.status
+        if dispute_update.status == "Resolved" and not dispute.resolved_at:
+            dispute.resolved_at = datetime.utcnow()
+
+    if dispute_update.priority is not None:
+        # Validate priority
+        if not 1 <= dispute_update.priority <= 5:
+            raise HTTPException(
+                status_code=400, detail="Priority must be between 1 and 5"
+            )
+        dispute.priority = dispute_update.priority
+
+    if dispute_update.description is not None:
+        dispute.description = dispute_update.description
+
+    try:
+        db.commit()
+        db.refresh(dispute)
+        # Convert to Pydantic model
+        return DisputeModel.model_validate(dispute.__dict__)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+
+
+# Rest of the code remains the same...
+# Just be sure to add the proper model_validate conversion in each endpoint
+
+
+@router.post(
+    "/{dispute_id}/analyze", response_model=DisputeAnalysisResponse, status_code=201
+)
+async def analyze_dispute(
+    dispute_id: str,
+    db: Session = Depends(get_db),
+    ai_service: DisputeAIService = Depends(get_ai_service),
+):
+    # The response is already properly converted to a Pydantic model
+    # No changes needed
+    try:
+        # Get dispute from database
+        dispute = db.query(Dispute).filter(Dispute.id == dispute_id).first()
+        if not dispute:
+            raise HTTPException(status_code=404, detail="Dispute not found")
+
+        # Check if analysis already exists
+        existing_insight = (
+            db.query(DisputeInsight)
+            .filter(DisputeInsight.dispute_id == dispute_id)
+            .first()
+        )
+        if existing_insight:
+            # Return existing analysis instead of creating a duplicate
+            analysis_result = {
+                "priority": existing_insight.priority_level,
+                "priority_reason": existing_insight.priority_reason,
+                "insights": existing_insight.insights,
+                "followup_questions": json.loads(existing_insight.followup_questions),
+                "probable_solutions": json.loads(existing_insight.probable_solutions),
+                "possible_reasons": json.loads(existing_insight.possible_reasons),
+                "risk_score": existing_insight.risk_score,
+                "risk_factors": json.loads(existing_insight.risk_factors),
+            }
+            response_data = {"dispute_id": dispute_id, "analysis": analysis_result}
+            return DisputeAnalysisResponse.model_validate(response_data)
+
+        # Get customer information
+        customer = db.query(Customer).filter(Customer.id == dispute.customer_id).first()
+        if not customer:
+            raise HTTPException(status_code=404, detail="Customer not found")
+
+        # Prepare data for AI analysis
+        dispute_data = {
+            "dispute_id": dispute.id,
+            "customer_id": dispute.customer_id,
+            "customer_name": customer.name,
+            "customer_type": customer.account_type,
+            "transaction_id": dispute.transaction_id,
+            "merchant_name": dispute.merchant_name,
+            "transaction_date": dispute.created_at.isoformat(),
+            "dispute_date": dispute.created_at.isoformat(),
+            "transaction_amount": dispute.amount,
+            "dispute_description": dispute.description,
+            "category": dispute.category,
+            "previous_disputes_count": customer.dispute_count,
+            "customer_account_age_days": (
+                (datetime.utcnow() - customer.created_at).days
+            ),
+            "has_supporting_documents": False,  # Example value
+        }
+
+        # Analyze dispute using AI
+        analysis_result = ai_service.analyze_dispute(dispute_data)
+
+        # Validate required fields in analysis_result
+        required_fields = [
+            "priority",
+            "priority_reason",
+            "insights",
+            "followup_questions",
+            "probable_solutions",
+            "possible_reasons",
+            "risk_score",
+            "risk_factors",
+        ]
+        for field in required_fields:
+            if field not in analysis_result:
+                raise ValueError(f"AI analysis missing required field: {field}")
+
+        # Update dispute with priority (from analysis_result, not directly setting it)
+        dispute.priority = analysis_result["priority"]
+        db.commit()
+
+        # Store AI insights with proper field validation
+        insight = DisputeInsight(
+            id=str(uuid.uuid4()),
+            dispute_id=dispute_id,
+            priority_level=analysis_result["priority"],
+            priority_reason=analysis_result["priority_reason"],
+            insights=analysis_result["insights"],
+            followup_questions=json.dumps(analysis_result["followup_questions"]),
+            probable_solutions=json.dumps(analysis_result["probable_solutions"]),
+            possible_reasons=json.dumps(analysis_result["possible_reasons"]),
+            risk_score=analysis_result["risk_score"],
+            risk_factors=json.dumps(analysis_result["risk_factors"]),
+        )
+        db.add(insight)
+        db.commit()
+
+        # Return analysis results
+        response_data = {"dispute_id": dispute_id, "analysis": analysis_result}
+        return DisputeAnalysisResponse.model_validate(response_data)
+    except ValueError as e:
+        # Handle missing fields in AI response
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        # Log the detailed error for debugging
+        import traceback
+
+        print(f"AI analysis failed: {str(e)}")
+        print(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"AI analysis failed: {str(e)}")
+
+
+@router.delete("/{dispute_id}", response_model=dict)
+async def delete_dispute(dispute_id: str, db: Session = Depends(get_db)):
+    """Delete a dispute"""
+    dispute = db.query(Dispute).filter(Dispute.id == dispute_id).first()
+    if not dispute:
+        raise HTTPException(status_code=404, detail="Dispute not found")
+
+    # Check and delete dispute notes if they exist
+    if db.query(DisputeNote).filter(DisputeNote.dispute_id == dispute_id).first():
+        db.query(DisputeNote).filter(DisputeNote.dispute_id == dispute_id).delete()
+
+    # Check and delete dispute insights if they exist
+    if db.query(DisputeInsight).filter(DisputeInsight.dispute_id == dispute_id).first():
+        db.query(DisputeInsight).filter(
+            DisputeInsight.dispute_id == dispute_id
+        ).delete()
+
+    # Delete the dispute
+    db.delete(dispute)
+    db.commit()
+
+    return {"message": "Dispute deleted successfully"}
+
+
+from app.api.models import Insights, InsightsCreate
+
+
+@router.post("/{dispute_id}/insights", response_model=Insights, status_code=201)
+async def create_dispute_insights(
+    dispute_id: str,
+    insight_data: InsightsCreate,
+    db: Session = Depends(get_db),
+):
+    """Create new insights for a dispute with proper validation"""
+    # Check if dispute exists
+    dispute = db.query(Dispute).filter(Dispute.id == dispute_id).first()
+    if not dispute:
+        raise HTTPException(status_code=404, detail="Dispute not found")
+
+    # Check if insight already exists for this dispute
+    existing_insight = (
+        db.query(DisputeInsight).filter(DisputeInsight.dispute_id == dispute_id).first()
+    )
+    if existing_insight:
+        raise HTTPException(
+            status_code=400, detail="Insights already exist for this dispute"
+        )
+
+    # Validate risk_score range
+    if not 0 <= insight_data.risk_score <= 10:
+        raise HTTPException(
+            status_code=400, detail="Risk score must be between 0 and 10"
+        )
+
+    # Validate priority_level range
+    if not 1 <= insight_data.priority_level <= 5:
+        raise HTTPException(
+            status_code=400, detail="Priority level must be between 1 and 5"
+        )
+
+    try:
+        # Create new insight with proper JSON serialization
+        new_insight = DisputeInsight(
+            id=str(uuid.uuid4()),
+            dispute_id=dispute_id,
+            insights=insight_data.insights,
+            followup_questions=json.dumps(insight_data.followup_questions),
+            probable_solutions=json.dumps(insight_data.probable_solutions),
+            possible_reasons=json.dumps(insight_data.possible_reasons),
+            risk_score=insight_data.risk_score,
+            risk_factors=json.dumps(insight_data.risk_factors),
+            priority_level=insight_data.priority_level,
+            priority_reason=insight_data.priority_reason,
+        )
+
+        # Update the dispute's priority to match the insight priority
+        dispute.priority = insight_data.priority_level
+
+        # Add insight to database
+        db.add(new_insight)
+        db.commit()
+        db.refresh(new_insight)
+
+        # Return formatted response
+        return _format_insight_response(new_insight)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=500, detail=f"Error creating insights: {str(e)}"
+        )
+
+
+@router.get("/{dispute_id}/insights", response_model=Insights)
+async def get_dispute_insights(dispute_id: str, db: Session = Depends(get_db)):
+    """Get insights for a specific dispute"""
+    # Check if dispute exists
+    dispute = db.query(Dispute).filter(Dispute.id == dispute_id).first()
+    if not dispute:
+        raise HTTPException(status_code=404, detail="Dispute not found")
+
+    # Get the insights
+    insight = (
+        db.query(DisputeInsight).filter(DisputeInsight.dispute_id == dispute_id).first()
+    )
+    if not insight:
+        raise HTTPException(
+            status_code=404, detail="No insights found for this dispute"
+        )
+
+    # Handle potentially malformed JSON with more detailed error messages
+    try:
+        return _format_insight_response(insight)
+    except json.JSONDecodeError as e:
+        # Log the specific JSON error
+        print(f"JSON decode error in dispute insights: {str(e)}")
+        # Create a response with empty lists for fields that failed to parse
+        insight_data = {
+            "id": insight.id,
+            "dispute_id": insight.dispute_id,
+            "insights": insight.insights,
+            "followup_questions": [],
+            "probable_solutions": [],
+            "possible_reasons": [],
+            "risk_score": insight.risk_score,
+            "risk_factors": [],
+            "priority_level": insight.priority_level,
+            "priority_reason": insight.priority_reason,
+            "created_at": insight.created_at,
+            "updated_at": insight.updated_at,
+        }
+        return Insights.model_validate(insight_data)
+
+
+@router.put("/{dispute_id}/insights", response_model=Insights)
+async def update_dispute_insights(
+    dispute_id: str, insight_data: InsightsCreate, db: Session = Depends(get_db)
+):
+    """Update insights for a specific dispute"""
+    # Check if dispute exists
+    dispute = db.query(Dispute).filter(Dispute.id == dispute_id).first()
+    if not dispute:
+        raise HTTPException(status_code=404, detail="Dispute not found")
+
+    # Get the existing insight
+    insight = (
+        db.query(DisputeInsight).filter(DisputeInsight.dispute_id == dispute_id).first()
+    )
+    if not insight:
+        raise HTTPException(
+            status_code=404, detail="No insights found for this dispute"
+        )
+
+    # Update fields
+    insight.insights = insight_data.insights
+    insight.followup_questions = json.dumps(insight_data.followup_questions)
+    insight.probable_solutions = json.dumps(insight_data.probable_solutions)
+    insight.possible_reasons = json.dumps(insight_data.possible_reasons)
+    insight.risk_score = insight_data.risk_score
+    insight.risk_factors = json.dumps(insight_data.risk_factors)
+    insight.priority_level = insight_data.priority_level
+    insight.priority_reason = insight_data.priority_reason
+
+    # Commit changes
+    db.commit()
+    db.refresh(insight)
+
+    # Convert the stored JSON strings back to lists for the response
+    return _format_insight_response(insight)
+
+
+# Helper function to format insight response
+def _format_insight_response(insight):
+    """Convert SQLAlchemy model to Pydantic model with JSON parsing"""
+    insight_data = {
+        "id": insight.id,
+        "dispute_id": insight.dispute_id,
+        "insights": insight.insights,
+        "followup_questions": json.loads(insight.followup_questions),
+        "probable_solutions": json.loads(insight.probable_solutions),
+        "possible_reasons": json.loads(insight.possible_reasons),
+        "risk_score": insight.risk_score,
+        "risk_factors": json.loads(insight.risk_factors),
+        "priority_level": insight.priority_level,
+        "priority_reason": insight.priority_reason,
+        "created_at": insight.created_at,
+        "updated_at": insight.updated_at if hasattr(insight, "updated_at") else None,
+    }
+    return Insights.model_validate(insight_data)

app/api/services/database_service.py

@@ -0,0 +1,331 @@
+import uuid
+from datetime import datetime
+from sqlalchemy.orm import Session
+from typing import List, Optional, Dict, Any, Union
+
+from ..database import (
+    Customer,
+    Dispute,
+    DisputeAnalysis,
+    SupportingDocument,
+    DisputeStatus,
+)
+from ..models import (
+    CustomerCreate,
+    DisputeCreate,
+    CustomerUpdate,
+    DisputeUpdate,
+    DisputeAnalysisCreate,
+)
+
+
+# Customer operations
+def create_customer(db: Session, customer: CustomerCreate) -> Customer:
+    """Create a new customer in the database"""
+    db_customer = Customer(
+        id=str(uuid.uuid4()),
+        name=customer.name,
+        email=customer.email,
+        phone=customer.phone,
+        account_type=customer.account_type,
+    )
+    db.add(db_customer)
+    db.commit()
+    db.refresh(db_customer)
+    return db_customer
+
+
+def get_customer(db: Session, customer_id: str) -> Optional[Customer]:
+    """Get a customer by ID"""
+    return db.query(Customer).filter(Customer.id == customer_id).first()
+
+
+def get_customer_by_email(db: Session, email: str) -> Optional[Customer]:
+    """Get a customer by email"""
+    return db.query(Customer).filter(Customer.email == email).first()
+
+
+def get_customers(db: Session, skip: int = 0, limit: int = 100) -> List[Customer]:
+    """Get a list of customers"""
+    return db.query(Customer).offset(skip).limit(limit).all()
+
+
+def update_customer(
+    db: Session, customer_id: str, customer: CustomerUpdate
+) -> Optional[Customer]:
+    """Update a customer's information"""
+    db_customer = get_customer(db, customer_id)
+    if not db_customer:
+        return None
+
+    # Update only the fields that are provided
+    customer_data = customer.dict(exclude_unset=True)
+    for key, value in customer_data.items():
+        setattr(db_customer, key, value)
+
+    db_customer.updated_at = datetime.utcnow()
+    db.commit()
+    db.refresh(db_customer)
+    return db_customer
+
+
+def delete_customer(db: Session, customer_id: str) -> bool:
+    """Delete a customer"""
+    db_customer = get_customer(db, customer_id)
+    if not db_customer:
+        return False
+
+    db.delete(db_customer)
+    db.commit()
+    return True
+
+
+def increment_dispute_count(db: Session, customer_id: str) -> Optional[Customer]:
+    """Increment the dispute count for a customer"""
+    db_customer = get_customer(db, customer_id)
+    if not db_customer:
+        return None
+
+    db_customer.dispute_count += 1
+    db_customer.updated_at = datetime.utcnow()
+    db.commit()
+    db.refresh(db_customer)
+    return db_customer
+
+
+# Dispute operations
+def create_dispute(db: Session, dispute: DisputeCreate) -> Dispute:
+    """Create a new dispute in the database"""
+    dispute_id = str(uuid.uuid4())
+    db_dispute = Dispute(
+        id=dispute_id,
+        customer_id=dispute.customer_id,
+        transaction_id=dispute.transaction_id,
+        merchant_name=dispute.merchant_name,
+        amount=dispute.amount,
+        description=dispute.description,
+        category=dispute.category,
+        status=DisputeStatus.NEW,
+    )
+    db.add(db_dispute)
+    db.commit()
+    db.refresh(db_dispute)
+
+    # Increment the customer's dispute count
+    increment_dispute_count(db, dispute.customer_id)
+
+    return db_dispute
+
+
+def get_dispute(db: Session, dispute_id: str) -> Optional[Dispute]:
+    """Get a dispute by ID"""
+    return db.query(Dispute).filter(Dispute.id == dispute_id).first()
+
+
+def get_disputes(
+    db: Session,
+    skip: int = 0,
+    limit: int = 100,
+    status: Optional[List[DisputeStatus]] = None,
+    priority: Optional[List[int]] = None,
+    customer_id: Optional[str] = None,
+    sort_by: str = "created_at",
+    sort_desc: bool = True,
+) -> List[Dispute]:
+    """Get a list of disputes with filtering and sorting options"""
+    query = db.query(Dispute)
+
+    # Apply filters
+    if status:
+        query = query.filter(Dispute.status.in_(status))
+
+    if priority:
+        query = query.filter(Dispute.priority.in_(priority))
+
+    if customer_id:
+        query = query.filter(Dispute.customer_id == customer_id)
+
+    # Apply sorting
+    if sort_by == "priority" and sort_desc:
+        query = query.order_by(
+            Dispute.priority.desc().nullslast(), Dispute.created_at.desc()
+        )
+    elif sort_by == "priority" and not sort_desc:
+        query = query.order_by(
+            Dispute.priority.asc().nullsfirst(), Dispute.created_at.desc()
+        )
+    elif sort_by == "amount" and sort_desc:
+        query = query.order_by(Dispute.amount.desc(), Dispute.created_at.desc())
+    elif sort_by == "amount" and not sort_desc:
+        query = query.order_by(Dispute.amount.asc(), Dispute.created_at.desc())
+    elif sort_desc:
+        query = query.order_by(getattr(Dispute, sort_by).desc())
+    else:
+        query = query.order_by(getattr(Dispute, sort_by).asc())
+
+    return query.offset(skip).limit(limit).all()
+
+
+def update_dispute(
+    db: Session, dispute_id: str, dispute: DisputeUpdate
+) -> Optional[Dispute]:
+    """Update a dispute's information"""
+    db_dispute = get_dispute(db, dispute_id)
+    if not db_dispute:
+        return None
+
+    # Update only the fields that are provided
+    dispute_data = dispute.dict(exclude_unset=True)
+    for key, value in dispute_data.items():
+        if key == "status" and value in [
+            DisputeStatus.APPROVED,
+            DisputeStatus.REJECTED,
+            DisputeStatus.CLOSED,
+        ]:
+            # Set resolved_at timestamp when dispute is resolved
+            db_dispute.resolved_at = datetime.utcnow()
+        setattr(db_dispute, key, value)
+
+    db_dispute.updated_at = datetime.utcnow()
+    db.commit()
+    db.refresh(db_dispute)
+    return db_dispute
+
+
+def delete_dispute(db: Session, dispute_id: str) -> bool:
+    """Delete a dispute"""
+    db_dispute = get_dispute(db, dispute_id)
+    if not db_dispute:
+        return False
+
+    db.delete(db_dispute)
+    db.commit()
+    return True
+
+
+# AI Analysis operations
+def create_dispute_analysis(
+    db: Session, dispute_id: str, analysis: DisputeAnalysisCreate
+) -> Optional[DisputeAnalysis]:
+    """Create a new AI analysis for a dispute"""
+    # Check if dispute exists
+    db_dispute = get_dispute(db, dispute_id)
+    if not db_dispute:
+        return None
+
+    # Check if analysis already exists
+    existing_analysis = (
+        db.query(DisputeAnalysis)
+        .filter(DisputeAnalysis.dispute_id == dispute_id)
+        .first()
+    )
+
+    if existing_analysis:
+        # Update existing analysis
+        existing_analysis.priority = analysis.priority
+        existing_analysis.priority_reason = analysis.priority_reason
+        existing_analysis.insights = analysis.insights
+        existing_analysis.possible_reasons = str(analysis.possible_reasons)
+        existing_analysis.probable_solutions = str(analysis.probable_solutions)
+        existing_analysis.followup_questions = str(analysis.followup_questions)
+        existing_analysis.updated_at = datetime.utcnow()
+
+        db.commit()
+        db.refresh(existing_analysis)
+        return existing_analysis
+    else:
+        # Create new analysis
+        db_analysis = DisputeAnalysis(
+            id=str(uuid.uuid4()),
+            dispute_id=dispute_id,
+            priority=analysis.priority,
+            priority_reason=analysis.priority_reason,
+            insights=analysis.insights,
+            possible_reasons=str(analysis.possible_reasons),
+            probable_solutions=str(analysis.probable_solutions),
+            followup_questions=str(analysis.followup_questions),
+        )
+
+        # Update dispute priority
+        db_dispute.priority = analysis.priority
+        db_dispute.updated_at = datetime.utcnow()
+
+        db.add(db_analysis)
+        db.commit()
+        db.refresh(db_analysis)
+        return db_analysis
+
+
+def get_dispute_analysis(db: Session, dispute_id: str) -> Optional[DisputeAnalysis]:
+    """Get AI analysis for a dispute"""
+    return (
+        db.query(DisputeAnalysis)
+        .filter(DisputeAnalysis.dispute_id == dispute_id)
+        .first()
+    )
+
+
+# Dashboard metrics
+def get_dashboard_metrics(db: Session) -> Dict[str, Any]:
+    """Get metrics for the dashboard"""
+    # Total disputes
+    total_disputes = db.query(Dispute).count()
+
+    # High priority disputes (4-5)
+    high_priority_count = db.query(Dispute).filter(Dispute.priority.in_([4, 5])).count()
+
+    # Pending disputes
+    pending_count = (
+        db.query(Dispute)
+        .filter(
+            Dispute.status.in_(
+                [
+                    DisputeStatus.NEW,
+                    DisputeStatus.UNDER_REVIEW,
+                    DisputeStatus.INFO_REQUESTED,
+                ]
+            )
+        )
+        .count()
+    )
+
+    # Resolved today
+    today_start = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
+    resolved_today = (
+        db.query(Dispute).filter(Dispute.resolved_at >= today_start).count()
+    )
+
+    # Disputes by category
+    category_query = (
+        db.query(Dispute.category, db.func.count(Dispute.id).label("count"))
+        .group_by(Dispute.category)
+        .all()
+    )
+    disputes_by_category = {category: count for category, count in category_query}
+
+    # Disputes by status
+    status_query = (
+        db.query(Dispute.status, db.func.count(Dispute.id).label("count"))
+        .group_by(Dispute.status)
+        .all()
+    )
+    disputes_by_status = {status.name: count for status, count in status_query}
+
+    # Disputes by priority
+    priority_query = (
+        db.query(Dispute.priority, db.func.count(Dispute.id).label("count"))
+        .filter(Dispute.priority.isnot(None))
+        .group_by(Dispute.priority)
+        .all()
+    )
+    disputes_by_priority = {priority: count for priority, count in priority_query}
+
+    return {
+        "total_disputes": total_disputes,
+        "high_priority_count": high_priority_count,
+        "pending_count": pending_count,
+        "resolved_today": resolved_today,
+        "disputes_by_category": disputes_by_category,
+        "disputes_by_status": disputes_by_status,
+        "disputes_by_priority": disputes_by_priority,
+    }

app/api/services/priority_service.py

@@ -0,0 +1,40 @@
+# app/api/services/priority_service.py
+from typing import Dict, Any
+from app.ai.dispute_analyzer import DisputeAnalyzer
+from app.core.ai_config import ai_settings
+
+class PriorityService:
+    def __init__(self):
+        self.analyzer = DisputeAnalyzer()
+        
+    def calculate_priority(self, dispute_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Calculate final priority considering both AI and rule-based factors"""
+        analysis = self.analyzer.analyze_dispute(dispute_data)
+        
+        # Combine AI priority with risk-based adjustment
+        ai_priority = analysis["priority"]
+        risk_priority = self._risk_based_priority(analysis["risk_score"])
+        
+        # Take the higher of the two priorities
+        final_priority = max(ai_priority, risk_priority)
+        
+        return {
+            "final_priority": final_priority,
+            "ai_priority": ai_priority,
+            "risk_priority": risk_priority,
+            "risk_score": analysis["risk_score"],
+            "priority_reason": analysis["priority_reason"],
+        }
+    
+    def _risk_based_priority(self, risk_score: float) -> int:
+        """Convert risk score to priority level"""
+        if risk_score >= 80:
+            return 5
+        elif risk_score >= 65:
+            return 4
+        elif risk_score >= 50:
+            return 3
+        elif risk_score >= 35:
+            return 2
+        else:
+            return 1

app/api/services/recommendation_service.py

@@ -0,0 +1,25 @@
+# app/api/services/recommendation_service.py
+from typing import Dict, Any, List
+from app.ai.dispute_analyzer import DisputeAnalyzer
+
+class RecommendationService:
+    def __init__(self):
+        self.analyzer = DisputeAnalyzer()
+    
+    def get_recommendations(self, dispute_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Get comprehensive recommendations for dispute resolution"""
+        analysis = self.analyzer.analyze_dispute(dispute_data)
+        
+        return {
+            "priority": analysis["priority"],
+            "risk_score": analysis["risk_score"],
+            "recommended_actions": analysis["recommended_actions"],
+            "sla_target": analysis["sla_target"].isoformat(),
+            "followup_questions": analysis["followup_questions"],
+            "similar_cases": self._find_similar_cases(dispute_data)
+        }
+    
+    def _find_similar_cases(self, dispute_data: Dict[str, Any]) -> List[Dict]:
+        """Placeholder for similar case lookup"""
+        # TODO: Implement actual similar case search
+        return []

app/core/ai_config.py

@@ -0,0 +1,20 @@
+# app/core/ai_config.py
+from pydantic_settings import BaseSettings
+
+class AISettings(BaseSettings):
+    # Use the same environment variable name
+    GOOGLE_API_KEY: str  # No default value
+
+    # Rest of your existing AI config
+    GEMINI_MODEL: str = "gemini-2.0-flash"
+    TEMPERATURE: float = 0.2
+    MAX_TOKENS: int = 1024
+    MAX_RETRIES: int = 2
+    RETRY_DELAY: int = 4
+
+    class Config:
+        env_file = ".env"
+        extra = "ignore"
+
+
+ai_settings = AISettings()

app/core/config.py

@@ -0,0 +1,20 @@
+# app/core/config.py
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    # Keep existing fields
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "Banking Disputes Resolution System"
+    DEBUG: bool = False
+    DATABASE_URL: str = "sqlite:///./disputes.db"
+
+    # Add this to accept Google API key from environment
+    GOOGLE_API_KEY: str = None
+
+    class Config:
+        env_file = ".env"
+        extra = "ignore"
+
+
+settings = Settings()

app/data/dispute_categories.json

@@ -0,0 +1,14 @@
+{
+    "categories": [
+        "Billing Error",
+        "Fraudulent Transaction",
+        "Item Not Received",
+        "Item Not As Described",
+        "Duplicate Charge",
+        "Cancelled Service",
+        "Refund Not Processed",
+        "Subscription Issue",
+        "ATM Issue",
+        "Other"
+    ]
+}

app/data/sample_disputes.json

@@ -0,0 +1,26 @@
+{
+    "disputes": [
+        {
+            "id": "D1001",
+            "customer_id": "C1001",
+            "transaction_id": "T12345",
+            "merchant_name": "Utility Co",
+            "amount": 120.00,
+            "category": "Billing Error",
+            "description": "Unexpected increase in monthly utility bill without prior notification.",
+            "status": "New",
+            "created_at": "2024-01-15T10:30:00Z"
+        },
+        {
+            "id": "D1002",
+            "customer_id": "C1002",
+            "transaction_id": "T67890",
+            "merchant_name": "Online Shop",
+            "amount": 89.99,
+            "category": "Item Not Received",
+            "description": "Ordered a headphone set 3 weeks ago but haven't received it yet. Tracking shows no movement for 2 weeks.",
+            "status": "New",
+            "created_at": "2024-01-18T14:15:00Z"
+        }
+    ]
+}

app/entrypoint.py

@@ -0,0 +1,34 @@
+import subprocess
+import sys
+import os
+import threading
+import time
+
+
+def run_fastapi():
+    print("Starting FastAPI backend...")
+    subprocess.run(["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"])
+
+
+def run_streamlit():
+    print("Starting Streamlit from frontend directory...")
+    # Change to the frontend directory first
+    os.chdir("app/frontend")
+    # Then run streamlit (note the path is now relative to the frontend directory)
+    subprocess.run(["streamlit", "run", "streamlit_app.py", "--server.port", "7860", "--server.address", "0.0.0.0"])
+
+
+if __name__ == "__main__":
+    # Store the original directory to potentially return to it later if needed
+    original_dir = os.getcwd()
+    
+    # Start FastAPI in a separate thread
+    api_thread = threading.Thread(target=run_fastapi)
+    api_thread.daemon = True
+    api_thread.start()
+
+    # Give FastAPI some time to start up
+    time.sleep(3)
+
+    # Start Streamlit in the main thread
+    run_streamlit()

app/frontend/components/dispute_card.py

@@ -0,0 +1,52 @@
+# app/frontend/components/dispute_card.py
+import streamlit as st
+from typing import Dict
+
+
+def dispute_card(dispute: Dict):
+    priority_colors = {
+        1: "#4a86e8",
+        2: "#5cb85c",
+        3: "#f0ad4e",
+        4: "#d9534f",
+        5: "#d9534f",
+    }
+
+    with st.container():
+        st.markdown(
+            f"""
+        <div style='
+            border-left: 5px solid {priority_colors.get(dispute.get("priority", 1), "#999")};
+            padding: 15px;
+            margin: 10px 0;
+            background: white;
+            border-radius: 5px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        '>
+            <div style='display: flex; justify-content: space-between;'>
+                <h3 style='margin: 0;'>#{dispute['id'][:6]}</h3>
+                <div style='
+                    background: {priority_colors.get(dispute.get("priority", 1))};
+                    color: white;
+                    padding: 2px 8px;
+                    border-radius: 12px;
+                    font-size: 0.8em;
+                '>
+                    {dispute.get('priority', 'N/A')}
+                </div>
+            </div>
+            <p style='margin: 8px 0; color: #666;'>{dispute['description'][:100]}...</p>
+            <div style='display: flex; justify-content: space-between; font-size: 0.9em;'>
+                <div>${dispute['amount']}</div>
+                <div>{dispute['status']}</div>
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+        # st.button(
+        #     "View Details",
+        #     on_click=lambda id=dispute["id"]: st.query_params.update(
+        #         {"page": "dispute_details", "id": id}
+        #     ),
+        # )

app/frontend/components/followup_questions.py

@@ -0,0 +1,33 @@
+# app/frontend/components/followup_questions.py
+import streamlit as st
+from typing import List, Dict
+
+def display_followup_questions(questions: List[str], dispute_id: str):
+    """Displays interactive follow-up questions with response handling"""
+    with st.container(border=True):
+        st.markdown("### Follow-up Questions")
+        
+        if not questions:
+            st.info("No follow-up questions generated for this case")
+            return
+            
+        for i, question in enumerate(questions):
+            with st.expander(f"Question #{i+1}: {question}", expanded=False):
+                response = st.text_area(
+                    "Agent Response",
+                    key=f"response_{dispute_id}_{i}",
+                    placeholder="Enter your response here...",
+                    height=100
+                )
+                col1, col2 = st.columns([3, 1])
+                with col1:
+                    if st.button("Save Response", key=f"save_{dispute_id}_{i}"):
+                        if response.strip():
+                            # Implement API call to save response
+                            st.success("Response saved successfully")
+                        else:
+                            st.warning("Please enter a response before saving")
+                with col2:
+                    if st.button("Mark as Completed", key=f"complete_{dispute_id}_{i}"):
+                        # Implement API call to mark question as resolved
+                        st.success("Question marked as completed")

app/frontend/components/insights_panel.py

@@ -0,0 +1,109 @@
+import streamlit as st
+from typing import Dict, Any, List
+
+
+def ai_insights_panel(analysis: Dict[str, Any], priority: int):
+    """Displays AI-generated insights in a structured panel."""
+
+    with st.container():
+
+        # Priority and Risk
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("Priority Level", f"{priority}/5")
+        with col2:
+            st.metric("Risk Score", f"{analysis.get('risk_score', 'N/A')}/10.0")
+
+        # Priority Reason
+        if analysis.get("priority_reason"):
+            with st.expander("Priority Reason", expanded=True):
+                st.markdown(analysis["priority_reason"])
+
+        # Key Insights
+        if analysis.get("insights"):
+            with st.expander("Key Insights", expanded=True):
+                # Use markdown instead of write to ensure full text is displayed
+                st.markdown("### AI Insights")
+                st.markdown(analysis["insights"])
+
+        # Follow-up Questions
+        if analysis.get("followup_questions"):
+            with st.expander("Follow-up Questions", expanded=False):
+                if isinstance(analysis["followup_questions"], str):
+                    try:
+                        # Attempt to parse as a list (in case it's a string representation)
+                        questions = eval(analysis["followup_questions"])
+                        if isinstance(questions, list):
+                            for question in questions:
+                                st.markdown(f"- {question}")
+                        else:
+                            st.markdown(analysis["followup_questions"])  # Display as is
+                    except:
+                        st.markdown(
+                            analysis["followup_questions"]
+                        )  # Display as is if parsing fails
+                elif isinstance(analysis["followup_questions"], list):
+                    for question in analysis["followup_questions"]:
+                        st.markdown(f"- {question}")
+                else:
+                    st.markdown(analysis["followup_questions"])
+
+        # Probable Solutions
+        if analysis.get("probable_solutions"):
+            with st.expander("Probable Solutions", expanded=False):
+                if isinstance(analysis["probable_solutions"], str):
+                    try:
+                        solutions = eval(analysis["probable_solutions"])
+                        if isinstance(solutions, list):
+                            for solution in solutions:
+                                st.markdown(f"- {solution}")
+                        else:
+                            st.markdown(analysis["probable_solutions"])
+                    except:
+                        st.markdown(analysis["probable_solutions"])
+                elif isinstance(analysis["probable_solutions"], list):
+                    for solution in analysis[
+                        "probable_solutions"
+                    ]:  # Use analysis["probable_solutions"] instead of solutions
+                        st.markdown(f"- {solution}")
+                else:
+                    st.markdown(analysis["probable_solutions"])
+
+        # Possible Reasons
+        if analysis.get("possible_reasons"):
+            with st.expander("Possible Reasons", expanded=False):
+                if isinstance(analysis["possible_reasons"], str):
+                    try:
+                        reasons = eval(analysis["possible_reasons"])
+                        if isinstance(reasons, list):
+                            for reason in reasons:
+                                st.markdown(f"- {reason}")
+                        else:
+                            st.markdown(analysis["possible_reasons"])
+                    except:
+                        st.markdown(analysis["possible_reasons"])
+
+                elif isinstance(analysis["possible_reasons"], list):
+                    for reason in analysis["possible_reasons"]:
+                        st.markdown(f"- {reason}")
+                else:
+                    st.markdown(analysis["possible_reasons"])
+
+        # Risk Factors
+        if analysis.get("risk_factors"):
+            with st.expander("Risk Factors", expanded=False):
+                if isinstance(analysis["risk_factors"], str):
+                    try:
+                        risk_factors = eval(analysis["risk_factors"])
+                        if isinstance(risk_factors, list):
+                            for risk_factor in risk_factors:
+                                st.markdown(f"- {risk_factor}")
+                        else:
+                            st.markdown(analysis["risk_factors"])
+                    except:
+                        st.markdown(analysis["risk_factors"])
+                elif isinstance(analysis["risk_factors"], list):
+                    for risk_factor in analysis["risk_factors"]:
+                        st.markdown(f"- {risk_factor}")
+                else:
+                    st.markdown(analysis["risk_factors"])

app/frontend/components/sidebar.py

@@ -0,0 +1,37 @@
+# app/frontend/components/sidebar.py
+import streamlit as st
+from utils.api_client import DisputeAPIClient
+
+
+def sidebar():
+    with st.sidebar:
+        st.title("Dispute Resolution")
+        st.button(
+            "🏠 Dashboard",
+            on_click=lambda: st.query_params.update({"page": "dashboard"}),
+        )
+        st.button(
+            "➕ New Dispute",
+            on_click=lambda: st.query_params.update({"page": "new_dispute"}),
+        )
+
+        # Quick stats
+        st.divider()
+        st.markdown("### System Status")
+        try:
+            metrics = DisputeAPIClient.get_dashboard_metrics()
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Disputes", metrics.get("total_disputes", 0))
+            with col2:
+                st.metric("High Priority", metrics.get("high_priority_count", 0))
+
+            st.metric("Pending Review", metrics.get("pending_count", 0))
+        except Exception as e:
+            st.error(f"Error loading metrics: {str(e)}")
+
+        # Admin section
+        st.divider()
+        st.button(
+            "⚙️ Admin Panel", on_click=lambda: st.query_params.update({"page": "admin"})
+        )

app/frontend/pages/admin.py

@@ -0,0 +1,43 @@
+# app/frontend/pages/admin.py
+import streamlit as st
+from utils.api_client import DisputeAPIClient
+
+
+def display_admin():
+    """Administration panel for system management"""
+
+    st.title("System Administration")
+
+    tab1, tab2, tab3 = st.tabs(["Metrics", "Configuration", "Users"])
+
+    with tab1:
+        st.header("System Metrics")
+        metrics = DisputeAPIClient.get_dashboard_metrics()
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("Total Disputes", metrics.get("total_disputes", 0))
+            st.metric("Average Resolution Time", "24h")
+        with col2:
+            st.metric("API Health", "✅ Operational")
+            st.metric("Active Users", 15)
+
+    with tab2:
+        st.header("System Configuration")
+        with st.form("config_form"):
+            st.number_input("Default SLA Days", value=7)
+            st.number_input("High Priority Threshold", value=4)
+            st.form_submit_button("Save Configuration")
+
+    with tab3:
+        st.header("User Management")
+        # Placeholder table
+        st.dataframe(
+            {
+                "User": ["admin", "analyst1", "reviewer2"],
+                "Role": ["Admin", "Analyst", "Reviewer"],
+                "Last Login": ["2h ago", "1d ago", "3d ago"],
+            }
+        )
+
+if __name__ == "__main__":
+    display_admin()

app/frontend/pages/api_docs.py

@@ -0,0 +1,400 @@
+import streamlit as st
+
+
+def display_api_docs():
+    st.title("API Documentation")
+
+    st.markdown(
+        """
+    ## REST API Reference
+    Explore our API endpoints for integration with the Banking Dispute Resolution System.
+    """
+    )
+
+    with st.expander("📚 Customer Endpoints", expanded=True):
+        st.markdown(
+            """
+        ### 1. Create Customer
+        **POST** `/customers/`
+        
+        **Input:**
+        ```json
+        {
+          "name": "John Doe",
+          "email": "[email protected]",
+          "account_type": "Individual"
+        }
+        ```
+        
+        **Response:** (Status Code: 201)
+        ```json
+        {
+          "id": "550e8400-e29b-41d4-a716-446655440000",
+          "name": "John Doe",
+          "email": "[email protected]",
+          "account_type": "Individual",
+          "dispute_count": 0,
+          "created_at": "2025-03-22T14:30:45.123456"
+        }
+        ```
+
+        ### 2. Get All Customers
+        **GET** `/customers/`
+        
+        **Query Parameters:**
+        - `skip`: int (default: 0)
+        - `limit`: int (default: 100)
+        - `account_type`: string (optional)
+        
+        **Response:** (Status Code: 200)
+        ```json
+        [
+          {
+            "id": "550e8400-e29b-41d4-a716-446655440000",
+            "name": "John Doe",
+            "email": "[email protected]",
+            "account_type": "Individual",
+            "dispute_count": 2,
+            "created_at": "2025-03-22T14:30:45.123456"
+          },
+          ...
+        ]
+        ```
+        
+        ### 3. Get Customer by ID
+        **GET** `/customers/{customer_id}`
+        
+        **Response:** (Status Code: 200)
+        ```json
+        {
+          "id": "550e8400-e29b-41d4-a716-446655440000",
+          "name": "John Doe",
+          "email": "[email protected]",
+          "account_type": "Individual",
+          "dispute_count": 2,
+          "created_at": "2025-03-22T14:30:45.123456"
+        }
+        ```
+        
+        ### 4. Get Customer's Disputes
+        **GET** `/customers/{customer_id}/disputes`
+        
+        **Query Parameters:**
+        - `skip`: int (default: 0)
+        - `limit`: int (default: 100)
+        
+        **Response:** (Status Code: 200)
+        ```json
+        [
+          {
+            "id": "550e8400-e29b-41d4-a716-446655440010",
+            "customer_id": "550e8400-e29b-41d4-a716-446655440000",
+            "transaction_id": "T12345",
+            "merchant_name": "Example Store",
+            "amount": 99.99,
+            "description": "Unauthorized charge",
+            "category": "Unauthorized",
+            "status": "Open",
+            "priority": 3,
+            "created_at": "2025-03-22T15:30:45.123456",
+            "resolved_at": null
+          },
+          ...
+        ]
+        ```
+        
+        ### 5. Update Customer
+        **PUT** `/customers/{customer_id}`
+        
+        **Input:**
+        ```json
+        {
+          "name": "John Doe Updated",
+          "email": "[email protected]",
+          "account_type": "Business"
+        }
+        ```
+        
+        **Response:** (Status Code: 200)
+        ```json
+        {
+          "id": "550e8400-e29b-41d4-a716-446655440000",
+          "name": "John Doe Updated",
+          "email": "[email protected]",
+          "account_type": "Business",
+          "dispute_count": 2,
+          "created_at": "2025-03-22T14:30:45.123456"
+        }
+        ```
+        
+        ### 6. Delete Customer
+        **DELETE** `/customers/{customer_id}`
+        
+        **Response:** (Status Code: 200)
+        ```json
+        {
+          "message": "Customer deleted successfully"
+        }
+        ```
+        """
+        )
+
+    with st.expander("⚖️ Dispute Endpoints", expanded=True):
+        st.markdown(
+            """
+        ### 1. Create Dispute
+        **POST** `/disputes/`
+        
+        **Input:**
+        ```json
+        {
+          "customer_id": "550e8400-e29b-41d4-a716-446655440000",
+          "transaction_id": "T12345",
+          "merchant_name": "Example Store",
+          "amount": 99.99,
+          "description": "Unauthorized charge",
+          "category": "Unauthorized"
+        }
+        ```
+        
+        **Response:** (Status Code: 201)
+        ```json
+        {
+          "id": "550e8400-e29b-41d4-a716-446655440010",
+          "customer_id": "550e8400-e29b-41d4-a716-446655440000",
+          "transaction_id": "T12345",
+          "merchant_name": "Example Store",
+          "amount": 99.99,
+          "description": "Unauthorized charge",
+          "category": "Unauthorized",
+          "status": "Open",
+          "priority": null,
+          "created_at": "2025-03-22T15:30:45.123456",
+          "resolved_at": null
+        }
+        ```
+        
+        ### 2. Get All Disputes
+        **GET** `/disputes/`
+        
+        **Query Parameters:**
+        - `skip`: int (default: 0)
+        - `limit`: int (default: 100)
+        - `status`: string (optional)
+        - `priority_sort`: bool (default: true)
+        
+        **Response:** (Status Code: 200)
+        ```json
+        [
+          {
+            "id": "550e8400-e29b-41d4-a716-446655440010",
+            "customer_id": "550e8400-e29b-41d4-a716-446655440000",
+            "transaction_id": "T12345",
+            "merchant_name": "Example Store",
+            "amount": 99.99,
+            "description": "Unauthorized charge",
+            "category": "Unauthorized",
+            "status": "Open",
+            "priority": 3,
+            "created_at": "2025-03-22T15:30:45.123456",
+            "resolved_at": null
+          },
+          ...
+        ]
+        ```
+        
+        ### 3. Get Dispute by ID
+        **GET** `/disputes/{dispute_id}`
+        
+        **Response:** (Status Code: 200)
+        ```json
+        {
+          "id": "550e8400-e29b-41d4-a716-446655440010",
+          "customer_id": "550e8400-e29b-41d4-a716-446655440000",
+          "transaction_id": "T12345",
+          "merchant_name": "Example Store",
+          "amount": 99.99,
+          "description": "Unauthorized charge",
+          "category": "Unauthorized",
+          "status": "Open",
+          "priority": 3,
+          "created_at": "2025-03-22T15:30:45.123456",
+          "resolved_at": null,
+          "customer": {
+            "id": "550e8400-e29b-41d4-a716-446655440000",
+            "name": "John Doe",
+            "email": "[email protected]",
+            "account_type": "Individual",
+            "dispute_count": 2,
+            "created_at": "2025-03-22T14:30:45.123456"
+          }
+        }
+        ```
+        
+        ### 4. Update Dispute
+        **PUT** `/disputes/{dispute_id}`
+        
+        **Input:**
+        ```json
+        {
+          "status": "Under Review",
+          "priority": 4,
+          "description": "Updated description of the dispute"
+        }
+        ```
+        
+        **Response:** (Status Code: 200)
+        ```json
+        {
+          "id": "550e8400-e29b-41d4-a716-446655440010",
+          "customer_id": "550e8400-e29b-41d4-a716-446655440000",
+          "transaction_id": "T12345",
+          "merchant_name": "Example Store",
+          "amount": 99.99,
+          "description": "Updated description of the dispute",
+          "category": "Unauthorized",
+          "status": "Under Review",
+          "priority": 4,
+          "created_at": "2025-03-22T15:30:45.123456",
+          "resolved_at": null
+        }
+        ```
+        
+        ### 5. Delete Dispute
+        **DELETE** `/disputes/{dispute_id}`
+        
+        **Response:** (Status Code: 200)
+        ```json
+        {
+          "message": "Dispute deleted successfully"
+        }
+        ```
+        
+        ### 6. Analyze Dispute
+        **POST** `/disputes/{dispute_id}/analyze`
+        
+        **Response:** (Status Code: 201)
+        ```json
+        {
+          "dispute_id": "550e8400-e29b-41d4-a716-446655440010",
+          "analysis": {
+            "priority": 4,
+            "priority_reason": "High value transaction with a new merchant",
+            "insights": "This appears to be a legitimate dispute based on transaction history.",
+            "followup_questions": ["When did you first notice the charge?", "Have you contacted the merchant?"],
+            "probable_solutions": ["Issue chargeback to merchant", "Request more information from customer"],
+            "possible_reasons": ["Fraudulent merchant", "Unauthorized use of card"],
+            "risk_score": 7.5,
+            "risk_factors": ["High transaction amount", "First transaction with merchant"]
+          }
+        }
+        ```
+        """
+        )
+
+    with st.expander("🔍 Dispute Insights Endpoints", expanded=True):
+        st.markdown(
+            """
+        ### 1. Create Dispute Insights
+        **POST** `/disputes/{dispute_id}/insights`
+        
+        **Input:**
+        ```json
+        {
+          "insights": "Detailed analysis of the dispute situation",
+          "followup_questions": ["Question 1?", "Question 2?"],
+          "probable_solutions": ["Solution 1", "Solution 2"],
+          "possible_reasons": ["Reason 1", "Reason 2"],
+          "risk_score": 6.5,
+          "risk_factors": ["Factor 1", "Factor 2"],
+          "priority_level": 4,
+          "priority_reason": "Explanation for the priority level"
+        }
+        ```
+        
+        **Response:** (Status Code: 201)
+        ```json
+        {
+          "id": "550e8400-e29b-41d4-a716-446655440020",
+          "dispute_id": "550e8400-e29b-41d4-a716-446655440010",
+          "insights": "Detailed analysis of the dispute situation",
+          "followup_questions": ["Question 1?", "Question 2?"],
+          "probable_solutions": ["Solution 1", "Solution 2"],
+          "possible_reasons": ["Reason 1", "Reason 2"],
+          "risk_score": 6.5,
+          "risk_factors": ["Factor 1", "Factor 2"],
+          "priority_level": 4,
+          "priority_reason": "Explanation for the priority level",
+          "created_at": "2025-03-22T16:30:45.123456",
+          "updated_at": null
+        }
+        ```
+        
+        ### 2. Get Dispute Insights
+        **GET** `/disputes/{dispute_id}/insights`
+        
+        **Response:** (Status Code: 200)
+        ```json
+        {
+          "id": "550e8400-e29b-41d4-a716-446655440020",
+          "dispute_id": "550e8400-e29b-41d4-a716-446655440010",
+          "insights": "Detailed analysis of the dispute situation",
+          "followup_questions": ["Question 1?", "Question 2?"],
+          "probable_solutions": ["Solution 1", "Solution 2"],
+          "possible_reasons": ["Reason 1", "Reason 2"],
+          "risk_score": 6.5,
+          "risk_factors": ["Factor 1", "Factor 2"],
+          "priority_level": 4,
+          "priority_reason": "Explanation for the priority level",
+          "created_at": "2025-03-22T16:30:45.123456",
+          "updated_at": null
+        }
+        ```
+        
+        ### 3. Update Dispute Insights
+        **PUT** `/disputes/{dispute_id}/insights`
+        
+        **Input:**
+        ```json
+        {
+          "insights": "Updated analysis of the dispute situation",
+          "followup_questions": ["Updated question 1?", "Updated question 2?"],
+          "probable_solutions": ["Updated solution 1", "Updated solution 2"],
+          "possible_reasons": ["Updated reason 1", "Updated reason 2"],
+          "risk_score": 8.0,
+          "risk_factors": ["Updated factor 1", "Updated factor 2"],
+          "priority_level": 5,
+          "priority_reason": "Updated explanation for the priority level"
+        }
+        ```
+        
+        **Response:** (Status Code: 200)
+        ```json
+        {
+          "id": "550e8400-e29b-41d4-a716-446655440020",
+          "dispute_id": "550e8400-e29b-41d4-a716-446655440010",
+          "insights": "Updated analysis of the dispute situation",
+          "followup_questions": ["Updated question 1?", "Updated question 2?"],
+          "probable_solutions": ["Updated solution 1", "Updated solution 2"],
+          "possible_reasons": ["Updated reason 1", "Updated reason 2"],
+          "risk_score": 8.0,
+          "risk_factors": ["Updated factor 1", "Updated factor 2"],
+          "priority_level": 5,
+          "priority_reason": "Updated explanation for the priority level",
+          "created_at": "2025-03-22T16:30:45.123456",
+          "updated_at": "2025-03-22T17:45:30.987654"
+        }
+        ```
+        """
+        )
+
+    st.markdown(
+        """
+    ## Note
+    No authentication is required for these API endpoints.
+    """
+    )
+
+
+if __name__ == "__main__":
+    display_api_docs()

app/frontend/pages/customer_details.py

@@ -0,0 +1,416 @@
+# app/frontend/pages/customer_details.py
+import streamlit as st
+from utils.api_client import DisputeAPIClient
+from components.dispute_card import dispute_card
+
+
+def display_customer_details():
+    """Display details for a specific customer"""
+
+    # Get all customer details
+    all_customers = DisputeAPIClient.get_customers()
+
+    # Get customer ID from query params
+    customer_id = st.query_params.get("id")
+    if customer := DisputeAPIClient.get_customer(customer_id):
+        st.title(f"Customer Profile: {customer.get('name', 'Unknown')}")
+
+    # Load customer data
+    customer = DisputeAPIClient.get_customer(customer_id)
+    if not customer:
+        st.error("Customer not found")
+        st.button(
+            "Return to Dashboard",
+            on_click=lambda: st.query_params.update({"page": "dashboard"}),
+        )
+        return
+
+    # Header Section with return button
+    col1, col2, col3 = st.columns([1, 3, 1])
+    with col1:
+        st.button(
+            "← Back", on_click=lambda: st.query_params.update({"page": "dashboard"})
+        )
+    with col2:
+        st.title(f"Customer Profile: {customer.get('name', 'Unknown')}")
+    with col3:
+        st.write("")
+
+    # Customer Information
+    col1, col2 = st.columns(2)
+    with col1:
+        with st.container(border=True):
+            st.markdown("### Profile Information")
+            st.markdown(f"**Name:** {customer.get('name', 'Unknown')}")
+            st.markdown(f"**Email:** {customer.get('email', 'Unknown')}")
+            st.markdown(f"**Account Type:** {customer.get('account_type', 'Unknown')}")
+            st.markdown(f"**Member Since:** {customer.get('created_at', 'Unknown')}")
+
+    with col2:
+        with st.container(border=True):
+            st.markdown("### Disputes Summary")
+            st.markdown(f"**Total Disputes:** {customer.get('dispute_count', 0)}")
+
+            # Create button to file new dispute for this customer
+            st.button(
+                "➕ File New Dispute for This Customer",
+                key="new_dispute_for_customer",
+                on_click=lambda: st.query_params.update(
+                    {"page": "new_dispute", "customer_id": customer_id}
+                ),
+                type="primary",
+            )
+
+    # Load customer disputes
+    st.markdown("### Customer Disputes")
+    disputes = DisputeAPIClient.get_customer_disputes(customer_id)
+
+    if disputes:
+        # Organize disputes in columns (2 per row)
+        disputes_per_row = 2
+        rows = [
+            disputes[i : i + disputes_per_row]
+            for i in range(0, len(disputes), disputes_per_row)
+        ]
+
+        for row in rows:
+            cols = st.columns(disputes_per_row)
+            for i, dispute in enumerate(row):
+                with cols[i]:
+                    with st.container(border=True):
+                        dispute_card(dispute)
+                        st.button(
+                            "View Details",
+                            key=f"view_{dispute['id']}",
+                            on_click=lambda id=dispute["id"]: st.query_params.update(
+                                {"page": "dispute_details", "id": id}
+                            ),
+                            use_container_width=True,
+                        )
+    else:
+        st.info("This customer has no disputes on record.")
+
+    # Customer Management Tab
+    with st.expander("Customer Management", expanded=False):
+        st.markdown("### Update Customer Information")
+        with st.form("update_customer_form"):
+            updated_name = st.text_input("Name", value=customer.get("name", ""))
+            updated_email = st.text_input("Email", value=customer.get("email", ""))
+            updated_account_type = st.selectbox(
+                "Account Type",
+                options=["Individual", "Business", "Premium", "VIP"],
+                index=["Individual", "Business", "Premium", "VIP"].index(
+                    customer.get("account_type", "Individual")
+                ),
+            )
+
+            if st.form_submit_button("Update Customer"):
+                update_data = {
+                    "name": updated_name,
+                    "email": updated_email,
+                    "account_type": updated_account_type,
+                }
+
+                if DisputeAPIClient.update_customer(customer_id, update_data):
+                    st.session_state.notifications.append(
+                        {"type": "success", "message": "Customer updated successfully!"}
+                    )
+                    st.rerun()
+                else:
+                    st.error("Failed to update customer information")
+
+        # Dangerous Zone
+        st.markdown("### Dangerous Zone")
+        st.warning("These actions are permanent and cannot be undone!")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            with st.form("delete_customer_form"):
+                st.markdown("**Delete Customer Account**")
+                st.markdown(
+                    "This will remove all customer information and associated disputes"
+                )
+                confirm_delete = st.checkbox("I understand this cannot be undone")
+
+                if st.form_submit_button(
+                    "🚨 Delete Customer", use_container_width=True
+                ):
+                    if confirm_delete:
+                        if DisputeAPIClient.delete_customer(customer_id):
+                            st.session_state.notifications.append(
+                                {
+                                    "type": "success",
+                                    "message": "Customer deleted successfully!",
+                                }
+                            )
+                            st.query_params.update({"page": "dashboard"})
+                            st.rerun()
+                        else:
+                            st.error("Failed to delete customer")
+                    else:
+                        st.error("Please confirm deletion")
+
+        with col2:
+            with st.form("merge_customer_form"):
+                st.markdown("**Merge Customer Accounts**")
+                target_customer = st.selectbox(
+                    "Select target customer",
+                    options=[
+                        c["id"]
+                        for c in DisputeAPIClient.get_customers()
+                        if c["id"] != customer_id
+                    ],
+                )
+                confirm_merge = st.checkbox("Confirm account merge")
+
+                if st.form_submit_button("🔀 Merge Accounts", use_container_width=True):
+                    if confirm_merge:
+                        st.info("Account merging functionality coming soon!")
+                    else:
+                        st.error("Please confirm merge")
+
+
+
+def display_customer_details_page():
+    """Display details for a specific customer and a list of all customers"""
+
+    # Get all customer details
+    all_customers = DisputeAPIClient.get_customers()
+    
+    # Initialize session state to store selected customer if not already set
+    if 'selected_customer_id' not in st.session_state:
+        st.session_state.selected_customer_id = None
+    
+    # Header Section with return button
+    col1, col2, col3 = st.columns([1, 3, 1])
+    with col1:
+        st.button(
+            "← Back", on_click=lambda: st.query_params.update({"page": "dashboard"})
+        )
+    with col2:
+        st.title("Customer Details")
+    with col3:
+        st.write("")
+        
+    # Display all customers section
+    with st.container(border=True):
+        st.markdown("### Customer List")
+        
+        # Create a searchable filter
+        search_term = st.text_input("Search customers by name or email", "")
+        
+        # Filter customers based on search term if provided
+        filtered_customers = all_customers
+        if search_term:
+            filtered_customers = [
+                c for c in all_customers 
+                if search_term.lower() in c.get('name', '').lower() 
+                or search_term.lower() in c.get('email', '').lower()
+            ]
+        
+        # Display customers in a table
+        if filtered_customers:
+            customer_data = {
+                "ID": [c.get('id') for c in filtered_customers],
+                "Name": [c.get('name', 'Unknown') for c in filtered_customers],
+                "Email": [c.get('email', 'Unknown') for c in filtered_customers],
+                "Account Type": [c.get('account_type', 'Unknown') for c in filtered_customers],
+                "Disputes": [c.get('dispute_count', 0) for c in filtered_customers]
+            }
+            
+            customer_df = st.dataframe(
+                customer_data,
+                use_container_width=True,
+                column_config={
+                    "ID": st.column_config.TextColumn(
+                        "ID",
+                        width="small",
+                    ),
+                    "Disputes": st.column_config.NumberColumn(
+                        "Disputes",
+                        format="%d",
+                        width="small",
+                    ),
+                },
+                hide_index=True,
+            )
+            
+            # Add dropdown to select customer
+            selected_idx = 0
+            if st.session_state.selected_customer_id:
+                selected_idx = next(
+                    (i for i, c in enumerate(filtered_customers) if c.get('id') == st.session_state.selected_customer_id), 
+                    0
+                )
+            
+            selected_customer_id = st.selectbox(
+                "Select a customer to view details",
+                options=[c.get('id') for c in filtered_customers],
+                format_func=lambda x: next((c.get('name', 'Unknown') for c in filtered_customers if c.get('id') == x), 'Unknown'),
+                index=selected_idx
+            )
+            
+            # Button to select the customer
+            if st.button(
+                "View Selected Customer",
+                type="primary",
+                use_container_width=True
+            ):
+                st.session_state.selected_customer_id = selected_customer_id
+                st.rerun()
+        else:
+            st.info("No customers found matching your search criteria.")
+
+    # If customer is selected, show detailed view
+    if st.session_state.selected_customer_id:
+        customer = DisputeAPIClient.get_customer(st.session_state.selected_customer_id)
+        if not customer:
+            st.error("Customer not found")
+            st.session_state.selected_customer_id = None  # Reset selection if customer not found
+            st.rerun()
+        else:
+            # Display detailed customer information
+            st.markdown(f"## Customer Profile: {customer.get('name', 'Unknown')}")
+            
+            # Customer Information
+            col1, col2 = st.columns(2)
+            with col1:
+                with st.container(border=True):
+                    st.markdown("### Profile Information")
+                    st.markdown(f"**Name:** {customer.get('name', 'Unknown')}")
+                    st.markdown(f"**Email:** {customer.get('email', 'Unknown')}")
+                    st.markdown(f"**Account Type:** {customer.get('account_type', 'Unknown')}")
+                    st.markdown(f"**Member Since:** {customer.get('created_at', 'Unknown')}")
+
+            with col2:
+                with st.container(border=True):
+                    st.markdown("### Disputes Summary")
+                    st.markdown(f"**Total Disputes:** {customer.get('dispute_count', 0)}")
+
+                    # Create button to file new dispute for this customer
+                    st.button(
+                        "➕ File New Dispute for This Customer",
+                        key="new_dispute_for_customer",
+                        on_click=lambda: st.query_params.update(
+                            {"page": "new_dispute", "customer_id": st.session_state.selected_customer_id}
+                        ),
+                        type="primary",
+                    )
+
+            # Load customer disputes
+            st.markdown("### Customer Disputes")
+            disputes = DisputeAPIClient.get_customer_disputes(st.session_state.selected_customer_id)
+
+            if disputes:
+                # Organize disputes in columns (2 per row)
+                disputes_per_row = 2
+                rows = [
+                    disputes[i : i + disputes_per_row]
+                    for i in range(0, len(disputes), disputes_per_row)
+                ]
+
+                for row in rows:
+                    cols = st.columns(disputes_per_row)
+                    for i, dispute in enumerate(row):
+                        with cols[i]:
+                            with st.container(border=True):
+                                dispute_card(dispute)
+                                st.button(
+                                    "View Details",
+                                    key=f"view_{dispute['id']}",
+                                    on_click=lambda id=dispute["id"]: st.query_params.update(
+                                        {"page": "dispute_details", "id": id}
+                                    ),
+                                    use_container_width=True,
+                                )
+            else:
+                st.info("This customer has no disputes on record.")
+
+            # Customer Management Tab
+            with st.expander("Customer Management", expanded=False):
+                st.markdown("### Update Customer Information")
+                with st.form("update_customer_form"):
+                    updated_name = st.text_input("Name", value=customer.get("name", ""))
+                    updated_email = st.text_input("Email", value=customer.get("email", ""))
+                    updated_account_type = st.selectbox(
+                        "Account Type",
+                        options=["Individual", "Business", "Premium", "VIP"],
+                        index=["Individual", "Business", "Premium", "VIP"].index(
+                            customer.get("account_type", "Individual")
+                        ),
+                    )
+
+                    if st.form_submit_button("Update Customer"):
+                        update_data = {
+                            "name": updated_name,
+                            "email": updated_email,
+                            "account_type": updated_account_type,
+                        }
+
+                        if DisputeAPIClient.update_customer(st.session_state.selected_customer_id, update_data):
+                            st.session_state.notifications.append(
+                                {"type": "success", "message": "Customer updated successfully!"}
+                            )
+                            st.rerun()
+                        else:
+                            st.error("Failed to update customer information")
+
+                # Dangerous Zone
+                st.markdown("### Dangerous Zone")
+                st.warning("These actions are permanent and cannot be undone!")
+
+                col1, col2 = st.columns(2)
+                with col1:
+                    with st.form("delete_customer_form"):
+                        st.markdown("**Delete Customer Account**")
+                        st.markdown(
+                            "This will remove all customer information and associated disputes"
+                        )
+                        confirm_delete = st.checkbox("I understand this cannot be undone")
+
+                        if st.form_submit_button(
+                            "🚨 Delete Customer", use_container_width=True
+                        ):
+                            if confirm_delete:
+                                if DisputeAPIClient.delete_customer(st.session_state.selected_customer_id):
+                                    st.session_state.notifications.append(
+                                        {
+                                            "type": "success",
+                                            "message": "Customer deleted successfully!",
+                                        }
+                                    )
+                                    st.session_state.selected_customer_id = None
+                                    st.query_params.update({"page": "dashboard"})
+                                    st.rerun()
+                                else:
+                                    st.error("Failed to delete customer")
+                            else:
+                                st.error("Please confirm deletion")
+
+                with col2:
+                    with st.form("merge_customer_form"):
+                        st.markdown("**Merge Customer Accounts**")
+                        target_customer = st.selectbox(
+                            "Select target customer",
+                            options=[
+                                c["id"]
+                                for c in DisputeAPIClient.get_customers()
+                                if c["id"] != st.session_state.selected_customer_id
+                            ],
+                        )
+                        confirm_merge = st.checkbox("Confirm account merge")
+
+                        if st.form_submit_button("🔀 Merge Accounts", use_container_width=True):
+                            if confirm_merge:
+                                st.info("Account merging functionality coming soon!")
+                            else:
+                                st.error("Please confirm merge")
+    else:
+        # If no customer is selected, show a prompt
+        st.info("Please select a customer from the list above to view their details.")
+
+
+if __name__ == "__main__":
+    display_customer_details_page()
+    
+

app/frontend/pages/dashboard.py

@@ -0,0 +1,203 @@
+# app/frontend/pages/dashboard.py
+import streamlit as st
+from typing import List, Dict
+from utils.api_client import DisputeAPIClient
+from components.dispute_card import dispute_card
+
+
+def display_dashboard():
+    """Main dashboard view with dispute overview and filtering"""
+
+    st.title("Dispute Management Dashboard")
+
+    # Metrics Row
+    metrics = DisputeAPIClient.get_dashboard_metrics()
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric(
+            "Total Disputes",
+            metrics.get("total_disputes", 0),
+        )
+    with col2:
+        st.metric(
+            "High Priority",
+            metrics.get("high_priority_count", 0),
+        )
+    with col3:
+        st.metric(
+            "Pending Review",
+            metrics.get("pending_count", 0),
+        )
+    with col4:
+        system_healthy = DisputeAPIClient.check_health()
+        st.metric("System Status", "✅ Online" if system_healthy else "❌ Offline")
+
+    # Store filter state in session state to persist between refreshes
+    if "priority_filter" not in st.session_state:
+        st.session_state.priority_filter = []
+    if "status_filter" not in st.session_state:
+        st.session_state.status_filter = []
+    if "sort_option" not in st.session_state:
+        st.session_state.sort_option = "Priority"
+
+    # Filters with two columns for better layout
+    with st.expander("Filter Disputes", expanded=True):
+        col1, col2 = st.columns(2)
+
+        with col1:
+            # Priority filter with more descriptive labels
+            priority_filter = st.multiselect(
+                "Priority Level",
+                options=[1, 2, 3, 4, 5],
+                default=st.session_state.priority_filter,
+                format_func=lambda x: f"P{x} - {'Critical' if x >= 4 else 'High' if x == 3 else 'Medium' if x == 2 else 'Low'}",
+            )
+            st.session_state.priority_filter = priority_filter
+
+            # Status filter with common statuses
+            status_filter = st.multiselect(
+                "Status",
+                options=[
+                    "Open",
+                    "Under Review",
+                    "Info Requested",
+                    "Resolved",
+                    "Approved",
+                    "Rejected",
+                ],
+                default=st.session_state.status_filter,
+            )
+            st.session_state.status_filter = status_filter
+
+        with col2:
+            # Sort options
+            sort_option = st.selectbox(
+                "Sort By",
+                options=[
+                    "Priority",
+                    "Date (Newest)",
+                    "Date (Oldest)",
+                    "Amount (High to Low)",
+                ],
+                index=[
+                    "Priority",
+                    "Date (Newest)",
+                    "Date (Oldest)",
+                    "Amount (High to Low)",
+                ].index(st.session_state.sort_option),
+            )
+            st.session_state.sort_option = sort_option
+
+            # Add a clear filters button
+            if st.button("Clear Filters"):
+                st.session_state.priority_filter = []
+                st.session_state.status_filter = []
+                st.session_state.sort_option = "Priority"
+                st.rerun()
+
+    # Create New Dispute Button
+    col1, col2 = st.columns([3, 1])
+    with col2:
+        st.button(
+            "➕ Create New Dispute",
+            on_click=lambda: st.query_params.update({"page": "new_dispute"}),
+            type="primary",
+            use_container_width=True,
+        )
+
+    # Load disputes with filters
+    sort_mapping = {
+        "Priority": "priority",
+        "Date (Newest)": "date_desc",
+        "Date (Oldest)": "date_asc",
+        "Amount (High to Low)": "amount_desc",
+    }
+
+    # Get all disputes
+    all_disputes = DisputeAPIClient.get_disputes(
+        sort_by=sort_mapping.get(sort_option, "priority")
+    )
+
+    # Apply filters manually (since API filter parameters aren't working)
+    if all_disputes:
+        filtered_disputes = all_disputes
+
+        # Apply priority filter if set
+        if priority_filter:
+            filtered_disputes = [
+                d for d in filtered_disputes if d.get("priority") in priority_filter
+            ]
+
+        # Apply status filter if set
+        if status_filter:
+            filtered_disputes = [
+                d for d in filtered_disputes if d.get("status") in status_filter
+            ]
+
+        # Apply sorting if needed
+        if sort_option == "Date (Newest)":
+            filtered_disputes.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+        elif sort_option == "Date (Oldest)":
+            filtered_disputes.sort(key=lambda x: x.get("created_at", ""))
+        elif sort_option == "Amount (High to Low)":
+            filtered_disputes.sort(
+                key=lambda x: float(x.get("amount", 0)), reverse=True
+            )
+        elif sort_option == "Priority":
+            filtered_disputes.sort(key=lambda x: x.get("priority", 1), reverse=True)
+
+        disputes = filtered_disputes
+    else:
+        disputes = []
+
+    # Display disputes
+    if disputes:
+        st.subheader(f"Disputes ({len(disputes)})")
+
+        # Organize disputes in columns (2 per row)
+        disputes_per_row = 2
+        rows = [
+            disputes[i : i + disputes_per_row]
+            for i in range(0, len(disputes), disputes_per_row)
+        ]
+
+        for row in rows:
+            cols = st.columns(disputes_per_row)
+            for i, dispute in enumerate(row):
+                with cols[i]:
+                    with st.container(border=True):
+                        dispute_card(dispute)
+
+                        # Show analysis summary if available
+                        if dispute.get("analysis"):
+                            st.info(
+                                f"Priority: P{dispute['analysis'].get('priority', 'N/A')} • Risk: {dispute['analysis'].get('risk_score', 'N/A')}%"
+                            )
+
+                        # Action buttons
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.button(
+                                "View Details",
+                                key=f"view_{dispute['id']}",
+                                on_click=lambda id=dispute["id"]: st.query_params.update(
+                                    {"page": "dispute_details", "id": id}  # Add clear params
+                                ),
+                                use_container_width=True,
+                            )
+                        with col2:
+                            if dispute.get("customer_id"):
+                                st.button(
+                                    "Customer Info",
+                                    key=f"customer_{dispute['id']}",
+                                    on_click=lambda cid=dispute["customer_id"]: st.query_params.update(
+                                        {"page": "customer_details", "id": cid}
+                                    ),
+                                    use_container_width=True,
+                                )
+    else:
+        st.info("No disputes found. Adjust your filters or create a new dispute.")
+
+
+if __name__ == "__main__":
+    display_dashboard()

app/frontend/pages/dispute_details.py

@@ -0,0 +1,544 @@
+# app/frontend/pages/dispute_details.py
+import streamlit as st
+from datetime import datetime
+from utils.api_client import DisputeAPIClient
+from components.insights_panel import ai_insights_panel
+from components.followup_questions import display_followup_questions
+
+
+def display_dispute_details():
+    """Detailed view of a single dispute"""
+
+    # Get all disputes
+    all_disputes = DisputeAPIClient.get_disputes()
+
+    # Get dispute ID from query params
+    dispute_id = st.query_params.get("id")
+
+
+    if not dispute_id:
+        st.error("No dispute selected")
+        st.button(
+            "Return to Dashboard",
+            on_click=lambda: st.query_params.update({"page": "dashboard"}),
+        )
+        return
+
+    # Load dispute data
+    dispute = DisputeAPIClient.get_dispute(dispute_id)
+    if not dispute:
+        st.error("Dispute not found")
+        st.button(
+            "Return to Dashboard",
+            on_click=lambda: st.query_params.update({"page": "dashboard"}),
+        )
+        return
+
+    # Header Section with return button
+    col1, col2, col3 = st.columns([1, 3, 1])
+    with col1:
+        st.button(
+            "← Back", on_click=lambda: st.query_params.update({"page": "dashboard"})
+        )
+    with col2:
+        st.title(f"Dispute #{dispute['id'][:6]}")
+    with col3:
+        st.write("")
+
+    # Status bar with styled colors
+    status_colors = {
+        "Open": "🔵",
+        "Under Review": "🟠",
+        "Info Requested": "🟡",
+        "Resolved": "🟢",
+        "Approved": "✅",
+        "Rejected": "❌",
+    }
+
+    status = dispute.get("status", "Unknown")
+    priority = dispute.get("priority", "N/A")
+
+    # Status and Priority Indicators
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown(f"### Status: {status_colors.get(status, '⚪')} {status}")
+    with col2:
+        priority_color = (
+            "red"
+            if priority >= 4
+            else "orange" if priority == 3 else "blue" if priority == 2 else "green"
+        )
+        st.markdown(
+            f"### Priority: <span style='color:{priority_color};'>P{priority}</span>",
+            unsafe_allow_html=True,
+        )
+
+    # Main Content Tabs
+    tab1, tab2, tab3 = st.tabs(["Details", "AI Analysis", "Resolution"])
+
+    with tab1:
+        # Basic Info Columns
+        col1, col2 = st.columns(2)
+        with col1:
+            with st.container(border=True):
+                st.markdown("### Customer Information")
+                if "customer" in dispute and dispute["customer"]:
+                    customer = dispute["customer"]
+                    st.markdown(f"**Name:** {customer.get('name', 'Unknown')}")
+                    st.markdown(f"**Email:** {customer.get('email', 'Unknown')}")
+                    st.markdown(
+                        f"**Account Type:** {customer.get('account_type', 'Unknown')}"
+                    )
+                    st.markdown(
+                        f"**Total Disputes:** {customer.get('dispute_count', 0)}"
+                    )
+
+                    # Customer details button
+                    st.button(
+                        "View Customer Profile",
+                        key="view_customer",
+                        on_click=lambda: st.query_params.update(
+                            {"page": "customer_details", "id": customer["id"]}
+                        ),
+                        use_container_width=True,
+                    )
+                else:
+                    customer_id = dispute.get("customer_id")
+                    st.markdown(f"**Customer ID:** {customer_id}")
+                    st.markdown("_Detailed customer information not available_")
+
+        with col2:
+            with st.container(border=True):
+                st.markdown("### Transaction Information")
+                st.markdown(f"**Amount:** ${dispute.get('amount', 0):.2f}")
+                st.markdown(f"**Merchant:** {dispute.get('merchant_name', 'Unknown')}")
+                st.markdown(
+                    f"**Transaction ID:** {dispute.get('transaction_id', 'Unknown')}"
+                )
+                st.markdown(f"**Category:** {dispute.get('category', 'Unknown')}")
+                st.markdown(f"**Created:** {dispute.get('created_at', 'Unknown')}")
+                if dispute.get("resolved_at"):
+                    st.markdown(f"**Resolved:** {dispute.get('resolved_at')}")
+
+        # Description Section
+        st.markdown("### Dispute Description")
+        st.write(dispute.get("description", "No description provided"))
+
+    with tab2:
+        # AI Insights Section
+        st.markdown("## AI Analysis")
+
+        # Get analysis from dedicated insights endpoint
+        analysis = DisputeAPIClient.get_insights(dispute_id)
+
+        if analysis:
+            ai_insights_panel(analysis, dispute.get("priority", 3))
+
+            # If followup questions exist
+            if analysis.get("followup_questions"):
+                st.markdown("### Follow-up Interactions")
+                display_followup_questions(
+                    questions=analysis["followup_questions"],
+                    dispute_id=dispute_id,
+                )
+
+        else:
+            st.warning("No stored analysis found")
+            if st.button("Generate New Analysis", type="primary"):
+                with st.spinner("Analyzing..."):
+                    new_analysis = DisputeAPIClient.analyze_dispute(dispute_id)
+                    if new_analysis and DisputeAPIClient.save_insights(
+                        dispute_id, new_analysis
+                    ):
+                        st.rerun()
+
+    with tab3:
+        # Resolution Actions
+        st.markdown("## Resolution Actions")
+
+        # Different action buttons based on current status
+        if status in ["Open", "Under Review", "Info Requested"]:
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                if st.button(
+                    "✅ Approve Dispute", use_container_width=True, type="primary"
+                ):
+                    if DisputeAPIClient.update_dispute_status(dispute_id, "Approved"):
+                        st.session_state.notifications.append(
+                            {
+                                "type": "success",
+                                "message": "Dispute approved successfully!",
+                            }
+                        )
+                        st.rerun()
+            with col2:
+                if st.button("❌ Reject Dispute", use_container_width=True):
+                    if DisputeAPIClient.update_dispute_status(dispute_id, "Rejected"):
+                        st.session_state.notifications.append(
+                            {"type": "success", "message": "Dispute rejected"}
+                        )
+                        st.rerun()
+            with col3:
+                if st.button("📩 Request More Info", use_container_width=True):
+                    if DisputeAPIClient.update_dispute_status(
+                        dispute_id, "Info Requested"
+                    ):
+                        st.session_state.notifications.append(
+                            {"type": "success", "message": "Information request sent"}
+                        )
+                        st.rerun()
+        else:
+            st.info(f"This dispute is already {status}. No further actions available.")
+
+            # Option to reopen the dispute
+            if st.button("Reopen Dispute", use_container_width=True):
+                if DisputeAPIClient.update_dispute_status(dispute_id, "Open"):
+                    st.session_state.notifications.append(
+                        {"type": "success", "message": "Dispute reopened successfully!"}
+                    )
+                    st.rerun()
+
+        # Add notes section
+        st.markdown("### Add Resolution Notes")
+        with st.form("resolution_notes_form"):
+            notes = st.text_area(
+                "Notes",
+                height=100,
+                placeholder="Add additional resolution notes here...",
+            )
+            submitted = st.form_submit_button("Save Notes")
+            if submitted:
+                # Add logic to save notes using API
+                st.success("Notes saved successfully!")
+
+        # Dangerous Zone
+        with st.expander("Advanced Options"):
+            st.warning("Danger Zone: These actions cannot be undone!")
+            if st.button("Delete Dispute", use_container_width=True):
+                confirm = st.checkbox("I understand this action cannot be undone")
+                if confirm and DisputeAPIClient.delete_dispute(dispute_id):
+                    st.session_state.notifications.append(
+                        {"type": "success", "message": "Dispute deleted successfully!"}
+                    )
+                    st.query_params.update({"page": "dashboard"})
+                    st.rerun()
+
+
+# import streamlit as st
+# from datetime import datetime
+# from utils.api_client import DisputeAPIClient
+# from components.insights_panel import ai_insights_panel
+# from components.followup_questions import display_followup_questions
+
+
+def display_dispute_details_page():
+    """Detailed view of a single dispute"""
+
+    # Get all disputes
+    all_disputes = DisputeAPIClient.get_disputes()
+
+    # Initialize session state to store selected dispute if not already set
+    if "selected_dispute_id" not in st.session_state:
+        st.session_state.selected_dispute_id = None
+
+    # Header Section with return button
+    col1, col2, col3 = st.columns([1, 3, 1])
+    with col1:
+        st.button(
+            "← Back", on_click=lambda: st.query_params.update({"page": "dashboard"})
+        )
+    with col2:
+        st.title("Dispute Details")
+    with col3:
+        st.write("")
+
+    # Display all disputes section for selection
+    with st.container(border=True):
+        st.markdown("### Dispute List")
+
+        # Create a searchable filter
+        search_term = st.text_input(
+            "Search disputes by ID, customer_id, or merchant", ""
+        )
+
+        # Filter disputes based on search term if provided
+        filtered_disputes = all_disputes
+        if search_term:
+            filtered_disputes = [
+                d
+                for d in all_disputes
+                if (
+                    search_term.lower() in str(d.get("id", "")).lower()
+                    or search_term.lower() in get_customer_name(d).lower()
+                    or search_term.lower() in str(d.get("merchant_name", "")).lower()
+                )
+            ]
+
+        # Display disputes in a table
+        if filtered_disputes:
+            dispute_data = {
+                "ID": [d.get("id", "")[:6] for d in filtered_disputes],
+                "Customer": [get_customer_name(d) for d in filtered_disputes],
+                "Amount": [f"${d.get('amount', 0):.2f}" for d in filtered_disputes],
+                "Merchant": [
+                    d.get("merchant_name", "Unknown") for d in filtered_disputes
+                ],
+                "Status": [d.get("status", "Unknown") for d in filtered_disputes],
+                "Priority": [f"P{d.get('priority', 'N/A')}" for d in filtered_disputes],
+            }
+
+            dispute_df = st.dataframe(
+                dispute_data,
+                use_container_width=True,
+                hide_index=True,
+            )
+
+            # Add dropdown to select dispute
+            selected_idx = 0
+            if st.session_state.selected_dispute_id:
+                selected_idx = next(
+                    (
+                        i
+                        for i, d in enumerate(filtered_disputes)
+                        if d.get("id") == st.session_state.selected_dispute_id
+                    ),
+                    0,
+                )
+
+            selected_dispute_id = st.selectbox(
+                "Select a dispute to view details",
+                options=[d.get("id") for d in filtered_disputes],
+                format_func=lambda x: f"#{x[:6]} - {next((d.get('merchant_name', 'Unknown') for d in filtered_disputes if d.get('id') == x), 'Unknown')}",
+                index=selected_idx,
+            )
+
+            # Button to select the dispute
+            if st.button(
+                "View Selected Dispute", type="primary", use_container_width=True
+            ):
+                st.session_state.selected_dispute_id = selected_dispute_id
+                st.rerun()
+        else:
+            st.info("No disputes found matching your search criteria.")
+
+    # If no dispute is selected, show a prompt
+    if not st.session_state.selected_dispute_id:
+        st.info("Please select a dispute from the list above to view its details.")
+        return
+
+    # Load dispute data
+    dispute = DisputeAPIClient.get_dispute(st.session_state.selected_dispute_id)
+    if not dispute:
+        st.error("Dispute not found")
+        st.session_state.selected_dispute_id = (
+            None  # Reset selection if dispute not found
+        )
+        st.rerun()
+        return
+
+    # Show the selected dispute title
+    st.markdown(f"## Dispute #{dispute['id'][:6]}")
+
+    # Status bar with styled colors
+    status_colors = {
+        "Open": "🔵",
+        "Under Review": "🟠",
+        "Info Requested": "🟡",
+        "Resolved": "🟢",
+        "Approved": "✅",
+        "Rejected": "❌",
+    }
+
+    status = dispute.get("status", "Unknown")
+    priority = dispute.get("priority", "N/A")
+
+    # Status and Priority Indicators
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown(f"### Status: {status_colors.get(status, '⚪')} {status}")
+    with col2:
+        priority_color = (
+            "red"
+            if priority >= 4
+            else "orange" if priority == 3 else "blue" if priority == 2 else "green"
+        )
+        st.markdown(
+            f"### Priority: <span style='color:{priority_color};'>P{priority}</span>",
+            unsafe_allow_html=True,
+        )
+
+    # Main Content Tabs
+    tab1, tab2, tab3 = st.tabs(["Details", "AI Analysis", "Resolution"])
+
+    with tab1:
+        # Basic Info Columns
+        col1, col2 = st.columns(2)
+        with col1:
+            with st.container(border=True):
+                st.markdown("### Customer Information")
+                customer_info = dispute.get("customer_id")
+                
+                # Check if customer_id is a dictionary or a string/other type
+                if isinstance(customer_info, dict):
+                    st.markdown(f"**Name:** {customer_info.get('name', 'Unknown')}")
+                    st.markdown(f"**Email:** {customer_info.get('email', 'Unknown')}")
+                    st.markdown(
+                        f"**Account Type:** {customer_info.get('account_type', 'Unknown')}"
+                    )
+                    st.markdown(
+                        f"**Total Disputes:** {customer_info.get('dispute_count', 0)}"
+                    )
+
+                    # Customer details button
+                    if st.button(
+                        "View Customer Profile",
+                        key="view_customer",
+                        use_container_width=True,
+                    ):
+                        # Update session state instead of query params
+                        st.session_state.page = "customer_details"
+                        st.session_state.selected_customer_id = customer_info["id"]
+                        st.query_params.update({"page": "customer_details"})
+                        st.rerun()
+                else:
+                    st.markdown(f"**Customer ID:** {customer_info}")
+                    st.markdown("_Detailed customer information not available_")
+
+        with col2:
+            with st.container(border=True):
+                st.markdown("### Transaction Information")
+                st.markdown(f"**Amount:** ${dispute.get('amount', 0):.2f}")
+                st.markdown(f"**Merchant:** {dispute.get('merchant_name', 'Unknown')}")
+                st.markdown(
+                    f"**Transaction ID:** {dispute.get('transaction_id', 'Unknown')}"
+                )
+                st.markdown(f"**Category:** {dispute.get('category', 'Unknown')}")
+                st.markdown(f"**Created:** {dispute.get('created_at', 'Unknown')}")
+                if dispute.get("resolved_at"):
+                    st.markdown(f"**Resolved:** {dispute.get('resolved_at')}")
+
+        # Description Section
+        st.markdown("### Dispute Description")
+        st.write(dispute.get("description", "No description provided"))
+
+    with tab2:
+        # AI Insights Section
+        st.markdown("## AI Analysis")
+
+        # Get analysis from dedicated insights endpoint
+        analysis = DisputeAPIClient.get_insights(st.session_state.selected_dispute_id)
+
+        if analysis:
+            ai_insights_panel(analysis, dispute.get("priority", 3))
+
+            # If followup questions exist
+            if analysis.get("followup_questions"):
+                st.markdown("### Follow-up Interactions")
+                display_followup_questions(
+                    questions=analysis["followup_questions"],
+                    dispute_id=st.session_state.selected_dispute_id,
+                )
+
+        else:
+            st.warning("No stored analysis found")
+            if st.button("Generate New Analysis", type="primary"):
+                with st.spinner("Analyzing..."):
+                    new_analysis = DisputeAPIClient.analyze_dispute(
+                        st.session_state.selected_dispute_id
+                    )
+                    if new_analysis and DisputeAPIClient.save_insights(
+                        st.session_state.selected_dispute_id, new_analysis
+                    ):
+                        st.rerun()
+
+    with tab3:
+        # Resolution Actions
+        st.markdown("## Resolution Actions")
+
+        # Different action buttons based on current status
+        if status in ["Open", "Under Review", "Info Requested"]:
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                if st.button(
+                    "✅ Approve Dispute", use_container_width=True, type="primary"
+                ):
+                    if DisputeAPIClient.update_dispute_status(
+                        st.session_state.selected_dispute_id, "Approved"
+                    ):
+                        st.session_state.notifications.append(
+                            {
+                                "type": "success",
+                                "message": "Dispute approved successfully!",
+                            }
+                        )
+                        st.rerun()
+            with col2:
+                if st.button("❌ Reject Dispute", use_container_width=True):
+                    if DisputeAPIClient.update_dispute_status(
+                        st.session_state.selected_dispute_id, "Rejected"
+                    ):
+                        st.session_state.notifications.append(
+                            {"type": "success", "message": "Dispute rejected"}
+                        )
+                        st.rerun()
+            with col3:
+                if st.button("📩 Request More Info", use_container_width=True):
+                    if DisputeAPIClient.update_dispute_status(
+                        st.session_state.selected_dispute_id, "Info Requested"
+                    ):
+                        st.session_state.notifications.append(
+                            {"type": "success", "message": "Information request sent"}
+                        )
+                        st.rerun()
+        else:
+            st.info(f"This dispute is already {status}. No further actions available.")
+
+            # Option to reopen the dispute
+            if st.button("Reopen Dispute", use_container_width=True):
+                if DisputeAPIClient.update_dispute_status(
+                    st.session_state.selected_dispute_id, "Open"
+                ):
+                    st.session_state.notifications.append(
+                        {"type": "success", "message": "Dispute reopened successfully!"}
+                    )
+                    st.rerun()
+
+        # Add notes section
+        st.markdown("### Add Resolution Notes")
+        with st.form("resolution_notes_form"):
+            notes = st.text_area(
+                "Notes",
+                height=100,
+                placeholder="Add additional resolution notes here...",
+            )
+            submitted = st.form_submit_button("Save Notes")
+            if submitted:
+                # Add logic to save notes using API
+                st.success("Notes saved successfully!")
+
+        # Dangerous Zone
+        with st.expander("Advanced Options"):
+            st.warning("Danger Zone: These actions cannot be undone!")
+            if st.button("Delete Dispute", use_container_width=True):
+                confirm = st.checkbox("I understand this action cannot be undone")
+                if confirm and DisputeAPIClient.delete_dispute(
+                    st.session_state.selected_dispute_id
+                ):
+                    st.session_state.notifications.append(
+                        {"type": "success", "message": "Dispute deleted successfully!"}
+                    )
+                    st.session_state.selected_dispute_id = None
+                    st.query_params.update({"page": "dashboard"})
+                    st.rerun()
+
+
+# Helper function to safely get customer name from dispute object
+def get_customer_name(dispute):
+    customer_id = dispute.get("customer_id")
+    if isinstance(customer_id, dict):
+        return customer_id.get("name", "Unknown")
+    return "Unknown"
+
+
+if __name__ == "__main__":
+    display_dispute_details_page()

app/frontend/pages/dispute_form.py

@@ -0,0 +1,259 @@
+# app/frontend/pages/dispute_form.py
+import streamlit as st
+import uuid
+from datetime import datetime
+from utils.api_client import DisputeAPIClient
+from components.insights_panel import ai_insights_panel
+
+
+def display_dispute_form():
+    st.title("New Dispute Form")
+    response = None
+    analysis = None
+    # Load customers for dropdown
+    customers = []
+    try:
+        customers = DisputeAPIClient.get_customers()
+    except Exception as e:
+        st.error(f"Failed to load customers: {str(e)}")
+
+    # Initialize variables
+    customer_id = st.session_state.get("prefill_customer_id", "")
+    customer_name = ""
+    customer_email = ""
+
+    col1, col2 = st.columns([3, 1])
+    with col2:
+        st.button(
+            "Back to Dashboard",
+            on_click=lambda: st.query_params.update({"page": "dashboard"}),
+        )
+
+    with st.form("dispute_form"):
+        # Customer Section
+        st.subheader("Customer Information")
+
+        # Customer selection method
+        customer_method = st.radio(
+            "Select Customer Method",
+            ["Existing Customer", "New Customer"],
+            horizontal=True,
+            index=0 if customer_id else 1,
+        )
+
+        if customer_method == "Existing Customer" and customers:
+            customer_options = {
+                f"{c['name']} ({c['email']})": c["id"] for c in customers
+            }
+            selected_customer = st.selectbox(
+                "Select Customer",
+                options=list(customer_options.keys()),
+                index=(
+                    next(
+                        (
+                            i
+                            for i, c_id in enumerate(customer_options.values())
+                            if c_id == customer_id
+                        ),
+                        0,
+                    )
+                    if customer_id
+                    else 0
+                ),
+            )
+            if selected_customer:
+                customer_id = customer_options[selected_customer]
+                # Find customer details for display
+                customer = next((c for c in customers if c["id"] == customer_id), None)
+                if customer:
+                    st.write(f"Account Type: {customer['account_type']}")
+                    st.write(f"Previous Disputes: {customer.get('dispute_count', 0)}")
+        else:
+            customer_name = st.text_input("Customer Name")
+            customer_email = st.text_input("Customer Email")
+            account_type = st.selectbox(
+                "Account Type", options=["Individual", "Business", "Premium", "VIP"]
+            )
+
+        # Transaction Details
+        st.subheader("Transaction Details")
+        col1, col2 = st.columns(2)
+        with col1:
+            transaction_id = st.text_input(
+                "Transaction ID - Auto Generated",
+                value=f"TXN-{uuid.uuid4().hex[:10].upper()}",
+                disabled=True,
+            )
+            amount = st.number_input(
+                "Amount ($)", min_value=0.01, step=1.0, value=100.00
+            )
+        with col2:
+            merchant_name = st.text_input("Merchant Name")
+            transaction_date = st.date_input("Transaction Date")
+
+        # Dispute Details
+        st.subheader("Dispute Information")
+        category = st.selectbox(
+            "Category",
+            [
+                "Unauthorized",
+                "Fraud",
+                "Service Not Rendered",
+                "Duplicate",
+                "Product Quality",
+                "Billing Error",
+                "Other",
+            ],
+        )
+        description = st.text_area(
+            "Description",
+            placeholder="Please provide detailed information about the dispute...",
+            height=150,
+        )
+
+        # Additional Information
+        with st.expander("Additional Information (Optional)"):
+            attach_evidence = st.checkbox("I have evidence to attach")
+            if attach_evidence:
+                st.file_uploader("Upload Evidence", type=["pdf", "jpg", "png"])
+            urgency = st.slider(
+                "Urgency Level",
+                1,
+                5,
+                2,
+                help="Higher urgency may affect prioritization",
+            )
+
+        # Add a hidden field to store action after form submission
+        view_details = st.checkbox(
+            "View complete details after submission", value=True, key="view_details"
+        )
+
+        # Form Submission
+        submitted = st.form_submit_button("Submit Dispute", use_container_width=True)
+
+    if submitted:
+        if customer_method == "New Customer" and (
+            not customer_name or not customer_email
+        ):
+            st.error("Please enter customer name and email")
+            return
+
+        if not merchant_name or not description:
+            st.error("Please fill in all required fields")
+            return
+
+        # If new customer, create customer first
+        if customer_method == "New Customer":
+            customer_data = {
+                "name": customer_name,
+                "email": customer_email,
+                "account_type": account_type,
+            }
+
+            try:
+                with st.spinner("Creating new customer..."):
+                    new_customer = DisputeAPIClient.create_customer(customer_data)
+                if new_customer:
+                    customer_id = new_customer["id"]
+                else:
+                    st.error("Failed to create customer: No data returned from API")
+                    return
+            except Exception as e:
+                st.error(f"Failed to create customer: {str(e)}")
+                return
+
+        # Now create the dispute
+        dispute_data = {
+            "customer_id": customer_id,
+            "transaction_id": transaction_id,
+            "merchant_name": merchant_name,
+            "amount": float(amount),
+            "description": description,
+            "category": category,
+        }
+
+        with st.spinner("Creating dispute and analyzing using AI 🤖..."):
+            try:
+                # Create dispute
+                response = DisputeAPIClient.create_dispute(dispute_data)
+                if not response:
+                    st.error("Failed to create dispute")
+                    return
+
+                # Generate and save analysis
+                # If analysis already present, load it
+                # analysis = DisputeAPIClient.get_dispute(response["id"])
+
+                # if not analysis:
+                #     analysis = DisputeAPIClient.analyze_dispute(response["id"])
+
+                # if analysis and DisputeAPIClient.save_insights(response["id"], analysis):
+                #     # Store in session state to maintain UI state
+                #     st.session_state.new_dispute_analysis = {
+                #         "dispute_id": response["id"],
+                #         "analysis": analysis
+                #     }
+                #     st.success("Dispute created successfully!")
+                # else:
+                #     st.error("Dispute created but analysis failed")
+
+                analysis = DisputeAPIClient.analyze_dispute(response["id"])
+                st.session_state.new_dispute_analysis = {
+                    "dispute_id": response["id"],
+                    "analysis": analysis,
+                }
+                st.success("Dispute created successfully!")
+
+            except Exception as e:
+                st.error(f"Error: {str(e)}")
+                return
+
+    # After form submission, show analysis if available
+    if "new_dispute_analysis" in st.session_state:
+        st.divider()
+        st.subheader("Initial AI Analysis Results")
+        print(st.session_state.new_dispute_analysis)
+        # Display the analysis panel
+        ai_insights_panel(
+            st.session_state.new_dispute_analysis["analysis"]["analysis"],
+            priority=st.session_state.new_dispute_analysis["analysis"]["analysis"][
+                "priority"
+            ],
+        )
+
+        # Add action buttons
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("🔄 Regenerate Analysis"):
+                with st.spinner("Re-analyzing..."):
+                    new_analysis = DisputeAPIClient.analyze_dispute(
+                        st.session_state.new_dispute_analysis["dispute_id"],
+                    )
+                    if new_analysis and DisputeAPIClient.save_insights(
+                        st.session_state.new_dispute_analysis["dispute_id"],
+                        new_analysis,
+                    ):
+                        st.session_state.new_dispute_analysis["analysis"] = new_analysis
+                        st.rerun()
+
+        with col2:
+            if st.button("📋 View Full Details"):
+                st.query_params.update(
+                    {
+                        "page": "dispute_details",
+                        "id": st.session_state.new_dispute_analysis["dispute_id"],
+                    }
+                )
+                del st.session_state.new_dispute_analysis  # Cleanup
+                st.rerun()
+
+        # Add option to create another dispute
+        if st.button("➕ Create Another Dispute"):
+            del st.session_state.new_dispute_analysis
+            st.query_params.update({"page": "new_dispute"})
+            st.rerun()
+
+
+if __name__ == "__main__":
+    display_dispute_form()

app/frontend/streamlit_app.py

@@ -0,0 +1,64 @@
+# app/frontend/streamlit_app.py
+import streamlit as st
+from components.sidebar import sidebar
+from pages.dashboard import display_dashboard
+from pages.dispute_details import display_dispute_details
+from pages.dispute_form import display_dispute_form
+from pages.admin import display_admin
+from pages.api_docs import display_api_docs
+from pages.customer_details import display_customer_details
+
+
+def main():
+    st.set_page_config(
+        page_title="Banking Dispute Resolution",
+        page_icon="⚖️",
+        layout="wide",
+        initial_sidebar_state="expanded",
+    )
+
+    # Initialize session state
+    if "current_page" not in st.session_state:
+        st.session_state.current_page = "dashboard"
+
+    if "notifications" not in st.session_state:
+        st.session_state.notifications = []
+
+    # Display sidebar
+    sidebar()
+
+    # Handle notifications if any
+    if st.session_state.notifications:
+        for notification in st.session_state.notifications:
+            if notification["type"] == "success":
+                st.success(notification["message"])
+            elif notification["type"] == "error":
+                st.error(notification["message"])
+            elif notification["type"] == "warning":
+                st.warning(notification["message"])
+            elif notification["type"] == "info":
+                st.info(notification["message"])
+        st.session_state.notifications = []
+
+    # Page routing
+    query_params = st.query_params
+    page = query_params.get("page", "dashboard")
+
+    if page == "dashboard":
+        display_dashboard()
+    elif page == "dispute_details":
+        display_dispute_details()
+    elif page == "new_dispute":
+        display_dispute_form()
+    elif page == "admin":
+        display_admin()
+    elif page == "api_docs":
+        display_api_docs()
+    elif page == "customer_details":
+        display_customer_details()
+    else:
+        st.error("Invalid page specified")
+
+
+if __name__ == "__main__":
+    main()