Prepare project for Hugging Face Space deployment - Add app.py with Gradio interface - Update requirements.txt with torch dependencies - Configure LFS for large files (models, data) - Update README with comprehensive documentation

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,65 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+env/
+.venv
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+
+# Environment variables
+.env
+.env.local
+
+# Model files (optional - uncomment if models are large)
+# *.pth
+# *.pt
+# *.h5
+
+# Data files (optional - uncomment if data is large)
+# data/raw/*.csv
+# data/processed/*.csv
+
+# Logs
+*.log
+logs/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Docker
+.dockerignore

Dockerfile

@@ -0,0 +1,34 @@
+# Vehicle Diagnostics Agent Dockerfile
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install PyTorch (CPU version for smaller image)
+RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu
+
+# Copy application code
+COPY src/ ./src/
+COPY data/ ./data/
+
+# Expose ports
+EXPOSE 8000 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONPATH=/app
+
+# Default command (can be overridden)
+CMD ["python", "src/api/main.py"]

PROJECT_SUMMARY.md

@@ -0,0 +1,332 @@
+# Vehicle Diagnostics Agent - Project Completion Summary
+
+## 🎉 Project Status: COMPLETED
+
+All phases of the Vehicle Diagnostics Agent project have been successfully implemented and tested.
+
+---
+
+## ✅ Completed Phases
+
+### Phase 1: Project Setup and Planning ✓
+- ✅ Created project structure with organized directories
+- ✅ Set up conda environment (vda)
+- ✅ Installed all dependencies (PyTorch, LangChain, FastAPI, Gradio, etc.)
+- ✅ Generated synthetic vehicle sensor dataset (50,000 records, 100 vehicles)
+- ✅ Dataset includes 14 sensor measurements with realistic anomaly patterns
+
+### Phase 2: Data Collection and Preprocessing ✓
+- ✅ Implemented comprehensive data preprocessing pipeline
+- ✅ Applied noise filtering with moving average (window=5)
+- ✅ Engineered 60+ features including:
+  - Rate of change features
+  - Rolling statistics
+  - Domain-specific features (temp differential, tire imbalance, engine stress, etc.)
+- ✅ Normalized features using StandardScaler
+- ✅ Split data: 70% train, 10% validation, 20% test
+- ✅ Saved preprocessing artifacts (scaler, feature columns)
+
+### Phase 3: Build Individual Agents ✓
+
+#### 1. Data Ingestion Agent ✓
+- ✅ Loads and prepares vehicle sensor data
+- ✅ Supports filtering by vehicle ID and time range
+- ✅ Generates sensor summary statistics
+- ✅ Prepares data for downstream agents
+
+#### 2. Anomaly Detection Agent ✓
+- ✅ LSTM-based neural network model
+- ✅ Architecture: 2-layer LSTM with 64 hidden units
+- ✅ Trained on 31,570 sequences
+- ✅ Validation accuracy: 99.53%
+- ✅ Best validation loss: 0.0409
+- ✅ Fallback rule-based detection system
+- ✅ Identifies anomalous sensors with severity levels
+
+#### 3. Root Cause Analysis Agent ✓
+- ✅ 8 fault pattern definitions with thresholds
+- ✅ Fault code mapping (P-codes, C-codes)
+- ✅ Sensor correlation analysis
+- ✅ Failure sequence determination
+- ✅ Confidence scoring for each root cause
+
+#### 4. Maintenance Recommendation Agent ✓
+- ✅ Comprehensive maintenance action database
+- ✅ Immediate, short-term, and long-term actions
+- ✅ Cost estimation for each fault type
+- ✅ Urgency-based prioritization
+- ✅ Downtime estimation
+
+#### 5. Report Generation Agent ✓
+- ✅ Executive summary generation
+- ✅ Natural language summaries for non-technical users
+- ✅ Detailed technical reports
+- ✅ JSON-formatted structured reports
+- ✅ Timestamp and metadata tracking
+
+### Phase 4: Agent Orchestration and Workflow ✓
+- ✅ Implemented LangGraph-based orchestration
+- ✅ Sequential agent execution pipeline
+- ✅ State management across agents
+- ✅ Error handling and recovery
+- ✅ Support for single and batch vehicle diagnostics
+- ✅ Complete workflow: Data Ingestion → Anomaly Detection → Root Cause → Recommendation → Report
+
+### Phase 5: Backend and Frontend Development ✓
+
+#### FastAPI Backend ✓
+- ✅ RESTful API with 7 endpoints:
+  - `/` - Root endpoint
+  - `/health` - Health check
+  - `/vehicles` - List available vehicles
+  - `/diagnose` - Single vehicle diagnostic
+  - `/batch-diagnose` - Batch diagnostics
+  - `/report/{vehicle_id}` - Full report
+  - `/vehicle/{vehicle_id}/status` - Vehicle status
+- ✅ CORS middleware enabled
+- ✅ Pydantic models for request/response validation
+- ✅ Comprehensive error handling
+- ✅ Auto-generated API documentation (Swagger/OpenAPI)
+
+#### Gradio Frontend ✓
+- ✅ Interactive web-based UI
+- ✅ Three main tabs:
+  - Single Vehicle Diagnostic
+  - Vehicle Overview
+  - About/Documentation
+- ✅ Real-time diagnostic execution
+- ✅ Plotly visualizations for anomaly detection
+- ✅ Vehicle information display
+- ✅ Full report viewing
+- ✅ Natural language summaries
+
+### Phase 6: Testing and Validation ✓
+- ✅ Comprehensive unit test suite (12 tests)
+- ✅ All tests passing (100% success rate)
+- ✅ Tests cover:
+  - Data Ingestion Agent
+  - Anomaly Detection Agent
+  - Root Cause Analysis Agent
+  - Maintenance Recommendation Agent
+  - Report Generation Agent
+  - Full pipeline integration
+- ✅ Pytest configuration
+- ✅ Test execution time: ~3.24 seconds
+
+### Phase 7: Deployment and Documentation ✓
+- ✅ Dockerfile for containerization
+- ✅ Docker Compose configuration (API + UI services)
+- ✅ Comprehensive README.md with:
+  - Project overview
+  - Architecture diagrams
+  - Installation instructions
+  - Usage examples
+  - API documentation
+  - Performance metrics
+- ✅ .gitignore file
+- ✅ Quick start scripts (run_ui.sh, run_api.sh)
+- ✅ Requirements.txt with all dependencies
+
+---
+
+## 📊 Key Metrics
+
+### Model Performance
+- **Validation Accuracy:** 99.53%
+- **Training Loss:** 0.0003 (final epoch)
+- **Validation Loss:** 0.0409 (best)
+- **Training Time:** ~2 minutes (20 epochs on GPU)
+
+### Dataset Statistics
+- **Total Records:** 50,000
+- **Vehicles:** 100
+- **Timesteps per Vehicle:** 500
+- **Features:** 60 (engineered)
+- **Anomaly Rate:** ~9% (train), ~2% (val), ~7% (test)
+
+### System Performance
+- **Pipeline Execution Time:** ~1 second per vehicle
+- **API Response Time:** < 2 seconds
+- **Memory Usage:** Moderate (suitable for production)
+
+---
+
+## 🗂️ Project Structure
+
+```
+VehicleDiagnosticsAgent/
+├── data/
+│   ├── raw/
+│   │   └── vehicle_sensor_data.csv (50,000 records)
+│   └── processed/
+│       ├── train.csv (35,000 records)
+│       ├── val.csv (5,000 records)
+│       ├── test.csv (10,000 records)
+│       ├── scaler.pkl
+│       └── feature_columns.pkl
+├── src/
+│   ├── agents/
+│   │   ├── data_ingestion_agent.py
+│   │   ├── anomaly_detection_agent.py
+│   │   ├── root_cause_agent.py
+│   │   ├── maintenance_recommendation_agent.py
+│   │   └── report_generation_agent.py
+│   ├── models/
+│   │   ├── anomaly_detector.py
+│   │   ├── train_anomaly_detector.py
+│   │   └── best_anomaly_detector.pth (trained model)
+│   ├── utils/
+│   │   ├── download_data.py
+│   │   └── data_preprocessing.py
+│   ├── api/
+│   │   └── main.py (FastAPI backend)
+│   ├── ui/
+│   │   └── gradio_app.py (Gradio frontend)
+│   └── orchestrator.py (LangGraph orchestration)
+├── tests/
+│   └── test_agents.py (12 unit tests)
+├── Dockerfile
+├── docker-compose.yml
+├── requirements.txt
+├── README.md
+├── .gitignore
+├── run_ui.sh
+├── run_api.sh
+└── project.md
+```
+
+---
+
+## 🚀 How to Run
+
+### Option 1: Gradio UI (Recommended)
+```bash
+conda activate vda
+./run_ui.sh
+# Access at http://localhost:7860
+```
+
+### Option 2: FastAPI Backend
+```bash
+conda activate vda
+./run_api.sh
+# API at http://localhost:8000
+# Docs at http://localhost:8000/docs
+```
+
+### Option 3: Docker (Production)
+```bash
+docker-compose up --build
+# API: http://localhost:8000
+# UI: http://localhost:7860
+```
+
+### Option 4: Python Direct
+```bash
+conda activate vda
+python src/orchestrator.py  # Test orchestrator
+python src/ui/gradio_app.py  # Launch UI
+uvicorn src.api.main:app --reload  # Launch API
+```
+
+---
+
+## 🎯 Key Features Demonstrated
+
+### Technical Skills
+- ✅ Multi-agent AI system design
+- ✅ Deep learning (LSTM for time-series)
+- ✅ LangChain/LangGraph orchestration
+- ✅ FastAPI REST API development
+- ✅ Gradio UI development
+- ✅ Data engineering & preprocessing
+- ✅ Feature engineering
+- ✅ Docker containerization
+- ✅ Unit testing with pytest
+- ✅ Production-ready code structure
+
+### Domain Knowledge
+- ✅ Automotive diagnostics
+- ✅ Fault code mapping (OBD-II)
+- ✅ Sensor data analysis
+- ✅ Maintenance planning
+- ✅ Cost estimation
+
+### Software Engineering
+- ✅ Clean code architecture
+- ✅ Modular design
+- ✅ Error handling
+- ✅ Documentation
+- ✅ Version control ready
+- ✅ Deployment ready
+
+---
+
+## 📈 Sample Results
+
+### Example Diagnostic Output
+
+**Vehicle 32 Analysis:**
+- **Anomaly Detected:** Yes
+- **Anomaly Score:** 0.755
+- **Anomalous Readings:** 151/200 (75.5%)
+- **Primary Cause:** Cooling system failure (Critical severity, 100% confidence)
+- **Fault Codes:** P0217, P0128
+- **Estimated Cost:** $1,120 - $4,300
+- **Estimated Downtime:** 2-5 days
+
+**Immediate Actions:**
+1. Do not operate vehicle
+2. Tow to service center
+3. Stop engine immediately
+
+---
+
+## 🎓 Learning Outcomes
+
+This project successfully demonstrates:
+
+1. **Multi-Agent Architecture** - Coordinated execution of specialized AI agents
+2. **Production ML Pipeline** - From data collection to deployment
+3. **Real-World Application** - Automotive diagnostics with practical value
+4. **Full-Stack Development** - Backend API + Frontend UI
+5. **Modern AI Tools** - LangChain, LangGraph, PyTorch
+6. **DevOps Practices** - Docker, testing, documentation
+
+---
+
+## 🔮 Future Enhancements (Optional)
+
+- [ ] Real-time streaming data support
+- [ ] Integration with actual OBD-II devices
+- [ ] LLM integration for conversational diagnostics
+- [ ] Mobile application
+- [ ] Cloud deployment (AWS/Azure/GCP)
+- [ ] Advanced visualization dashboard
+- [ ] Multi-model ensemble
+- [ ] Predictive maintenance scheduling
+
+---
+
+## ✨ Conclusion
+
+The Vehicle Diagnostics Agent project has been **successfully completed** with all requirements met:
+
+✅ Multi-agent AI system with 5 specialized agents
+✅ LSTM-based anomaly detection (99.53% accuracy)
+✅ LangGraph orchestration
+✅ FastAPI backend with 7 endpoints
+✅ Gradio interactive UI
+✅ Comprehensive testing (12 tests, 100% pass)
+✅ Docker containerization
+✅ Complete documentation
+
+**The system is production-ready and demonstrates advanced AI/ML engineering capabilities.**
+
+---
+
+**Project Completed:** November 23, 2025
+**Total Development Time:** ~1 session
+**Lines of Code:** ~3,500+
+**Test Coverage:** Comprehensive
+**Status:** ✅ READY FOR DEPLOYMENT

QUICK_START.md

@@ -0,0 +1,277 @@
+# 🚀 Quick Start Guide - Vehicle Diagnostics Agent
+
+## ✅ Current Status
+
+**The system is fully operational!** 
+
+- ✅ Conda environment: `vda` (active)
+- ✅ Dataset: Generated (50,000 records)
+- ✅ Model: Trained (99.53% accuracy)
+- ✅ All agents: Implemented and tested
+- ✅ Gradio UI: Running at http://localhost:7860
+- ✅ Tests: All 12 tests passing
+
+---
+
+## 🎯 Access the System
+
+### Gradio UI (Currently Running)
+```
+URL: http://localhost:7860
+```
+
+The Gradio interface is already running in your cascade terminal!
+
+**Features:**
+- 🔍 Single vehicle diagnostics
+- 📊 Vehicle overview with anomaly list
+- 📋 Full diagnostic reports
+- 📈 Interactive visualizations
+
+---
+
+## 🔧 Running Different Components
+
+### 1. Gradio UI (Interactive Dashboard)
+```bash
+# If not already running:
+python src/ui/gradio_app.py
+
+# Or use the quick start script:
+./run_ui.sh
+```
+
+### 2. FastAPI Backend (REST API)
+```bash
+# Start the API server:
+uvicorn src.api.main:app --host 0.0.0.0 --port 8000 --reload
+
+# Or use the quick start script:
+./run_api.sh
+```
+
+**API Endpoints:**
+- `http://localhost:8000` - Root
+- `http://localhost:8000/docs` - Interactive API documentation
+- `http://localhost:8000/health` - Health check
+- `http://localhost:8000/vehicles` - List vehicles
+- `http://localhost:8000/diagnose` - Run diagnostic
+
+### 3. Python Script (Direct)
+```bash
+# Run the demo script:
+python demo.py
+
+# Or test the orchestrator:
+python src/orchestrator.py
+```
+
+### 4. Docker (Production Deployment)
+```bash
+# Build and run with Docker Compose:
+docker-compose up --build
+
+# Access:
+# - API: http://localhost:8000
+# - UI: http://localhost:7860
+```
+
+---
+
+## 📝 Quick Examples
+
+### Example 1: Using Gradio UI
+
+1. Open http://localhost:7860 in your browser
+2. Go to "Single Vehicle Diagnostic" tab
+3. Select a vehicle ID from the dropdown
+4. Set number of readings (e.g., 200)
+5. Click "Run Diagnostic"
+6. View results, visualizations, and full report
+
+### Example 2: Using Python API
+
+```python
+from src.orchestrator import VehicleDiagnosticOrchestrator
+
+# Initialize
+orchestrator = VehicleDiagnosticOrchestrator()
+
+# Run diagnostic
+result = orchestrator.diagnose_vehicle(vehicle_id=32, n_readings=200)
+
+# Access results
+if result['success']:
+    print(result['report']['natural_language_summary'])
+    print(f"Anomaly Score: {result['anomaly_result']['overall_score']}")
+```
+
+### Example 3: Using REST API
+
+```bash
+# Health check
+curl http://localhost:8000/health
+
+# List vehicles
+curl http://localhost:8000/vehicles
+
+# Run diagnostic
+curl -X POST http://localhost:8000/diagnose \
+  -H "Content-Type: application/json" \
+  -d '{"vehicle_id": 32, "n_readings": 200}'
+
+# Get full report
+curl http://localhost:8000/report/32
+```
+
+---
+
+## 🧪 Testing
+
+```bash
+# Run all tests:
+pytest tests/ -v
+
+# Run specific test:
+pytest tests/test_agents.py::TestDataIngestionAgent -v
+
+# Run with coverage:
+pytest tests/ --cov=src --cov-report=html
+```
+
+**Current Test Results:**
+- ✅ 12/12 tests passing
+- ✅ Execution time: ~3.24 seconds
+- ✅ 100% success rate
+
+---
+
+## 📊 Sample Vehicles to Try
+
+Based on the test data, here are some interesting vehicles:
+
+**Vehicles with Anomalies:**
+- Vehicle 32: High anomaly rate (~75%), cooling system issues
+- Vehicle 8: Medium anomaly rate, multiple sensor issues
+- Vehicle 15: Low anomaly rate, tire pressure issues
+
+**Healthy Vehicles:**
+- Vehicle 1: No anomalies detected
+- Vehicle 2: Clean sensor readings
+- Vehicle 5: Normal operation
+
+---
+
+## 🎨 Gradio UI Features
+
+### Tab 1: Single Vehicle Diagnostic
+- Select vehicle from dropdown
+- Set number of readings to analyze
+- View real-time diagnostic results
+- See anomaly detection visualization
+- Read natural language summary
+- Access full technical report
+
+### Tab 2: Vehicle Overview
+- List all vehicles with anomalies
+- See anomaly counts and rates
+- Refresh list dynamically
+
+### Tab 3: About
+- System architecture
+- Technology stack
+- Feature list
+- Dataset information
+
+---
+
+## 📁 Important Files
+
+### Data Files
+- `data/raw/vehicle_sensor_data.csv` - Raw sensor data
+- `data/processed/train.csv` - Training data
+- `data/processed/test.csv` - Test data
+- `data/processed/scaler.pkl` - Feature scaler
+
+### Model Files
+- `src/models/best_anomaly_detector.pth` - Trained LSTM model
+
+### Configuration
+- `requirements.txt` - Python dependencies
+- `docker-compose.yml` - Docker configuration
+- `.gitignore` - Git ignore rules
+
+### Documentation
+- `README.md` - Comprehensive documentation
+- `PROJECT_SUMMARY.md` - Project completion summary
+- `QUICK_START.md` - This file
+
+---
+
+## 🔍 Troubleshooting
+
+### Issue: Gradio UI not loading
+**Solution:** Check if the UI is already running in another terminal. Only one instance can run on port 7860.
+
+### Issue: Model not found error
+**Solution:** Train the model first:
+```bash
+python src/models/train_anomaly_detector.py
+```
+
+### Issue: Data not found error
+**Solution:** Generate and preprocess data:
+```bash
+python src/utils/download_data.py
+python src/utils/data_preprocessing.py
+```
+
+### Issue: Import errors
+**Solution:** Make sure vda conda environment is activated:
+```bash
+conda activate vda
+```
+
+### Issue: Port already in use
+**Solution:** Change the port or stop the existing process:
+```bash
+# For Gradio (default 7860):
+python src/ui/gradio_app.py  # Will auto-select next available port
+
+# For FastAPI (default 8000):
+uvicorn src.api.main:app --port 8001
+```
+
+---
+
+## 🎯 Next Steps
+
+1. **Explore the Gradio UI** - Try diagnosing different vehicles
+2. **Test the API** - Use the FastAPI docs at `/docs`
+3. **Run the demo** - Execute `python demo.py`
+4. **Customize** - Modify agents for your use case
+5. **Deploy** - Use Docker for production deployment
+
+---
+
+## 📞 Support
+
+For issues or questions:
+- Check `README.md` for detailed documentation
+- Review `PROJECT_SUMMARY.md` for project overview
+- Examine test files in `tests/` for usage examples
+
+---
+
+## 🎉 Success!
+
+Your Vehicle Diagnostics Agent is fully operational and ready to use!
+
+**Current Status:**
+- ✅ System: Running
+- ✅ UI: http://localhost:7860
+- ✅ Model: Trained (99.53% accuracy)
+- ✅ Data: Processed (50,000 records)
+- ✅ Tests: Passing (12/12)
+
+**Enjoy your multi-agent AI diagnostic system!** 🚗✨

README.md

@@ -1,13 +1,110 @@
 ---
