# Project export: XightMD This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small. ## Project metadata - Hackathon: UC Berkeley AI Hackathon 2025 - Tagline: Supplementing and Complementing Radiologist Expertise. - Devpost: https://devpost.com/software/xightmd - GitHub: https://github.com/joannsum/XightMD - Demo: https://xightmd.up.railway.app/ - Video: https://www.youtube.com/embed/0P4xNDoM9OM?enablejsapi=1&hl=en_US&rel=0&start=&version=3&wmode=transparent - Team: 3 GitHub contributor(s) — joannsum (30 commits), laurakallem (10 commits), johnson-liu-code (3 commits) ## Devpost submission (written by the team) ### Inspiration The global radiologist shortage is reaching crisis levels - with over 42,000 radiologists needed by 2033 and patients waiting hours or days for critical chest X-ray diagnoses. We were inspired by the potential to use AI not to replace radiologists, but to extend upon their expertise and ensure no patient waits for a life-saving diagnosis. Emergency departments need instant triage for conditions like pneumothorax, while rural hospitals lack access to in-person specialist expertise entirely. ### What it does XightMD is an AI-powered chest X-ray analysis platform that provides instant triage and structured radiology reports in under 30 seconds. Our multi-agent system coordinates four specialized AI agents: Triage Agent: Analyzes X-rays for 14 lung conditions, assigns urgency scores (1-5), and identifies critical findings Report Agent: Generates structured radiology reports following professional medical standards (Indication, Comparison, Findings, Impression) QA Agent: Validates analysis consistency and flags cases requiring manual review Coordinator Agent: Orchestrates the entire pipeline and manages workflow Intended functionaliy=ty The system provides confidence scores, priority levels, and detailed medical findings while maintaining HIPAA-compliant de-identification processes. ### How we built it Frontend: Next.js 14 with TypeScript and Tailwind CSS for a responsive medical interface Backend: FastAPI server bridging frontend requests to the agent network AI Framework: Fetch.ai's uAgents for multi-agent coordination with Claude 4 for multimodal analysis ML Pipeline: Custom lung disease classifier trained on medical datasets Data: Trained done using the NIH Chest X-ray dataset (100,000+ images) and reports structured using ReXGradient-160K formats Architecture Flow: ### Challenges we ran into Deployment Nightmares: Multiple deployment failures across different platforms, with agent network connectivity issues preventing final deployment despite working locally. Model Architecture Chaos: Experienced difficulties training on the data using various architectures due to poor understanding of the effect that class imbalance has on training multi-class classifiers. Agent Integration Hell: Getting four separate uAgents to communicate reliably was far more complex than expected. Message passing, state management, and coordination between agents broke multiple times, especially under load. Last-Minute Breaks: With hours left before submission, our agent network mysteriously stopped communicating properly, forcing us to implement fallback mock responses to demonstrate the UI. Medical Data Complexity: Real medical datasets are messy - inconsistent formats, missing labels, and strict privacy requirements made training significantly harder than standard ML projects. Time Crunch: Ambitious multi-agent architecture proved too complex for hackathon timeframe - we underestimated the coordination complexity between Claude API, uAgents, and medical data processing. ### Accomplishments we're proud of Built a Working Medical AI Pipeline: Despite challenges, created a functional chest X-ray analysis system that produces medically accurate reports Multi-Agent Architecture: Successfully implemented complex agent coordination using Fetch.ai's uAgents framework with specialized roles Professional Medical Interface: Created a polished healthcare-grade UI that medical professionals could actually use Real Dataset Integration: Trained models on legitimate medical datasets (NIH, ReXGradient-160K) rather than toy examples Technical Innovation: Combined computer vision, natural language processing, and multi-agent systems in a novel healthcare application. ### What we learned Hackathon Projects ≠ Ready Medical Systems: Medical AI is significantly more complex than typical hackathon projects due to regulatory, accuracy, and safety requirements. Multi-Agent Systems Are Hard: Coordinating multiple AI agents reliably requires robust error handling, state management, and fallback mechanisms we didn't initially account for. Deployment is Critical: The most impressive local demo means nothing if you can't deploy it reliably - should have prioritized deployment infrastructure earlier. Medical Data is Unique: Healthcare datasets require specialized preprocessing, privacy handling, and domain expertise that differs drastically from standard ML workflows. Scope Creep Kills: Our ambitious vision of multiple agents, custom ML models, and production-ready features was too much for 24 hours - simpler MVP would have been more successful. Integration Testing Matters: Individual components worked perfectly, but integration between agents, APIs, and frontend broke in unexpected ways under pressure. ### What's next Immediate Fixes: Resolve deployment issues and stabilize agent communication for reliable demo deployment. Model Optimization: Improve lung disease detection accuracy through better handling of class imbalances and more compute time/resources. Clinical Validation: Partner with radiologists to validate our reports against real clinical cases and refine medical accuracy. Expansion: Extend beyond chest X-rays to other imaging modalities (CT, MRI) and anatomical regions. Real-World Pilot: Deploy pilot programs in emergency departments and rural hospitals to demonstrate real clinical impact. Agent Improvements: Enhance multi-agent coordination, add specialized agents for specific conditions, and improve quality assurance algorithms. XightMD represents the future of AI-assisted radiology - not replacing doctors, but empowering them to save more lives, reliably and faster. ## README (from the GitHub repository) # XightMD - Chest X-Ray Multi-Label Classification ## Model Performance - **Current F1 Score**: 0.23 (epoch 60, still training) - **Baseline**: Random = 0.067, so 3.43x improvement - **Architecture**: EfficientNet-B0 with 2-layer classifier - **Dataset**: NIH Chest X-ray 14, ~10k samples ## Architecture ### OptimizedLungClassifier (`lung_classifier.py`) ```python # EfficientNet-B0 backbone # Custom classifier: 1280 -> 512 -> 15 outputs # No sigmoid (BCEWithLogitsLoss handles it) # Dropout: 0.3, 0.2 ``` ### SimpleLungModel (`balanced_lung_trainer.py`) ```python # ResNet18 backbone # Direct FC: 512 -> 15 outputs # Used for balanced training experiments ``` ## Multi-Label Classification **15 Classes**: ``` Atelectasis, Cardiomegaly, Consolidation, Edema, Effusion, Emphysema, Fibrosis, Hernia, Infiltration, Mass, Nodule, Pleural Thickening, Pneumonia, Pneumothorax, No Finding ``` **Problem**: Severe class imbalance - "No Finding": ~60% of samples - "Hernia": ~0.2% of samples **Solution**: Balanced sampling in `BalancedNIHDataset` - Limits "No Finding" to 25% of training data - Ensures minimum samples per pathology class ## Training Configuration ### Data Processing ```python # Input: 224x224 RGB (grayscale X-rays converted) # Augmentation: RandomCrop, HorizontalFlip, Rotation(5°), ColorJitter # Normalization: ImageNet stats [0.485, 0.456, 0.406], [0.229, 0.224, 0.225] ``` ### Training Parameters ```python # Loss: BCEWithLogitsLoss (multi-label) # Optimizer: AdamW, lr=0.001, weight_decay=1e-4 # Scheduler: ReduceLROnPlateau(patience=3, factor=0.5) # Batch size: 16 # Gradient clipping: max_norm=1.0 ``` ## Thresholds Per-condition optimized thresholds (not standard 0.5): ```python 'Pneumothorax': 0.25, # Critical condition 'Mass': 0.20, # Cancer screening 'Pneumonia': 0.22, 'Atelectasis': 0.18, 'Hernia': 0.50, # Rare condition 'No Finding': 0.60 # High threshold to reduce false normals ``` ## Implementation Details ### Prediction Pipeline ```python def predict(self, image_path: str) -> Dict[str, float]: # Load image -> RGB conversion -> resize(224,224) # Forward pass -> sigmoid(logits) -> numpy # Return dict of condition:probability ``` ### Class Imbalance Handling ```python class BalancedNIHDataset: # Separate "No Finding" from pathology samples # Limit pathology samples per condition # Shuffle and create balanced final dataset ``` ## File Structure ``` backend/utils/lung_classifier.py # Main model definition and inference balanced_lung_trainer.py # Balanced training pipeline train_optimized.py # Full training with metrics tracking ``` ## Current Results (Epoch 60) **Macro F1**: 0.23 - Training trend: Consistent improvement over 60 epochs - Better performing classes: Cardiomegaly (~0.35), Pneumonia (~0.28) - Challenging classes: Hernia, Fibrosis (limited training data) **Training stability**: Loss decreasing, F1 improving consistently ## Technical Challenges Solved 1. **Double sigmoid issue**: Fixed BCEWithLogitsLoss + model architecture mismatch 2. **Class imbalance**: Implemented balanced sampling strategy 3. **14 vs 15 class mismatch**: Unified architecture to handle all LABELS 4. **Dataset inconsistency**: Standardized on NIH Chest X-ray 14 ## Benchmarking ``` NIH Chest X-ray 14 Literature: - Basic CNN: F1 = 0.15-0.20 - ResNet/DenseNet: F1 = 0.20-0.30 ← Current range - Ensemble methods: F1 = 0.30-0.40 - SOTA research: F1 = 0.40+ ``` ## Dependencies ``` torch==2.7.1 torchvision==0.22.1 datasets==3.6.0 scikit-learn==1.7.0 Pillow==11.2.1 ``` ## Usage ```python # Load model classifier = LungClassifierTrainer('path/to/model.pth') # Inference predictions = classifier.predict('xray.jpg') # Returns: {'Pneumonia': 0.78, 'Effusion': 0.23, ...} # Apply thresholds significance = classifier.get_statistical_significance(predictions) ``` ## Training Commands ```bash # Balanced training (handles class imbalance) python balanced_lung_trainer.py # Full training pipeline python train_optimized.py --epochs 50 --batch-size 16 ``` ## Model Files - Best model: `models/lung_classifier_BEST.pth` - Training history: `models/training_history_optimized.json` - Balanced model: `balanced_lung_model.pth` ## Detected evidence (automated analysis) Indexed codebase: 29 recognized source files, 213 KB. - Anthropic (technology) — detected in the code - CSS (language) — detected in the code - FastAPI (technology) — detected in the code - Hugging Face (technology) — detected in the code - Next.js (technology) — detected in the code - Python (language) — detected in the code - PyTorch (technology) — detected in the code - React (technology) — detected in the code - Tailwind CSS (technology) — detected in the code - TypeScript (language) — detected in the code - AI coding agent: Claude Code — evidence: config files committed to the repository ## Codebase structure (from repository index) ### Files (50 of 50) ``` .gitignore backend/.gitignore backend/agents/coordinator.py backend/agents/qa_agent.py backend/agents/report_agent.py backend/agents/triage_agent.py backend/api/server.py backend/Dockerfile backend/models/balanced_lung_model.pth backend/models/lung_classifier_best.pth backend/models/lung_classifier_final.pth backend/models/lung_classifier.pth backend/models/training_history.json backend/requirements-minimal.txt backend/requirements.txt backend/start.sh backend/test_classifier.py backend/train_model.py backend/utils/lung_classifier.py backend/validate_setup.py CLAUDE.md modal_deployment/model_service.py modal_deployment/models/lung_classifier_best.pth modal_deployment/models/lung_classifier_checkpoint_epoch_30.pth modal_deployment/models/lung_classifier_final.pth modal_deployment/models/lung_classifier.pth modal_deployment/models/training_history.json modal_deployment/requirements_modal.txt README.md xightmd/.gitignore xightmd/Dockerfile xightmd/next.config.ts xightmd/package.json xightmd/postcss.config.mjs xightmd/README.md xightmd/src/app/api/agent-status/route.ts xightmd/src/app/api/analyze/route.ts xightmd/src/app/api/health/route.ts xightmd/src/app/globals.css xightmd/src/app/layout.tsx xightmd/src/app/page.tsx xightmd/src/app/viewport.ts xightmd/src/components/AgentStatus.tsx xightmd/src/components/Dashboard.tsx xightmd/src/components/ImageUpload.tsx xightmd/src/components/ReportDisplay.tsx xightmd/src/lib/api.ts xightmd/src/types/index.ts xightmd/tailwind.config.ts xightmd/tsconfig.json ``` ### Dependencies - backend/requirements.txt: aiofiles@>=23.0.0, anthropic@==0.54.0, black@>=24.0.0, datasets@==3.6.0, fastapi@==0.115.13, httpx@>=0.25.0, huggingface-hub@>=0.26.0, isort@>=5.13.0, numpy@>=1.24.0,<2.0.0, opencv-python@>=4.8.0, pandas@>=2.0.0,<3.0.0, Pillow@==11.2.1, pydantic@>=2.0.0, pytest@>=8.0.0, python-dotenv@>=1.0.0, python-multipart@==0.0.20, reportlab@==4.4.2, rich@>=13.0.0, scikit-image@>=0.22.0, scikit-learn@==1.7.0, structlog@>=23.0.0, torch@==2.7.1, torchvision@==0.22.1, tqdm@>=4.65.0, transformers@>=4.46.0, uagents@==0.22.5, uvicorn@==0.34.3 - xightmd/package.json: @tailwindcss/postcss@^4, @types/node@^20, @types/react@^19, @types/react-dom@^19, autoprefixer@^10.4.17, eslint@^8, eslint-config-next@15.3.4, next@15.3.4, postcss@^8.4.33, react@^19.0.0, react-dom@^19.0.0, tailwindcss@^4, typescript@^5 ### Recent commits (newest first) - Committing final working model - Added readme to main. - modified thresholds, moved .pth file into modal deployment - Merge remote-tracking branch 'refs/remotes/origin/main' - Add trained model checkpoint from raspberry-yogurt branch - modified server - Merge remote-tracking branch 'refs/remotes/origin/main' - modified server - train model push - removed real model - added reportlab import - another - edited start.sh - updated Dockerfile - frontend connection - Switch to Modal for ML inference, lightweight Railway deployment - Merge pull request #9 from joannsum/modal - railway config3000 - railway config2 - railway config ## Key source files (fetched from GitHub, selected and truncated for size) ### CLAUDE.md ```markdown # CLAUDE.md - XightMD Project ## Project Overview **XightMD** is a multi-agent AI system that assists radiologists in analyzing chest X-rays and generating structured reports. The system uses Fetch.ai's uAgents framework with Claude 4 for multimodal analysis and report generation. ### Key Features - **Multimodal AI**: Combines computer vision (chest X-ray analysis) with natural language processing (report generation) - **Multi-Agent Architecture**: Coordinated agents for triage, analysis, and reporting - **Real-time Processing**: Instant analysis and structured report generation - **Healthcare Focus**: Designed to assist radiologists, not replace them ## Architecture ``` Frontend (Next.js) ↔ API Bridge (FastAPI) ↔ Agent Network (uAgents) ↔ Claude 4 API ``` ### Components 1. **Frontend**: Next.js React application for image upload and results display 2. **API Bridge**: FastAPI server connecting frontend to agent network 3. **Agent Network**: Three coordinated uAgents handling different aspects 4. **AI Models**: Claude 4 for vision analysis and report generation ## Technology Stack ### Frontend - **Framework**: Next.js 14 with TypeScript - **Styling**: Tailwind CSS - **UI Components**: Custom React components - **API Communication**: Fetch API with FormData for file uploads ### Backend - **Agent Framework**: Fetch.ai uAgents - **API Server**: FastAPI with CORS support - **AI Integration**: Anthropic Claude API - **File Handling**: Python multipart for image uploads ### AI & ML - **Vision Model**: Claude 3.5 Sonnet (multimodal) - **Text Generation**: Claude 4 for structured reports - **Medical Dataset**: NIH Chest X-ray dataset for validation - **Report Structure**: Based on ReXGradient-160K format ## Project Structure ``` XightMD/ ├── backend/ │ ├── api/ │ │ └── server.py # FastAPI bridge │ ├── agents/ │ │ ├── coordinator.py # Main coordination agent │ │ ├── triage_agent.py # Image analysis & urgency │ │ ├── report_agent.py # Report generation │ │ └── qa_agent.py # Quality assurance │ ├── utils/ │ │ ├── image_processing.py # Image preprocessing │ │ └── claude_client.py # Claude API wrapper │ ├── requirements.txt │ └── .env # API keys └── xightmd/ # Next.js frontend ├── src/ │ ├── app/ │ │ ├── page.tsx # Main dashboard │ │ ├── upload/ # Upload interface │ │ └── api/ # API routes │ ├── components/ │ │ ├── ImageUpload.tsx # File upload component │ │ ├── ReportDisplay.tsx # Results display │ │ ├── AgentStatus.tsx # Agent monitoring │ │ └── Dashboard.tsx # Main layout │ └── lib/ │ └── api.ts # API client functions ├── package.json └── tailwind.config.js ``` ## Agent Architecture ### 1. Coordinator Agent - **Role**: Orchestrates the entire analysis pipel [truncated — 5652 more characters] ``` ### xightmd/Dockerfile ``` # xightmd/Dockerfile FROM node:18-alpine WORKDIR /app # Copy package files COPY package*.json ./ # Install ALL dependencies (including devDependencies for build) RUN npm ci # Copy source code COPY . . # Build the application RUN npm run build # Expose port EXPOSE 3000 # Start the application CMD ["npm", "start"] ``` ### xightmd/package.json ``` { "name": "xightmd", "version": "0.1.0", "private": true, "scripts": { "dev": "next dev", "build": "next build", "start": "next start", "lint": "next lint" }, "dependencies": { "react": "^19.0.0", "react-dom": "^19.0.0", "next": "15.3.4" }, "devDependencies": { "typescript": "^5", "@types/node": "^20", "@types/react": "^19", "@types/react-dom": "^19", "@tailwindcss/postcss": "^4", "tailwindcss": "^4", "postcss": "^8.4.33", "autoprefixer": "^10.4.17", "eslint": "^8", "eslint-config-next": "15.3.4" } } ``` ### backend/Dockerfile ``` FROM python:3.12.10-slim WORKDIR /app # Install system dependencies RUN apt-get update && apt-get install -y \ gcc \ g++ \ && rm -rf /var/lib/apt/lists/* # Copy minimal requirements for deployment COPY requirements-minimal.txt . # Install Python dependencies with no cache to save space RUN pip install --no-cache-dir --upgrade pip && \ pip install --no-cache-dir -r requirements-minimal.txt # Copy the rest of the application COPY . . # Make the start script executable RUN chmod +x start.sh # Expose port EXPOSE 8000 # Use the start script instead of just the API server CMD ["./start.sh"] ``` ### backend/requirements.txt ``` # Python 3.12.10 compatible requirements reportlab==4.4.2 # Agent Framework uagents==0.22.5 # AI and API Integration anthropic==0.54.0 # Web Framework and API fastapi==0.115.13 uvicorn==0.34.3 python-multipart==0.0.20 # Computer Vision and Image Processing Pillow==11.2.1 # Machine Learning and Deep Learning - COMPATIBLE VERSIONS torch==2.7.1 torchvision==0.22.1 # Note: If you have torchaudio installed and getting conflicts, uninstall it first: # pip uninstall torchaudio # We don't need torchaudio for chest X-ray analysis scikit-learn==1.7.0 # Dataset and Data Processing datasets==3.6.0 transformers>=4.46.0 huggingface-hub>=0.26.0 # Data Science and Utilities numpy>=1.24.0,<2.0.0 pandas>=2.0.0,<3.0.0 # Additional ML utilities scikit-image>=0.22.0 opencv-python>=4.8.0 # Environment and Configuration python-dotenv>=1.0.0 pydantic>=2.0.0 # Development and Testing pytest>=8.0.0 black>=24.0.0 isort>=5.13.0 # Async and HTTP httpx>=0.25.0 aiofiles>=23.0.0 # Logging and Monitoring structlog>=23.0.0 rich>=13.0.0 # Training utilities tqdm>=4.65.0 # Optional: For CUDA support (uncomment if using GPU) # torch==2.7.1+cu121 --index-url https://download.pytorch.org/whl/cu121 # torchvision==0.22.1+cu121 --index-url https://download.pytorch.org/whl/cu121 ``` ### xightmd/src/app/layout.tsx ```typescript import type { Metadata } from 'next'; import { Inter } from 'next/font/google'; import './globals.css'; const inter = Inter({ subsets: ['latin'] }); export const metadata: Metadata = { title: 'XightMD - AI-Powered Chest X-ray Analysis', description: 'Multi-agent AI system for radiologists to analyze chest X-rays and generate structured reports using Claude 4 and Fetch.ai uAgents.', keywords: ['AI', 'radiology', 'chest X-ray', 'medical imaging', 'Claude', 'uAgents'], authors: [{ name: 'XightMD Team' }], }; export default function RootLayout({ children, }: { children: React.ReactNode; }) { return ( {children} ); } ``` ### xightmd/src/types/index.ts ```typescript // Shared types for XightMD application export interface AnalysisResult { pdf_data: any; id: string; timestamp: string; urgency: number; confidence: number; findings: string[]; report: { indication: string; comparison: string; findings: string; impression: string; }; image?: string; processing_details?: { model_predictions?: Record; statistical_significance?: Record; critical_findings?: string[]; processing_time_ms?: number; agent_pipeline?: string[]; mode?: string; }; } export interface AgentInfo { status: 'active' | 'idle' | 'error' | 'offline'; lastSeen: Date | string; details?: Record; // Add this line } export interface AgentStatuses { coordinator: AgentInfo; triage: AgentInfo; report: AgentInfo; qa: AgentInfo; } export interface ApiResponse { success: boolean; data?: T; error?: string; } export interface HealthStatus { status: 'healthy' | 'unhealthy'; timestamp: string; version: string; services: { frontend: { status: string; responseTime: string }; backend: { status: string; responseTime: string; url: string }; agents: { coordinator: { status: string; lastSeen: string }; triage: { status: string; lastSeen: string }; report: { status: string; lastSeen: string }; qa: { status: string; lastSeen: string }; }; claude_api: { status: string; model: string }; }; uptime: number; memory: { used: number; total: number }; } ``` ### backend/api/server.py ```python # backend/api/server.py from fastapi import FastAPI, File, UploadFile, HTTPException from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import JSONResponse import base64 import asyncio import uuid import httpx from datetime import datetime from typing import Dict, Any, Optional import os import sys import logging from dotenv import load_dotenv load_dotenv() # Setup logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # Add the backend directory to the Python path to import utils backend_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.insert(0, backend_dir) app = FastAPI(title="XightMD API", version="1.0.0") # CORS middleware app.add_middleware( CORSMiddleware, allow_origins=["http://localhost:3000", "http://127.0.0.1:3000"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # Agent endpoint configuration for health checks AGENT_PORTS = { "coordinator": 8000, # This server "triage": 9001, # Updated ports to match uAgents "report": 9002, "qa": 9003 } MODAL_ENDPOINT = "https://joannsum--xightmd-simple-predict-lung-conditions.modal.run" # Store completed analysis results analysis_results = {} class APIServer: def __init__(self): self.lung_classifier = None self.model_loaded = False self.setup_routes() self.initialize_model() def initialize_model(self): """Initialize Modal connection instead of local model""" try: logger.info("🤖 Connecting to Modal service...") # Test Modal connection instead of loading local model import asyncio asyncio.create_task(self.test_modal_connection()) except Exception as e: logger.error(f"❌ Failed to connect to Modal: {e}") self.model_loaded = False async def test_modal_connection(self): """Test Modal service availability""" try: async with httpx.AsyncClient() as client: response = await client.get("https://joannsum--xightmd-simple-health.modal.run", timeout=10) if response.status_code == 200: self.model_loaded = True logger.info("✅ Modal service connected successfully!") else: logger.warning(f"⚠️ Modal service returned status {response.status_code}") except Exception as e: logger.error(f"❌ Modal connection failed: {e}") self.model_loaded = False def setup_routes(self): """Setup API routes""" @app.post("/api/analyze") async def analyze_image(file: UploadFile = File(...)): """Analyze uploaded chest X-ray image""" try: # Validate file if not file.content_type or not file.content_type.startswith('image/'): raise HTTPException(status_code=400, detail="File must be an image") # Check file size (15MB limit) file_size = 0 image_data = await file.read() file_size = len(image_data) if file_size > 15 * 1024 * 1024: raise HTTPException( status_code=400, detail=f"File size ({file_size / 1024 / 1024:.1f}MB) exceeds 15MB limit" ) # Encode image base64_image = base64.b64encode(image_data).decode('utf-8') # Generate request ID request_id = str(uuid.uuid4()) logger.info(f"🔍 Starting analysis for request {request_id} (file: {file.filename}, size: {file_size / 1024 / 1024:.1f}MB)") # Analyze with lung classifier result = await self.analyze_with_lung_classifier( base64_image, file.content_type, request_id, file.filename ) return JSONResponse(content={ "success": True, "data": result }) except HTTPException: raise except Exception as e: logger.error(f"❌ Analysis error: {e}") import traceback traceback.print_exc() raise HTTPException(status_code=500, detail=str(e)) @app.get("/api/health") async def health_check(): """Health check endpoint""" return { "status": "healthy", "timestamp": datetime.now().isoformat(), "version": "1.0.0", "service": "xightmd_api", "model_loaded": self.model_loaded, "lung_classifier": "available" if self.model_loaded else "unavailable" } # Add this to your server.py - improved agent status detection @app.get("/api/agents/status") async def get_agent_status(): """Get real status of all agents using simple port checking""" import socket agent_statuses = {} agents = { "coordinator": {"port": 9000, "address": os.getenv("COORDINATOR_AGENT_ADDRESS", "agent1q...")}, "triage": {"port": 8001, "address": os.getenv("TRIAGE_AGENT_ADDRESS", "agent1q...")}, "report": {"port": 8002, "address": os.getenv("REPORT_AGENT_ADDRESS", "agent1q...")}, "qa": {"port": 8006, "address": os.getenv("QA_AGENT_ADDRESS", "agent1q...")} # CHANGED: 8003 → 8006 } logger.info("🔍 Checking agent network status...") for agent_name, config in agents.items(): try: # Simple port check [truncated — 20584 more characters] ``` ### xightmd/src/app/page.tsx ```typescript 'use client'; import { useState, useEffect } from 'react'; import ImageUpload from '@/components/ImageUpload'; import ReportDisplay from '@/components/ReportDisplay'; import AgentStatus from '@/components/AgentStatus'; import Dashboard from '@/components/Dashboard'; import { AnalysisResult, AgentStatuses } from '@/types'; export default function Home() { const [isAnalyzing, setIsAnalyzing] = useState(false); const [currentAnalysis, setCurrentAnalysis] = useState(null); const [analysisHistory, setAnalysisHistory] = useState([]); const [agentStatuses, setAgentStatuses] = useState({ coordinator: { status: 'offline', lastSeen: new Date() }, triage: { status: 'offline', lastSeen: new Date() }, report: { status: 'offline', lastSeen: new Date() }, qa: { status: 'offline', lastSeen: new Date() } }); // Fetch real agent status updates useEffect(() => { const fetchAgentStatus = async () => { try { console.log('🔍 Fetching agent status...'); const response = await fetch('/api/agent-status'); console.log('📡 Response status:', response.status); if (response.ok) { const data = await response.json(); console.log('📊 Agent status response:', data); if (data.success && data.agents) { // Convert API response to the format expected by frontend const formattedAgents: AgentStatuses = { coordinator: { status: data.agents.coordinator?.status || 'offline', lastSeen: data.agents.coordinator?.lastSeen ? new Date(data.agents.coordinator.lastSeen) : new Date(), details: data.agents.coordinator?.details || {} }, triage: { status: data.agents.triage?.status || 'offline', lastSeen: data.agents.triage?.lastSeen ? new Date(data.agents.triage.lastSeen) : new Date(), details: data.agents.triage?.details || {} }, report: { status: data.agents.report?.status || 'offline', lastSeen: data.agents.report?.lastSeen ? new Date(data.agents.report.lastSeen) : new Date(), details: data.agents.report?.details || {} }, qa: { status: data.agents.qa?.status || 'offline', lastSeen: data.agents.qa?.lastSeen ? new Date(data.agents.qa.lastSeen) : new Date(), details: data.agents.qa?.details || {} } }; setAgentStatuses(formattedAgents); console.log('✅ Agent statuses updated:', formattedAgents); console.log('🔍 Active agents count:', Object.values(formattedAgents).filter(a => a.status === 'active').length); } else { console.warn('⚠️ API response missing success or agents data:', data); } } else { console.warn('⚠️ Agent status API returned non-OK status:', response.status); // Try to read error response try { const errorData = await response.text(); console.error('Error response:', errorData); } catch (e) { console.error('Could not read error response'); } } } catch (error) { console.error('❌ Failed to fetch agent status:', error); // Set all agents to offline on error setAgentStatuses(prev => ({ coordinator: { ...prev.coordinator, status: 'offline' }, triage: { ...prev.triage, status: 'offline' }, report: { ...prev.report, status: 'offline' }, qa: { ...prev.qa, status: 'offline' } })); } }; // Initial fetch fetchAgentStatus(); // Set up polling every 10 seconds (reduced frequency to avoid spam) const interval = setInterval(fetchAgentStatus, 10000); return () => clearInterval(interval); }, []); const handleImageUpload = async (file: File) => { setIsAnalyzing(true); setCurrentAnalysis(null); try { // Create FormData for file upload const formData = new FormData(); formData.append('image', file); console.log('🔍 Sending image to backend for analysis...'); // Call actual API const response = await fetch('/api/analyze', { method: 'POST', body: formData, }); if (!response.ok) { throw new Error(`Analysis failed: ${response.status} ${response.statusText}`); } const result = await response.json(); console.log('✅ Analysis result received:', result); if (result.success && result.data) { // Use real API result setCurrentAnalysis(result.data); setAnalysisHistory(prev => [result.data, ...prev.slice(0, 9)]); } else { throw new Error('Invalid response format'); } } catch (error) { console.error('❌ Analysis failed:', error); // Create fallback mock result only on error const mockResult: AnalysisResult = { id: `analysis-${Date.now()}`, timestamp: new Date().toISOString(), urgency: Math.floor(Math.random() * 5) + 1, confidence: Math.random() * 0.3 + 0.7, findings: ['Analysis failed - using mock data', 'Check server connection', 'Ensure backend is running'], report: { indication: 'System error occurred during analysis', comparison: 'No comparison available due to system error', findings: 'Unable to analyze image due to system error. Please check that the backend server and agent network are running properly.', impression: 'System maintenance required. Mock result displayed for demonstration purposes.' }, image: URL.createObjectURL(file), pdf_data: undefined }; setCurrentAnalysis(mockResult); setAnalysisHistory(prev => [mockResult, ...p [truncated — 1786 more characters] ``` ### xightmd/src/app/api/health/route.ts ```typescript // src/api/health/route.ts import { NextResponse } from 'next/server'; export async function GET() { try { // In a real implementation, you would check: // - Backend API connectivity // - Agent network status // - Claude API availability // - Database connections // Mock health check const healthStatus = { status: 'healthy', timestamp: new Date().toISOString(), version: '1.0.0', services: { frontend: { status: 'up', responseTime: '< 100ms' }, backend: { status: 'up', responseTime: '< 200ms', url: 'http://localhost:8000' }, agents: { coordinator: { status: 'active', lastSeen: new Date().toISOString() }, triage: { status: 'active', lastSeen: new Date().toISOString() }, report: { status: 'active', lastSeen: new Date().toISOString() }, qa: { status: 'active', lastSeen: new Date().toISOString() } }, claude_api: { status: 'up', model: 'claude-3-5-sonnet-20241022' } }, uptime: process.uptime(), memory: { used: Math.round(process.memoryUsage().heapUsed / 1024 / 1024), total: Math.round(process.memoryUsage().heapTotal / 1024 / 1024) } }; return NextResponse.json(healthStatus); } catch (error: unknown) { const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred'; return NextResponse.json( { status: 'unhealthy', timestamp: new Date().toISOString(), error: 'Health check failed', details: errorMessage }, { status: 500 } ); } } ``` [21 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]