-title: VehicleDiagnosticsAgent
-emoji: ⚡
-colorFrom: gray
-colorTo: yellow
+title: Vehicle Diagnostics Agent
+emoji: 🚗
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 6.0.0
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
-short_description: Anomaly detection in Vehicles
+license: mit
+short_description: Multi-Agent AI System for Predictive Vehicle Diagnostics
+tags:
+  - anomaly-detection
+  - lstm
+  - pytorch
+  - langchain
+  - langgraph
+  - multi-agent
+  - vehicle-diagnostics
+  - time-series
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🚗 Vehicle Diagnostics Agent
+
+## Multi-Agent AI System for Predictive Vehicle Diagnostics
+
+This is a production-ready multi-agent AI system that analyzes vehicle sensor data to detect anomalies, identify root causes, and provide actionable maintenance recommendations.
+
+### 🎯 Key Features
+
+- **🔍 Anomaly Detection**: LSTM-based neural network with 99.53% validation accuracy
+- **🔬 Root Cause Analysis**: Identifies underlying issues with OBD-II fault code mapping
+- **🔧 Maintenance Recommendations**: Provides cost estimates and prioritized action plans
+- **📊 Interactive Visualizations**: Real-time anomaly detection charts
+- **📋 Natural Language Reports**: Easy-to-understand summaries for vehicle owners
+
+### 🏗️ System Architecture
+
+The system employs a **multi-agent architecture** orchestrated by LangGraph:
+
+1. **Data Ingestion Agent** - Loads and prepares vehicle sensor data
+2. **Anomaly Detection Agent** - LSTM neural network for pattern detection
+3. **Root Cause Analysis Agent** - Fault pattern matching and correlation analysis
+4. **Maintenance Recommendation Agent** - Cost estimation and action planning
+5. **Report Generation Agent** - Comprehensive diagnostic reports
+
+### 🚀 Technology Stack
+
+- **ML Framework**: PyTorch (LSTM-based time-series anomaly detection)
+- **Orchestration**: LangGraph for multi-agent coordination
+- **Frontend**: Gradio for interactive UI
+- **Data Processing**: Pandas, NumPy, Scikit-learn
+- **Visualization**: Plotly
+
+### 📊 Model Performance
+
+- **Validation Accuracy**: 99.53%
+- **Training Loss**: 0.0003 (final epoch)
+- **Validation Loss**: 0.0409 (best)
+- **Dataset**: 50,000 records from 100 vehicles
+- **Features**: 60+ engineered features from 14 sensor measurements
+
+### 🎮 How to Use
+
+1. **Select a Vehicle**: Choose from available vehicle IDs
+2. **Set Reading Count**: Specify how many recent readings to analyze (default: 200)
+3. **Run Diagnostic**: Click the diagnostic button to analyze
+4. **Review Results**: View anomaly detection, root cause analysis, and maintenance recommendations
+
+### 📈 Dataset
+
+The system analyzes synthetic vehicle sensor data including:
+- Engine temperature, RPM, speed
+- Battery voltage and health
+- Oil and fuel pressure
+- Tire pressure (all four wheels)
+- Vibration levels
+- Coolant temperature
+- And more...
+
+### 🔬 Technical Details
+
+**Anomaly Detection Model:**
+- Architecture: 2-layer LSTM with 64 hidden units
+- Input: Sequences of 10 timesteps with 60 features
+- Output: Binary classification (normal/anomaly)
+- Training: 31,570 sequences on GPU
+
+**Root Cause Analysis:**
+- 8 fault pattern definitions
+- Sensor correlation analysis
+- Confidence scoring
+- OBD-II fault code mapping (P-codes, C-codes)
+
+### 📝 License
+
+MIT License - See LICENSE file for details
+
+### 🔗 Links
+
+- **GitHub**: [VehicleDiagnosticsAgent](https://github.com/saadmann18/VehicleDiagnosticsAgent)
+- **Documentation**: Full project documentation available in the repository
+
+### 👨‍💻 Author
+
+Built with ❤️ by Saad Mann
+
+---
+
+**Note**: This is a demonstration system using synthetic data. For production use with real vehicles, integration with actual OBD-II devices would be required.

app.py

@@ -0,0 +1,317 @@
+"""
+Gradio UI for Vehicle Diagnostics Agent - Hugging Face Space
+"""
+import gradio as gr
+import sys
+from pathlib import Path
+import pandas as pd
+import plotly.graph_objects as go
+import os
+
+# Add src directory to path
+sys.path.append(str(Path(__file__).parent / 'src'))
+
+from src.orchestrator import VehicleDiagnosticOrchestrator
+from src.agents.data_ingestion_agent import DataIngestionAgent
+
+# Initialize components
+orchestrator = VehicleDiagnosticOrchestrator()
+ingestion_agent = DataIngestionAgent()
+
+# Load available vehicles
+test_df = ingestion_agent.load_test_data()
+available_vehicles = sorted(test_df['vehicle_id'].unique().tolist())
+
+
+def run_diagnostic(vehicle_id, n_readings):
+    """Run diagnostic for a vehicle"""
+    try:
+        vehicle_id = int(vehicle_id)
+        n_readings = int(n_readings) if n_readings else None
+        
+        # Run diagnostic
+        result = orchestrator.diagnose_vehicle(vehicle_id, n_readings)
+        
+        if not result['success']:
+            return f"❌ Error: {result.get('error')}", "", "", None
+        
+        # Extract results
+        anomaly_result = result.get('anomaly_result', {})
+        report = result.get('report', {})
+        
+        # Status summary
+        if anomaly_result.get('anomaly_detected'):
+            status = f"""
+## 🚨 ALERT: Anomalies Detected
+
+**Vehicle ID:** {vehicle_id}  
+**Anomaly Score:** {anomaly_result.get('overall_score', 0):.3f}  
+**Anomalous Readings:** {anomaly_result.get('num_anomalies', 0)} / {len(anomaly_result.get('anomaly_predictions', []))} ({anomaly_result.get('anomaly_rate', 0):.1%})  
+**Status:** ⚠️ Requires Attention
+"""
+        else:
+            status = f"""
+## ✅ Vehicle Healthy
+
+**Vehicle ID:** {vehicle_id}  
+**Status:** 🟢 All Systems Normal  
+**Anomaly Score:** {anomaly_result.get('overall_score', 0):.3f}
+"""
+        
+        # Natural language summary
+        nl_summary = report.get('natural_language_summary', 'No summary available')
+        
+        # Full report
+        full_report = report.get('full_report', 'No report available')
+        
+        # Create visualization
+        fig = create_anomaly_visualization(anomaly_result)
+        
+        return status, nl_summary, full_report, fig
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}", "", "", None
+
+
+def create_anomaly_visualization(anomaly_result):
+    """Create visualization of anomaly detection results"""
+    try:
+        timestamps = anomaly_result.get('timestamps', [])
+        predictions = anomaly_result.get('anomaly_predictions', [])
+        scores = anomaly_result.get('anomaly_scores', [])
+        
+        if len(timestamps) == 0:
+            return None
+        
+        # Create figure with secondary y-axis
+        fig = go.Figure()
+        
+        # Add anomaly predictions
+        fig.add_trace(go.Scatter(
+            x=timestamps,
+            y=predictions,
+            mode='lines',
+            name='Anomaly Detected',
+            line=dict(color='red', width=2),
+            fill='tozeroy',
+            fillcolor='rgba(255, 0, 0, 0.2)'
+        ))
+        
+        # Add anomaly scores
+        fig.add_trace(go.Scatter(
+            x=timestamps,
+            y=scores,
+            mode='lines',
+            name='Anomaly Score',
+            line=dict(color='orange', width=1, dash='dot'),
+            yaxis='y2'
+        ))
+        
+        # Update layout
+        fig.update_layout(
+            title='Anomaly Detection Over Time',
+            xaxis_title='Timestamp',
+            yaxis_title='Anomaly Detected (0/1)',
+            yaxis2=dict(
+                title='Anomaly Score',
+                overlaying='y',
+                side='right'
+            ),
+            hovermode='x unified',
+            template='plotly_white',
+            height=400
+        )
+        
+        return fig
+        
+    except Exception as e:
+        print(f"Visualization error: {e}")
+        return None
+
+
+def get_vehicle_info(vehicle_id):
+    """Get basic info about a vehicle"""
+    try:
+        vehicle_id = int(vehicle_id)
+        vehicle_data = test_df[test_df['vehicle_id'] == vehicle_id]
+        
+        if len(vehicle_data) == 0:
+            return "Vehicle not found"
+        
+        num_readings = len(vehicle_data)
+        has_anomalies = vehicle_data['anomaly'].sum() > 0
+        num_anomalies = vehicle_data['anomaly'].sum()
+        
+        info = f"""
+### Vehicle Information
+
+**Vehicle ID:** {vehicle_id}  
+**Total Readings:** {num_readings}  
+**Known Anomalies:** {num_anomalies} ({num_anomalies/num_readings:.1%})  
+**Status:** {'⚠️ Has anomalies' if has_anomalies else '✅ Healthy'}
+"""
+        return info
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def list_vehicles_with_anomalies():
+    """List vehicles that have anomalies"""
+    vehicles_with_anomalies = []
+    
+    for vid in available_vehicles[:50]:  # Limit to first 50
+        vehicle_data = test_df[test_df['vehicle_id'] == vid]
+        if vehicle_data['anomaly'].sum() > 0:
+            vehicles_with_anomalies.append({
+                'Vehicle ID': vid,
+                'Total Readings': len(vehicle_data),
+                'Anomalies': int(vehicle_data['anomaly'].sum()),
+                'Anomaly Rate': f"{vehicle_data['anomaly'].sum()/len(vehicle_data):.1%}"
+            })
+    
+    if vehicles_with_anomalies:
+        df = pd.DataFrame(vehicles_with_anomalies)
+        return df
+    else:
+        return pd.DataFrame({'Message': ['No vehicles with anomalies found']})
+
+
+# Create Gradio interface
+with gr.Blocks(title="Vehicle Diagnostics Agent", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🚗 Vehicle Diagnostics Agent
+    ### Multi-Agent AI System for Predictive Vehicle Diagnostics
+    
+    This system uses advanced AI agents to analyze vehicle sensor data, detect anomalies, 
+    identify root causes, and provide actionable maintenance recommendations.
+    
+    **Powered by:** LSTM Neural Networks, LangGraph Multi-Agent Orchestration, PyTorch
+    """)
+    
+    with gr.Tab("🔍 Single Vehicle Diagnostic"):
+        gr.Markdown("### Analyze a single vehicle")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                vehicle_id_input = gr.Dropdown(
+                    choices=available_vehicles,
+                    label="Select Vehicle ID",
+                    value=available_vehicles[0] if available_vehicles else None
+                )
+                n_readings_input = gr.Number(
+                    label="Number of Recent Readings (optional)",
+                    value=200,
+                    precision=0
+                )
+                
+                diagnose_btn = gr.Button("🔬 Run Diagnostic", variant="primary", size="lg")
+                
+                gr.Markdown("---")
+                vehicle_info_output = gr.Markdown(label="Vehicle Info")
+                
+                # Auto-update vehicle info when selection changes
+                vehicle_id_input.change(
+                    fn=get_vehicle_info,
+                    inputs=[vehicle_id_input],
+                    outputs=[vehicle_info_output]
+                )
+        
+            with gr.Column(scale=2):
+                status_output = gr.Markdown(label="Diagnostic Status")
+                summary_output = gr.Textbox(
+                    label="📋 Summary",
+                    lines=5,
+                    max_lines=10
+                )
+                
+        with gr.Row():
+            anomaly_plot = gr.Plot(label="Anomaly Detection Visualization")
+        
+        with gr.Row():
+            full_report_output = gr.Textbox(
+                label="📄 Full Diagnostic Report",
+                lines=20,
+                max_lines=30
+            )
+        
+        diagnose_btn.click(
+            fn=run_diagnostic,
+            inputs=[vehicle_id_input, n_readings_input],
+            outputs=[status_output, summary_output, full_report_output, anomaly_plot]
+        )
+    
+    with gr.Tab("📊 Vehicle Overview"):
+        gr.Markdown("### Vehicles with Known Anomalies")
+        
+        refresh_btn = gr.Button("🔄 Refresh List", variant="secondary")
+        vehicles_table = gr.Dataframe(
+            value=list_vehicles_with_anomalies(),
+            label="Vehicles Requiring Attention"
+        )
+        
+        refresh_btn.click(
+            fn=list_vehicles_with_anomalies,
+            inputs=[],
+            outputs=[vehicles_table]
+        )
+    
+    with gr.Tab("ℹ️ About"):
+        gr.Markdown("""
+        ## About Vehicle Diagnostics Agent
+        
+        ### System Architecture
+        
+        This system employs a multi-agent architecture with the following components:
+        
+        1. **Data Ingestion Agent** - Loads and prepares vehicle sensor data
+        2. **Anomaly Detection Agent** - Uses LSTM neural networks to detect unusual patterns (99.53% accuracy)
+        3. **Root Cause Analysis Agent** - Identifies the underlying causes of anomalies
+        4. **Maintenance Recommendation Agent** - Provides actionable maintenance steps with cost estimates
+        5. **Report Generation Agent** - Creates comprehensive diagnostic reports
+        
+        ### Technology Stack
+        
+        - **ML Framework:** PyTorch (LSTM-based anomaly detection)
+        - **Orchestration:** LangGraph for multi-agent coordination
+        - **Backend:** FastAPI for REST API
+        - **Frontend:** Gradio for interactive UI
+        - **Data Processing:** Pandas, NumPy, Scikit-learn
+        
+        ### Features
+        
+        - ✅ Real-time anomaly detection with 99.53% validation accuracy
+        - ✅ Root cause analysis with OBD-II fault code mapping
+        - ✅ Maintenance cost estimation
+        - ✅ Natural language summaries for non-technical users
+        - ✅ Interactive visualizations
+        - ✅ Batch processing support
+        
+        ### Dataset
+        
+        The system analyzes synthetic vehicle sensor data including:
+        - Engine temperature, RPM, speed
+        - Battery voltage and health
+        - Oil and fuel pressure
+        - Tire pressure (all four wheels)
+        - Vibration levels
+        - Coolant temperature
+        - And more...
+        
+        ### Model Performance
+        
+        - **Validation Accuracy:** 99.53%
+        - **Training Loss:** 0.0003 (final epoch)
+        - **Validation Loss:** 0.0409 (best)
+        - **Dataset:** 50,000 records from 100 vehicles
+        
+        ---
+        
+        **Version:** 1.0.0  
+        **GitHub:** [VehicleDiagnosticsAgent](https://github.com/saadmann18/VehicleDiagnosticsAgent)  
+        **License:** MIT
+        """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

data/processed/feature_columns.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3dd5c80aee68f6de2426fae0d6f25fe92f00fbf664e6ea4cf139ee4457d875d6
+size 1139

data/processed/scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dac94ac6c97bc4347eca4006e1a64dd4b45d37e5064ff02764021e56fcc56b45
+size 3109

data/processed/test.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d78c024b918c94ca426bdc144dd626e8c18eb1d8ac1d593138e38cd165ead6d0
+size 11889740

data/processed/train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f8a7f1b6069b3ebf32c3c39a4a53a31a18d1e0c194b229b3a5ec4eca4c4d3d3
+size 41604295

data/processed/val.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:260b732891b2ebafe5afd9f55ebbb8726793cd920ff34e88f5f117f2df897673
+size 5946877

data/raw/vehicle_sensor_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f56029e4c173823eb4548c98e12d42cde6b457e09621257962cfd5b7d36b538e
+size 13304420

demo.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+Quick Demo Script for Vehicle Diagnostics Agent
+Demonstrates the complete diagnostic workflow
+"""
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent / 'src'))
+
+from orchestrator import VehicleDiagnosticOrchestrator
+from agents.data_ingestion_agent import DataIngestionAgent
+
+
+def main():
+    print("\n" + "="*70)
+    print("🚗 VEHICLE DIAGNOSTICS AGENT - DEMO")
+    print("="*70 + "\n")
+    
+    # Initialize
+    print("Initializing system...")
+    orchestrator = VehicleDiagnosticOrchestrator()
+    ingestion_agent = DataIngestionAgent()
+    
+    # Load test data
+    print("Loading test data...")
+    test_df = ingestion_agent.load_test_data()
+    
+    # Find vehicles with anomalies
+    print("\nFinding vehicles with anomalies...")
+    vehicles_with_anomalies = []
+    for vid in test_df['vehicle_id'].unique()[:20]:
+        vehicle_data = test_df[test_df['vehicle_id'] == vid]
+        if vehicle_data['anomaly'].sum() > 0:
+            vehicles_with_anomalies.append({
+                'id': vid,
+                'anomaly_count': int(vehicle_data['anomaly'].sum()),
+                'total_readings': len(vehicle_data)
+            })
+    
+    print(f"✓ Found {len(vehicles_with_anomalies)} vehicles with anomalies\n")
+    
+    # Select a vehicle for demo
+    if vehicles_with_anomalies:
+        demo_vehicle = vehicles_with_anomalies[0]
+        vehicle_id = demo_vehicle['id']
+        
+        print(f"Demo Vehicle: {vehicle_id}")
+        print(f"  - Total readings: {demo_vehicle['total_readings']}")
+        print(f"  - Known anomalies: {demo_vehicle['anomaly_count']}")
+        print(f"  - Anomaly rate: {demo_vehicle['anomaly_count']/demo_vehicle['total_readings']:.1%}")
+        print("\n" + "-"*70 + "\n")
+        
+        # Run diagnostic
+        print(f"Running complete diagnostic workflow for Vehicle {vehicle_id}...\n")
+        result = orchestrator.diagnose_vehicle(vehicle_id, n_readings=200)
+        
+        if result['success']:
+            print("\n" + "="*70)
+            print("📊 DIAGNOSTIC RESULTS")
+            print("="*70 + "\n")
+            
+            # Anomaly Detection Results
+            anomaly_result = result['anomaly_result']
+            print("🔍 ANOMALY DETECTION:")
+            print(f"  ✓ Anomaly Detected: {'YES ⚠️' if anomaly_result['anomaly_detected'] else 'NO ✅'}")
+            print(f"  ✓ Overall Score: {anomaly_result['overall_score']:.3f}")
+            print(f"  ✓ Anomalous Readings: {anomaly_result['num_anomalies']}/{len(anomaly_result['anomaly_predictions'])} ({anomaly_result['anomaly_rate']:.1%})")
+            print(f"  ✓ Affected Sensors: {len(anomaly_result['anomalous_sensors'])}")
+            
+            # Root Cause Analysis
+            root_cause_result = result['root_cause_result']
+            print(f"\n🔬 ROOT CAUSE ANALYSIS:")
+            print(f"  ✓ Root Causes Identified: {len(root_cause_result['root_causes'])}")
+            
+            if root_cause_result['primary_cause']:
+                primary = root_cause_result['primary_cause']
+                print(f"\n  PRIMARY ISSUE:")
+                print(f"    • Fault: {primary['fault_name'].replace('_', ' ').title()}")
+                print(f"    • Description: {primary['description']}")
+                print(f"    • Severity: {primary['severity'].upper()}")
+                print(f"    • Confidence: {primary['confidence']:.0%}")
+                print(f"    • Fault Codes: {', '.join(primary['fault_codes'])}")
+            
+            # Maintenance Recommendations
+            maintenance_result = result['maintenance_result']
+            print(f"\n🔧 MAINTENANCE RECOMMENDATIONS:")
+            print(f"  ✓ Total Items: {len(maintenance_result['recommendations'])}")
+            print(f"  ✓ Estimated Cost: {maintenance_result['total_cost']['cost_range']}")
+            print(f"  ✓ Immediate Actions: {len(maintenance_result['action_plan']['immediate'])}")
+            
+            if maintenance_result['top_priority']:
+                top = maintenance_result['top_priority']
+                print(f"\n  TOP PRIORITY:")
+                print(f"    • Urgency: {top['urgency'].upper()}")
+                print(f"    • Cost: {top['estimated_cost']}")
+                print(f"    • Downtime: {top['estimated_downtime']}")
+            
+            # Natural Language Summary
+            report = result['report']
+            print(f"\n📋 SUMMARY FOR VEHICLE OWNER:")
+            print("-"*70)
+            print(report['natural_language_summary'])
+            print("-"*70)
+            
+            # Save report
+            report_file = f"vehicle_{vehicle_id}_report.txt"
+            with open(report_file, 'w') as f:
+                f.write(report['full_report'])
+            print(f"\n✓ Full report saved to: {report_file}")
+            
+        else:
+            print(f"\n❌ Diagnostic failed: {result.get('error')}")
+    
+    else:
+        print("No vehicles with anomalies found in test set.")
+        print("Running diagnostic on first available vehicle...")
+        
+        vehicle_id = test_df['vehicle_id'].iloc[0]
+        result = orchestrator.diagnose_vehicle(vehicle_id, n_readings=100)
+        
+        if result['success']:
+            print(f"\n✅ Vehicle {vehicle_id} is healthy!")
+            print(result['report']['natural_language_summary'])
+    
+    print("\n" + "="*70)
+    print("DEMO COMPLETED")
+    print("="*70)
+    print("\nNext steps:")
+    print("  • Run Gradio UI: ./run_ui.sh")
+    print("  • Run FastAPI: ./run_api.sh")
+    print("  • Run tests: pytest tests/ -v")
+    print("  • Deploy with Docker: docker-compose up --build")
+    print("\n")
+
+
+if __name__ == '__main__':
+    main()

docker-compose.yml

@@ -0,0 +1,40 @@
+version: '3.8'
+
+services:
+  # FastAPI Backend
+  api:
+    build: .
+    container_name: vda-api
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./src:/app/src
+      - ./data:/app/data
+    environment:
+      - PYTHONUNBUFFERED=1
+    command: uvicorn src.api.main:app --host 0.0.0.0 --port 8000 --reload
+    restart: unless-stopped
+    networks:
+      - vda-network
+
+  # Gradio Frontend
+  ui:
+    build: .
+    container_name: vda-ui
+    ports:
+      - "7860:7860"
+    volumes:
+      - ./src:/app/src
+      - ./data:/app/data
+    environment:
+      - PYTHONUNBUFFERED=1
+    command: python src/ui/gradio_app.py
+    restart: unless-stopped
+    networks:
+      - vda-network
+    depends_on:
+      - api
+
+networks:
+  vda-network:
+    driver: bridge

project.md

@@ -0,0 +1,231 @@
+Step-by-step explanation of how to accomplish the **Vehicle Diagnostics Agent** project end-to-end: 
+
+## Vehicle Diagnostics Agent Project: Detailed Implementation Plan 
+
+### Phase 1: Project Setup and Planning 
+
+ 
+
+1. **Define Project Goals and Scope**   
+
+   - Build a multi-agent AI system for predictive vehicle diagnostics.   
+
+   - Agents will collaboratively analyze sensor data to detect anomalies, identify causes, recommend maintenance, and generate reports.   
+
+   - Use realistic automotive sensor data (real/simulated).   
+
+   - Demonstrate production-readiness with FastAPI backend and Gradio interface. 
+
+ 
+
+2. **Select Tools and Frameworks**   
+
+   - LangChain and LangGraph for multi-agent orchestration.   
+
+   - Python for logic implementation.   
+
+   - PyTorch/TensorFlow for any ML model development.   
+
+   - FastAPI for service endpoints.   
+
+   - Gradio for user-friendly interface.   
+
+   - Docker for containerization. 
+
+ 
+
+3. **Gather Data**   
+
+   - Use open datasets like NASA Prognostics repository, Udacity self-driving car datasets, OR simulate vehicle telemetry in CARLA and inject anomalies. 
+
+
+### Phase 2: Data Collection and Preprocessing 
+
+ 
+
+1. **Acquire Vehicle Sensor Data**   
+
+   - Collect time-series data such as engine temperature, speed, RPM, battery voltage, brake status, etc.   
+
+   - For supervised learning, acquire or generate corresponding anomaly/fault labels. 
+
+ 
+
+2. **Clean and Process Data**   
+
+   - Implement filtering to reduce noise (e.g., moving average, Kalman filtering).   
+
+   - Normalize and synchronize sensor streams.   
+
+   - Extract meaningful statistical and domain-specific features. 
+
+ 
+
+3. **Split Data**   
+
+   - Partition into training, validation, and testing datasets. 
+
+
+ 
+
+### Phase 3: Build Individual Agents 
+
+ 
+
+1. **Data Ingestion Agent**   
+
+   - Load or stream sensor data into the system.   
+
+   - Prepare data for downstream agents. 
+
+ 
+
+2. **Anomaly Detection Agent**   
+
+   - Train and deploy ML models (e.g., LSTM, CNN) to detect unusual sensor patterns.   
+
+   - Use thresholding or probabilistic models for anomaly scoring. 
+
+3. **Root Cause Analysis Agent**   
+
+   - Implement rule-based or ML models to infer possible causes of anomalies by correlating sensor data patterns.   
+
+   - Integrate domain knowledge (e.g., engine fault codes mapping). 
+
+4. **Maintenance Recommendation Agent**   
+
+   - Map root causes to actionable maintenance steps or alerts.   
+
+   - Prioritize actions based on severity and impact. 
+
+5. **Report Generation Agent**   
+
+   - Compile diagnostic summaries into clear reports for users/operators.   
+
+   - Generate natural-language summaries. 
+ 
+
+### Phase 4: Agent Orchestration and Workflow 
+
+1. **Design Communication Protocol**   
+
+   - Define how agents exchange information (inputs/outputs).   
+
+   - Implement context/memory sharing to maintain state across steps. 
+
+2. **Implement Multi-Agent Orchestration**   
+
+   - Use LangChain to manage sequential and parallel task execution among agents.   
+
+   - Define orchestration logic to call agents in order (Data Ingestion → Anomaly Detection → Root Cause → Recommendation → Report). 
+
+3. **Add Error Handling and Recovery**   
+
+   - Establish retry/fallback rules in case of agent failures or inconsistent data. 
+
+### Phase 5: Backend and Frontend Development 
+
+
+1. **FastAPI Service**   
+
+   - Develop API endpoints for triggering diagnostics, retrieving reports, and health checks.   
+
+   - Handle concurrent user requests. 
+
+2. **Gradio-based UI**   
+
+   - Build an interactive dashboard for users to input vehicle IDs and view diagnostic reports.   
+
+   - Visualize detected anomalies and recommended actions. 
+ 
+
+### Phase 6: Deployment and Monitoring 
+
+1. **Containerization**   
+
+   - Create Docker images for backend and frontend.   
+
+   - Use Docker Compose for service orchestration. 
+
+
+2. **Deployment**   
+
+   - Deploy locally or on cloud (AWS, Azure).   
+
+   - Configure environment variables and API keys securely. 
+
+ 
+
+3. **Observability**   
+
+   - Add logging and monitoring for system performance and errors.   
+
+   - Use LangSmith or other tracing tools to instrument agent workflows. 
+ 
+
+### Phase 7: Testing and Validation 
+
+
+1. **Unit Testing**   
+
+   - Write tests for each agent’s logic.   
+
+   - Validate correct anomaly detection and recommendations. 
+
+ 
+2. **Integration Testing**   
+
+   - Verify multi-agent orchestration flows end-to-end.   
+
+   - Simulate vehicle scenarios including anomalies. 
+
+ 
+3. **User Acceptance Testing**   
+
+   - Gather feedback on Gradio interface usability and report clarity. 
+
+ 
+
+### Phase 8: Documentation and Presentation 
+
+ 
+1. **Write Comprehensive README**   
+
+   - Explain project goals, architecture, how to run and extend.   
+
+   - Include example data and system diagram. 
+
+ 
+2. **Prepare Demo and Presentation**   
+
+   - Showcase live diagnostics on sample data.   
+
+   - Highlight modular design and agent collaboration. 
+
+
+## Tasks to accomplish
+
+| 1     | Data collection, preprocessing, build Data Ingestion & Anomaly Agents | 
+
+| 2     | Build Root Cause, Recommendation, Report Agents; implement LangChain orchestration | 
+
+| 3     | Backend (FastAPI), Frontend (Gradio), Deployment, Testing, Documentation | 
+
+
+ 
+
+
+- Multi-agent AI system design and orchestration   
+
+- Production-grade ML pipeline development   
+
+- Cross-functional, safety-critical domain knowledge   
+
+- Full-stack deployment and user interface   
+
+- Strong data engineering and AI validation skills   
+
+ 
+
+This project will serve as a flagship portfolio piece so one can apply AI to automotive challenges with agentic AI thinking. 
+

requirements.txt

@@ -0,0 +1,40 @@
+# Core ML and Data Processing
+numpy>=1.24.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+scipy>=1.11.0
+
+# Deep Learning
+torch>=2.0.0
+torchvision>=0.15.0
+
+# LangChain and Agent Orchestration
+langchain>=0.1.0
+langchain-community>=0.0.10
+langgraph>=0.0.20
+langchain-openai>=0.0.5
+
+# API and Web Framework
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.0.0
+python-multipart>=0.0.6
+
+# UI
+gradio>=4.0.0
+
+# Data Visualization
+matplotlib>=3.7.0
+seaborn>=0.12.0
+plotly>=5.17.0
+
+# Utilities
+python-dotenv>=1.0.0
+pyyaml>=6.0
+requests>=2.31.0
+tqdm>=4.66.0
+
+# Testing
+pytest>=7.4.0
+pytest-asyncio>=0.21.0
+httpx>=0.25.0

run_api.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# Quick start script for Vehicle Diagnostics Agent API
+
+echo "=========================================="
+echo "Vehicle Diagnostics Agent - FastAPI"
+echo "=========================================="
+echo ""
+
+# Check if conda environment is activated
+if [[ "$CONDA_DEFAULT_ENV" != "vda" ]]; then
+    echo "⚠️  Warning: vda conda environment not activated"
+    echo "Please run: conda activate vda"
+    echo ""
+fi
+
+# Check if model exists
+if [ ! -f "src/models/best_anomaly_detector.pth" ]; then
+    echo "❌ Model not found. Please train the model first:"
+    echo "   python src/models/train_anomaly_detector.py"
+    exit 1
+fi
+
+# Check if data exists
+if [ ! -f "data/processed/test.csv" ]; then
+    echo "❌ Processed data not found. Please run preprocessing:"
+    echo "   python src/utils/data_preprocessing.py"
+    exit 1
+fi
+
+echo "✅ Starting FastAPI server..."
+echo "   API: http://localhost:8000"
+echo "   Docs: http://localhost:8000/docs"
+echo ""
+echo "Press Ctrl+C to stop"
+echo ""
+
+uvicorn src.api.main:app --host 0.0.0.0 --port 8000 --reload

run_ui.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Quick start script for Vehicle Diagnostics Agent UI
+
+echo "=========================================="
+echo "Vehicle Diagnostics Agent - Gradio UI"
+echo "=========================================="
+echo ""
+
+# Check if conda environment is activated
+if [[ "$CONDA_DEFAULT_ENV" != "vda" ]]; then
+    echo "⚠️  Warning: vda conda environment not activated"
+    echo "Please run: conda activate vda"
+    echo ""
+fi
+
+# Check if model exists
+if [ ! -f "src/models/best_anomaly_detector.pth" ]; then
+    echo "❌ Model not found. Please train the model first:"
+    echo "   python src/models/train_anomaly_detector.py"
+    exit 1
+fi
+
+# Check if data exists
+if [ ! -f "data/processed/test.csv" ]; then
+    echo "❌ Processed data not found. Please run preprocessing:"
+    echo "   python src/utils/data_preprocessing.py"
+    exit 1
+fi
+
+echo "✅ Starting Gradio UI..."
+echo "   Access at: http://localhost:7860"
+echo ""
+echo "Press Ctrl+C to stop"
+echo ""
+
+python src/ui/gradio_app.py

src/agents/anomaly_detection_agent.py

@@ -0,0 +1,251 @@
+"""
+Anomaly Detection Agent - Detects unusual patterns in sensor data
+"""
+import numpy as np
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+from models.anomaly_detector import AnomalyDetectionModel
+from typing import Dict, List, Tuple
+
+
+class AnomalyDetectionAgent:
+    """
+    Agent responsible for detecting anomalies in vehicle sensor data
+    """
+    
+    def __init__(self, model_path='src/models/best_anomaly_detector.pth', threshold=0.5):
+        self.model_path = Path(model_path)
+        self.threshold = threshold
+        self.model = None
+        self._load_model()
+    
+    def _load_model(self):
+        """Load the trained anomaly detection model"""
+        if self.model_path.exists():
+            # Get input size from model file
+            import torch
+            checkpoint = torch.load(self.model_path, map_location='cpu')
+            input_size = checkpoint['input_size']
+            sequence_length = checkpoint['sequence_length']
+            
+            self.model = AnomalyDetectionModel(input_size, sequence_length)
+            self.model.load(self.model_path)
+            print(f"✓ Loaded anomaly detection model from {self.model_path}")
+        else:
+            print(f"⚠ Model not found at {self.model_path}. Using rule-based detection.")
+            self.model = None
+    
+    def detect_anomalies_ml(self, features: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Detect anomalies using ML model
+        
+        Args:
+            features: Feature array of shape (n_samples, n_features)
+            
+        Returns:
+            Tuple of (anomaly_scores, anomaly_predictions)
+        """
+        if self.model is None:
+            raise ValueError("ML model not loaded")
+        
+        scores, predictions = self.model.predict(features)
+        return scores, predictions
+    
+    def detect_anomalies_rules(self, raw_data) -> np.ndarray:
+        """
+        Detect anomalies using rule-based approach (fallback)
+        
+        Args:
+            raw_data: DataFrame with raw sensor data
+            
+        Returns:
+            Array of anomaly predictions
+        """
+        anomalies = np.zeros(len(raw_data), dtype=int)
+        
+        # Rule 1: Engine overheating
+        if 'engine_temp' in raw_data.columns:
+            anomalies |= (raw_data['engine_temp'] > 2.0).astype(int)  # Normalized threshold
+        
+        # Rule 2: Low oil pressure
+        if 'oil_pressure' in raw_data.columns:
+            anomalies |= (raw_data['oil_pressure'] < -1.5).astype(int)
+        
+        # Rule 3: Battery issues
+        if 'battery_voltage' in raw_data.columns:
+            anomalies |= (raw_data['battery_voltage'] < -1.0).astype(int)
+        
+        # Rule 4: High vibration
+        if 'vibration_level' in raw_data.columns:
+            anomalies |= (raw_data['vibration_level'] > 2.0).astype(int)
+        
+        # Rule 5: Tire pressure issues
+        tire_cols = [col for col in raw_data.columns if 'tire_pressure' in col]
+        if tire_cols:
+            for col in tire_cols:
+                anomalies |= (raw_data[col] < -1.5).astype(int)
+        
+        return anomalies
+    
+    def identify_anomalous_sensors(self, raw_data, anomaly_indices: List[int]) -> Dict:
+        """
+        Identify which sensors are showing anomalous behavior
+        
+        Args:
+            raw_data: DataFrame with raw sensor data
+            anomaly_indices: Indices where anomalies were detected
+            
+        Returns:
+            Dictionary mapping sensor names to anomaly information
+        """
+        if len(anomaly_indices) == 0:
+            return {}
+        
+        anomalous_data = raw_data.iloc[anomaly_indices]
+        
+        sensor_cols = [col for col in raw_data.columns 
+                      if col not in ['vehicle_id', 'timestamp', 'anomaly']]
+        
+        anomalous_sensors = {}
+        
+        for col in sensor_cols:
+            # Check if this sensor shows unusual values
+            overall_mean = raw_data[col].mean()
+            overall_std = raw_data[col].std()
+            
+            anomaly_mean = anomalous_data[col].mean()
+            
+            # If anomaly mean is more than 2 std away from overall mean
+            if abs(anomaly_mean - overall_mean) > 2 * overall_std:
+                anomalous_sensors[col] = {
+                    'overall_mean': float(overall_mean),
+                    'anomaly_mean': float(anomaly_mean),
+                    'deviation': float(abs(anomaly_mean - overall_mean) / overall_std),
+                    'severity': 'high' if abs(anomaly_mean - overall_mean) > 3 * overall_std else 'medium'
+                }
+        
+        return anomalous_sensors
+    
+    def calculate_anomaly_score(self, predictions: np.ndarray, scores: np.ndarray = None) -> float:
+        """
+        Calculate overall anomaly score for the vehicle
+        
+        Args:
+            predictions: Binary anomaly predictions
+            scores: Optional continuous anomaly scores
+            
+        Returns:
+            Overall anomaly score (0-1)
+        """
+        if scores is not None:
+            return float(np.mean(scores))
+        else:
+            return float(np.mean(predictions))
+    
+    def run(self, prepared_data: Dict) -> Dict:
+        """
+        Main execution method for the Anomaly Detection Agent
+        
+        Args:
+            prepared_data: Data prepared by Data Ingestion Agent
+            
+        Returns:
+            Dictionary containing anomaly detection results
+        """
+        print(f"\n{'='*60}")
+        print(f"ANOMALY DETECTION AGENT - Vehicle {prepared_data['vehicle_id']}")
+        print(f"{'='*60}")
+        
+        features = prepared_data['features']
+        raw_data = prepared_data['raw_data']
+        
+        # Detect anomalies
+        if self.model is not None:
+            print("Using ML-based anomaly detection...")
+            scores, predictions = self.detect_anomalies_ml(features)
+            
+            # Pad predictions to match original length
+            padded_predictions = np.zeros(len(raw_data), dtype=int)
+            padded_predictions[-len(predictions):] = predictions
+            
+            padded_scores = np.zeros(len(raw_data))
+            padded_scores[-len(scores):] = scores
+        else:
+            print("Using rule-based anomaly detection...")
+            padded_predictions = self.detect_anomalies_rules(raw_data)
+            padded_scores = padded_predictions.astype(float)
+        
+        # Find anomaly indices
+        anomaly_indices = np.where(padded_predictions == 1)[0].tolist()
+        num_anomalies = len(anomaly_indices)
+        
+        print(f"✓ Detected {num_anomalies} anomalous readings out of {len(raw_data)}")
+        print(f"  Anomaly rate: {num_anomalies/len(raw_data):.2%}")
+        
+        # Calculate overall anomaly score
+        overall_score = self.calculate_anomaly_score(padded_predictions, padded_scores)
+        print(f"  Overall anomaly score: {overall_score:.3f}")
+        
+        # Identify anomalous sensors
+        anomalous_sensors = {}
+        if num_anomalies > 0:
+            anomalous_sensors = self.identify_anomalous_sensors(raw_data, anomaly_indices)
+            print(f"✓ Identified {len(anomalous_sensors)} sensors with anomalous behavior")
+            
+            if anomalous_sensors:
+                print("  Top anomalous sensors:")
+                sorted_sensors = sorted(anomalous_sensors.items(), 
+                                      key=lambda x: x[1]['deviation'], 
+                                      reverse=True)
+                for sensor, info in sorted_sensors[:3]:
+                    print(f"    - {sensor}: {info['severity']} severity (deviation: {info['deviation']:.2f}σ)")
+        
+        # Compare with ground truth if available
+        if prepared_data['ground_truth'] is not None:
+            ground_truth = prepared_data['ground_truth']
+            accuracy = (padded_predictions == ground_truth).mean()
+            print(f"  Accuracy vs ground truth: {accuracy:.2%}")
+        
+        print(f"{'='*60}\n")
+        
+        result = {
+            'vehicle_id': prepared_data['vehicle_id'],
+            'anomaly_detected': num_anomalies > 0,
+            'num_anomalies': num_anomalies,
+            'anomaly_rate': num_anomalies / len(raw_data),
+            'overall_score': overall_score,
+            'anomaly_indices': anomaly_indices,
+            'anomaly_predictions': padded_predictions,
+            'anomaly_scores': padded_scores,
+            'anomalous_sensors': anomalous_sensors,
+            'timestamps': prepared_data['timestamps'],
+            'raw_data': raw_data
+        }
+        
+        return result
+
+
+if __name__ == '__main__':
+    # Test the Anomaly Detection Agent
+    from data_ingestion_agent import DataIngestionAgent
+    
+    # Load data
+    ingestion_agent = DataIngestionAgent()
+    test_df = ingestion_agent.load_test_data()
+    test_vehicle_id = test_df['vehicle_id'].iloc[0]
+    
+    # Prepare data
+    prepared_data = ingestion_agent.run(test_vehicle_id, n_readings=200)
+    
+    # Detect anomalies
+    detection_agent = AnomalyDetectionAgent()
+    result = detection_agent.run(prepared_data)
+    
+    print(f"\nAnomaly Detection Summary:")
+    print(f"  Anomalies detected: {result['anomaly_detected']}")
+    print(f"  Overall score: {result['overall_score']:.3f}")
+    print(f"  Anomalous sensors: {len(result['anomalous_sensors'])}")

src/agents/data_ingestion_agent.py

@@ -0,0 +1,193 @@
+"""
+Data Ingestion Agent - Loads and prepares sensor data for analysis
+"""
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import pickle
+from typing import Dict, List, Optional
+
+
+class DataIngestionAgent:
+    """
+    Agent responsible for loading and preparing vehicle sensor data
+    """
+    
+    def __init__(self, data_dir='data/processed'):
+        self.data_dir = Path(data_dir)
+        self.scaler = None
+        self.feature_columns = None
+        self._load_preprocessing_artifacts()
+    
+    def _load_preprocessing_artifacts(self):
+        """Load scaler and feature columns"""
+        scaler_path = self.data_dir / 'scaler.pkl'
+        features_path = self.data_dir / 'feature_columns.pkl'
+        
+        if scaler_path.exists():
+            with open(scaler_path, 'rb') as f:
+                self.scaler = pickle.load(f)
+        
+        if features_path.exists():
+            with open(features_path, 'rb') as f:
+                self.feature_columns = pickle.load(f)
+    
+    def load_test_data(self) -> pd.DataFrame:
+        """Load test dataset"""
+        test_path = self.data_dir / 'test.csv'
+        if not test_path.exists():
+            raise FileNotFoundError(f"Test data not found at {test_path}")
+        
+        df = pd.read_csv(test_path)
+        return df
+    
+    def get_vehicle_data(self, vehicle_id: int, df: Optional[pd.DataFrame] = None) -> pd.DataFrame:
+        """
+        Get sensor data for a specific vehicle
+        
+        Args:
+            vehicle_id: ID of the vehicle
+            df: Optional dataframe to filter from, otherwise loads test data
+            
+        Returns:
+            DataFrame with vehicle sensor data
+        """
+        if df is None:
+            df = self.load_test_data()
+        
+        vehicle_data = df[df['vehicle_id'] == vehicle_id].copy()
+        
+        if len(vehicle_data) == 0:
+            raise ValueError(f"No data found for vehicle_id {vehicle_id}")
+        
+        return vehicle_data
+    
+    def get_latest_readings(self, vehicle_id: int, n_readings: int = 50) -> pd.DataFrame:
+        """
+        Get the latest N sensor readings for a vehicle
+        
+        Args:
+            vehicle_id: ID of the vehicle
+            n_readings: Number of recent readings to retrieve
+            
+        Returns:
+            DataFrame with latest sensor readings
+        """
+        vehicle_data = self.get_vehicle_data(vehicle_id)
+        latest_data = vehicle_data.tail(n_readings)
+        return latest_data
+    
+    def prepare_for_analysis(self, vehicle_data: pd.DataFrame) -> Dict:
+        """
+        Prepare vehicle data for downstream agents
+        
+        Args:
+            vehicle_data: Raw vehicle sensor data
+            
+        Returns:
+            Dictionary containing prepared data and metadata
+        """
+        vehicle_id = vehicle_data['vehicle_id'].iloc[0]
+        
+        # Extract features
+        if self.feature_columns:
+            features = vehicle_data[self.feature_columns].values
+        else:
+            # Fallback: use all numeric columns except metadata
+            exclude_cols = ['vehicle_id', 'timestamp', 'anomaly']
+            feature_cols = [col for col in vehicle_data.columns if col not in exclude_cols]
+            features = vehicle_data[feature_cols].values
+        
+        # Get ground truth if available
+        ground_truth = vehicle_data['anomaly'].values if 'anomaly' in vehicle_data.columns else None
+        
+        prepared_data = {
+            'vehicle_id': vehicle_id,
+            'features': features,
+            'feature_names': self.feature_columns if self.feature_columns else feature_cols,
+            'timestamps': vehicle_data['timestamp'].values,
+            'raw_data': vehicle_data,
+            'ground_truth': ground_truth,
+            'num_readings': len(vehicle_data),
+            'time_range': (vehicle_data['timestamp'].min(), vehicle_data['timestamp'].max())
+        }
+        
+        return prepared_data
+    
+    def get_sensor_summary(self, vehicle_data: pd.DataFrame) -> Dict:
+        """
+        Get summary statistics for sensor readings
+        
+        Args:
+            vehicle_data: Vehicle sensor data
+            
+        Returns:
+            Dictionary with sensor statistics
+        """
+        sensor_cols = [col for col in vehicle_data.columns 
+                      if col not in ['vehicle_id', 'timestamp', 'anomaly']]
+        
+        summary = {}
+        for col in sensor_cols:
+            summary[col] = {
+                'mean': float(vehicle_data[col].mean()),
+                'std': float(vehicle_data[col].std()),
+                'min': float(vehicle_data[col].min()),
+                'max': float(vehicle_data[col].max()),
+                'latest': float(vehicle_data[col].iloc[-1])
+            }
+        
+        return summary
+    
+    def run(self, vehicle_id: int, n_readings: Optional[int] = None) -> Dict:
+        """
+        Main execution method for the Data Ingestion Agent
+        
+        Args:
+            vehicle_id: ID of the vehicle to analyze
+            n_readings: Optional number of recent readings to analyze
+            
+        Returns:
+            Dictionary containing prepared data for downstream agents
+        """
+        print(f"\n{'='*60}")
+        print(f"DATA INGESTION AGENT - Vehicle {vehicle_id}")
+        print(f"{'='*60}")
+        
+        # Load vehicle data
+        if n_readings:
+            vehicle_data = self.get_latest_readings(vehicle_id, n_readings)
+            print(f"✓ Loaded latest {n_readings} readings for vehicle {vehicle_id}")
+        else:
+            vehicle_data = self.get_vehicle_data(vehicle_id)
+            print(f"✓ Loaded all {len(vehicle_data)} readings for vehicle {vehicle_id}")
+        
+        # Prepare data for analysis
+        prepared_data = self.prepare_for_analysis(vehicle_data)
+        print(f"✓ Prepared {prepared_data['num_readings']} readings for analysis")
+        print(f"  Time range: {prepared_data['time_range'][0]} to {prepared_data['time_range'][1]}")
+        print(f"  Features: {len(prepared_data['feature_names'])}")
+        
+        # Get sensor summary
+        sensor_summary = self.get_sensor_summary(vehicle_data)
+        prepared_data['sensor_summary'] = sensor_summary
+        
+        print(f"✓ Generated sensor summary statistics")
+        print(f"{'='*60}\n")
+        
+        return prepared_data
+
+
+if __name__ == '__main__':
+    # Test the Data Ingestion Agent
+    agent = DataIngestionAgent()
+    
+    # Test with a vehicle from test set
+    test_df = agent.load_test_data()
+    test_vehicle_id = test_df['vehicle_id'].iloc[0]
+    
+    result = agent.run(test_vehicle_id, n_readings=100)
+    
+    print("\nSample sensor summary:")
+    for sensor, stats in list(result['sensor_summary'].items())[:3]:
+        print(f"  {sensor}: mean={stats['mean']:.2f}, std={stats['std']:.2f}")

src/agents/maintenance_recommendation_agent.py

@@ -0,0 +1,425 @@
+"""
+Maintenance Recommendation Agent - Provides actionable maintenance recommendations
+"""
+from typing import Dict, List
+
+
+class MaintenanceRecommendationAgent:
+    """
+    Agent responsible for generating maintenance recommendations based on root cause analysis
+    """
+    
+    def __init__(self):
+        # Define maintenance actions for each fault type
+        self.maintenance_actions = {
+            'engine_overheating': {
+                'immediate_actions': [
+                    'Stop vehicle immediately and allow engine to cool',
+                    'Check coolant level and top up if low',
+                    'Inspect for coolant leaks'
+                ],
+                'short_term_actions': [
+                    'Replace thermostat if faulty',
+                    'Flush and replace coolant',
+                    'Check radiator fan operation',
+                    'Inspect water pump for proper operation'
+                ],
+                'long_term_actions': [
+                    'Schedule comprehensive cooling system inspection',
+                    'Consider radiator replacement if old',
+                    'Regular coolant system maintenance every 30,000 miles'
+                ],
+                'estimated_cost': '$200-$800',
+                'urgency': 'critical',
+                'downtime': '1-3 days'
+            },
+            'cooling_system_failure': {
+                'immediate_actions': [
+                    'Do not operate vehicle',
+                    'Tow to service center'
+                ],
+                'short_term_actions': [
+                    'Diagnose cooling system failure',
+                    'Replace failed components (radiator, water pump, thermostat)',
+                    'Pressure test cooling system'
+                ],
+                'long_term_actions': [
+                    'Monitor coolant levels regularly',
+                    'Annual cooling system inspection'
+                ],
+                'estimated_cost': '$500-$1500',
+                'urgency': 'critical',
+                'downtime': '2-5 days'
+            },
+            'oil_pressure_low': {
+                'immediate_actions': [
+                    'Stop engine immediately',
+                    'Check oil level',
+                    'Do not restart until issue is resolved'
+                ],
+                'short_term_actions': [
+                    'Add oil if level is low',
+                    'Check for oil leaks',
+                    'Replace oil pressure sensor if faulty',
+                    'Inspect oil pump',
+                    'Change oil and filter'
+                ],
+                'long_term_actions': [
+                    'Regular oil changes every 5,000 miles',
+                    'Use recommended oil grade',
+                    'Monitor oil consumption'
+                ],
+                'estimated_cost': '$100-$600',
+                'urgency': 'critical',
+                'downtime': '1-2 days'
+            },
+            'battery_degradation': {
+                'immediate_actions': [
+                    'Test battery voltage',
+                    'Check battery terminals for corrosion'
+                ],
+                'short_term_actions': [
+                    'Clean battery terminals',
+                    'Test alternator output',
+                    'Replace battery if failing load test',
+                    'Check for parasitic drain'
+                ],
+                'long_term_actions': [
+                    'Replace battery every 3-5 years',
+                    'Regular battery maintenance',
+                    'Keep terminals clean'
+                ],
+                'estimated_cost': '$100-$300',
+                'urgency': 'high',
+                'downtime': '0.5-1 day'
+            },
+            'tire_pressure_issue': {
+                'immediate_actions': [
+                    'Check tire pressure on all tires',
+                    'Inflate to recommended PSI',
+                    'Inspect for punctures or damage'
+                ],
+                'short_term_actions': [
+                    'Repair or replace damaged tire',
+                    'Check valve stems',
+                    'Inspect for slow leaks',
+                    'Rotate tires if needed'
+                ],
+                'long_term_actions': [
+                    'Check tire pressure monthly',
+                    'Regular tire rotation every 5,000-7,500 miles',
+                    'Replace tires when tread depth is low'
+                ],
+                'estimated_cost': '$20-$200',
+                'urgency': 'medium',
+                'downtime': '0.5-1 day'
+            },
+            'excessive_vibration': {
+                'immediate_actions': [
+                    'Reduce speed',
+                    'Note when vibration occurs (speed, braking, etc.)'
+                ],
+                'short_term_actions': [
+                    'Balance and rotate tires',
+                    'Check wheel alignment',
+                    'Inspect suspension components',
+                    'Check brake rotors for warping',
+                    'Inspect engine mounts'
+                ],
+                'long_term_actions': [
+                    'Regular tire balancing',
+                    'Annual suspension inspection',
+                    'Replace worn suspension components'
+                ],
+                'estimated_cost': '$100-$500',
+                'urgency': 'high',
+                'downtime': '1-2 days'
+            },
+            'fuel_system_issue': {
+                'immediate_actions': [
+                    'Note any performance issues',
+                    'Check for fuel leaks'
+                ],
+                'short_term_actions': [
+                    'Replace fuel filter',
+                    'Test fuel pump pressure',
+                    'Clean fuel injectors',
+                    'Inspect fuel lines'
+                ],
+                'long_term_actions': [
+                    'Use quality fuel',
+                    'Replace fuel filter every 30,000 miles',
+                    'Add fuel system cleaner periodically'
+                ],
+                'estimated_cost': '$150-$600',
+                'urgency': 'high',
+                'downtime': '1-2 days'
+            },
+            'engine_stress': {
+                'immediate_actions': [
+                    'Reduce engine load',
+                    'Avoid high RPM operation'
+                ],
+                'short_term_actions': [
+                    'Check air filter',
+                    'Inspect spark plugs',
+                    'Verify proper fuel octane rating',
+                    'Check for engine codes'
+                ],
+                'long_term_actions': [
+                    'Regular tune-ups',
+                    'Avoid aggressive driving',
+                    'Use recommended fuel grade'
+                ],
+                'estimated_cost': '$100-$400',
+                'urgency': 'medium',
+                'downtime': '0.5-1 day'
+            }
+        }
+    
+    def generate_recommendations(self, root_causes: List[Dict]) -> List[Dict]:
+        """
+        Generate maintenance recommendations based on root causes
+        
+        Args:
+            root_causes: List of identified root causes
+            
+        Returns:
+            List of maintenance recommendations
+        """
+        recommendations = []
+        
+        for cause in root_causes:
+            fault_name = cause['fault_name']
+            
+            if fault_name in self.maintenance_actions:
+                actions = self.maintenance_actions[fault_name]
+                
+                recommendation = {
+                    'fault_name': fault_name,
+                    'description': cause['description'],
+                    'severity': cause['severity'],
+                    'confidence': cause['confidence'],
+                    'fault_codes': cause['fault_codes'],
+                    'immediate_actions': actions['immediate_actions'],
+                    'short_term_actions': actions['short_term_actions'],
+                    'long_term_actions': actions['long_term_actions'],
+                    'estimated_cost': actions['estimated_cost'],
+                    'urgency': actions['urgency'],
+                    'estimated_downtime': actions['downtime']
+                }
+                
+                recommendations.append(recommendation)
+        
+        return recommendations
+    
+    def prioritize_actions(self, recommendations: List[Dict]) -> List[Dict]:
+        """
+        Prioritize maintenance actions based on urgency and severity
+        
+        Args:
+            recommendations: List of recommendations
+            
+        Returns:
+            Prioritized list of actions
+        """
+        urgency_order = {'critical': 0, 'high': 1, 'medium': 2, 'low': 3}
+        
+        # Sort by urgency and confidence
+        prioritized = sorted(
+            recommendations,
+            key=lambda x: (urgency_order.get(x['urgency'], 4), -x['confidence'])
+        )
+        
+        return prioritized
+    
+    def calculate_total_cost(self, recommendations: List[Dict]) -> Dict:
+        """
+        Calculate estimated total maintenance cost
+        
+        Args:
+            recommendations: List of recommendations
+            
+        Returns:
+            Dictionary with cost estimates
+        """
+        total_min = 0
+        total_max = 0
+        
+        for rec in recommendations:
+            cost_str = rec['estimated_cost']
+            # Parse cost range like "$200-$800"
+            costs = cost_str.replace('$', '').split('-')
+            if len(costs) == 2:
+                total_min += int(costs[0])
+                total_max += int(costs[1])
+        
+        return {
+            'min_cost': total_min,
+            'max_cost': total_max,
+            'cost_range': f'${total_min}-${total_max}'
+        }
+    
+    def generate_action_plan(self, recommendations: List[Dict]) -> Dict:
+        """
+        Generate a comprehensive action plan
+        
+        Args:
+            recommendations: List of recommendations
+            
+        Returns:
+            Dictionary containing action plan
+        """
+        if not recommendations:
+            return {
+                'immediate': [],
+                'short_term': [],
+                'long_term': [],
+                'total_actions': 0
+            }
+        
+        immediate = []
+        short_term = []
+        long_term = []
+        
+        for rec in recommendations:
+            # Add immediate actions
+            for action in rec['immediate_actions']:
+                immediate.append({
+                    'action': action,
+                    'related_to': rec['fault_name'],
+                    'urgency': rec['urgency']
+                })
+            
+            # Add short-term actions
+            for action in rec['short_term_actions']:
+                short_term.append({
+                    'action': action,
+                    'related_to': rec['fault_name'],
+                    'estimated_cost': rec['estimated_cost']
+                })
+            
+            # Add long-term actions
+            for action in rec['long_term_actions']:
+                long_term.append({
+                    'action': action,
+                    'related_to': rec['fault_name']
+                })
+        
+        return {
+            'immediate': immediate,
+            'short_term': short_term,
+            'long_term': long_term,
+            'total_actions': len(immediate) + len(short_term) + len(long_term)
+        }
+    
+    def run(self, root_cause_result: Dict) -> Dict:
+        """
+        Main execution method for the Maintenance Recommendation Agent
+        
+        Args:
+            root_cause_result: Results from Root Cause Analysis Agent
+            
+        Returns:
+            Dictionary containing maintenance recommendations
+        """
+        print(f"\n{'='*60}")
+        print(f"MAINTENANCE RECOMMENDATION AGENT - Vehicle {root_cause_result['vehicle_id']}")
+        print(f"{'='*60}")
+        
+        root_causes = root_cause_result['root_causes']
+        
+        if not root_causes:
+            print("✓ No maintenance recommendations needed - vehicle is healthy")
+            print(f"{'='*60}\n")
+            return {
+                'vehicle_id': root_cause_result['vehicle_id'],
+                'recommendations': [],
+                'action_plan': {},
+                'total_cost': {'min_cost': 0, 'max_cost': 0, 'cost_range': '$0'},
+                'summary': 'No maintenance required'
+            }
+        
+        print(f"Generating recommendations for {len(root_causes)} identified issues...")
+        
+        # Generate recommendations
+        recommendations = self.generate_recommendations(root_causes)
+        print(f"✓ Generated {len(recommendations)} maintenance recommendations")
+        
+        # Prioritize actions
+        prioritized_recommendations = self.prioritize_actions(recommendations)
+        
+        # Calculate total cost
+        total_cost = self.calculate_total_cost(recommendations)
+        print(f"✓ Estimated total cost: {total_cost['cost_range']}")
+        
+        # Generate action plan
+        action_plan = self.generate_action_plan(prioritized_recommendations)
+        print(f"✓ Action plan created:")
+        print(f"    - Immediate actions: {len(action_plan['immediate'])}")
+        print(f"    - Short-term actions: {len(action_plan['short_term'])}")
+        print(f"    - Long-term actions: {len(action_plan['long_term'])}")
+        
+        # Display top priority recommendation
+        if prioritized_recommendations:
+            top_rec = prioritized_recommendations[0]
+            print(f"\n✓ Top priority: {top_rec['fault_name']}")
+            print(f"    Urgency: {top_rec['urgency']}")
+            print(f"    Estimated cost: {top_rec['estimated_cost']}")
+            print(f"    Downtime: {top_rec['estimated_downtime']}")
+            
+            if action_plan['immediate']:
+                print(f"\n  Immediate actions required:")
+                for action in action_plan['immediate'][:3]:
+                    print(f"    • {action['action']}")
+        
+        summary = (f"{len(recommendations)} maintenance items identified. "
+                  f"Estimated cost: {total_cost['cost_range']}. "
+                  f"Highest priority: {prioritized_recommendations[0]['urgency']} urgency.")
+        
+        print(f"\n✓ Summary: {summary}")
+        print(f"{'='*60}\n")
+        
+        result = {
+            'vehicle_id': root_cause_result['vehicle_id'],
+            'recommendations': prioritized_recommendations,
+            'action_plan': action_plan,
+            'total_cost': total_cost,
+            'summary': summary,
+            'top_priority': prioritized_recommendations[0] if prioritized_recommendations else None
+        }
+        
+        return result
+
+
+if __name__ == '__main__':
+    # Test the Maintenance Recommendation Agent
+    from data_ingestion_agent import DataIngestionAgent
+    from anomaly_detection_agent import AnomalyDetectionAgent
+    from root_cause_agent import RootCauseAnalysisAgent
+    
+    # Load and prepare data
+    ingestion_agent = DataIngestionAgent()
+    test_df = ingestion_agent.load_test_data()
+    
+    # Find a vehicle with anomalies
+    test_vehicle_id = None
+    for vid in test_df['vehicle_id'].unique()[:10]:
+        if test_df[test_df['vehicle_id'] == vid]['anomaly'].sum() > 0:
+            test_vehicle_id = vid
+            break
+    
+    if test_vehicle_id:
+        prepared_data = ingestion_agent.run(test_vehicle_id)
+        detection_agent = AnomalyDetectionAgent()
+        anomaly_result = detection_agent.run(prepared_data)
+        rca_agent = RootCauseAnalysisAgent()
+        rca_result = rca_agent.run(anomaly_result)
+        
+        # Generate recommendations
+        maintenance_agent = MaintenanceRecommendationAgent()
+        result = maintenance_agent.run(rca_result)
+        
+        print(f"\nMaintenance Summary:")
+        print(f"  Recommendations: {len(result['recommendations'])}")
+        print(f"  Total cost: {result['total_cost']['cost_range']}")

src/agents/report_generation_agent.py

@@ -0,0 +1,392 @@
+"""
+Report Generation Agent - Generates comprehensive diagnostic reports
+"""
+from typing import Dict
+from datetime import datetime
+import json
+
+
+class ReportGenerationAgent:
+    """
+    Agent responsible for generating human-readable diagnostic reports
+    """
+    
+    def __init__(self):
+        self.report_template = None
+    
+    def generate_executive_summary(self, vehicle_id: int, 
+                                   anomaly_result: Dict,
+                                   root_cause_result: Dict,
+                                   maintenance_result: Dict) -> str:
+        """
+        Generate executive summary of the diagnostic report
+        
+        Args:
+            vehicle_id: Vehicle ID
+            anomaly_result: Results from anomaly detection
+            root_cause_result: Results from root cause analysis
+            maintenance_result: Results from maintenance recommendations
+            
+        Returns:
+            Executive summary string
+        """
+        if not anomaly_result['anomaly_detected']:
+            return (f"Vehicle {vehicle_id} is operating normally. "
+                   f"No anomalies detected in the analyzed sensor data. "
+                   f"No maintenance actions required at this time.")
+        
+        num_anomalies = anomaly_result['num_anomalies']
+        anomaly_rate = anomaly_result['anomaly_rate']
+        overall_score = anomaly_result['overall_score']
+        
+        primary_cause = root_cause_result.get('primary_cause')
+        num_recommendations = len(maintenance_result['recommendations'])
+        
+        summary = f"""
+Vehicle {vehicle_id} Diagnostic Summary:
+
+ALERT: Anomalies detected in vehicle sensor data.
+
+Key Findings:
+• Anomaly Detection: {num_anomalies} anomalous readings detected ({anomaly_rate:.1%} of analyzed data)
+• Overall Anomaly Score: {overall_score:.3f}
+• Affected Sensors: {len(anomaly_result['anomalous_sensors'])} sensors showing abnormal behavior
+"""
+        
+        if primary_cause:
+            summary += f"""
+Primary Issue Identified:
+• {primary_cause['description']}
+• Severity: {primary_cause['severity'].upper()}
+• Confidence: {primary_cause['confidence']:.0%}
+• Fault Codes: {', '.join(primary_cause['fault_codes'])}
+"""
+        
+        if num_recommendations > 0:
+            top_priority = maintenance_result.get('top_priority')
+            total_cost = maintenance_result['total_cost']
+            
+            summary += f"""
+Maintenance Required:
+• {num_recommendations} maintenance items identified
+• Highest Priority: {top_priority['urgency'].upper()} urgency
+• Estimated Cost: {total_cost['cost_range']}
+• Immediate Actions: {len(maintenance_result['action_plan']['immediate'])} required
+"""
+        
+        return summary.strip()
+    
+    def format_anomaly_details(self, anomaly_result: Dict) -> str:
+        """Format anomaly detection details"""
+        if not anomaly_result['anomaly_detected']:
+            return "No anomalies detected."
+        
+        details = f"""
+ANOMALY DETECTION DETAILS
+{'='*60}
+
+Overall Statistics:
+• Total Readings Analyzed: {len(anomaly_result['anomaly_predictions'])}
+• Anomalous Readings: {anomaly_result['num_anomalies']}
+• Anomaly Rate: {anomaly_result['anomaly_rate']:.2%}
+• Overall Anomaly Score: {anomaly_result['overall_score']:.3f}
+
+Affected Sensors:
+"""
+        
+        anomalous_sensors = anomaly_result['anomalous_sensors']
+        sorted_sensors = sorted(anomalous_sensors.items(), 
+                               key=lambda x: x[1]['deviation'], 
+                               reverse=True)
+        
+        for sensor, info in sorted_sensors:
+            details += f"""
+• {sensor.upper()}
+  - Severity: {info['severity']}
+  - Deviation: {info['deviation']:.2f}σ from normal
+  - Normal Mean: {info['overall_mean']:.3f}
+  - Anomaly Mean: {info['anomaly_mean']:.3f}
+"""
+        
+        return details.strip()
+    
+    def format_root_cause_analysis(self, root_cause_result: Dict) -> str:
+        """Format root cause analysis details"""
+        if not root_cause_result['root_causes']:
+            return "No root causes identified."
+        
+        details = f"""
+ROOT CAUSE ANALYSIS
+{'='*60}
+
+Analysis Summary:
+{root_cause_result['analysis_summary']}
+
+Failure Progression:
+• Type: {root_cause_result['failure_sequence'].get('progression', 'unknown').upper()}
+• Duration: {root_cause_result['failure_sequence'].get('duration', 0)} timesteps
+• First Anomaly: Timestep {root_cause_result['failure_sequence'].get('first_anomaly_time', 'N/A')}
+• Last Anomaly: Timestep {root_cause_result['failure_sequence'].get('last_anomaly_time', 'N/A')}
+
+Identified Root Causes:
+"""
+        
+        for i, cause in enumerate(root_cause_result['root_causes'], 1):
+            details += f"""
+{i}. {cause['fault_name'].upper().replace('_', ' ')}
+   Description: {cause['description']}
+   Severity: {cause['severity'].upper()}
+   Confidence: {cause['confidence']:.0%}
+   Fault Codes: {', '.join(cause['fault_codes'])}
+   Affected Sensors: {', '.join(cause['affected_sensors'])}
+"""
+        
+        if root_cause_result['correlations']:
+            details += "\nCorrelated Sensor Failures:\n"
+            for sensor1, sensor2, strength in root_cause_result['correlations']:
+                details += f"• {sensor1} ↔ {sensor2} (correlation: {strength:.2f})\n"
+        
+        return details.strip()
+    
+    def format_maintenance_recommendations(self, maintenance_result: Dict) -> str:
+        """Format maintenance recommendations"""
+        if not maintenance_result['recommendations']:
+            return "No maintenance required at this time."
+        
+        details = f"""
+MAINTENANCE RECOMMENDATIONS
+{'='*60}
+
+Cost Estimate: {maintenance_result['total_cost']['cost_range']}
+Total Actions: {maintenance_result['action_plan']['total_actions']}
+
+IMMEDIATE ACTIONS (Perform Now):
+"""
+        
+        for i, action in enumerate(maintenance_result['action_plan']['immediate'], 1):
+            details += f"{i}. {action['action']}\n   Related to: {action['related_to'].replace('_', ' ').title()}\n   Urgency: {action['urgency'].upper()}\n\n"
+        
+        details += "\nSHORT-TERM ACTIONS (Within 1-2 Weeks):\n"
+        for i, action in enumerate(maintenance_result['action_plan']['short_term'], 1):
+            details += f"{i}. {action['action']}\n   Related to: {action['related_to'].replace('_', ' ').title()}\n\n"
+        
+        details += "\nLONG-TERM ACTIONS (Preventive Maintenance):\n"
+        for i, action in enumerate(maintenance_result['action_plan']['long_term'], 1):
+            details += f"{i}. {action['action']}\n   Related to: {action['related_to'].replace('_', ' ').title()}\n\n"
+        
+        # Add detailed recommendations
+        details += "\nDETAILED MAINTENANCE ITEMS:\n"
+        for i, rec in enumerate(maintenance_result['recommendations'], 1):
+            details += f"""
+{i}. {rec['fault_name'].upper().replace('_', ' ')}
+   Severity: {rec['severity'].upper()}
+   Urgency: {rec['urgency'].upper()}
+   Estimated Cost: {rec['estimated_cost']}
+   Estimated Downtime: {rec['estimated_downtime']}
+   Fault Codes: {', '.join(rec['fault_codes'])}
+"""
+        
+        return details.strip()
+    
+    def generate_natural_language_summary(self, vehicle_id: int,
+                                         anomaly_result: Dict,
+                                         root_cause_result: Dict,
+                                         maintenance_result: Dict) -> str:
+        """Generate natural language summary for non-technical users"""
+        if not anomaly_result['anomaly_detected']:
+            return (f"Good news! Vehicle {vehicle_id} is running smoothly. "
+                   f"Our diagnostic system analyzed all sensor data and found no issues. "
+                   f"Continue with regular maintenance schedule.")
+        
+        primary_cause = root_cause_result.get('primary_cause')
+        top_priority = maintenance_result.get('top_priority')
+        
+        summary = f"Vehicle {vehicle_id} requires attention. "
+        
+        if primary_cause:
+            summary += f"Our analysis detected {primary_cause['description'].lower()}. "
+            
+            if primary_cause['severity'] == 'critical':
+                summary += "This is a critical issue that requires immediate attention. "
+            elif primary_cause['severity'] == 'high':
+                summary += "This is a high-priority issue that should be addressed soon. "
+            else:
+                summary += "This issue should be addressed during your next service visit. "
+        
+        if top_priority:
+            summary += f"\n\nWhat you need to do: "
+            immediate_actions = maintenance_result['action_plan']['immediate']
+            if immediate_actions:
+                summary += f"{immediate_actions[0]['action']} "
+            
+            summary += f"\n\nEstimated repair cost: {maintenance_result['total_cost']['cost_range']}. "
+            summary += f"Expected downtime: {top_priority['estimated_downtime']}."
+        
+        return summary
+    
+    def generate_json_report(self, vehicle_id: int,
+                            prepared_data: Dict,
+                            anomaly_result: Dict,
+                            root_cause_result: Dict,
+                            maintenance_result: Dict) -> Dict:
+        """Generate structured JSON report"""
+        report = {
+            'report_metadata': {
+                'vehicle_id': vehicle_id,
+                'report_timestamp': datetime.now().isoformat(),
+                'report_version': '1.0',
+                'analysis_timerange': prepared_data['time_range']
+            },
+            'anomaly_detection': {
+                'anomaly_detected': anomaly_result['anomaly_detected'],
+                'num_anomalies': anomaly_result['num_anomalies'],
+                'anomaly_rate': anomaly_result['anomaly_rate'],
+                'overall_score': anomaly_result['overall_score'],
+                'anomalous_sensors': anomaly_result['anomalous_sensors']
+            },
+            'root_cause_analysis': {
+                'root_causes': root_cause_result['root_causes'],
+                'primary_cause': root_cause_result.get('primary_cause'),
+                'failure_sequence': root_cause_result['failure_sequence'],
+                'correlations': root_cause_result['correlations']
+            },
+            'maintenance_recommendations': {
+                'recommendations': maintenance_result['recommendations'],
+                'action_plan': maintenance_result['action_plan'],
+                'total_cost': maintenance_result['total_cost'],
+                'top_priority': maintenance_result.get('top_priority')
+            }
+        }
+        
+        return report
+    
+    def run(self, vehicle_id: int,
+            prepared_data: Dict,
+            anomaly_result: Dict,
+            root_cause_result: Dict,
+            maintenance_result: Dict) -> Dict:
+        """
+        Main execution method for the Report Generation Agent
+        
+        Args:
+            vehicle_id: Vehicle ID
+            prepared_data: Data from ingestion agent
+            anomaly_result: Results from anomaly detection
+            root_cause_result: Results from root cause analysis
+            maintenance_result: Results from maintenance recommendations
+            
+        Returns:
+            Dictionary containing complete diagnostic report
+        """
+        print(f"\n{'='*60}")
+        print(f"REPORT GENERATION AGENT - Vehicle {vehicle_id}")
+        print(f"{'='*60}")
+        
+        print("Generating comprehensive diagnostic report...")
+        
+        # Generate all report sections
+        executive_summary = self.generate_executive_summary(
+            vehicle_id, anomaly_result, root_cause_result, maintenance_result
+        )
+        
+        anomaly_details = self.format_anomaly_details(anomaly_result)
+        root_cause_details = self.format_root_cause_analysis(root_cause_result)
+        maintenance_details = self.format_maintenance_recommendations(maintenance_result)
+        
+        natural_language_summary = self.generate_natural_language_summary(
+            vehicle_id, anomaly_result, root_cause_result, maintenance_result
+        )
+        
+        json_report = self.generate_json_report(
+            vehicle_id, prepared_data, anomaly_result, root_cause_result, maintenance_result
+        )
+        
+        # Compile full report
+        full_report = f"""
+{'='*60}
+VEHICLE DIAGNOSTIC REPORT
+Vehicle ID: {vehicle_id}
+Report Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+{'='*60}
+
+EXECUTIVE SUMMARY
+{'='*60}
+{executive_summary}
+
+{anomaly_details}
+
+{root_cause_details}
+
+{maintenance_details}
+
+{'='*60}
+PLAIN LANGUAGE SUMMARY
+{'='*60}
+{natural_language_summary}
+
+{'='*60}
+END OF REPORT
+{'='*60}
+"""
+        
+        print("✓ Generated executive summary")
+        print("✓ Generated anomaly detection details")
+        print("✓ Generated root cause analysis")
+        print("✓ Generated maintenance recommendations")
+        print("✓ Generated natural language summary")
+        print("✓ Generated JSON report")
+        
+        print(f"\n✓ Complete diagnostic report generated")
+        print(f"{'='*60}\n")
+        
+        result = {
+            'vehicle_id': vehicle_id,
+            'full_report': full_report,
+            'executive_summary': executive_summary,
+            'natural_language_summary': natural_language_summary,
+            'json_report': json_report,
+            'report_timestamp': datetime.now().isoformat()
+        }
+        
+        return result
+
+
+if __name__ == '__main__':
+    # Test the Report Generation Agent
+    from data_ingestion_agent import DataIngestionAgent
+    from anomaly_detection_agent import AnomalyDetectionAgent
+    from root_cause_agent import RootCauseAnalysisAgent
+    from maintenance_recommendation_agent import MaintenanceRecommendationAgent
+    
+    # Run full pipeline
+    ingestion_agent = DataIngestionAgent()
+    test_df = ingestion_agent.load_test_data()
+    
+    # Find a vehicle with anomalies
+    test_vehicle_id = None
+    for vid in test_df['vehicle_id'].unique()[:10]:
+        if test_df[test_df['vehicle_id'] == vid]['anomaly'].sum() > 0:
+            test_vehicle_id = vid
+            break
+    
+    if test_vehicle_id:
+        prepared_data = ingestion_agent.run(test_vehicle_id)
+        
+        detection_agent = AnomalyDetectionAgent()
+        anomaly_result = detection_agent.run(prepared_data)
+        
+        rca_agent = RootCauseAnalysisAgent()
+        rca_result = rca_agent.run(anomaly_result)
+        
+        maintenance_agent = MaintenanceRecommendationAgent()
+        maintenance_result = maintenance_agent.run(rca_result)
+        
+        # Generate report
+        report_agent = ReportGenerationAgent()
+        report = report_agent.run(test_vehicle_id, prepared_data, anomaly_result, 
+                                 rca_result, maintenance_result)
+        
+        print("\n" + "="*60)
+        print("SAMPLE REPORT OUTPUT")
+        print("="*60)
+        print(report['full_report'][:1000] + "...")

src/agents/root_cause_agent.py

@@ -0,0 +1,307 @@
+"""
+Root Cause Analysis Agent - Identifies the root cause of detected anomalies
+"""
+import numpy as np
+from typing import Dict, List, Tuple
+
+
+class RootCauseAnalysisAgent:
+    """
+    Agent responsible for determining the root cause of detected anomalies
+    """
+    
+    def __init__(self):
+        # Define fault patterns and their associated root causes
+        self.fault_patterns = {
+            'engine_overheating': {
+                'sensors': ['engine_temp', 'coolant_temp', 'temp_differential'],
+                'thresholds': {'engine_temp': 1.5, 'coolant_temp': 1.5, 'temp_differential': 1.0},
+                'description': 'Engine temperature exceeds safe operating limits',
+                'severity': 'critical',
+                'fault_codes': ['P0217', 'P0218', 'P0219']
+            },
+            'cooling_system_failure': {
+                'sensors': ['coolant_temp', 'engine_temp'],
+                'thresholds': {'coolant_temp': 2.0, 'engine_temp': 1.8},
+                'description': 'Cooling system not maintaining proper temperature',
+                'severity': 'critical',
+                'fault_codes': ['P0217', 'P0128']
+            },
+            'oil_pressure_low': {
+                'sensors': ['oil_pressure'],
+                'thresholds': {'oil_pressure': -1.5},
+                'description': 'Oil pressure below safe operating range',
+                'severity': 'critical',
+                'fault_codes': ['P0520', 'P0521', 'P0522']
+            },
+            'battery_degradation': {
+                'sensors': ['battery_voltage', 'battery_health'],
+                'thresholds': {'battery_voltage': -1.0, 'battery_health': -1.0},
+                'description': 'Battery voltage or health declining',
+                'severity': 'high',
+                'fault_codes': ['P0560', 'P0562', 'P0563']
+            },
+            'tire_pressure_issue': {
+                'sensors': ['tire_pressure_fl', 'tire_pressure_fr', 'tire_pressure_rl', 'tire_pressure_rr', 'tire_pressure_imbalance'],
+                'thresholds': {'tire_pressure_fl': -1.5, 'tire_pressure_fr': -1.5, 
+                              'tire_pressure_rl': -1.5, 'tire_pressure_rr': -1.5,
+                              'tire_pressure_imbalance': 1.5},
+                'description': 'One or more tires have incorrect pressure',
+                'severity': 'medium',
+                'fault_codes': ['C1234', 'C1235']
+            },
+            'excessive_vibration': {
+                'sensors': ['vibration_level'],
+                'thresholds': {'vibration_level': 2.0},
+                'description': 'Abnormal vibration detected',
+                'severity': 'high',
+                'fault_codes': ['P0300', 'P0301']
+            },
+            'fuel_system_issue': {
+                'sensors': ['fuel_pressure'],
+                'thresholds': {'fuel_pressure': -1.5},
+                'description': 'Fuel pressure outside normal range',
+                'severity': 'high',
+                'fault_codes': ['P0087', 'P0088']
+            },
+            'engine_stress': {
+                'sensors': ['engine_stress', 'rpm', 'engine_temp'],
+                'thresholds': {'engine_stress': 2.0, 'rpm': 2.0},
+                'description': 'Engine operating under excessive stress',
+                'severity': 'medium',
+                'fault_codes': ['P0101', 'P0102']
+            }
+        }
+    
+    def analyze_sensor_patterns(self, anomalous_sensors: Dict, raw_data) -> List[Dict]:
+        """
+        Analyze anomalous sensor patterns to identify root causes
+        
+        Args:
+            anomalous_sensors: Dictionary of sensors showing anomalous behavior
+            raw_data: Raw sensor data DataFrame
+            
+        Returns:
+            List of identified root causes with confidence scores
+        """
+        identified_causes = []
+        
+        for fault_name, fault_info in self.fault_patterns.items():
+            # Check if any of the fault's sensors are anomalous
+            matching_sensors = []
+            confidence_scores = []
+            
+            for sensor in fault_info['sensors']:
+                if sensor in anomalous_sensors:
+                    matching_sensors.append(sensor)
+                    
+                    # Calculate confidence based on deviation
+                    deviation = anomalous_sensors[sensor]['deviation']
+                    confidence = min(deviation / 5.0, 1.0)  # Normalize to 0-1
+                    confidence_scores.append(confidence)
+                
+                # Also check if sensor values exceed thresholds
+                elif sensor in raw_data.columns:
+                    threshold = fault_info['thresholds'].get(sensor)
+                    if threshold is not None:
+                        # Check recent values
+                        recent_values = raw_data[sensor].tail(20)
+                        if threshold > 0:
+                            exceeds = (recent_values > threshold).sum() / len(recent_values)
+                        else:
+                            exceeds = (recent_values < threshold).sum() / len(recent_values)
+                        
+                        if exceeds > 0.3:  # If 30% of recent values exceed threshold
+                            matching_sensors.append(sensor)
+                            confidence_scores.append(exceeds)
+            
+            # If we have matching sensors, this is a potential root cause
+            if matching_sensors:
+                avg_confidence = np.mean(confidence_scores)
+                
+                identified_causes.append({
+                    'fault_name': fault_name,
+                    'description': fault_info['description'],
+                    'severity': fault_info['severity'],
+                    'confidence': float(avg_confidence),
+                    'affected_sensors': matching_sensors,
+                    'fault_codes': fault_info['fault_codes'],
+                    'num_sensors_affected': len(matching_sensors)
+                })
+        
+        # Sort by confidence
+        identified_causes.sort(key=lambda x: x['confidence'], reverse=True)
+        
+        return identified_causes
+    
+    def correlate_sensor_failures(self, anomalous_sensors: Dict) -> List[Tuple[str, str, float]]:
+        """
+        Find correlations between anomalous sensors
+        
+        Args:
+            anomalous_sensors: Dictionary of anomalous sensors
+            
+        Returns:
+            List of correlated sensor pairs with correlation strength
+        """
+        correlations = []
+        
+        # Known sensor correlations
+        known_correlations = [
+            ('engine_temp', 'coolant_temp', 0.9),
+            ('engine_temp', 'oil_pressure', -0.7),
+            ('rpm', 'engine_temp', 0.6),
+            ('battery_voltage', 'battery_health', 0.95),
+            ('tire_pressure_fl', 'tire_pressure_fr', 0.8),
+            ('tire_pressure_rl', 'tire_pressure_rr', 0.8),
+        ]
+        
+        for sensor1, sensor2, corr_strength in known_correlations:
+            if sensor1 in anomalous_sensors and sensor2 in anomalous_sensors:
+                correlations.append((sensor1, sensor2, corr_strength))
+        
+        return correlations
+    
+    def determine_failure_sequence(self, anomaly_indices: List[int], 
+                                   anomalous_sensors: Dict, 
+                                   timestamps: np.ndarray) -> Dict:
+        """
+        Determine the sequence of failures
+        
+        Args:
+            anomaly_indices: Indices where anomalies occurred
+            anomalous_sensors: Dictionary of anomalous sensors
+            timestamps: Array of timestamps
+            
+        Returns:
+            Dictionary describing failure sequence
+        """
+        if not anomaly_indices:
+            return {'sequence': [], 'duration': 0}
+        
+        first_anomaly = min(anomaly_indices)
+        last_anomaly = max(anomaly_indices)
+        duration = last_anomaly - first_anomaly
+        
+        sequence = {
+            'first_anomaly_time': int(timestamps[first_anomaly]),
+            'last_anomaly_time': int(timestamps[last_anomaly]),
+            'duration': int(duration),
+            'progression': 'gradual' if duration > 50 else 'sudden',
+            'affected_sensors': list(anomalous_sensors.keys())
+        }
+        
+        return sequence
+    
+    def run(self, anomaly_result: Dict) -> Dict:
+        """
+        Main execution method for the Root Cause Analysis Agent
+        
+        Args:
+            anomaly_result: Results from Anomaly Detection Agent
+            
+        Returns:
+            Dictionary containing root cause analysis
+        """
+        print(f"\n{'='*60}")
+        print(f"ROOT CAUSE ANALYSIS AGENT - Vehicle {anomaly_result['vehicle_id']}")
+        print(f"{'='*60}")
+        
+        if not anomaly_result['anomaly_detected']:
+            print("✓ No anomalies detected - no root cause analysis needed")
+            print(f"{'='*60}\n")
+            return {
+                'vehicle_id': anomaly_result['vehicle_id'],
+                'root_causes': [],
+                'correlations': [],
+                'failure_sequence': {},
+                'analysis_summary': 'No anomalies detected'
+            }
+        
+        anomalous_sensors = anomaly_result['anomalous_sensors']
+        raw_data = anomaly_result['raw_data']
+        anomaly_indices = anomaly_result['anomaly_indices']
+        timestamps = anomaly_result['timestamps']
+        
+        print(f"Analyzing {len(anomalous_sensors)} anomalous sensors...")
+        
+        # Identify root causes
+        root_causes = self.analyze_sensor_patterns(anomalous_sensors, raw_data)
+        print(f"✓ Identified {len(root_causes)} potential root causes")
+        
+        if root_causes:
+            print("\nTop root causes:")
+            for i, cause in enumerate(root_causes[:3], 1):
+                print(f"  {i}. {cause['fault_name']} ({cause['severity']} severity)")
+                print(f"     Confidence: {cause['confidence']:.2%}")
+                print(f"     Description: {cause['description']}")
+                print(f"     Fault codes: {', '.join(cause['fault_codes'])}")
+        
+        # Find sensor correlations
+        correlations = self.correlate_sensor_failures(anomalous_sensors)
+        if correlations:
+            print(f"\n✓ Found {len(correlations)} correlated sensor failures")
+            for sensor1, sensor2, strength in correlations:
+                print(f"    - {sensor1} ↔ {sensor2} (correlation: {strength:.2f})")
+        
+        # Determine failure sequence
+        failure_sequence = self.determine_failure_sequence(
+            anomaly_indices, anomalous_sensors, timestamps
+        )
+        print(f"\n✓ Failure progression: {failure_sequence.get('progression', 'unknown')}")
+        print(f"  Duration: {failure_sequence.get('duration', 0)} timesteps")
+        
+        # Generate analysis summary
+        if root_causes:
+            primary_cause = root_causes[0]
+            summary = (f"Primary issue: {primary_cause['description']} "
+                      f"({primary_cause['severity']} severity, "
+                      f"{primary_cause['confidence']:.0%} confidence)")
+        else:
+            summary = "Anomalies detected but root cause unclear"
+        
+        print(f"\n✓ Analysis summary: {summary}")
+        print(f"{'='*60}\n")
+        
+        result = {
+            'vehicle_id': anomaly_result['vehicle_id'],
+            'root_causes': root_causes,
+            'correlations': correlations,
+            'failure_sequence': failure_sequence,
+            'analysis_summary': summary,
+            'primary_cause': root_causes[0] if root_causes else None
+        }
+        
+        return result
+
+
+if __name__ == '__main__':
+    # Test the Root Cause Analysis Agent
+    from data_ingestion_agent import DataIngestionAgent
+    from anomaly_detection_agent import AnomalyDetectionAgent
+    
+    # Load and prepare data
+    ingestion_agent = DataIngestionAgent()
+    test_df = ingestion_agent.load_test_data()
+    
+    # Find a vehicle with anomalies
+    test_vehicle_id = None
+    for vid in test_df['vehicle_id'].unique()[:10]:
+        if test_df[test_df['vehicle_id'] == vid]['anomaly'].sum() > 0:
+            test_vehicle_id = vid
+            break
+    
+    if test_vehicle_id:
+        prepared_data = ingestion_agent.run(test_vehicle_id)
+        
+        # Detect anomalies
+        detection_agent = AnomalyDetectionAgent()
+        anomaly_result = detection_agent.run(prepared_data)
+        
+        # Analyze root cause
+        rca_agent = RootCauseAnalysisAgent()
+        result = rca_agent.run(anomaly_result)
+        
+        print(f"\nRoot Cause Analysis Summary:")
+        print(f"  Primary cause: {result['primary_cause']['fault_name'] if result['primary_cause'] else 'None'}")
+        print(f"  Root causes found: {len(result['root_causes'])}")

src/api/main.py

@@ -0,0 +1,277 @@
+"""
+FastAPI Backend for Vehicle Diagnostics Agent
+"""
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+from orchestrator import VehicleDiagnosticOrchestrator
+from agents.data_ingestion_agent import DataIngestionAgent
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Vehicle Diagnostics Agent API",
+    description="Multi-agent AI system for predictive vehicle diagnostics",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize orchestrator
+orchestrator = VehicleDiagnosticOrchestrator()
+ingestion_agent = DataIngestionAgent()
+
+# Store for async job results
+job_results = {}
+
+
+# Pydantic models for request/response
+class DiagnosticRequest(BaseModel):
+    vehicle_id: int = Field(..., description="ID of the vehicle to diagnose")
+    n_readings: Optional[int] = Field(None, description="Number of recent readings to analyze")
+
+
+class DiagnosticResponse(BaseModel):
+    success: bool
+    vehicle_id: int
+    message: str
+    anomaly_detected: Optional[bool] = None
+    overall_score: Optional[float] = None
+    num_anomalies: Optional[int] = None
+    primary_cause: Optional[str] = None
+    estimated_cost: Optional[str] = None
+    report_summary: Optional[str] = None
+
+
+class BatchDiagnosticRequest(BaseModel):
+    vehicle_ids: List[int] = Field(..., description="List of vehicle IDs to diagnose")
+    n_readings: Optional[int] = Field(None, description="Number of recent readings to analyze")
+
+
+class HealthCheckResponse(BaseModel):
+    status: str
+    version: str
+    available_vehicles: int
+
+
+@app.get("/", response_model=Dict)
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "Vehicle Diagnostics Agent API",
+        "version": "1.0.0",
+        "endpoints": {
+            "health": "/health",
+            "diagnose": "/diagnose",
+            "batch_diagnose": "/batch-diagnose",
+            "vehicles": "/vehicles",
+            "report": "/report/{vehicle_id}"
+        }
+    }
+
+
+@app.get("/health", response_model=HealthCheckResponse)
+async def health_check():
+    """Health check endpoint"""
+    try:
+        test_df = ingestion_agent.load_test_data()
+        num_vehicles = test_df['vehicle_id'].nunique()
+        
+        return HealthCheckResponse(
+            status="healthy",
+            version="1.0.0",
+            available_vehicles=num_vehicles
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Health check failed: {str(e)}")
+
+
+@app.get("/vehicles", response_model=Dict)
+async def list_vehicles():
+    """List available vehicles for diagnosis"""
+    try:
+        test_df = ingestion_agent.load_test_data()
+        vehicle_ids = test_df['vehicle_id'].unique().tolist()
+        
+        # Get basic stats for each vehicle
+        vehicle_info = []
+        for vid in vehicle_ids[:20]:  # Limit to first 20 for performance
+            vehicle_data = test_df[test_df['vehicle_id'] == vid]
+            vehicle_info.append({
+                'vehicle_id': int(vid),
+                'num_readings': len(vehicle_data),
+                'has_anomalies': bool(vehicle_data['anomaly'].sum() > 0),
+                'anomaly_count': int(vehicle_data['anomaly'].sum())
+            })
+        
+        return {
+            "total_vehicles": len(vehicle_ids),
+            "vehicles": vehicle_info
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to list vehicles: {str(e)}")
+
+
+@app.post("/diagnose", response_model=DiagnosticResponse)
+async def diagnose_vehicle(request: DiagnosticRequest):
+    """
+    Run diagnostic analysis for a single vehicle
+    """
+    try:
+        # Run diagnostic workflow
+        result = orchestrator.diagnose_vehicle(
+            vehicle_id=request.vehicle_id,
+            n_readings=request.n_readings
+        )
+        
+        if not result['success']:
+            return DiagnosticResponse(
+                success=False,
+                vehicle_id=request.vehicle_id,
+                message=f"Diagnostic failed: {result.get('error', 'Unknown error')}"
+            )
+        
+        # Extract key information
+        anomaly_result = result.get('anomaly_result', {})
+        root_cause_result = result.get('root_cause_result', {})
+        maintenance_result = result.get('maintenance_result', {})
+        report = result.get('report', {})
+        
+        primary_cause = root_cause_result.get('primary_cause')
+        
+        return DiagnosticResponse(
+            success=True,
+            vehicle_id=request.vehicle_id,
+            message="Diagnostic completed successfully",
+            anomaly_detected=anomaly_result.get('anomaly_detected', False),
+            overall_score=anomaly_result.get('overall_score'),
+            num_anomalies=anomaly_result.get('num_anomalies'),
+            primary_cause=primary_cause['fault_name'] if primary_cause else None,
+            estimated_cost=maintenance_result.get('total_cost', {}).get('cost_range'),
+            report_summary=report.get('natural_language_summary')
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Diagnostic failed: {str(e)}")
+
+
+@app.post("/batch-diagnose")
+async def batch_diagnose(request: BatchDiagnosticRequest, background_tasks: BackgroundTasks):
+    """
+    Run diagnostic analysis for multiple vehicles (async)
+    """
+    try:
+        # For simplicity, run synchronously for now
+        # In production, this would be handled by a task queue
+        results = orchestrator.diagnose_multiple_vehicles(
+            vehicle_ids=request.vehicle_ids,
+            n_readings=request.n_readings
+        )
+        
+        # Summarize results
+        summary = {
+            'total_vehicles': len(request.vehicle_ids),
+            'successful': sum(1 for r in results.values() if r['success']),
+            'with_anomalies': sum(1 for r in results.values() 
+                                 if r['success'] and r.get('anomaly_result', {}).get('anomaly_detected')),
+            'results': {}
+        }
+        
+        for vid, result in results.items():
+            if result['success']:
+                anomaly_result = result.get('anomaly_result', {})
+                summary['results'][vid] = {
+                    'anomaly_detected': anomaly_result.get('anomaly_detected', False),
+                    'overall_score': anomaly_result.get('overall_score'),
+                    'num_anomalies': anomaly_result.get('num_anomalies')
+                }
+            else:
+                summary['results'][vid] = {
+                    'error': result.get('error')
+                }
+        
+        return summary
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Batch diagnostic failed: {str(e)}")
+
+
+@app.get("/report/{vehicle_id}")
+async def get_full_report(vehicle_id: int, n_readings: Optional[int] = None):
+    """
+    Get full diagnostic report for a vehicle
+    """
+    try:
+        # Run diagnostic workflow
+        result = orchestrator.diagnose_vehicle(
+            vehicle_id=vehicle_id,
+            n_readings=n_readings
+        )
+        
+        if not result['success']:
+            raise HTTPException(status_code=500, detail=result.get('error', 'Unknown error'))
+        
+        report = result.get('report', {})
+        
+        return {
+            'vehicle_id': vehicle_id,
+            'report_timestamp': report.get('report_timestamp'),
+            'full_report': report.get('full_report'),
+            'executive_summary': report.get('executive_summary'),
+            'natural_language_summary': report.get('natural_language_summary'),
+            'json_report': report.get('json_report')
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to generate report: {str(e)}")
+
+
+@app.get("/vehicle/{vehicle_id}/status")
+async def get_vehicle_status(vehicle_id: int):
+    """
+    Get current status of a vehicle without full diagnostic
+    """
+    try:
+        test_df = ingestion_agent.load_test_data()
+        vehicle_data = test_df[test_df['vehicle_id'] == vehicle_id]
+        
+        if len(vehicle_data) == 0:
+            raise HTTPException(status_code=404, detail=f"Vehicle {vehicle_id} not found")
+        
+        # Get basic statistics
+        latest_data = vehicle_data.tail(50)
+        sensor_summary = ingestion_agent.get_sensor_summary(latest_data)
+        
+        return {
+            'vehicle_id': vehicle_id,
+            'num_readings': len(vehicle_data),
+            'latest_timestamp': int(vehicle_data['timestamp'].iloc[-1]),
+            'has_anomalies': bool(vehicle_data['anomaly'].sum() > 0),
+            'total_anomalies': int(vehicle_data['anomaly'].sum()),
+            'sensor_summary': sensor_summary
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get vehicle status: {str(e)}")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

src/models/anomaly_detector.py

@@ -0,0 +1,205 @@
+"""
+Anomaly Detection Model using LSTM Neural Network
+"""
+import torch
+import torch.nn as nn
+import numpy as np
+from pathlib import Path
+import pickle
+
+
+class LSTMAnomalyDetector(nn.Module):
+    """
+    LSTM-based anomaly detection model for time-series sensor data
+    """
+    
+    def __init__(self, input_size, hidden_size=64, num_layers=2, dropout=0.2):
+        super(LSTMAnomalyDetector, self).__init__()
+        
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        
+        # LSTM layers
+        self.lstm = nn.LSTM(
+            input_size=input_size,
+            hidden_size=hidden_size,
+            num_layers=num_layers,
+            batch_first=True,
+            dropout=dropout if num_layers > 1 else 0
+        )
+        
+        # Fully connected layers
+        self.fc1 = nn.Linear(hidden_size, 32)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+        self.fc2 = nn.Linear(32, 1)
+        self.sigmoid = nn.Sigmoid()
+    
+    def forward(self, x):
+        # LSTM forward pass
+        lstm_out, _ = self.lstm(x)
+        
+        # Take the last output
+        last_output = lstm_out[:, -1, :]
+        
+        # Fully connected layers
+        out = self.fc1(last_output)
+        out = self.relu(out)
+        out = self.dropout(out)
+        out = self.fc2(out)
+        out = self.sigmoid(out)
+        
+        return out
+
+
+class AnomalyDetectionModel:
+    """
+    Wrapper class for anomaly detection model with training and inference
+    """
+    
+    def __init__(self, input_size, sequence_length=50, device=None):
+        self.input_size = input_size
+        self.sequence_length = sequence_length
+        self.device = device or torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        
+        self.model = LSTMAnomalyDetector(input_size).to(self.device)
+        self.criterion = nn.BCELoss()
+        self.optimizer = torch.optim.Adam(self.model.parameters(), lr=0.001)
+        
+        print(f"Initialized Anomaly Detection Model on {self.device}")
+    
+    def create_sequences(self, data, labels=None):
+        """
+        Create sequences for LSTM input
+        
+        Args:
+            data: numpy array of shape (n_samples, n_features)
+            labels: optional numpy array of labels
+            
+        Returns:
+            Sequences and labels (if provided)
+        """
+        sequences = []
+        seq_labels = []
+        
+        for i in range(len(data) - self.sequence_length + 1):
+            seq = data[i:i + self.sequence_length]
+            sequences.append(seq)
+            
+            if labels is not None:
+                # Label is 1 if any point in sequence is anomalous
+                label = labels[i + self.sequence_length - 1]
+                seq_labels.append(label)
+        
+        sequences = np.array(sequences)
+        
+        if labels is not None:
+            seq_labels = np.array(seq_labels)
+            return sequences, seq_labels
+        
+        return sequences
+    
+    def train_epoch(self, train_loader):
+        """Train for one epoch"""
+        self.model.train()
+        total_loss = 0
+        
+        for batch_x, batch_y in train_loader:
+            batch_x = batch_x.to(self.device)
+            batch_y = batch_y.to(self.device)
+            
+            # Forward pass
+            outputs = self.model(batch_x)
+            loss = self.criterion(outputs.squeeze(), batch_y.float())
+            
+            # Backward pass
+            self.optimizer.zero_grad()
+            loss.backward()
+            self.optimizer.step()
+            
+            total_loss += loss.item()
+        
+        return total_loss / len(train_loader)
+    
+    def evaluate(self, val_loader):
+        """Evaluate on validation set"""
+        self.model.eval()
+        total_loss = 0
+        all_preds = []
+        all_labels = []
+        
+        with torch.no_grad():
+            for batch_x, batch_y in val_loader:
+                batch_x = batch_x.to(self.device)
+                batch_y = batch_y.to(self.device)
+                
+                outputs = self.model(batch_x)
+                loss = self.criterion(outputs.squeeze(), batch_y.float())
+                
+                total_loss += loss.item()
+                
+                preds = (outputs.squeeze() > 0.5).cpu().numpy()
+                all_preds.extend(preds)
+                all_labels.extend(batch_y.cpu().numpy())
+        
+        avg_loss = total_loss / len(val_loader)
+        
+        # Calculate metrics
+        all_preds = np.array(all_preds)
+        all_labels = np.array(all_labels)
+        
+        accuracy = (all_preds == all_labels).mean()
+        
+        return avg_loss, accuracy
+    
+    def predict(self, data):
+        """
+        Predict anomalies for given data
+        
+        Args:
+            data: numpy array of shape (n_samples, n_features)
+            
+        Returns:
+            Anomaly scores and binary predictions
+        """
+        self.model.eval()
+        
+        # Create sequences
+        sequences = self.create_sequences(data)
+        
+        # Convert to tensor
+        sequences_tensor = torch.FloatTensor(sequences).to(self.device)
+        
+        # Predict
+        with torch.no_grad():
+            scores = self.model(sequences_tensor).squeeze().cpu().numpy()
+        
+        # Binary predictions
+        predictions = (scores > 0.5).astype(int)
+        
+        return scores, predictions
+    
+    def save(self, path):
+        """Save model"""
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        
+        torch.save({
+            'model_state_dict': self.model.state_dict(),
+            'optimizer_state_dict': self.optimizer.state_dict(),
+            'input_size': self.input_size,
+            'sequence_length': self.sequence_length,
+        }, path)
+        
+        print(f"✓ Model saved to {path}")
+    
+    def load(self, path):
+        """Load model"""
+        checkpoint = torch.load(path, map_location=self.device)
+        
+        self.model.load_state_dict(checkpoint['model_state_dict'])
+        self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+        self.input_size = checkpoint['input_size']
+        self.sequence_length = checkpoint['sequence_length']
+        
+        print(f"✓ Model loaded from {path}")

src/models/best_anomaly_detector.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca38939ee83cea0a7846731c4888718af19218b6fc233918143bbedc7b1372fd
+size 825850

src/models/train_anomaly_detector.py

@@ -0,0 +1,116 @@
+"""
+Train the LSTM Anomaly Detection Model
+"""
+import pandas as pd
+import numpy as np
+import torch
+from torch.utils.data import TensorDataset, DataLoader
+from pathlib import Path
+import pickle
+from anomaly_detector import AnomalyDetectionModel
+
+
+def load_data(data_dir='data/processed'):
+    """Load preprocessed data"""
+    data_path = Path(data_dir)
+    
+    train_df = pd.read_csv(data_path / 'train.csv')
+    val_df = pd.read_csv(data_path / 'val.csv')
+    
+    # Load feature columns
+    with open(data_path / 'feature_columns.pkl', 'rb') as f:
+        feature_columns = pickle.load(f)
+    
+    return train_df, val_df, feature_columns
+
+
+def prepare_data_by_vehicle(df, feature_columns, sequence_length=50):
+    """Prepare sequences grouped by vehicle"""
+    all_sequences = []
+    all_labels = []
+    
+    for vehicle_id in df['vehicle_id'].unique():
+        vehicle_data = df[df['vehicle_id'] == vehicle_id]
+        
+        features = vehicle_data[feature_columns].values
+        labels = vehicle_data['anomaly'].values
+        
+        # Create sequences for this vehicle
+        for i in range(len(features) - sequence_length + 1):
+            seq = features[i:i + sequence_length]
+            label = labels[i + sequence_length - 1]
+            
+            all_sequences.append(seq)
+            all_labels.append(label)
+    
+    return np.array(all_sequences), np.array(all_labels)
+
+
+def train_model(epochs=20, batch_size=32, sequence_length=50):
+    """Train the anomaly detection model"""
+    print("="*60)
+    print("TRAINING ANOMALY DETECTION MODEL")
+    print("="*60)
+    
+    # Load data
+    print("\nLoading data...")
+    train_df, val_df, feature_columns = load_data()
+    print(f"✓ Loaded train: {len(train_df)} records, val: {len(val_df)} records")
+    print(f"✓ Features: {len(feature_columns)}")
+    
+    # Prepare sequences
+    print("\nPreparing sequences...")
+    X_train, y_train = prepare_data_by_vehicle(train_df, feature_columns, sequence_length)
+    X_val, y_val = prepare_data_by_vehicle(val_df, feature_columns, sequence_length)
+    
+    print(f"✓ Train sequences: {X_train.shape}")
+    print(f"✓ Val sequences: {X_val.shape}")
+    print(f"✓ Train anomaly rate: {y_train.mean():.2%}")
+    print(f"✓ Val anomaly rate: {y_val.mean():.2%}")
+    
+    # Create data loaders
+    train_dataset = TensorDataset(
+        torch.FloatTensor(X_train),
+        torch.FloatTensor(y_train)
+    )
+    val_dataset = TensorDataset(
+        torch.FloatTensor(X_val),
+        torch.FloatTensor(y_val)
+    )
+    
+    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
+    
+    # Initialize model
+    input_size = len(feature_columns)
+    model = AnomalyDetectionModel(input_size, sequence_length)
+    
+    # Training loop
+    print(f"\nTraining for {epochs} epochs...")
+    print("-"*60)
+    
+    best_val_loss = float('inf')
+    
+    for epoch in range(epochs):
+        train_loss = model.train_epoch(train_loader)
+        val_loss, val_acc = model.evaluate(val_loader)
+        
+        print(f"Epoch {epoch+1}/{epochs} - "
+              f"Train Loss: {train_loss:.4f}, "
+              f"Val Loss: {val_loss:.4f}, "
+              f"Val Acc: {val_acc:.4f}")
+        
+        # Save best model
+        if val_loss < best_val_loss:
+            best_val_loss = val_loss
+            model.save('src/models/best_anomaly_detector.pth')
+    
+    print("-"*60)
+    print(f"\n✓ Training complete! Best val loss: {best_val_loss:.4f}")
+    print("="*60)
+    
+    return model
+
+
+if __name__ == '__main__':
+    model = train_model(epochs=20, batch_size=32, sequence_length=50)

src/orchestrator.py

@@ -0,0 +1,249 @@
+"""
+Multi-Agent Orchestrator using LangGraph
+Coordinates the execution of all diagnostic agents
+"""
+from typing import Dict, TypedDict, Annotated
+from langgraph.graph import StateGraph, END
+import operator
+
+from agents.data_ingestion_agent import DataIngestionAgent
+from agents.anomaly_detection_agent import AnomalyDetectionAgent
+from agents.root_cause_agent import RootCauseAnalysisAgent
+from agents.maintenance_recommendation_agent import MaintenanceRecommendationAgent
+from agents.report_generation_agent import ReportGenerationAgent
+
+
+class DiagnosticState(TypedDict):
+    """State object passed between agents"""
+    vehicle_id: int
+    n_readings: int
+    prepared_data: Dict
+    anomaly_result: Dict
+    root_cause_result: Dict
+    maintenance_result: Dict
+    report_result: Dict
+    error: str
+
+
+class VehicleDiagnosticOrchestrator:
+    """
+    Orchestrates the multi-agent vehicle diagnostic workflow using LangGraph
+    """
+    
+    def __init__(self):
+        self.ingestion_agent = DataIngestionAgent()
+        self.anomaly_agent = AnomalyDetectionAgent()
+        self.root_cause_agent = RootCauseAnalysisAgent()
+        self.maintenance_agent = MaintenanceRecommendationAgent()
+        self.report_agent = ReportGenerationAgent()
+        
+        self.workflow = self._build_workflow()
+    
+    def _build_workflow(self) -> StateGraph:
+        """Build the LangGraph workflow"""
+        
+        # Define the workflow graph
+        workflow = StateGraph(DiagnosticState)
+        
+        # Add nodes for each agent
+        workflow.add_node("data_ingestion", self._run_data_ingestion)
+        workflow.add_node("anomaly_detection", self._run_anomaly_detection)
+        workflow.add_node("root_cause_analysis", self._run_root_cause_analysis)
+        workflow.add_node("maintenance_recommendation", self._run_maintenance_recommendation)
+        workflow.add_node("report_generation", self._run_report_generation)
+        
+        # Define the workflow edges (sequential execution)
+        workflow.set_entry_point("data_ingestion")
+        workflow.add_edge("data_ingestion", "anomaly_detection")
+        workflow.add_edge("anomaly_detection", "root_cause_analysis")
+        workflow.add_edge("root_cause_analysis", "maintenance_recommendation")
+        workflow.add_edge("maintenance_recommendation", "report_generation")
+        workflow.add_edge("report_generation", END)
+        
+        return workflow.compile()
+    
+    def _run_data_ingestion(self, state: DiagnosticState) -> DiagnosticState:
+        """Execute Data Ingestion Agent"""
+        try:
+            prepared_data = self.ingestion_agent.run(
+                state['vehicle_id'], 
+                state.get('n_readings')
+            )
+            state['prepared_data'] = prepared_data
+        except Exception as e:
+            state['error'] = f"Data Ingestion Error: {str(e)}"
+        
+        return state
+    
+    def _run_anomaly_detection(self, state: DiagnosticState) -> DiagnosticState:
+        """Execute Anomaly Detection Agent"""
+        try:
+            if 'error' not in state:
+                anomaly_result = self.anomaly_agent.run(state['prepared_data'])
+                state['anomaly_result'] = anomaly_result
+        except Exception as e:
+            state['error'] = f"Anomaly Detection Error: {str(e)}"
+        
+        return state
+    
+    def _run_root_cause_analysis(self, state: DiagnosticState) -> DiagnosticState:
+        """Execute Root Cause Analysis Agent"""
+        try:
+            if 'error' not in state:
+                root_cause_result = self.root_cause_agent.run(state['anomaly_result'])
+                state['root_cause_result'] = root_cause_result
+        except Exception as e:
+            state['error'] = f"Root Cause Analysis Error: {str(e)}"
+        
+        return state
+    
+    def _run_maintenance_recommendation(self, state: DiagnosticState) -> DiagnosticState:
+        """Execute Maintenance Recommendation Agent"""
+        try:
+            if 'error' not in state:
+                maintenance_result = self.maintenance_agent.run(state['root_cause_result'])
+                state['maintenance_result'] = maintenance_result
+        except Exception as e:
+            state['error'] = f"Maintenance Recommendation Error: {str(e)}"
+        
+        return state
+    
+    def _run_report_generation(self, state: DiagnosticState) -> DiagnosticState:
+        """Execute Report Generation Agent"""
+        try:
+            if 'error' not in state:
+                report_result = self.report_agent.run(
+                    state['vehicle_id'],
+                    state['prepared_data'],
+                    state['anomaly_result'],
+                    state['root_cause_result'],
+                    state['maintenance_result']
+                )
+                state['report_result'] = report_result
+        except Exception as e:
+            state['error'] = f"Report Generation Error: {str(e)}"
+        
+        return state
+    
+    def diagnose_vehicle(self, vehicle_id: int, n_readings: int = None) -> Dict:
+        """
+        Run complete diagnostic workflow for a vehicle
+        
+        Args:
+            vehicle_id: ID of the vehicle to diagnose
+            n_readings: Optional number of recent readings to analyze
+            
+        Returns:
+            Dictionary containing complete diagnostic results
+        """
+        print("\n" + "="*60)
+        print("VEHICLE DIAGNOSTIC ORCHESTRATOR")
+        print("="*60)
+        print(f"Starting diagnostic workflow for Vehicle {vehicle_id}")
+        print("="*60 + "\n")
+        
+        # Initialize state
+        initial_state = {
+            'vehicle_id': vehicle_id,
+            'n_readings': n_readings
+        }
+        
+        # Execute workflow
+        final_state = self.workflow.invoke(initial_state)
+        
+        # Check for errors
+        if 'error' in final_state:
+            print(f"\n❌ Error occurred: {final_state['error']}")
+            return {
+                'success': False,
+                'error': final_state['error'],
+                'vehicle_id': vehicle_id
+            }
+        
+        print("\n" + "="*60)
+        print("DIAGNOSTIC WORKFLOW COMPLETED SUCCESSFULLY")
+        print("="*60)
+        
+        # Return comprehensive results
+        return {
+            'success': True,
+            'vehicle_id': vehicle_id,
+            'prepared_data': final_state.get('prepared_data'),
+            'anomaly_result': final_state.get('anomaly_result'),
+            'root_cause_result': final_state.get('root_cause_result'),
+            'maintenance_result': final_state.get('maintenance_result'),
+            'report': final_state.get('report_result')
+        }
+    
+    def diagnose_multiple_vehicles(self, vehicle_ids: list, n_readings: int = None) -> Dict:
+        """
+        Run diagnostics for multiple vehicles
+        
+        Args:
+            vehicle_ids: List of vehicle IDs
+            n_readings: Optional number of recent readings to analyze
+            
+        Returns:
+            Dictionary mapping vehicle IDs to diagnostic results
+        """
+        results = {}
+        
+        print(f"\n{'='*60}")
+        print(f"BATCH DIAGNOSTICS - {len(vehicle_ids)} vehicles")
+        print(f"{'='*60}\n")
+        
+        for i, vehicle_id in enumerate(vehicle_ids, 1):
+            print(f"\nProcessing vehicle {i}/{len(vehicle_ids)}: {vehicle_id}")
+            results[vehicle_id] = self.diagnose_vehicle(vehicle_id, n_readings)
+        
+        print(f"\n{'='*60}")
+        print(f"BATCH DIAGNOSTICS COMPLETED")
+        print(f"{'='*60}")
+        
+        # Summary statistics
+        successful = sum(1 for r in results.values() if r['success'])
+        with_anomalies = sum(1 for r in results.values() 
+                           if r['success'] and r.get('anomaly_result', {}).get('anomaly_detected'))
+        
+        print(f"\nSummary:")
+        print(f"  Total vehicles: {len(vehicle_ids)}")
+        print(f"  Successfully analyzed: {successful}")
+        print(f"  Vehicles with anomalies: {with_anomalies}")
+        
+        return results
+
+
+def main():
+    """Test the orchestrator"""
+    orchestrator = VehicleDiagnosticOrchestrator()
+    
+    # Load test data to get vehicle IDs
+    from agents.data_ingestion_agent import DataIngestionAgent
+    ingestion_agent = DataIngestionAgent()
+    test_df = ingestion_agent.load_test_data()
+    
+    # Get a vehicle with anomalies
+    test_vehicle_id = None
+    for vid in test_df['vehicle_id'].unique()[:10]:
+        if test_df[test_df['vehicle_id'] == vid]['anomaly'].sum() > 0:
+            test_vehicle_id = vid
+            break
+    
+    if test_vehicle_id:
+        # Run single vehicle diagnostic
+        result = orchestrator.diagnose_vehicle(test_vehicle_id, n_readings=200)
+        
+        if result['success']:
+            print("\n" + "="*60)
+            print("DIAGNOSTIC REPORT PREVIEW")
+            print("="*60)
+            report = result['report']['full_report']
+            print(report[:2000] + "\n...\n")
+            
+            print("\nNatural Language Summary:")
+            print("-"*60)
+            print(result['report']['natural_language_summary'])
+
+
+if __name__ == '__main__':
+    main()

src/ui/gradio_app.py

@@ -0,0 +1,307 @@
+"""
+Gradio UI for Vehicle Diagnostics Agent
+"""
+import gradio as gr
+import sys
+from pathlib import Path
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+
+# Add parent directory to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+from orchestrator import VehicleDiagnosticOrchestrator
+from agents.data_ingestion_agent import DataIngestionAgent
+
+# Initialize components
+orchestrator = VehicleDiagnosticOrchestrator()
+ingestion_agent = DataIngestionAgent()
+
+# Load available vehicles
+test_df = ingestion_agent.load_test_data()
+available_vehicles = sorted(test_df['vehicle_id'].unique().tolist())
+
+
+def run_diagnostic(vehicle_id, n_readings):
+    """Run diagnostic for a vehicle"""
+    try:
+        vehicle_id = int(vehicle_id)
+        n_readings = int(n_readings) if n_readings else None
+        
+        # Run diagnostic
+        result = orchestrator.diagnose_vehicle(vehicle_id, n_readings)
+        
+        if not result['success']:
+            return f"❌ Error: {result.get('error')}", "", "", None
+        
+        # Extract results
+        anomaly_result = result.get('anomaly_result', {})
+        report = result.get('report', {})
+        
+        # Status summary
+        if anomaly_result.get('anomaly_detected'):
+            status = f"""
+## 🚨 ALERT: Anomalies Detected
+
+**Vehicle ID:** {vehicle_id}  
+**Anomaly Score:** {anomaly_result.get('overall_score', 0):.3f}  
+**Anomalous Readings:** {anomaly_result.get('num_anomalies', 0)} / {len(anomaly_result.get('anomaly_predictions', []))} ({anomaly_result.get('anomaly_rate', 0):.1%})  
+**Status:** ⚠️ Requires Attention
+"""
+        else:
+            status = f"""
+## ✅ Vehicle Healthy
+
+**Vehicle ID:** {vehicle_id}  
+**Status:** 🟢 All Systems Normal  
+**Anomaly Score:** {anomaly_result.get('overall_score', 0):.3f}
+"""
+        
+        # Natural language summary
+        nl_summary = report.get('natural_language_summary', 'No summary available')
+        
+        # Full report
+        full_report = report.get('full_report', 'No report available')
+        
+        # Create visualization
+        fig = create_anomaly_visualization(anomaly_result)
+        
+        return status, nl_summary, full_report, fig
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}", "", "", None
+
+
+def create_anomaly_visualization(anomaly_result):
+    """Create visualization of anomaly detection results"""
+    try:
+        timestamps = anomaly_result.get('timestamps', [])
+        predictions = anomaly_result.get('anomaly_predictions', [])
+        scores = anomaly_result.get('anomaly_scores', [])
+        
+        if len(timestamps) == 0:
+            return None
+        
+        # Create figure with secondary y-axis
+        fig = go.Figure()
+        
+        # Add anomaly predictions
+        fig.add_trace(go.Scatter(
+            x=timestamps,
+            y=predictions,
+            mode='lines',
+            name='Anomaly Detected',
+            line=dict(color='red', width=2),
+            fill='tozeroy',
+            fillcolor='rgba(255, 0, 0, 0.2)'
+        ))
+        
+        # Add anomaly scores
+        fig.add_trace(go.Scatter(
+            x=timestamps,
+            y=scores,
+            mode='lines',
+            name='Anomaly Score',
+            line=dict(color='orange', width=1, dash='dot'),
+            yaxis='y2'
+        ))
+        
+        # Update layout
+        fig.update_layout(
+            title='Anomaly Detection Over Time',
+            xaxis_title='Timestamp',
+            yaxis_title='Anomaly Detected (0/1)',
+            yaxis2=dict(
+                title='Anomaly Score',
+                overlaying='y',
+                side='right'
+            ),
+            hovermode='x unified',
+            template='plotly_white',
+            height=400
+        )
+        
+        return fig
+        
+    except Exception as e:
+        print(f"Visualization error: {e}")
+        return None
+
+
+def get_vehicle_info(vehicle_id):
+    """Get basic info about a vehicle"""
+    try:
+        vehicle_id = int(vehicle_id)
+        vehicle_data = test_df[test_df['vehicle_id'] == vehicle_id]
+        
+        if len(vehicle_data) == 0:
+            return "Vehicle not found"
+        
+        num_readings = len(vehicle_data)
+        has_anomalies = vehicle_data['anomaly'].sum() > 0
+        num_anomalies = vehicle_data['anomaly'].sum()
+        
+        info = f"""
+### Vehicle Information
+
+**Vehicle ID:** {vehicle_id}  
+**Total Readings:** {num_readings}  
+**Known Anomalies:** {num_anomalies} ({num_anomalies/num_readings:.1%})  
+**Status:** {'⚠️ Has anomalies' if has_anomalies else '✅ Healthy'}
+"""
+        return info
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def list_vehicles_with_anomalies():
+    """List vehicles that have anomalies"""
+    vehicles_with_anomalies = []
+    
+    for vid in available_vehicles[:50]:  # Limit to first 50
+        vehicle_data = test_df[test_df['vehicle_id'] == vid]
+        if vehicle_data['anomaly'].sum() > 0:
+            vehicles_with_anomalies.append({
+                'Vehicle ID': vid,
+                'Total Readings': len(vehicle_data),
+                'Anomalies': int(vehicle_data['anomaly'].sum()),
+                'Anomaly Rate': f"{vehicle_data['anomaly'].sum()/len(vehicle_data):.1%}"
+            })
+    
+    if vehicles_with_anomalies:
+        df = pd.DataFrame(vehicles_with_anomalies)
+        return df
+    else:
+        return pd.DataFrame({'Message': ['No vehicles with anomalies found']})
+
+
+# Create Gradio interface
+with gr.Blocks(title="Vehicle Diagnostics Agent") as demo:
+    gr.Markdown("""
+    # 🚗 Vehicle Diagnostics Agent
+    ### Multi-Agent AI System for Predictive Vehicle Diagnostics
+    
+    This system uses advanced AI agents to analyze vehicle sensor data, detect anomalies, 
+    identify root causes, and provide actionable maintenance recommendations.
+    """)
+    
+    with gr.Tab("🔍 Single Vehicle Diagnostic"):
+        gr.Markdown("### Analyze a single vehicle")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                vehicle_id_input = gr.Dropdown(
+                    choices=available_vehicles,
+                    label="Select Vehicle ID",
+                    value=available_vehicles[0] if available_vehicles else None
+                )
+                n_readings_input = gr.Number(
+                    label="Number of Recent Readings (optional)",
+                    value=200,
+                    precision=0
+                )
+                
+                diagnose_btn = gr.Button("🔬 Run Diagnostic", variant="primary", size="lg")
+                
+                gr.Markdown("---")
+                vehicle_info_output = gr.Markdown(label="Vehicle Info")
+                
+                # Auto-update vehicle info when selection changes
+                vehicle_id_input.change(
+                    fn=get_vehicle_info,
+                    inputs=[vehicle_id_input],
+                    outputs=[vehicle_info_output]
+                )
+        
+            with gr.Column(scale=2):
+                status_output = gr.Markdown(label="Diagnostic Status")
+                summary_output = gr.Textbox(
+                    label="📋 Summary",
+                    lines=5,
+                    max_lines=10
+                )
+                
+        with gr.Row():
+            anomaly_plot = gr.Plot(label="Anomaly Detection Visualization")
+        
+        with gr.Row():
+            full_report_output = gr.Textbox(
+                label="📄 Full Diagnostic Report",
+                lines=20,
+                max_lines=30
+            )
+        
+        diagnose_btn.click(
+            fn=run_diagnostic,
+            inputs=[vehicle_id_input, n_readings_input],
+            outputs=[status_output, summary_output, full_report_output, anomaly_plot]
+        )
+    
+    with gr.Tab("📊 Vehicle Overview"):
+        gr.Markdown("### Vehicles with Known Anomalies")
+        
+        refresh_btn = gr.Button("🔄 Refresh List", variant="secondary")
+        vehicles_table = gr.Dataframe(
+            value=list_vehicles_with_anomalies(),
+            label="Vehicles Requiring Attention"
+        )
+        
+        refresh_btn.click(
+            fn=list_vehicles_with_anomalies,
+            inputs=[],
+            outputs=[vehicles_table]
+        )
+    
+    with gr.Tab("ℹ️ About"):
+        gr.Markdown("""
+        ## About Vehicle Diagnostics Agent
+        
+        ### System Architecture
+        
+        This system employs a multi-agent architecture with the following components:
+        
+        1. **Data Ingestion Agent** - Loads and prepares vehicle sensor data
+        2. **Anomaly Detection Agent** - Uses LSTM neural networks to detect unusual patterns
+        3. **Root Cause Analysis Agent** - Identifies the underlying causes of anomalies
+        4. **Maintenance Recommendation Agent** - Provides actionable maintenance steps
+        5. **Report Generation Agent** - Creates comprehensive diagnostic reports
+        
+        ### Technology Stack
+        
+        - **ML Framework:** PyTorch (LSTM-based anomaly detection)
+        - **Orchestration:** LangGraph for multi-agent coordination
+        - **Backend:** FastAPI for REST API
+        - **Frontend:** Gradio for interactive UI
+        - **Data Processing:** Pandas, NumPy, Scikit-learn
+        
+        ### Features
+        
+        - ✅ Real-time anomaly detection
+        - ✅ Root cause analysis with fault code mapping
+        - ✅ Maintenance cost estimation
+        - ✅ Natural language summaries
+        - ✅ Interactive visualizations
+        - ✅ Batch processing support
+        
+        ### Dataset
+        
+        The system analyzes synthetic vehicle sensor data including:
+        - Engine temperature, RPM, speed
+        - Battery voltage and health
+        - Oil and fuel pressure
+        - Tire pressure (all four wheels)
+        - Vibration levels
+        - And more...
+        
+        ---
+        
+        **Version:** 1.0.0  
+        **Author:** Vehicle Diagnostics Team  
+        **License:** MIT
+        """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)

src/utils/data_preprocessing.py

@@ -0,0 +1,209 @@
+"""
+Data preprocessing and feature engineering for vehicle sensor data
+"""
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
+from sklearn.model_selection import train_test_split
+from pathlib import Path
+import pickle
+
+
+class VehicleDataPreprocessor:
+    """Preprocess and engineer features from vehicle sensor data"""
+    
+    def __init__(self, data_path='data/raw/vehicle_sensor_data.csv'):
+        self.data_path = Path(data_path)
+        self.scaler = StandardScaler()
+        self.feature_columns = None
+        self.target_column = 'anomaly'
+        
+    def load_data(self):
+        """Load raw sensor data"""
+        print(f"Loading data from {self.data_path}...")
+        df = pd.read_csv(self.data_path)
+        print(f"✓ Loaded {len(df)} records for {df['vehicle_id'].nunique()} vehicles")
+        return df
+    
+    def clean_data(self, df):
+        """Clean and filter noisy data"""
+        print("Cleaning data...")
+        
+        # Remove duplicates
+        df = df.drop_duplicates()
+        
+        # Handle missing values
+        df = df.fillna(df.median(numeric_only=True))
+        
+        # Remove outliers using IQR method for key sensors
+        sensor_cols = [col for col in df.columns if col not in ['vehicle_id', 'timestamp', 'anomaly']]
+        
+        for col in sensor_cols:
+            Q1 = df[col].quantile(0.01)
+            Q3 = df[col].quantile(0.99)
+            IQR = Q3 - Q1
+            lower_bound = Q1 - 3 * IQR
+            upper_bound = Q3 + 3 * IQR
+            df[col] = df[col].clip(lower_bound, upper_bound)
+        
+        print(f"✓ Cleaned data: {len(df)} records remaining")
+        return df
+    
+    def apply_moving_average(self, df, window=5):
+        """Apply moving average filter to reduce noise"""
+        print(f"Applying moving average filter (window={window})...")
+        
+        sensor_cols = [col for col in df.columns if col not in ['vehicle_id', 'timestamp', 'anomaly']]
+        
+        # Group by vehicle and apply rolling average
+        for col in sensor_cols:
+            df[f'{col}_ma'] = df.groupby('vehicle_id')[col].transform(
+                lambda x: x.rolling(window=window, min_periods=1).mean()
+            )
+        
+        print(f"✓ Applied moving average to {len(sensor_cols)} sensors")
+        return df
+    
+    def engineer_features(self, df):
+        """Create domain-specific features"""
+        print("Engineering features...")
+        
+        # Rate of change features
+        sensor_cols = [col for col in df.columns if col not in ['vehicle_id', 'timestamp', 'anomaly'] and not col.endswith('_ma')]
+        
+        for col in sensor_cols:
+            # Rate of change
+            df[f'{col}_rate'] = df.groupby('vehicle_id')[col].diff()
+            
+            # Rolling statistics
+            df[f'{col}_std'] = df.groupby('vehicle_id')[col].transform(
+                lambda x: x.rolling(window=10, min_periods=1).std()
+            )
+        
+        # Domain-specific features
+        # Temperature differential
+        df['temp_differential'] = df['engine_temp'] - df['coolant_temp']
+        
+        # Tire pressure imbalance
+        df['tire_pressure_imbalance'] = df[['tire_pressure_fl', 'tire_pressure_fr', 
+                                             'tire_pressure_rl', 'tire_pressure_rr']].std(axis=1)
+        
+        # Engine stress indicator
+        df['engine_stress'] = (df['rpm'] / 1000) * (df['engine_temp'] / 100)
+        
+        # Battery health indicator
+        df['battery_health'] = df['battery_voltage'] / 12.6  # Normalized to ideal voltage
+        
+        # Fill NaN values created by diff and rolling operations
+        df = df.fillna(0)
+        
+        print(f"✓ Engineered features: {df.shape[1]} total columns")
+        return df
+    
+    def normalize_features(self, df, fit=True):
+        """Normalize sensor values"""
+        print("Normalizing features...")
+        
+        # Select feature columns (exclude metadata and target)
+        exclude_cols = ['vehicle_id', 'timestamp', 'anomaly']
+        self.feature_columns = [col for col in df.columns if col not in exclude_cols]
+        
+        if fit:
+            df[self.feature_columns] = self.scaler.fit_transform(df[self.feature_columns])
+        else:
+            df[self.feature_columns] = self.scaler.transform(df[self.feature_columns])
+        
+        print(f"✓ Normalized {len(self.feature_columns)} features")
+        return df
+    
+    def split_data(self, df, test_size=0.2, val_size=0.1):
+        """Split data into train, validation, and test sets"""
+        print("Splitting data...")
+        
+        # Split by vehicle to avoid data leakage
+        vehicle_ids = df['vehicle_id'].unique()
+        
+        # First split: train+val vs test
+        train_val_ids, test_ids = train_test_split(
+            vehicle_ids, test_size=test_size, random_state=42
+        )
+        
+        # Second split: train vs val
+        train_ids, val_ids = train_test_split(
+            train_val_ids, test_size=val_size/(1-test_size), random_state=42
+        )
+        
+        train_df = df[df['vehicle_id'].isin(train_ids)]
+        val_df = df[df['vehicle_id'].isin(val_ids)]
+        test_df = df[df['vehicle_id'].isin(test_ids)]
+        
+        print(f"✓ Train: {len(train_df)} records ({len(train_ids)} vehicles)")
+        print(f"✓ Val: {len(val_df)} records ({len(val_ids)} vehicles)")
+        print(f"✓ Test: {len(test_df)} records ({len(test_ids)} vehicles)")
+        
+        return train_df, val_df, test_df
+    
+    def save_processed_data(self, train_df, val_df, test_df, output_dir='data/processed'):
+        """Save processed datasets"""
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+        
+        print(f"Saving processed data to {output_path}...")
+        
+        train_df.to_csv(output_path / 'train.csv', index=False)
+        val_df.to_csv(output_path / 'val.csv', index=False)
+        test_df.to_csv(output_path / 'test.csv', index=False)
+        
+        # Save scaler
+        with open(output_path / 'scaler.pkl', 'wb') as f:
+            pickle.dump(self.scaler, f)
+        
+        # Save feature columns
+        with open(output_path / 'feature_columns.pkl', 'wb') as f:
+            pickle.dump(self.feature_columns, f)
+        
+        print("✓ Saved all processed datasets and preprocessing artifacts")
+        
+        # Print statistics
+        print("\nDataset Statistics:")
+        print(f"Train anomaly rate: {train_df['anomaly'].mean():.2%}")
+        print(f"Val anomaly rate: {val_df['anomaly'].mean():.2%}")
+        print(f"Test anomaly rate: {test_df['anomaly'].mean():.2%}")
+    
+    def preprocess_pipeline(self):
+        """Run complete preprocessing pipeline"""
+        print("="*60)
+        print("VEHICLE DATA PREPROCESSING PIPELINE")
+        print("="*60)
+        
+        # Load data
+        df = self.load_data()
+        
+        # Clean data
+        df = self.clean_data(df)
+        
+        # Apply filters
+        df = self.apply_moving_average(df, window=5)
+        
+        # Engineer features
+        df = self.engineer_features(df)
+        
+        # Normalize features
+        df = self.normalize_features(df, fit=True)
+        
+        # Split data
+        train_df, val_df, test_df = self.split_data(df)
+        
+        # Save processed data
+        self.save_processed_data(train_df, val_df, test_df)
+        
+        print("\n" + "="*60)
+        print("PREPROCESSING COMPLETE!")
+        print("="*60)
+        
+        return train_df, val_df, test_df
+
+
+if __name__ == '__main__':
+    preprocessor = VehicleDataPreprocessor()
+    train_df, val_df, test_df = preprocessor.preprocess_pipeline()

src/utils/download_data.py

@@ -0,0 +1,158 @@
+"""
+Download NASA Turbofan Engine Degradation Dataset
+This dataset simulates engine sensor data with degradation patterns
+"""
+import os
+import zipfile
+import requests
+from pathlib import Path
+from tqdm import tqdm
+
+
+def download_file(url, destination):
+    """Download file with progress bar"""
+    response = requests.get(url, stream=True)
+    total_size = int(response.headers.get('content-length', 0))
+    
+    with open(destination, 'wb') as file, tqdm(
+        desc=destination.name,
+        total=total_size,
+        unit='iB',
+        unit_scale=True,
+        unit_divisor=1024,
+    ) as progress_bar:
+        for data in response.iter_content(chunk_size=1024):
+            size = file.write(data)
+            progress_bar.update(size)
+
+
+def download_nasa_turbofan_data(data_dir='data/raw'):
+    """
+    Download NASA Turbofan Engine Degradation Simulation Data Set
+    Source: https://ti.arc.nasa.gov/tech/dash/groups/pcoe/prognostic-data-repository/
+    """
+    data_path = Path(data_dir)
+    data_path.mkdir(parents=True, exist_ok=True)
+    
+    # NASA C-MAPSS Dataset URL
+    url = "https://ti.arc.nasa.gov/c/6/"
+    
+    print("Downloading NASA Turbofan Engine Degradation Dataset...")
+    print("This dataset contains simulated engine sensor data with degradation patterns")
+    
+    # Alternative: Use a direct download link or create synthetic data
+    # Since the NASA link requires manual download, we'll create a synthetic dataset
+    print("\nNote: Creating synthetic vehicle sensor dataset based on NASA patterns...")
+    
+    return create_synthetic_vehicle_data(data_path)
+
+
+def create_synthetic_vehicle_data(data_path):
+    """
+    Create synthetic vehicle sensor data with realistic patterns
+    Simulates: engine temp, RPM, speed, battery voltage, oil pressure, etc.
+    """
+    import numpy as np
+    import pandas as pd
+    
+    print("Generating synthetic vehicle sensor data...")
+    
+    np.random.seed(42)
+    
+    # Number of vehicles and time steps
+    n_vehicles = 100
+    n_timesteps = 500
+    
+    datasets = {}
+    
+    for vehicle_id in range(1, n_vehicles + 1):
+        data = []
+        
+        # Determine if vehicle will have anomaly
+        has_anomaly = np.random.rand() > 0.7  # 30% have anomalies
+        anomaly_start = np.random.randint(300, 450) if has_anomaly else n_timesteps + 1
+        
+        for t in range(n_timesteps):
+            # Base sensor readings with some noise
+            base_engine_temp = 90 + np.random.normal(0, 5)
+            base_rpm = 2000 + np.random.normal(0, 200)
+            base_speed = 60 + np.random.normal(0, 10)
+            base_battery = 12.6 + np.random.normal(0, 0.2)
+            base_oil_pressure = 40 + np.random.normal(0, 3)
+            base_coolant_temp = 85 + np.random.normal(0, 4)
+            base_fuel_pressure = 50 + np.random.normal(0, 2)
+            base_throttle = 50 + np.random.normal(0, 10)
+            base_brake_temp = 150 + np.random.normal(0, 15)
+            base_tire_pressure_fl = 32 + np.random.normal(0, 0.5)
+            base_tire_pressure_fr = 32 + np.random.normal(0, 0.5)
+            base_tire_pressure_rl = 32 + np.random.normal(0, 0.5)
+            base_tire_pressure_rr = 32 + np.random.normal(0, 0.5)
+            base_vibration = 0.5 + np.random.normal(0, 0.1)
+            
+            # Introduce anomalies after anomaly_start
+            if t >= anomaly_start:
+                degradation_factor = (t - anomaly_start) / 100
+                
+                # Engine overheating
+                base_engine_temp += degradation_factor * 20
+                base_coolant_temp += degradation_factor * 15
+                
+                # Oil pressure drop
+                base_oil_pressure -= degradation_factor * 10
+                
+                # Battery degradation
+                base_battery -= degradation_factor * 0.5
+                
+                # Increased vibration
+                base_vibration += degradation_factor * 0.3
+                
+                # Tire pressure issues
+                if np.random.rand() > 0.8:
+                    base_tire_pressure_fl -= degradation_factor * 2
+            
+            # Create data point
+            data_point = {
+                'vehicle_id': vehicle_id,
+                'timestamp': t,
+                'engine_temp': max(0, base_engine_temp),
+                'rpm': max(0, base_rpm),
+                'speed': max(0, base_speed),
+                'battery_voltage': max(0, base_battery),
+                'oil_pressure': max(0, base_oil_pressure),
+                'coolant_temp': max(0, base_coolant_temp),
+                'fuel_pressure': max(0, base_fuel_pressure),
+                'throttle_position': np.clip(base_throttle, 0, 100),
+                'brake_temp': max(0, base_brake_temp),
+                'tire_pressure_fl': max(0, base_tire_pressure_fl),
+                'tire_pressure_fr': max(0, base_tire_pressure_fr),
+                'tire_pressure_rl': max(0, base_tire_pressure_rl),
+                'tire_pressure_rr': max(0, base_tire_pressure_rr),
+                'vibration_level': max(0, base_vibration),
+                'anomaly': 1 if t >= anomaly_start else 0
+            }
+            data.append(data_point)
+        
+        datasets[f'vehicle_{vehicle_id}'] = pd.DataFrame(data)
+    
+    # Combine all vehicles into one dataset
+    full_dataset = pd.concat(datasets.values(), ignore_index=True)
+    
+    # Save to CSV
+    output_file = data_path / 'vehicle_sensor_data.csv'
+    full_dataset.to_csv(output_file, index=False)
+    print(f"✓ Saved synthetic vehicle sensor data to {output_file}")
+    print(f"  - Total records: {len(full_dataset)}")
+    print(f"  - Vehicles: {n_vehicles}")
+    print(f"  - Timesteps per vehicle: {n_timesteps}")
+    print(f"  - Anomaly rate: ~30%")
+    
+    # Create summary statistics
+    summary = full_dataset.groupby('vehicle_id')['anomaly'].sum()
+    vehicles_with_anomalies = (summary > 0).sum()
+    print(f"  - Vehicles with anomalies: {vehicles_with_anomalies}/{n_vehicles}")
+    
+    return output_file
+
+
+if __name__ == '__main__':
+    download_nasa_turbofan_data()

tests/test_agents.py

@@ -0,0 +1,197 @@
+"""
+Unit tests for individual agents
+"""
+import pytest
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent / 'src'))
+
+from agents.data_ingestion_agent import DataIngestionAgent
+from agents.anomaly_detection_agent import AnomalyDetectionAgent
+from agents.root_cause_agent import RootCauseAnalysisAgent
+from agents.maintenance_recommendation_agent import MaintenanceRecommendationAgent
+from agents.report_generation_agent import ReportGenerationAgent
+
+
+class TestDataIngestionAgent:
+    """Test Data Ingestion Agent"""
+    
+    def test_load_data(self):
+        """Test loading test data"""
+        agent = DataIngestionAgent()
+        df = agent.load_test_data()
+        
+        assert df is not None
+        assert len(df) > 0
+        assert 'vehicle_id' in df.columns
+        assert 'timestamp' in df.columns
+    
+    def test_get_vehicle_data(self):
+        """Test getting data for specific vehicle"""
+        agent = DataIngestionAgent()
+        df = agent.load_test_data()
+        vehicle_id = df['vehicle_id'].iloc[0]
+        
+        vehicle_data = agent.get_vehicle_data(vehicle_id)
+        
+        assert len(vehicle_data) > 0
+        assert (vehicle_data['vehicle_id'] == vehicle_id).all()
+    
+    def test_prepare_for_analysis(self):
+        """Test data preparation"""
+        agent = DataIngestionAgent()
+        df = agent.load_test_data()
+        vehicle_id = df['vehicle_id'].iloc[0]
+        vehicle_data = agent.get_vehicle_data(vehicle_id)
+        
+        prepared = agent.prepare_for_analysis(vehicle_data)
+        
+        assert 'vehicle_id' in prepared
+        assert 'features' in prepared
+        assert 'timestamps' in prepared
+        assert prepared['vehicle_id'] == vehicle_id
+
+
+class TestAnomalyDetectionAgent:
+    """Test Anomaly Detection Agent"""
+    
+    def test_initialization(self):
+        """Test agent initialization"""
+        agent = AnomalyDetectionAgent()
+        assert agent is not None
+    
+    def test_detect_anomalies(self):
+        """Test anomaly detection"""
+        ingestion_agent = DataIngestionAgent()
+        detection_agent = AnomalyDetectionAgent()
+        
+        df = ingestion_agent.load_test_data()
+        vehicle_id = df['vehicle_id'].iloc[0]
+        
+        prepared_data = ingestion_agent.run(vehicle_id, n_readings=100)
+        result = detection_agent.run(prepared_data)
+        
+        assert 'vehicle_id' in result
+        assert 'anomaly_detected' in result
+        assert 'overall_score' in result
+        assert 'anomaly_predictions' in result
+
+
+class TestRootCauseAnalysisAgent:
+    """Test Root Cause Analysis Agent"""
+    
+    def test_initialization(self):
+        """Test agent initialization"""
+        agent = RootCauseAnalysisAgent()
+        assert agent is not None
+        assert len(agent.fault_patterns) > 0
+    
+    def test_analyze_no_anomalies(self):
+        """Test analysis when no anomalies"""
+        agent = RootCauseAnalysisAgent()
+        
+        anomaly_result = {
+            'vehicle_id': 1,
+            'anomaly_detected': False,
+            'anomalous_sensors': {},
+            'raw_data': None,
+            'anomaly_indices': [],
+            'timestamps': []
+        }
+        
+        result = agent.run(anomaly_result)
+        
+        assert result['vehicle_id'] == 1
+        assert len(result['root_causes']) == 0
+
+
+class TestMaintenanceRecommendationAgent:
+    """Test Maintenance Recommendation Agent"""
+    
+    def test_initialization(self):
+        """Test agent initialization"""
+        agent = MaintenanceRecommendationAgent()
+        assert agent is not None
+        assert len(agent.maintenance_actions) > 0
+    
+    def test_generate_recommendations(self):
+        """Test recommendation generation"""
+        agent = MaintenanceRecommendationAgent()
+        
+        root_causes = [{
+            'fault_name': 'engine_overheating',
+            'description': 'Test',
+            'severity': 'critical',
+            'confidence': 0.9,
+            'fault_codes': ['P0217']
+        }]
+        
+        recommendations = agent.generate_recommendations(root_causes)
+        
+        assert len(recommendations) > 0
+        assert 'immediate_actions' in recommendations[0]
+        assert 'estimated_cost' in recommendations[0]
+
+
+class TestReportGenerationAgent:
+    """Test Report Generation Agent"""
+    
+    def test_initialization(self):
+        """Test agent initialization"""
+        agent = ReportGenerationAgent()
+        assert agent is not None
+    
+    def test_generate_summary(self):
+        """Test summary generation"""
+        agent = ReportGenerationAgent()
+        
+        anomaly_result = {
+            'vehicle_id': 1,
+            'anomaly_detected': False,
+            'num_anomalies': 0,
+            'anomaly_rate': 0.0,
+            'overall_score': 0.0,
+            'anomalous_sensors': {}
+        }
+        
+        root_cause_result = {
+            'root_causes': [],
+            'primary_cause': None
+        }
+        
+        maintenance_result = {
+            'recommendations': [],
+            'total_cost': {'cost_range': '$0'}
+        }
+        
+        summary = agent.generate_executive_summary(
+            1, anomaly_result, root_cause_result, maintenance_result
+        )
+        
+        assert 'Vehicle 1' in summary
+        assert 'normally' in summary.lower()
+
+
+def test_full_pipeline():
+    """Test complete diagnostic pipeline"""
+    from orchestrator import VehicleDiagnosticOrchestrator
+    
+    orchestrator = VehicleDiagnosticOrchestrator()
+    
+    # Get a test vehicle
+    ingestion_agent = DataIngestionAgent()
+    df = ingestion_agent.load_test_data()
+    vehicle_id = df['vehicle_id'].iloc[0]
+    
+    # Run diagnostic
+    result = orchestrator.diagnose_vehicle(vehicle_id, n_readings=100)
+    
+    assert result['success'] == True
+    assert result['vehicle_id'] == vehicle_id
+    assert 'report' in result
+    assert 'anomaly_result' in result
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])