Upload 6 files

dynamic_simulation.py

@@ -0,0 +1,418 @@
+"""
+Dynamic Simulation Module - Real-time fire spread and sensor updates
+Simulates how fire conditions change over time and updates evacuation recommendations
+"""
+import random
+import time
+from typing import Dict, List, Tuple
+from .floor_plan import FloorPlan
+from .sensor_system import SensorSystem, SensorReading
+from .pathfinding import PathFinder, RiskAssessment
+
+
+class FireSpreadSimulator:
+    """Simulates dynamic fire spread and environmental changes"""
+    
+    def __init__(self, floor_plan: FloorPlan, sensor_system: SensorSystem):
+        self.floor_plan = floor_plan
+        self.sensor_system = sensor_system
+        self.time_step = 0
+        self.fire_sources = []  # List of rooms where fire started
+        
+    def initialize_fire(self, fire_locations: List[str]):
+        """Initialize fire at specific locations with all real-world factors"""
+        self.fire_sources = fire_locations
+        
+        for location in fire_locations:
+            if location in self.sensor_system.sensors:
+                # Generate comprehensive mock data for fire location
+                self.sensor_system.update_sensor(
+                    location,
+                    # Basic factors
+                    fire_detected=True,
+                    smoke_level=random.uniform(0.7, 0.9),
+                    temperature=random.uniform(150, 250),
+                    oxygen_level=random.uniform(14, 16),
+                    visibility=random.uniform(5, 15),
+                    structural_integrity=random.uniform(60, 80),
+                    
+                    # Fire-specific factors
+                    fire_growth_rate=random.uniform(5, 15),  # m²/min
+                    flashover_risk=random.uniform(0.3, 0.6),
+                    backdraft_risk=random.uniform(0.2, 0.4),
+                    heat_radiation=random.uniform(3, 8),  # kW/m²
+                    fire_type=random.choice(["wood", "electrical", "chemical"]),
+                    
+                    # Toxic gases (high in fire areas)
+                    carbon_monoxide=random.uniform(50, 200),  # ppm
+                    carbon_dioxide=random.uniform(5000, 15000),  # ppm
+                    hydrogen_cyanide=random.uniform(10, 50),  # ppm
+                    hydrogen_chloride=random.uniform(5, 20),  # ppm
+                    
+                    # Environmental (affected by fire)
+                    wind_direction=random.uniform(0, 360),
+                    wind_speed=random.uniform(2, 8),  # m/s
+                    air_pressure=random.uniform(1000, 1020),
+                    humidity=random.uniform(30, 60),
+                    
+                    # Human factors
+                    occupancy_density=random.uniform(0.3, 0.7),
+                    mobility_limitations=random.randint(0, 3),
+                    panic_level=random.uniform(0.6, 0.9),
+                    evacuation_progress=0.0,
+                    
+                    # Infrastructure (may fail near fire)
+                    sprinkler_active=random.choice([True, False]),
+                    emergency_lighting=random.choice([True, False]),
+                    elevator_available=False,  # Elevators disabled in fire
+                    stairwell_clear=random.choice([True, False]),
+                    exit_accessible=random.choice([True, False]),
+                    exit_capacity=random.randint(50, 150),
+                    ventilation_active=random.choice([True, False]),
+                    
+                    # Time-based
+                    time_since_fire_start=0,
+                    estimated_time_to_exit=random.randint(60, 300),
+                    
+                    # Communication
+                    emergency_comm_working=random.choice([True, False]),
+                    wifi_signal_strength=random.uniform(40, 80),
+                    
+                    # External
+                    weather_temperature=random.uniform(15, 25),
+                    weather_rain=random.choice([True, False]),
+                    time_of_day=random.randint(8, 18),
+                    day_of_week=random.randint(0, 6)
+                )
+    
+    def update_simulation(self, intensity: float = 1.0):
+        """
+        Update fire conditions for one time step
+        
+        Args:
+            intensity: Fire spread intensity (0.5 = slow, 1.0 = normal, 2.0 = fast)
+        """
+        self.time_step += 1
+        
+        # Update time for all sensors
+        for sensor in self.sensor_system.sensors.values():
+            sensor.time_since_fire_start = self.time_step * 30  # 30 seconds per step
+        
+        # 1. Intensify existing fires
+        self._intensify_fires(intensity)
+        
+        # 2. Spread fire to adjacent rooms
+        self._spread_fire(intensity)
+        
+        # 3. Spread smoke further
+        self._spread_smoke(intensity)
+        
+        # 4. Update structural integrity
+        self._update_structures(intensity)
+        
+        # 5. Update evacuation progress
+        self._update_evacuation_progress(intensity)
+    
+    def _intensify_fires(self, intensity: float):
+        """Make existing fires worse over time with all factors"""
+        for location_id, sensor in self.sensor_system.sensors.items():
+            if sensor.fire_detected:
+                # Fire gets hotter
+                temp_increase = random.uniform(5, 15) * intensity
+                new_temp = min(sensor.temperature + temp_increase, 300)
+                
+                # More smoke
+                smoke_increase = random.uniform(0.02, 0.05) * intensity
+                new_smoke = min(sensor.smoke_level + smoke_increase, 1.0)
+                
+                # Less oxygen
+                oxygen_decrease = random.uniform(0.2, 0.5) * intensity
+                new_oxygen = max(sensor.oxygen_level - oxygen_decrease, 10.0)
+                
+                # Worse visibility
+                visibility_decrease = random.uniform(1, 3) * intensity
+                new_visibility = max(sensor.visibility - visibility_decrease, 0.0)
+                
+                # Structural damage
+                integrity_decrease = random.uniform(1, 3) * intensity
+                new_integrity = max(sensor.structural_integrity - integrity_decrease, 30.0)
+                
+                # Update all fire-related factors
+                self.sensor_system.update_sensor(
+                    location_id,
+                    temperature=new_temp,
+                    smoke_level=new_smoke,
+                    oxygen_level=new_oxygen,
+                    visibility=new_visibility,
+                    structural_integrity=new_integrity,
+                    
+                    # Fire growth increases
+                    fire_growth_rate=min(sensor.fire_growth_rate + random.uniform(0.5, 2) * intensity, 20),
+                    flashover_risk=min(sensor.flashover_risk + random.uniform(0.02, 0.05) * intensity, 1.0),
+                    backdraft_risk=min(sensor.backdraft_risk + random.uniform(0.01, 0.03) * intensity, 1.0),
+                    heat_radiation=min(sensor.heat_radiation + random.uniform(0.2, 0.5) * intensity, 15),
+                    
+                    # Toxic gases increase
+                    carbon_monoxide=min(sensor.carbon_monoxide + random.uniform(5, 15) * intensity, 500),
+                    carbon_dioxide=min(sensor.carbon_dioxide + random.uniform(200, 500) * intensity, 20000),
+                    hydrogen_cyanide=min(sensor.hydrogen_cyanide + random.uniform(1, 3) * intensity, 100),
+                    hydrogen_chloride=min(sensor.hydrogen_chloride + random.uniform(0.5, 2) * intensity, 50),
+                    
+                    # Time increases
+                    time_since_fire_start=sensor.time_since_fire_start + 30,  # 30 seconds per step
+                    
+                    # Panic increases
+                    panic_level=min(sensor.panic_level + random.uniform(0.01, 0.03) * intensity, 1.0),
+                    
+                    # Infrastructure may fail
+                    emergency_lighting=random.random() > 0.1,  # 10% chance of failure
+                    exit_accessible=random.random() > 0.15,  # 15% chance of blockage
+                    stairwell_clear=random.random() > 0.2  # 20% chance of blockage
+                )
+    
+    def _spread_fire(self, intensity: float):
+        """Fire spreads to adjacent rooms based on conditions"""
+        new_fires = []
+        
+        for location_id, sensor in self.sensor_system.sensors.items():
+            if sensor.fire_detected:
+                # Get adjacent rooms
+                neighbors = self.floor_plan.get_neighbors(location_id)
+                
+                for neighbor_id, _ in neighbors:
+                    neighbor_sensor = self.sensor_system.get_sensor_reading(neighbor_id)
+                    
+                    if neighbor_sensor and not neighbor_sensor.fire_detected:
+                        # Chance of fire spreading based on conditions
+                        spread_chance = 0.15 * intensity  # Base 15% chance per time step
+                        
+                        # Higher chance if already hot or smoky
+                        if neighbor_sensor.temperature > 80:
+                            spread_chance += 0.2
+                        if neighbor_sensor.smoke_level > 0.5:
+                            spread_chance += 0.15
+                        
+                        # Check if oxygen cylinder present (explosion!)
+                        room = self.floor_plan.get_room(neighbor_id)
+                        if room and room.has_oxygen_cylinder and neighbor_sensor.temperature > 60:
+                            spread_chance += 0.4  # Much higher chance!
+                        
+                        if random.random() < spread_chance:
+                            new_fires.append(neighbor_id)
+        
+        # Apply new fires
+        for location_id in new_fires:
+            self.sensor_system.update_sensor(
+                location_id,
+                fire_detected=True,
+                smoke_level=random.uniform(0.6, 0.8),
+                temperature=random.uniform(120, 180),
+                oxygen_level=random.uniform(15, 17),
+                visibility=random.uniform(15, 30)
+            )
+            self.fire_sources.append(location_id)
+    
+    def _spread_smoke(self, intensity: float):
+        """Smoke and toxic gases spread to all connected areas"""
+        for location_id, sensor in self.sensor_system.sensors.items():
+            # Rooms with fire or high smoke affect neighbors
+            if sensor.fire_detected or sensor.smoke_level > 0.3:
+                neighbors = self.floor_plan.get_neighbors(location_id)
+                
+                for neighbor_id, _ in neighbors:
+                    neighbor_sensor = self.sensor_system.get_sensor_reading(neighbor_id)
+                    
+                    if neighbor_sensor and not neighbor_sensor.fire_detected:
+                        # Smoke drifts to adjacent areas
+                        smoke_increase = random.uniform(0.03, 0.08) * intensity
+                        new_smoke = min(neighbor_sensor.smoke_level + smoke_increase, 1.0)
+                        
+                        # Temperature rises slightly
+                        temp_increase = random.uniform(2, 8) * intensity
+                        new_temp = min(neighbor_sensor.temperature + temp_increase, 100)
+                        
+                        # Oxygen decreases
+                        oxygen_decrease = random.uniform(0.1, 0.3) * intensity
+                        new_oxygen = max(neighbor_sensor.oxygen_level - oxygen_decrease, 16.0)
+                        
+                        # Visibility decreases
+                        visibility_decrease = random.uniform(2, 5) * intensity
+                        new_visibility = max(neighbor_sensor.visibility - visibility_decrease, 10.0)
+                        
+                        # Toxic gases spread (reduced concentration)
+                        co_spread = sensor.carbon_monoxide * 0.1 * intensity
+                        co2_spread = sensor.carbon_dioxide * 0.05 * intensity
+                        hcn_spread = sensor.hydrogen_cyanide * 0.15 * intensity
+                        hcl_spread = sensor.hydrogen_chloride * 0.2 * intensity
+                        
+                        # Heat radiation spreads
+                        heat_spread = sensor.heat_radiation * 0.3 * intensity
+                        
+                        self.sensor_system.update_sensor(
+                            neighbor_id,
+                            smoke_level=new_smoke,
+                            temperature=new_temp,
+                            oxygen_level=new_oxygen,
+                            visibility=new_visibility,
+                            
+                            # Toxic gases (accumulate)
+                            carbon_monoxide=min(neighbor_sensor.carbon_monoxide + co_spread, 200),
+                            carbon_dioxide=min(neighbor_sensor.carbon_dioxide + co2_spread, 10000),
+                            hydrogen_cyanide=min(neighbor_sensor.hydrogen_cyanide + hcn_spread, 50),
+                            hydrogen_chloride=min(neighbor_sensor.hydrogen_chloride + hcl_spread, 30),
+                            
+                            # Heat radiation
+                            heat_radiation=min(neighbor_sensor.heat_radiation + heat_spread, 5),
+                            
+                            # Flashover risk increases slightly
+                            flashover_risk=min(neighbor_sensor.flashover_risk + random.uniform(0.01, 0.02) * intensity, 0.5),
+                            
+                            # Occupancy may increase (people moving away)
+                            occupancy_density=max(neighbor_sensor.occupancy_density - random.uniform(0.05, 0.15), 0.0),
+                            panic_level=min(neighbor_sensor.panic_level + random.uniform(0.02, 0.05) * intensity, 1.0)
+                        )
+    
+    def _update_structures(self, intensity: float):
+        """Update structural integrity based on fire exposure"""
+        for location_id, sensor in self.sensor_system.sensors.items():
+            if sensor.fire_detected or sensor.temperature > 100:
+                # Structural damage from heat
+                damage = random.uniform(0.5, 2.0) * intensity
+                new_integrity = max(sensor.structural_integrity - damage, 20.0)
+                
+                self.sensor_system.update_sensor(
+                    location_id,
+                    structural_integrity=new_integrity
+                )
+    
+    def _update_evacuation_progress(self, intensity: float):
+        """Update evacuation progress and occupancy"""
+        for location_id, sensor in self.sensor_system.sensors.items():
+            # People evacuate from rooms (occupancy decreases)
+            if sensor.occupancy_density > 0:
+                evacuation_rate = random.uniform(0.05, 0.15) * intensity
+                new_occupancy = max(sensor.occupancy_density - evacuation_rate, 0.0)
+                new_progress = min(sensor.evacuation_progress + evacuation_rate * 100, 100.0)
+                
+                self.sensor_system.update_sensor(
+                    location_id,
+                    occupancy_density=new_occupancy,
+                    evacuation_progress=new_progress
+                )
+            
+            # Exits may get more crowded as people arrive
+            room = self.floor_plan.get_room(location_id)
+            if room and room.room_type == "exit":
+                # Exits get more crowded as people evacuate
+                if sensor.occupancy_density < 0.8:
+                    arrival_rate = random.uniform(0.02, 0.08) * intensity
+                    new_occupancy = min(sensor.occupancy_density + arrival_rate, 0.9)
+                    self.sensor_system.update_sensor(
+                        location_id,
+                        occupancy_density=new_occupancy
+                    )
+
+
+class DynamicEvacuationSystem:
+    """Manages dynamic evacuation with changing conditions"""
+    
+    def __init__(self, floor_plan: FloorPlan):
+        self.floor_plan = floor_plan
+        self.sensor_system = SensorSystem(floor_plan)
+        self.simulator = FireSpreadSimulator(floor_plan, self.sensor_system)
+        self.pathfinder = PathFinder(floor_plan, self.sensor_system)
+        self.current_recommendation = None
+        self.recommendation_history = []
+        
+    def initialize_scenario(self, fire_locations: List[str], 
+                           affected_areas: Dict[str, Dict] = None):
+        """Initialize the fire scenario"""
+        # Set up initial conditions
+        if affected_areas:
+            for location, values in affected_areas.items():
+                if location in self.sensor_system.sensors:
+                    self.sensor_system.update_sensor(location, **values)
+        
+        # Initialize fires
+        self.simulator.initialize_fire(fire_locations)
+        
+        # Get initial recommendation
+        self._update_recommendation()
+    
+    def step(self, intensity: float = 1.0, start_location: str = "R1"):
+        """
+        Advance simulation by one time step
+        
+        Args:
+            intensity: Fire spread intensity
+            start_location: Where person is evacuating from
+            
+        Returns:
+            (time_step, routes, recommended_route, route_changed)
+        """
+        # Update fire conditions
+        self.simulator.update_simulation(intensity)
+        
+        # Recalculate best route
+        previous_rec = self.current_recommendation
+        self._update_recommendation(start_location)
+        
+        # Check if recommendation changed
+        route_changed = False
+        if previous_rec and self.current_recommendation:
+            prev_path = previous_rec[0] if previous_rec else None
+            curr_path = self.current_recommendation[0] if self.current_recommendation else None
+            route_changed = (prev_path != curr_path)
+        
+        # Get all routes
+        routes = self.pathfinder.find_all_evacuation_routes(start_location)
+        
+        return self.simulator.time_step, routes, self.current_recommendation, route_changed
+    
+    def _update_recommendation(self, start_location: str = "R1"):
+        """Update the evacuation recommendation"""
+        routes = self.pathfinder.find_all_evacuation_routes(start_location)
+        
+        if routes:
+            recommended = RiskAssessment.recommend_path(
+                [(path, risk) for _, path, risk in routes]
+            )
+            self.current_recommendation = recommended
+            
+            # Track history
+            if recommended:
+                rec_path, rec_risk = recommended
+                rec_exit = [e for e, p, _ in routes if p == rec_path][0]
+                self.recommendation_history.append({
+                    'time_step': self.simulator.time_step,
+                    'exit': rec_exit,
+                    'path': rec_path,
+                    'danger': rec_risk['avg_danger']
+                })
+        else:
+            self.current_recommendation = None
+    
+    def get_status_summary(self, start_location: str = "R1"):
+        """Get current status summary"""
+        routes = self.pathfinder.find_all_evacuation_routes(start_location)
+        
+        summary = {
+            'time_step': self.simulator.time_step,
+            'total_fires': sum(1 for s in self.sensor_system.sensors.values() 
+                              if s.fire_detected),
+            'passable_routes': sum(1 for _, _, r in routes if r['passable']),
+            'total_routes': len(routes),
+            'avg_danger': sum(r['avg_danger'] for _, _, r in routes) / len(routes) if routes else 100,
+        }
+        
+        if self.current_recommendation:
+            rec_path, rec_risk = self.current_recommendation
+            rec_exit = [e for e, p, _ in routes if p == rec_path][0]
+            summary['recommended_exit'] = rec_exit
+            summary['recommended_danger'] = rec_risk['avg_danger']
+        else:
+            summary['recommended_exit'] = None
+            summary['recommended_danger'] = 100.0
+        
+        return summary
+

floor_plan.py

@@ -0,0 +1,168 @@
+"""
+Floor Plan Module - Represents building layout with rooms, corridors, and connections
+"""
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+
+
+class Room:
+    """Represents a room or area in the building"""
+    def __init__(self, room_id: str, name: str, position: Tuple[float, float], 
+                 room_type: str = "room", size: Tuple[float, float] = (5, 5)):
+        self.room_id = room_id
+        self.name = name
+        self.position = position  # (x, y) coordinates
+        self.room_type = room_type  # room, corridor, exit, stairwell
+        self.size = size  # (width, height)
+        self.connected_to = []  # List of connected room IDs
+        self.has_oxygen_cylinder = False
+        self.has_fire_extinguisher = False
+        
+    def add_connection(self, room_id: str, distance: float = None):
+        """Add connection to another room"""
+        if distance is None:
+            distance = 1.0
+        self.connected_to.append((room_id, distance))
+        
+    def __repr__(self):
+        return f"Room({self.room_id}, {self.name})"
+
+
+class FloorPlan:
+    """Represents the complete building floor plan"""
+    def __init__(self, floor_name: str = "Ground Floor"):
+        self.floor_name = floor_name
+        self.rooms: Dict[str, Room] = {}
+        self.exits: List[str] = []
+        
+    def add_room(self, room: Room):
+        """Add a room to the floor plan"""
+        self.rooms[room.room_id] = room
+        if room.room_type == "exit":
+            self.exits.append(room.room_id)
+            
+    def add_connection(self, room_id1: str, room_id2: str, distance: float = 1.0):
+        """Create bidirectional connection between two rooms"""
+        if room_id1 in self.rooms and room_id2 in self.rooms:
+            self.rooms[room_id1].add_connection(room_id2, distance)
+            self.rooms[room_id2].add_connection(room_id1, distance)
+            
+    def get_neighbors(self, room_id: str) -> List[Tuple[str, float]]:
+        """Get all neighboring rooms and their distances"""
+        if room_id in self.rooms:
+            return self.rooms[room_id].connected_to
+        return []
+    
+    def get_all_exits(self) -> List[str]:
+        """Get all exit points"""
+        return self.exits
+    
+    def get_room(self, room_id: str) -> Optional[Room]:
+        """Get room by ID"""
+        return self.rooms.get(room_id)
+
+
+def create_sample_floor_plan() -> FloorPlan:
+    """
+    Create an expanded floor plan with multiple rooms and 5 exit routes
+    
+    Layout:
+    [R1] - [C1] - [R2] - [C4] - [R5] - [EXIT1] (Route 1: has oxygen cylinder)
+      |            |                      |
+    [C2]         [C3]                  [C8]
+      |            |                      |
+    [R3] - [C5] - [R4] - [C6] - [R6] - [EXIT2] (Route 2)
+      |                                    |
+    [C7]                                [C9]
+      |                                    |
+    [EXIT3] (Route 3)                  [EXIT4] (Route 4)
+    
+    [R7] - [C10] - [EXIT5] (Route 5)
+    """
+    plan = FloorPlan("Ground Floor")
+    
+    # Create rooms with better spacing
+    rooms = [
+        # Main floor rooms
+        Room("R1", "Room 101", (10, 10), "room", (12, 12)),
+        Room("R2", "Room 102", (60, 10), "room", (12, 12)),
+        Room("R3", "Room 103", (10, 50), "room", (12, 12)),
+        Room("R4", "Room 104", (60, 50), "room", (12, 12)),
+        Room("R5", "Room 105", (110, 10), "room", (12, 12)),
+        Room("R6", "Room 106", (110, 50), "room", (12, 12)),
+        Room("R7", "Room 107", (10, 100), "room", (12, 12)),
+        
+        # Corridors
+        Room("C1", "Corridor 1", (35, 10), "corridor", (15, 6)),
+        Room("C2", "Corridor 2", (10, 30), "corridor", (6, 12)),
+        Room("C3", "Corridor 3", (60, 30), "corridor", (6, 12)),
+        Room("C4", "Corridor 4", (85, 10), "corridor", (15, 6)),
+        Room("C5", "Corridor 5", (35, 50), "corridor", (15, 6)),
+        Room("C6", "Corridor 6", (85, 50), "corridor", (15, 6)),
+        Room("C7", "Corridor 7", (10, 75), "corridor", (6, 15)),
+        Room("C8", "Corridor 8", (110, 30), "corridor", (6, 12)),
+        Room("C9", "Corridor 9", (110, 75), "corridor", (6, 15)),
+        Room("C10", "Corridor 10", (35, 100), "corridor", (15, 6)),
+        
+        # Exits (5 exits now!)
+        Room("EXIT1", "North Exit", (135, 10), "exit", (8, 8)),
+        Room("EXIT2", "East Exit", (135, 50), "exit", (8, 8)),
+        Room("EXIT3", "South Exit", (10, 125), "exit", (8, 8)),
+        Room("EXIT4", "Southeast Exit", (110, 125), "exit", (8, 8)),
+        Room("EXIT5", "West Exit", (60, 100), "exit", (8, 8)),
+    ]
+    
+    # Add oxygen cylinder to corridor 1 (Route 1)
+    for room in rooms:
+        if room.room_id == "C1":
+            room.has_oxygen_cylinder = True
+        if room.room_id in ["R2", "R3", "R5"]:
+            room.has_fire_extinguisher = True
+    
+    # Add all rooms to floor plan
+    for room in rooms:
+        plan.add_room(room)
+    
+    # Create connections (building the graph)
+    connections = [
+        # Route 1 path (North - via oxygen cylinder area)
+        ("R1", "C1", 1.0),
+        ("C1", "R2", 1.0),
+        ("R2", "C4", 1.0),
+        ("C4", "R5", 1.0),
+        ("R5", "EXIT1", 1.0),
+        
+        # Route 2 path (East)
+        ("R1", "C2", 1.0),
+        ("C2", "R3", 1.0),
+        ("R3", "C5", 1.0),
+        ("C5", "R4", 1.0),
+        ("R4", "C6", 1.0),
+        ("C6", "R6", 1.0),
+        ("R6", "EXIT2", 1.0),
+        
+        # Route 3 path (South)
+        ("R3", "C7", 1.0),
+        ("C7", "EXIT3", 1.0),
+        
+        # Route 4 path (Southeast)
+        ("R6", "C9", 1.0),
+        ("C9", "EXIT4", 1.0),
+        
+        # Route 5 path (West)
+        ("R7", "C10", 1.0),
+        ("C10", "EXIT5", 1.0),
+        
+        # Cross connections
+        ("R2", "C3", 1.0),
+        ("C3", "R4", 1.0),
+        ("R5", "C8", 1.0),
+        ("C8", "R6", 1.0),
+        ("R3", "R7", 1.0),  # Direct connection
+    ]
+    
+    for room1, room2, distance in connections:
+        plan.add_connection(room1, room2, distance)
+    
+    return plan
+

llm_faiss_rag.py

@@ -0,0 +1,1848 @@
+"""
+Llama + FAISS RAG System for Fire Evacuation with Advanced Reasoning
+
+This module implements a RAG (Retrieval-Augmented Generation) system for fire evacuation scenarios
+with advanced LLM reasoning techniques including:
+
+1. Chain-of-Thought (CoT) Prompting:
+   - Enables step-by-step reasoning through intermediate steps
+   - Improves complex problem-solving capabilities
+   - Reference: https://arxiv.org/pdf/2201.11903
+
+2. Tree-of-Thoughts (ToT):
+   - Maintains multiple reasoning paths
+   - Self-evaluates progress through intermediate thoughts
+   - Enables deliberate reasoning process
+   - Reference: https://arxiv.org/pdf/2305.10601
+
+3. Reflexion:
+   - Reinforces language-based agents through linguistic feedback
+   - Self-reflection and iterative improvement
+   - Reference: https://arxiv.org/pdf/2303.11366
+
+4. CoT with Tools:
+   - Combines CoT prompting with external tools
+   - Interleaved reasoning and tool usage
+   - Reference: https://arxiv.org/pdf/2303.09014
+
+5. Advanced Decoding Strategies:
+   - Greedy: Deterministic highest probability
+   - Sampling: Random sampling with temperature
+   - Beam Search: Explores multiple paths
+   - Nucleus (Top-p): Samples from top-p probability mass
+   - Temperature: Temperature-based sampling
+
+Downloads Llama model, creates JSON dataset, builds FAISS index, and provides RAG querying
+"""
+import json
+import os
+import pickle
+import glob
+import re
+from typing import List, Dict, Any, Optional, Tuple
+from pathlib import Path
+from enum import Enum
+import copy
+
+import numpy as np
+import faiss
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from sentence_transformers import SentenceTransformer
+
+# Import project modules (package-relative imports)
+from .floor_plan import FloorPlan, create_sample_floor_plan
+from .sensor_system import SensorSystem, create_sample_fire_scenario
+from .pathfinding import PathFinder
+
+
+class FireEvacuationDataExporter:
+    """Exports fire evacuation system data to JSON format"""
+    
+    def __init__(self, floor_plan: FloorPlan, sensor_system: SensorSystem, pathfinder: PathFinder):
+        self.floor_plan = floor_plan
+        self.sensor_system = sensor_system
+        self.pathfinder = pathfinder
+    
+    def export_room_data(self, room_id: str) -> Dict[str, Any]:
+        """Export comprehensive room data to JSON"""
+        room = self.floor_plan.get_room(room_id)
+        sensor = self.sensor_system.get_sensor_reading(room_id)
+        
+        if not room or not sensor:
+            return {}
+        
+        return {
+            "room_id": room_id,
+            "name": room.name,
+            "room_type": room.room_type,
+            "position": room.position,
+            "size": room.size,
+            "has_oxygen_cylinder": room.has_oxygen_cylinder,
+            "has_fire_extinguisher": room.has_fire_extinguisher,
+            "connected_to": [conn[0] for conn in room.connected_to],
+            "sensor_data": {
+                "fire_detected": sensor.fire_detected,
+                "smoke_level": round(sensor.smoke_level, 2),
+                "temperature_c": round(sensor.temperature, 1),
+                "oxygen_pct": round(sensor.oxygen_level, 1),
+                "visibility_pct": round(sensor.visibility, 1),
+                "structural_integrity_pct": round(sensor.structural_integrity, 1),
+                "fire_growth_rate": round(sensor.fire_growth_rate, 2),
+                "flashover_risk": round(sensor.flashover_risk, 2),
+                "backdraft_risk": round(sensor.backdraft_risk, 2),
+                "heat_radiation": round(sensor.heat_radiation, 2),
+                "fire_type": sensor.fire_type,
+                "carbon_monoxide_ppm": round(sensor.carbon_monoxide, 1),
+                "carbon_dioxide_ppm": round(sensor.carbon_dioxide, 1),
+                "hydrogen_cyanide_ppm": round(sensor.hydrogen_cyanide, 2),
+                "hydrogen_chloride_ppm": round(sensor.hydrogen_chloride, 2),
+                "wind_direction": round(sensor.wind_direction, 1),
+                "wind_speed": round(sensor.wind_speed, 2),
+                "air_pressure": round(sensor.air_pressure, 2),
+                "humidity": round(sensor.humidity, 1),
+                "occupancy_density": round(sensor.occupancy_density, 2),
+                "mobility_limitations": sensor.mobility_limitations,
+                "panic_level": round(sensor.panic_level, 2),
+                "evacuation_progress": round(sensor.evacuation_progress, 1),
+                "sprinkler_active": sensor.sprinkler_active,
+                "emergency_lighting": sensor.emergency_lighting,
+                "elevator_available": sensor.elevator_available,
+                "stairwell_clear": sensor.stairwell_clear,
+                "exit_accessible": sensor.exit_accessible,
+                "exit_capacity": sensor.exit_capacity,
+                "ventilation_active": sensor.ventilation_active,
+                "time_since_fire_start": sensor.time_since_fire_start,
+                "estimated_time_to_exit": sensor.estimated_time_to_exit,
+                "emergency_comm_working": sensor.emergency_comm_working,
+                "wifi_signal_strength": round(sensor.wifi_signal_strength, 1),
+                "danger_score": round(sensor.calculate_danger_score(), 1),
+                "passable": sensor.is_passable()
+            }
+        }
+    
+    def export_route_data(self, start_location: str = "R1") -> Dict[str, Any]:
+        """Export all evacuation routes with detailed information"""
+        routes = self.pathfinder.find_all_evacuation_routes(start_location)
+        
+        route_data = {
+            "timestamp_sec": 0,
+            "start_location": start_location,
+            "total_routes": len(routes),
+            "routes": []
+        }
+        
+        for idx, (exit_id, path, risk) in enumerate(routes, 1):
+            route_info = {
+                "route_id": f"Route {idx}",
+                "exit": exit_id,
+                "path": path,
+                "metrics": {
+                    "avg_danger": round(risk['avg_danger'], 2),
+                    "max_danger": round(risk['max_danger'], 2),
+                    "max_danger_location": risk['max_danger_location'],
+                    "total_danger": round(risk['total_danger'], 2),
+                    "path_length": risk['path_length'],
+                    "has_fire": risk['has_fire'],
+                    "has_oxygen_hazard": risk['has_oxygen_hazard'],
+                    "passable": risk['passable'],
+                    "risk_factors": risk['risk_factors']
+                },
+                "nodes": []
+            }
+            
+            # Add detailed node information
+            for room_id in path:
+                node_data = self.export_room_data(room_id)
+                if node_data:
+                    route_info["nodes"].append(node_data)
+            
+            route_data["routes"].append(route_info)
+        
+        return route_data
+    
+    def export_all_rooms(self) -> List[Dict[str, Any]]:
+        """Export all rooms as separate documents"""
+        all_rooms = []
+        for room_id in self.floor_plan.rooms:
+            room_data = self.export_room_data(room_id)
+            if room_data:
+                all_rooms.append(room_data)
+        return all_rooms
+    
+    def export_to_json(self, output_path: str, start_location: str = "R1"):
+        """Export complete dataset to JSON file"""
+        data = {
+            "floor_plan": {
+                "floor_name": self.floor_plan.floor_name,
+                "total_rooms": len(self.floor_plan.rooms),
+                "exits": self.floor_plan.exits
+            },
+            "all_rooms": self.export_all_rooms(),
+            "evacuation_routes": self.export_route_data(start_location)
+        }
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        
+        print(f"[OK] Exported data to {output_path}")
+        return data
+
+
+class ReasoningMode(Enum):
+    """Enumeration of reasoning modes"""
+    STANDARD = "standard"
+    CHAIN_OF_THOUGHT = "chain_of_thought"
+    TREE_OF_THOUGHTS = "tree_of_thoughts"
+    REFLEXION = "reflexion"
+    COT_WITH_TOOLS = "cot_with_tools"
+
+
+class DecodingStrategy(Enum):
+    """Enumeration of decoding strategies"""
+    GREEDY = "greedy"
+    SAMPLING = "sampling"
+    BEAM_SEARCH = "beam_search"
+    NUCLEUS = "nucleus"
+    TEMPERATURE = "temperature"
+
+
+class FireEvacuationRAG:
+    """RAG system using FAISS for retrieval and Llama for generation with advanced reasoning"""
+    
+    def __init__(self, model_name: str = "nvidia/Llama-3.1-Minitron-4B-Width-Base", model_dir: str = "./models", 
+                 use_8bit: bool = False, use_unsloth: bool = False, load_in_4bit: bool = True, max_seq_length: int = 2048,
+                 reasoning_mode: ReasoningMode = ReasoningMode.CHAIN_OF_THOUGHT,
+                 decoding_strategy: DecodingStrategy = DecodingStrategy.NUCLEUS):
+        self.model_name = model_name
+        self.model_dir = model_dir
+        self.local_model_path = os.path.join(model_dir, model_name.replace("/", "_"))
+        self.use_8bit = use_8bit
+        self.use_unsloth = use_unsloth
+        self.load_in_4bit = load_in_4bit
+        self.max_seq_length = max_seq_length
+        self.reasoning_mode = reasoning_mode
+        self.decoding_strategy = decoding_strategy
+        self.tokenizer = None
+        self.model = None
+        self.pipe = None
+        self.embedder = None
+        self.index = None
+        self.documents = []
+        self.metadata = []
+        self.reflexion_history = []  # Store reflection history for Reflexion
+        
+        # Create model directory if it doesn't exist
+        os.makedirs(self.model_dir, exist_ok=True)
+        os.makedirs(self.local_model_path, exist_ok=True)
+        
+        print(f"Initializing RAG system with model: {model_name}")
+        print(f"Model will be saved to: {self.local_model_path}")
+        print(f"Reasoning mode: {reasoning_mode.value}")
+        print(f"Decoding strategy: {decoding_strategy.value}")
+        if use_unsloth:
+            print("[*] Unsloth enabled (faster loading and inference)")
+            if load_in_4bit:
+                print("  - 4-bit quantization enabled (very fast, low memory)")
+        elif use_8bit:
+            print("[!] 8-bit quantization enabled (faster loading, lower memory, slight quality trade-off)")
+    
+    def _check_model_files_exist(self, model_path: str) -> bool:
+        """Check if model files actually exist (not just config.json)"""
+        required_files = [
+            "config.json",
+            "model.safetensors.index.json"  # Check for sharded model index
+        ]
+        
+        # Check for at least one model file
+        model_file_patterns = [
+            "model.safetensors",
+            "pytorch_model.bin",
+            "model-*.safetensors"  # Sharded models
+        ]
+        
+        config_exists = os.path.exists(os.path.join(model_path, "config.json"))
+        if not config_exists:
+            return False
+        
+        # Check for model weight files
+        for pattern in model_file_patterns:
+            if glob.glob(os.path.join(model_path, pattern)):
+                return True
+        
+        # Check for sharded model index
+        if os.path.exists(os.path.join(model_path, "model.safetensors.index.json")):
+            return True
+        
+        return False
+    
+    def download_model(self):
+        """Download and load the Llama model, saving weights to local directory"""
+        print("Downloading Llama model (this may take a while)...")
+        print(f"Model weights will be saved to: {self.local_model_path}")
+        
+        # Use Unsloth if enabled (much faster loading) - PRIMARY METHOD
+        if self.use_unsloth:
+            try:
+                from unsloth import FastLanguageModel
+                from transformers import TextStreamer
+                print("[*] Using Unsloth for fast model loading...")
+                
+                # Check if model name indicates it's already quantized (contains "bnb-4bit" or "bnb-8bit")
+                is_pre_quantized = "bnb-4bit" in self.model_name.lower() or "bnb-8bit" in self.model_name.lower()
+                
+                # For pre-quantized models, don't set load_in_4bit (model is already quantized)
+                # For non-quantized models, check if bitsandbytes is available
+                if self.load_in_4bit and not is_pre_quantized:
+                    try:
+                        import bitsandbytes
+                        print("[OK] bitsandbytes available for 4-bit quantization")
+                    except ImportError:
+                        print("[!] bitsandbytes not found. 4-bit quantization requires bitsandbytes.")
+                        print("  Install with: pip install bitsandbytes")
+                        print("  Falling back to full precision...")
+                        self.load_in_4bit = False
+                
+                # Check if model exists locally
+                if self._check_model_files_exist(self.local_model_path):
+                    print(f"Loading from local path: {self.local_model_path}")
+                    model_path = self.local_model_path
+                else:
+                    print(f"Downloading model: {self.model_name}")
+                    model_path = self.model_name
+                
+                # ==== Load Model with Unsloth (exact pattern from user) ====
+                dtype = None  # Auto-detect dtype
+                
+                # Try loading with proper error handling for bitsandbytes
+                # The model config might have quantization settings that trigger bitsandbytes check
+                max_retries = 2
+                for attempt in range(max_retries):
+                    try:
+                        # For pre-quantized models, don't specify load_in_4bit (it's already quantized)
+                        if is_pre_quantized or attempt > 0:
+                            print("[OK] Loading model without quantization parameters...")
+                            # Don't pass any quantization parameters
+                            load_kwargs = {
+                                "model_name": model_path,
+                                "max_seq_length": self.max_seq_length,
+                                "dtype": dtype,
+                            }
+                        else:
+                            # For non-quantized models, try quantization if requested
+                            load_kwargs = {
+                                "model_name": model_path,
+                                "max_seq_length": self.max_seq_length,
+                                "dtype": dtype,
+                            }
+                            if self.load_in_4bit:
+                                load_kwargs["load_in_4bit"] = True
+                        
+                        self.model, self.tokenizer = FastLanguageModel.from_pretrained(**load_kwargs)
+                        break  # Success, exit retry loop
+                        
+                    except (ImportError, Exception) as quant_error:
+                        error_str = str(quant_error)
+                        is_bitsandbytes_error = (
+                            "bitsandbytes" in error_str.lower() or 
+                            "PackageNotFoundError" in error_str or 
+                            "No package metadata" in error_str or
+                            "quantization_config" in error_str.lower()
+                        )
+                        
+                        if is_bitsandbytes_error and attempt < max_retries - 1:
+                            print(f"[!] Attempt {attempt + 1}: bitsandbytes error detected.")
+                            print(f"  Error: {error_str[:150]}...")
+                            print("  Retrying without quantization parameters...")
+                            continue  # Retry without quantization
+                        elif is_bitsandbytes_error:
+                            print("[!] bitsandbytes required but not installed.")
+                            print("  Options:")
+                            print("  1. Install bitsandbytes: pip install bitsandbytes")
+                            print("  2. Use a non-quantized model")
+                            print("  3. Set USE_UNSLOTH=False to use standard loading")
+                            raise ImportError(
+                                "bitsandbytes is required for this model. "
+                                "Install with: pip install bitsandbytes"
+                            ) from quant_error
+                        else:
+                            # Re-raise if it's a different error
+                            raise
+                
+                # Optimize for inference
+                FastLanguageModel.for_inference(self.model)
+                
+                print("[OK] Model loaded successfully with Unsloth!")
+                
+                # Verify device
+                if torch.cuda.is_available():
+                    actual_device = next(self.model.parameters()).device
+                    print(f"[OK] Model loaded on {actual_device}!")
+                    allocated = torch.cuda.memory_allocated(0) / 1024**3
+                    print(f"[OK] GPU Memory allocated: {allocated:.2f} GB")
+                else:
+                    print("[OK] Model loaded on CPU!")
+                
+                # Set pipe to model for compatibility (we'll use model directly in generation)
+                self.pipe = self.model  # Store model reference for compatibility checks
+                
+                return  # Exit early, Unsloth loading complete
+                
+            except ImportError:
+                print("[!] Unsloth not installed. Falling back to standard loading.")
+                print("  Install with: pip install unsloth")
+                self.use_unsloth = False  # Disable unsloth for this session
+            except Exception as e:
+                print(f"[!] Unsloth loading failed: {e}")
+                print("  Falling back to standard loading...")
+                self.use_unsloth = False
+        
+        # Standard loading (original code)
+        # Check GPU availability and optimize settings
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        if device == "cuda":
+            gpu_name = torch.cuda.get_device_name(0)
+            gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+            print(f"[OK] GPU detected: {gpu_name}")
+            print(f"[OK] GPU Memory: {gpu_memory:.2f} GB")
+            # Use bfloat16 for faster loading and inference on GPU
+            torch_dtype = torch.bfloat16
+            print("[OK] Using bfloat16 precision for faster loading")
+        else:
+            print("[!] No GPU detected, using CPU (will be slower)")
+            torch_dtype = torch.float32
+            print("[OK] Using float32 precision for CPU")
+        
+        # Check for optimized attention implementation
+        try:
+            import flash_attn  # noqa: F401
+            attn_impl = 'flash_attention_2'
+            print("[OK] FlashAttention2 available - using for optimal performance")
+        except ImportError:
+            attn_impl = 'sdpa'  # Scaled Dot Product Attention (built into PyTorch)
+            print("[OK] Using SDPA (Scaled Dot Product Attention) for faster inference")
+        
+        # Check for 8-bit quantization support
+        use_quantization = False
+        if self.use_8bit and device == "cuda":
+            try:
+                import bitsandbytes
+                use_quantization = True
+                print("[OK] 8-bit quantization available - will use for faster loading")
+            except ImportError:
+                print("[!] 8-bit requested but bitsandbytes not installed, using full precision")
+                print("  Install with: pip install bitsandbytes")
+        
+        try:
+            # Check if model already exists locally with actual model files
+            if self._check_model_files_exist(self.local_model_path):
+                print(f"Found existing model at {self.local_model_path}, loading from local...")
+                model_path = self.local_model_path
+                load_from_local = True
+            else:
+                print("Downloading model from HuggingFace...")
+                model_path = self.model_name
+                load_from_local = False
+            
+            # Load tokenizer
+            print("Loading tokenizer...")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                model_path,
+                trust_remote_code=True
+            )
+            
+            # Save tokenizer locally if downloaded (wrap in try-except to avoid crashes)
+            if not load_from_local:
+                try:
+                    print("Saving tokenizer to local directory...")
+                    self.tokenizer.save_pretrained(self.local_model_path)
+                    print(f"[OK] Tokenizer saved to {self.local_model_path}")
+                except Exception as save_err:
+                    print(f"[!] Warning: Could not save tokenizer locally: {save_err}")
+                    print("Continuing without local save...")
+            
+            # Load model with optimizations
+            print("Loading model with optimizations...")
+            load_kwargs = {
+                "trust_remote_code": True,
+                "low_cpu_mem_usage": True,  # Reduces memory usage during loading
+                "_attn_implementation": attn_impl,  # Optimized attention
+            }
+            
+            # Add quantization or dtype
+            if use_quantization:
+                from transformers import BitsAndBytesConfig
+                load_kwargs["quantization_config"] = BitsAndBytesConfig(
+                    load_in_8bit=True,
+                    llm_int8_threshold=6.0
+                )
+                print("[OK] Using 8-bit quantization for faster loading and lower memory")
+            else:
+                load_kwargs["torch_dtype"] = torch_dtype
+            
+            # Use device_map="auto" for GPU, manual placement for CPU
+            if device == "cuda":
+                try:
+                    load_kwargs["device_map"] = "auto"
+                    print("[OK] Using device_map='auto' for optimal GPU memory management")
+                except Exception as e:
+                    print(f"[!] device_map='auto' failed, using manual GPU placement: {e}")
+                    load_kwargs.pop("device_map", None)
+            
+            self.model = AutoModelForCausalLM.from_pretrained(
+                model_path,
+                **load_kwargs
+            )
+            
+            # Manual device placement if device_map wasn't used
+            if device == "cuda" and "device_map" not in load_kwargs:
+                self.model = self.model.cuda()
+                print("[OK] Model moved to GPU")
+            
+            # Save model locally if downloaded (wrap in try-except to handle DTensor errors)
+            if not load_from_local:
+                try:
+                    print("Saving model weights to local directory (this may take a while)...")
+                    self.model.save_pretrained(
+                        self.local_model_path,
+                        safe_serialization=True  # Use safetensors format
+                    )
+                    print(f"[OK] Model saved to {self.local_model_path}")
+                except ImportError as import_err:
+                    if "DTensor" in str(import_err):
+                        print(f"[!] Warning: Could not save model due to PyTorch/transformers compatibility issue: {import_err}")
+                        print("This is a known issue with certain versions. Model will work but won't be saved locally.")
+                        print("Continuing without local save...")
+                    else:
+                        raise
+                except Exception as save_err:
+                    print(f"[!] Warning: Could not save model locally: {save_err}")
+                    print("Continuing without local save...")
+            
+            # Create pipeline with optimizations
+            print("Creating pipeline...")
+            pipeline_kwargs = {
+                "model": self.model,
+                "tokenizer": self.tokenizer,
+            }
+            if device == "cuda":
+                pipeline_kwargs["device_map"] = "auto"
+            
+            self.pipe = pipeline("text-generation", **pipeline_kwargs)
+            
+            # Verify model device
+            if device == "cuda":
+                actual_device = next(self.model.parameters()).device
+                print(f"[OK] Model loaded successfully on {actual_device}!")
+                if torch.cuda.is_available():
+                    allocated = torch.cuda.memory_allocated(0) / 1024**3
+                    print(f"[OK] GPU Memory allocated: {allocated:.2f} GB")
+            else:
+                print("[OK] Model loaded successfully on CPU!")
+            
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            print("Falling back to pipeline-only loading...")
+            try:
+                # Determine device and dtype for fallback
+                device = "cuda" if torch.cuda.is_available() else "cpu"
+                torch_dtype = torch.bfloat16 if device == "cuda" else torch.float32
+                
+                # Try loading from local path first (only if model files actually exist)
+                if self._check_model_files_exist(self.local_model_path):
+                    print(f"Attempting to load from local path: {self.local_model_path}")
+                    pipeline_kwargs = {
+                        "model": self.local_model_path,
+                        "trust_remote_code": True,
+                        "torch_dtype": torch_dtype,
+                    }
+                    if device == "cuda":
+                        pipeline_kwargs["device_map"] = "auto"
+                    self.pipe = pipeline("text-generation", **pipeline_kwargs)
+                    # Extract tokenizer from pipeline if available
+                    if hasattr(self.pipe, 'tokenizer'):
+                        self.tokenizer = self.pipe.tokenizer
+                else:
+                    print(f"Downloading model: {self.model_name}")
+                    pipeline_kwargs = {
+                        "model": self.model_name,
+                        "trust_remote_code": True,
+                        "torch_dtype": torch_dtype,
+                    }
+                    if device == "cuda":
+                        pipeline_kwargs["device_map"] = "auto"
+                    self.pipe = pipeline("text-generation", **pipeline_kwargs)
+                    # Extract tokenizer from pipeline if available
+                    if hasattr(self.pipe, 'tokenizer'):
+                        self.tokenizer = self.pipe.tokenizer
+                    
+                    # Try to save after loading (but don't fail if it doesn't work)
+                    try:
+                        if hasattr(self.pipe, 'model') and hasattr(self.pipe.model, 'save_pretrained'):
+                            print("Attempting to save downloaded model to local directory...")
+                            self.pipe.model.save_pretrained(self.local_model_path, safe_serialization=True)
+                            if hasattr(self.pipe, 'tokenizer'):
+                                self.pipe.tokenizer.save_pretrained(self.local_model_path)
+                            print("[OK] Model saved successfully")
+                    except ImportError as import_err:
+                        if "DTensor" in str(import_err):
+                            print(f"[!] Warning: Could not save model due to compatibility issue. Model will work but won't be saved locally.")
+                        else:
+                            print(f"[!] Warning: Could not save model: {import_err}")
+                    except Exception as save_err:
+                        print(f"[!] Warning: Could not save model locally: {save_err}")
+                    
+            except Exception as e2:
+                print(f"Pipeline loading also failed: {e2}")
+                raise
+    
+    def load_embedder(self, model_name: str = "all-MiniLM-L6-v2"):
+        """Load sentence transformer for embeddings, saving to local directory"""
+        embedder_dir = os.path.join(self.model_dir, "embedder", model_name.replace("/", "_"))
+        os.makedirs(embedder_dir, exist_ok=True)
+        
+        print(f"Loading embedding model: {model_name}...")
+        print(f"Embedder will be cached in: {embedder_dir}")
+        
+        # Check if embedder exists locally (check for actual model files, not just config)
+        config_path = os.path.join(embedder_dir, "config.json")
+        has_model_files = False
+        if os.path.exists(config_path):
+            # Check if model files exist
+            model_files = glob.glob(os.path.join(embedder_dir, "*.safetensors")) + \
+                         glob.glob(os.path.join(embedder_dir, "pytorch_model.bin"))
+            if model_files or os.path.exists(os.path.join(embedder_dir, "model.safetensors.index.json")):
+                has_model_files = True
+        
+        if has_model_files:
+            print(f"Loading embedder from local cache: {embedder_dir}")
+            self.embedder = SentenceTransformer(embedder_dir)
+        else:
+            print("Downloading embedder from HuggingFace...")
+            self.embedder = SentenceTransformer(model_name, cache_folder=embedder_dir)
+            # Try to save to local directory (but don't fail if it doesn't work)
+            try:
+                self.embedder.save(embedder_dir)
+                print(f"[OK] Embedder saved to {embedder_dir}")
+            except ImportError as import_err:
+                if "DTensor" in str(import_err):
+                    print(f"[!] Warning: Could not save embedder due to PyTorch/transformers compatibility issue: {import_err}")
+                    print("This is a known issue with certain versions. Embedder will work but won't be saved locally.")
+                    print("Continuing without local save...")
+                else:
+                    print(f"[!] Warning: Could not save embedder: {import_err}")
+            except Exception as save_err:
+                print(f"[!] Warning: Could not save embedder locally: {save_err}")
+                print("Continuing without local save...")
+        
+        print("[OK] Embedding model loaded!")
+    
+    def build_faiss_index(self, documents: List[str], metadata: List[Dict] = None):
+        """
+        Build FAISS index from documents
+        
+        Args:
+            documents: List of text documents to index
+            metadata: Optional metadata for each document
+        """
+        if not self.embedder:
+            self.load_embedder()
+        
+        print(f"Building FAISS index for {len(documents)} documents...")
+        
+        # Generate embeddings
+        embeddings = self.embedder.encode(documents, show_progress_bar=True)
+        embeddings = np.array(embeddings).astype('float32')
+        
+        # Get dimension
+        dimension = embeddings.shape[1]
+        
+        # Create FAISS index (L2 distance)
+        self.index = faiss.IndexFlatL2(dimension)
+        
+        # Add embeddings to index
+        self.index.add(embeddings)
+        
+        # Store documents and metadata
+        self.documents = documents
+        self.metadata = metadata if metadata else [{}] * len(documents)
+        
+        print(f"[OK] FAISS index built with {self.index.ntotal} vectors")
+    
+    def build_index_from_json(self, json_data: Dict[str, Any]):
+        """Build FAISS index from exported JSON data"""
+        documents = []
+        metadata = []
+        
+        # Add room documents
+        for room in json_data.get("all_rooms", []):
+            # Create text representation
+            room_text = self._room_to_text(room)
+            documents.append(room_text)
+            metadata.append({
+                "type": "room",
+                "room_id": room.get("room_id"),
+                "data": room
+            })
+        
+        # Add route documents
+        for route in json_data.get("evacuation_routes", {}).get("routes", []):
+            route_text = self._route_to_text(route)
+            documents.append(route_text)
+            metadata.append({
+                "type": "route",
+                "route_id": route.get("route_id"),
+                "exit": route.get("exit"),
+                "data": route
+            })
+        
+        # Build index
+        self.build_faiss_index(documents, metadata)
+    
+    def _room_to_text(self, room: Dict[str, Any]) -> str:
+        """Convert room data to searchable text"""
+        sensor = room.get("sensor_data", {})
+        
+        text_parts = [
+            f"Room {room.get('room_id')} ({room.get('name')})",
+            f"Type: {room.get('room_type')}",
+        ]
+        
+        if room.get("has_oxygen_cylinder"):
+            text_parts.append("[!]️ OXYGEN CYLINDER PRESENT - EXPLOSION RISK")
+        
+        if sensor.get("fire_detected"):
+            text_parts.append("[FIRE] FIRE DETECTED")
+        
+        text_parts.extend([
+            f"Temperature: {sensor.get('temperature_c')}°C",
+            f"Smoke level: {sensor.get('smoke_level')}",
+            f"Oxygen: {sensor.get('oxygen_pct')}%",
+            f"Visibility: {sensor.get('visibility_pct')}%",
+            f"Structural integrity: {sensor.get('structural_integrity_pct')}%",
+            f"Danger score: {sensor.get('danger_score')}",
+            f"Passable: {sensor.get('passable')}"
+        ])
+        
+        if sensor.get("carbon_monoxide_ppm", 0) > 50:
+            text_parts.append(f"[!]️ HIGH CARBON MONOXIDE: {sensor.get('carbon_monoxide_ppm')} ppm")
+        
+        if sensor.get("flashover_risk", 0) > 0.5:
+            text_parts.append(f"[!]️ FLASHOVER RISK: {sensor.get('flashover_risk')*100:.0f}%")
+        
+        if not sensor.get("exit_accessible", True):
+            text_parts.append("[!]️ EXIT BLOCKED")
+        
+        if sensor.get("occupancy_density", 0) > 0.7:
+            text_parts.append(f"[!]️ HIGH CROWD DENSITY: {sensor.get('occupancy_density')*100:.0f}%")
+        
+        return " | ".join(text_parts)
+    
+    def _route_to_text(self, route: Dict[str, Any]) -> str:
+        """Convert route data to searchable text"""
+        metrics = route.get("metrics", {})
+        
+        text_parts = [
+            f"{route.get('route_id')} to {route.get('exit')}",
+            f"Path: {' → '.join(route.get('path', []))}",
+            f"Average danger: {metrics.get('avg_danger')}",
+            f"Max danger: {metrics.get('max_danger')} at {metrics.get('max_danger_location')}",
+            f"Passable: {metrics.get('passable')}",
+            f"Has fire: {metrics.get('has_fire')}",
+            f"Has oxygen hazard: {metrics.get('has_oxygen_hazard')}"
+        ]
+        
+        risk_factors = metrics.get("risk_factors", [])
+        if risk_factors:
+            text_parts.append(f"Risks: {', '.join(risk_factors[:3])}")
+        
+        return " | ".join(text_parts)
+    
+    def search(self, query: str, k: int = 5) -> List[Dict[str, Any]]:
+        """
+        Search FAISS index for relevant documents
+        
+        Args:
+            query: Search query
+            k: Number of results to return
+            
+        Returns:
+            List of relevant documents with metadata
+        """
+        if not self.index or not self.embedder:
+            raise ValueError("Index not built. Call build_faiss_index() first.")
+        
+        # Encode query
+        query_embedding = self.embedder.encode([query])
+        query_embedding = np.array(query_embedding).astype('float32')
+        
+        # Search
+        distances, indices = self.index.search(query_embedding, k)
+        
+        # Return results
+        results = []
+        for i, idx in enumerate(indices[0]):
+            if idx < len(self.documents):
+                results.append({
+                    "document": self.documents[idx],
+                    "metadata": self.metadata[idx],
+                    "distance": float(distances[0][i])
+                })
+        
+        return results
+    
+    def _build_cot_prompt(self, query: str, context: List[str]) -> str:
+        """Build Chain-of-Thought prompt with step-by-step reasoning"""
+        context_text = "\n".join([f"- {ctx}" for ctx in context])
+        
+        prompt = f"""You are an expert fire evacuation safety advisor. Use the following context to answer the question concisely.
+
+CONTEXT:
+{context_text}
+
+QUESTION: {query}
+
+Think step by step, then provide a brief answer:
+
+REASONING:
+1. Analyze available information
+2. Identify key safety factors
+3. Evaluate risks and prioritize
+4. Conclude with recommendation
+
+ANSWER:"""
+        return prompt
+    
+    def _build_tot_prompt(self, query: str, context: List[str], thought: str = "") -> str:
+        """Build Tree-of-Thoughts prompt for exploring multiple reasoning paths"""
+        context_text = "\n".join([f"- {ctx}" for ctx in context])
+        
+        if not thought:
+            prompt = f"""You are an expert fire evacuation safety advisor. Use the following context to explore different reasoning approaches.
+
+CONTEXT:
+{context_text}
+
+QUESTION: {query}
+
+Let's explore different reasoning approaches to solve this problem:
+
+APPROACH 1 - Safety-First Analysis:
+"""
+        else:
+            prompt = f"""CONTEXT:
+{context_text}
+
+QUESTION: {query}
+
+CURRENT THOUGHT: {thought}
+
+Evaluate this thought:
+- Is this reasoning sound?
+- What are the strengths and weaknesses?
+- What alternative approaches should we consider?
+
+EVALUATION:
+"""
+        return prompt
+    
+    def _build_reflexion_prompt(self, query: str, context: List[str], previous_answer: str = "", 
+                                reflection: str = "") -> str:
+        """Build Reflexion prompt for self-reflection and improvement"""
+        context_text = "\n".join([f"- {ctx}" for ctx in context])
+        
+        if not previous_answer:
+            # Initial answer
+            prompt = f"""You are an expert fire evacuation safety advisor. Use the following context to answer the question.
+
+CONTEXT:
+{context_text}
+
+QUESTION: {query}
+
+Provide a clear, safety-focused answer based on the context.
+
+ANSWER:"""
+        else:
+            # Reflection phase
+            prompt = f"""You are an expert fire evacuation safety advisor. Review and improve your previous answer.
+
+CONTEXT:
+{context_text}
+
+QUESTION: {query}
+
+PREVIOUS ANSWER:
+{previous_answer}
+
+REFLECTION:
+{reflection}
+
+Now provide an improved answer based on your reflection:
+
+IMPROVED ANSWER:"""
+        return prompt
+    
+    def _build_cot_with_tools_prompt(self, query: str, context: List[str], tool_results: List[str] = None) -> str:
+        """Build Chain-of-Thought prompt with tool integration"""
+        context_text = "\n".join([f"- {ctx}" for ctx in context])
+        
+        tool_text = ""
+        if tool_results:
+            tool_text = "\nTOOL RESULTS:\n" + "\n".join([f"- {result}" for result in tool_results])
+        
+        prompt = f"""You are an expert fire evacuation safety advisor. Use the following context and tool results to answer the question.
+
+CONTEXT:
+{context_text}
+{tool_text}
+
+QUESTION: {query}
+
+Let's solve this step by step, using both the context and tool results:
+
+STEP 1 - Understand the question and available data:
+"""
+        return prompt
+    
+    def _generate_with_decoding_strategy(self, prompt: str, max_length: int = 500, 
+                                        temperature: float = 0.7, top_p: float = 0.9,
+                                        num_beams: int = 3, stop_sequences: List[str] = None) -> str:
+        """Generate response using specified decoding strategy"""
+        if not self.pipe and not self.model:
+            raise ValueError("Model not loaded. Call download_model() first.")
+        
+        try:
+            if self.use_unsloth and self.model:
+                inputs = self.tokenizer(
+                    prompt,
+                    return_tensors="pt",
+                    truncation=True,
+                    max_length=self.max_seq_length
+                ).to(self.model.device)
+                
+                # Configure generation parameters based on decoding strategy
+                gen_kwargs = {
+                    "max_new_tokens": max_length,
+                    "pad_token_id": self.tokenizer.eos_token_id,
+                    "eos_token_id": self.tokenizer.eos_token_id,
+                }
+                
+                if self.decoding_strategy == DecodingStrategy.GREEDY:
+                    gen_kwargs.update({
+                        "do_sample": False,
+                        "num_beams": 1
+                    })
+                elif self.decoding_strategy == DecodingStrategy.SAMPLING:
+                    gen_kwargs.update({
+                        "do_sample": True,
+                        "temperature": temperature,
+                        "top_k": 50
+                    })
+                elif self.decoding_strategy == DecodingStrategy.BEAM_SEARCH:
+                    gen_kwargs.update({
+                        "do_sample": False,
+                        "num_beams": num_beams,
+                        "early_stopping": True
+                    })
+                elif self.decoding_strategy == DecodingStrategy.NUCLEUS:
+                    gen_kwargs.update({
+                        "do_sample": True,
+                        "temperature": temperature,
+                        "top_p": top_p,
+                        "top_k": 0
+                    })
+                elif self.decoding_strategy == DecodingStrategy.TEMPERATURE:
+                    gen_kwargs.update({
+                        "do_sample": True,
+                        "temperature": temperature
+                    })
+                
+                with torch.no_grad():
+                    outputs = self.model.generate(**inputs, **gen_kwargs)
+                
+                response = self.tokenizer.batch_decode(
+                    outputs, 
+                    skip_special_tokens=True
+                )[0]
+                
+                # Extract response after prompt
+                if prompt in response:
+                    response = response.split(prompt)[-1].strip()
+                
+                # Post-process to stop at verbose endings
+                stop_phrases = [
+                    "\n\nHowever, please note",
+                    "\n\nAdditionally,",
+                    "\n\nLet me know",
+                    "\n\nIf you have",
+                    "\n\nHere's another",
+                    "\n\nQUESTION:",
+                    "\n\nLet's break",
+                    "\n\nHave a great day",
+                    "\n\nI'm here to help"
+                ]
+                for phrase in stop_phrases:
+                    if phrase in response:
+                        response = response.split(phrase)[0].strip()
+                        break
+                
+                return response
+            else:
+                # Use pipeline for standard models
+                gen_kwargs = {
+                    "max_length": len(self.tokenizer.encode(prompt)) + max_length,
+                    "num_return_sequences": 1,
+                }
+                
+                if self.decoding_strategy == DecodingStrategy.GREEDY:
+                    gen_kwargs.update({
+                        "do_sample": False
+                    })
+                elif self.decoding_strategy == DecodingStrategy.SAMPLING:
+                    gen_kwargs.update({
+                        "do_sample": True,
+                        "temperature": temperature,
+                        "top_k": 50
+                    })
+                elif self.decoding_strategy == DecodingStrategy.BEAM_SEARCH:
+                    gen_kwargs.update({
+                        "do_sample": False,
+                        "num_beams": num_beams,
+                        "early_stopping": True
+                    })
+                elif self.decoding_strategy == DecodingStrategy.NUCLEUS:
+                    gen_kwargs.update({
+                        "do_sample": True,
+                        "temperature": temperature,
+                        "top_p": top_p,
+                        "top_k": 0
+                    })
+                elif self.decoding_strategy == DecodingStrategy.TEMPERATURE:
+                    gen_kwargs.update({
+                        "do_sample": True,
+                        "temperature": temperature
+                    })
+                
+                gen_kwargs["pad_token_id"] = self.tokenizer.eos_token_id if self.tokenizer else None
+                
+                outputs = self.pipe(prompt, **gen_kwargs)
+                response = outputs[0]['generated_text']
+                
+                # Extract response after prompt
+                if prompt in response:
+                    response = response.split(prompt)[-1].strip()
+                
+                # Post-process to stop at verbose endings
+                stop_phrases = [
+                    "\n\nHowever, please note",
+                    "\n\nAdditionally,",
+                    "\n\nLet me know",
+                    "\n\nIf you have",
+                    "\n\nHere's another",
+                    "\n\nQUESTION:",
+                    "\n\nLet's break",
+                    "\n\nHave a great day",
+                    "\n\nI'm here to help"
+                ]
+                for phrase in stop_phrases:
+                    if phrase in response:
+                        response = response.split(phrase)[0].strip()
+                        break
+            
+            return response
+            
+        except Exception as e:
+            return f"Error generating response: {e}"
+    
+    def _chain_of_thought_reasoning(self, query: str, context: List[str], max_length: int = 500) -> Tuple[str, str]:
+        """Generate response using Chain-of-Thought reasoning
+        
+        Returns:
+            Tuple of (full_reasoning, final_answer)
+        """
+        prompt = self._build_cot_prompt(query, context)
+        # Use shorter max_length for CoT to prevent verbosity
+        full_response = self._generate_with_decoding_strategy(prompt, max_length=min(max_length, 300))
+        
+        # Extract reasoning steps (everything before ANSWER)
+        reasoning = ""
+        if "REASONING:" in full_response:
+            reasoning_parts = full_response.split("REASONING:")
+            if len(reasoning_parts) > 1:
+                reasoning_section = reasoning_parts[1].split("ANSWER:")[0] if "ANSWER:" in reasoning_parts[1] else reasoning_parts[1]
+                reasoning = reasoning_section.strip()
+        elif "ANSWER:" in full_response:
+            reasoning = full_response.split("ANSWER:")[0].strip()
+        else:
+            # Try to extract reasoning from numbered steps
+            lines = full_response.split('\n')
+            reasoning_lines = []
+            for line in lines:
+                if line.strip().startswith(('1.', '2.', '3.', '4.', '5.', 'Step', 'STEP')):
+                    reasoning_lines.append(line.strip())
+                elif "ANSWER" in line.upper():
+                    break
+                elif reasoning_lines:  # Continue collecting if we've started
+                    reasoning_lines.append(line.strip())
+            reasoning = '\n'.join(reasoning_lines)
+        
+        # Extract final answer (everything after ANSWER:)
+        final_answer = full_response
+        if "ANSWER:" in full_response:
+            answer_parts = full_response.split("ANSWER:")
+            if len(answer_parts) > 1:
+                answer_text = answer_parts[-1].strip()
+                # Stop at common continuation markers
+                stop_markers = [
+                    "\n\nHowever, please note",
+                    "\n\nAdditionally,",
+                    "\n\nLet me know",
+                    "\n\nIf you have",
+                    "\n\nHere's another",
+                    "\n\nQUESTION:",
+                    "\n\nLet's break",
+                    "\n\nHave a great day",
+                    "\n\nI'm here to help",
+                    "\n\nThese general guidelines",
+                    "\n\nIf you have any further"
+                ]
+                for marker in stop_markers:
+                    if marker in answer_text:
+                        answer_text = answer_text.split(marker)[0].strip()
+                        break
+                # Also limit to first 2-3 sentences if it's still too long
+                sentences = answer_text.split('. ')
+                if len(sentences) > 3:
+                    answer_text = '. '.join(sentences[:3])
+                    if not answer_text.endswith('.'):
+                        answer_text += '.'
+                final_answer = answer_text
+        
+        # Clean up reasoning - remove verbose parts
+        if reasoning:
+            # Remove common verbose endings
+            verbose_endings = [
+                "However, please note",
+                "Additionally,",
+                "Let me know",
+                "If you have",
+                "Here's another",
+                "Have a great day",
+                "I'm here to help"
+            ]
+            for ending in verbose_endings:
+                if ending in reasoning:
+                    reasoning = reasoning.split(ending)[0].strip()
+                    break
+        
+        return reasoning or "Reasoning steps generated", final_answer
+    
+    def _tree_of_thoughts_reasoning(self, query: str, context: List[str], max_length: int = 500, 
+                                     max_thoughts: int = 3) -> Tuple[str, str]:
+        """Generate response using Tree-of-Thoughts reasoning
+        
+        Returns:
+            Tuple of (full_reasoning, final_answer)
+        """
+        thoughts = []
+        reasoning_log = []
+        
+        # Generate initial thoughts
+        for i in range(max_thoughts):
+            thought_prompt = self._build_tot_prompt(query, context, 
+                                                   thought=f"Exploring approach {i+1}")
+            thought = self._generate_with_decoding_strategy(thought_prompt, max_length // max_thoughts)
+            thoughts.append(thought)
+            reasoning_log.append(f"APPROACH {i+1}:\n{thought}\n")
+        
+        # Evaluate thoughts and select best
+        evaluation_prompt = f"""Evaluate these different reasoning approaches for answering the question:
+
+QUESTION: {query}
+
+APPROACHES:
+"""
+        for i, thought in enumerate(thoughts, 1):
+            evaluation_prompt += f"\nAPPROACH {i}:\n{thought}\n"
+        
+        evaluation_prompt += "\nWhich approach is most sound and complete? Provide the best answer based on the evaluation.\n\nBEST ANSWER:"
+        
+        final_response = self._generate_with_decoding_strategy(evaluation_prompt, max_length)
+        
+        full_reasoning = "\n".join(reasoning_log) + f"\n\nEVALUATION:\n{final_response}"
+        return full_reasoning, final_response
+    
+    def _reflexion_reasoning(self, query: str, context: List[str], max_length: int = 500, 
+                            max_iterations: int = 2) -> Tuple[str, str]:
+        """Generate response using Reflexion (self-reflection and improvement)
+        
+        Returns:
+            Tuple of (full_reasoning, final_answer)
+        """
+        reasoning_log = []
+        
+        # Initial answer
+        initial_prompt = self._build_reflexion_prompt(query, context)
+        answer = self._generate_with_decoding_strategy(initial_prompt, max_length)
+        reasoning_log.append(f"INITIAL ANSWER:\n{answer}\n")
+        
+        # Reflection and improvement iterations
+        for iteration in range(max_iterations):
+            # Generate reflection
+            reflection_prompt = f"""Review this answer for a fire evacuation safety question:
+
+QUESTION: {query}
+
+CURRENT ANSWER:
+{answer}
+
+What could be improved? Consider:
+- Accuracy of safety information
+- Completeness of the response
+- Clarity and actionability
+- Missing critical safety factors
+
+REFLECTION:"""
+            
+            reflection = self._generate_with_decoding_strategy(reflection_prompt, max_length // 2)
+            reasoning_log.append(f"ITERATION {iteration + 1} - REFLECTION:\n{reflection}\n")
+            
+            # Generate improved answer
+            improved_prompt = self._build_reflexion_prompt(query, context, answer, reflection)
+            improved_answer = self._generate_with_decoding_strategy(improved_prompt, max_length)
+            reasoning_log.append(f"ITERATION {iteration + 1} - IMPROVED ANSWER:\n{improved_answer}\n")
+            
+            # Check if improvement is significant (simple heuristic)
+            if len(improved_answer) > len(answer) * 0.8:  # At least 80% of original length
+                answer = improved_answer
+            else:
+                break  # Stop if answer becomes too short
+        
+        self.reflexion_history.append({
+            "query": query,
+            "final_answer": answer,
+            "iterations": iteration + 1
+        })
+        
+        full_reasoning = "\n".join(reasoning_log)
+        return full_reasoning, answer
+    
+    def _cot_with_tools_reasoning(self, query: str, context: List[str], max_length: int = 500) -> Tuple[str, str]:
+        """Generate response using Chain-of-Thought with tool integration
+        
+        Returns:
+            Tuple of (full_reasoning, final_answer)
+        """
+        reasoning_log = []
+        
+        # Simulate tool calls (in real implementation, these would call actual tools)
+        tool_results = []
+        
+        # Tool 1: Route analysis
+        if "route" in query.lower() or "path" in query.lower():
+            tool_result = "Tool: Route Analyzer - Found 3 evacuation routes with risk scores"
+            tool_results.append(tool_result)
+            reasoning_log.append(f"TOOL CALL: {tool_result}\n")
+        
+        # Tool 2: Risk calculator
+        if "danger" in query.lower() or "risk" in query.lower():
+            tool_result = "Tool: Risk Calculator - Calculated danger scores for all rooms"
+            tool_results.append(tool_result)
+            reasoning_log.append(f"TOOL CALL: {tool_result}\n")
+        
+        # Tool 3: Sensor aggregator
+        if "sensor" in query.lower() or "temperature" in query.lower() or "smoke" in query.lower():
+            tool_result = "Tool: Sensor Aggregator - Aggregated sensor data from all rooms"
+            tool_results.append(tool_result)
+            reasoning_log.append(f"TOOL CALL: {tool_result}\n")
+        
+        prompt = self._build_cot_with_tools_prompt(query, context, tool_results)
+        response = self._generate_with_decoding_strategy(prompt, max_length)
+        
+        reasoning_log.append(f"REASONING WITH TOOLS:\n{response}\n")
+        full_reasoning = "\n".join(reasoning_log)
+        
+        # Extract final answer
+        final_answer = response
+        if "ANSWER:" in response or "answer:" in response.lower():
+            parts = response.split("ANSWER:") if "ANSWER:" in response else response.split("answer:")
+            if len(parts) > 1:
+                final_answer = parts[-1].strip()
+        
+        return full_reasoning, final_answer
+    
+    def generate_response(self, query: str, context: List[str] = None, max_length: int = 500, 
+                         return_reasoning: bool = False) -> str:
+        """
+        Generate response using Llama model with context and advanced reasoning
+        
+        Args:
+            query: User query
+            context: Optional context strings (if None, will retrieve from FAISS)
+            max_length: Maximum response length
+            return_reasoning: If True, returns tuple of (reasoning, answer), else just answer
+        
+        Returns:
+            If return_reasoning is True: Tuple of (reasoning_steps, final_answer)
+            Otherwise: Just the final answer string
+        """
+        if not self.pipe and not self.model:
+            raise ValueError("Model not loaded. Call download_model() first.")
+        
+        # Retrieve context if not provided
+        if context is None:
+            search_results = self.search(query, k=3)
+            context = [r["document"] for r in search_results]
+        
+        # Route to appropriate reasoning method based on mode
+        if self.reasoning_mode == ReasoningMode.CHAIN_OF_THOUGHT:
+            reasoning, answer = self._chain_of_thought_reasoning(query, context, max_length)
+        elif self.reasoning_mode == ReasoningMode.TREE_OF_THOUGHTS:
+            reasoning, answer = self._tree_of_thoughts_reasoning(query, context, max_length)
+        elif self.reasoning_mode == ReasoningMode.REFLEXION:
+            reasoning, answer = self._reflexion_reasoning(query, context, max_length)
+        elif self.reasoning_mode == ReasoningMode.COT_WITH_TOOLS:
+            reasoning, answer = self._cot_with_tools_reasoning(query, context, max_length)
+        else:
+            # Standard mode - use enhanced prompt with decoding strategy
+            context_text = "\n".join([f"- {ctx}" for ctx in context])
+            
+            prompt = f"""You are an expert fire evacuation safety advisor. Use the following context about the building's fire safety status to answer the question.
+
+CONTEXT:
+{context_text}
+
+QUESTION: {query}
+
+Provide a clear, safety-focused answer based on the context. If the context doesn't contain enough information, say so.
+
+ANSWER:"""
+            
+            answer = self._generate_with_decoding_strategy(prompt, max_length)
+            reasoning = f"Standard reasoning mode - Direct answer generation.\n\n{answer}"
+        
+        if return_reasoning:
+            return reasoning, answer
+        return answer
+    
+    def set_reasoning_mode(self, mode: ReasoningMode):
+        """Set the reasoning mode for future queries"""
+        self.reasoning_mode = mode
+        print(f"[OK] Reasoning mode set to: {mode.value}")
+    
+    def set_decoding_strategy(self, strategy: DecodingStrategy):
+        """Set the decoding strategy for future queries"""
+        self.decoding_strategy = strategy
+        print(f"[OK] Decoding strategy set to: {strategy.value}")
+    
+    def query(self, question: str, k: int = 3, reasoning_mode: Optional[ReasoningMode] = None, 
+              show_reasoning: bool = True) -> Dict[str, Any]:
+        """
+        Complete RAG query: retrieve context and generate response with advanced reasoning
+        
+        Args:
+            question: User question
+            k: Number of context documents to retrieve
+            reasoning_mode: Optional override for reasoning mode (uses instance default if None)
+            show_reasoning: If True, includes full reasoning steps in response
+            
+        Returns:
+            Dictionary with answer, context, metadata, reasoning information, and reasoning steps
+        """
+        # Retrieve relevant context
+        search_results = self.search(question, k=k)
+        
+        # Generate response with reasoning
+        context = [r["document"] for r in search_results]
+        
+        # Temporarily override reasoning mode if provided
+        original_mode = self.reasoning_mode
+        if reasoning_mode is not None:
+            self.reasoning_mode = reasoning_mode
+        
+        try:
+            reasoning, answer = self.generate_response(question, context, return_reasoning=True)
+        finally:
+            # Restore original mode
+            self.reasoning_mode = original_mode
+        
+        result = {
+            "question": question,
+            "answer": answer,
+            "context": context,
+            "reasoning_mode": self.reasoning_mode.value,
+            "decoding_strategy": self.decoding_strategy.value,
+            "sources": [
+                {
+                    "type": r["metadata"].get("type"),
+                    "room_id": r["metadata"].get("room_id"),
+                    "route_id": r["metadata"].get("route_id"),
+                    "relevance_score": 1.0 / (1.0 + r["distance"])
+                }
+                for r in search_results
+            ]
+        }
+        
+        if show_reasoning:
+            result["reasoning_steps"] = reasoning
+        
+        return result
+    
+    def save_index(self, index_path: str, metadata_path: str):
+        """Save FAISS index and metadata"""
+        if self.index:
+            faiss.write_index(self.index, index_path)
+            with open(metadata_path, 'wb') as f:
+                pickle.dump({
+                    "documents": self.documents,
+                    "metadata": self.metadata
+                }, f)
+            print(f"[OK] Saved index to {index_path} and metadata to {metadata_path}")
+    
+    def load_index(self, index_path: str, metadata_path: str):
+        """Load FAISS index and metadata"""
+        self.index = faiss.read_index(index_path)
+        with open(metadata_path, 'rb') as f:
+            data = pickle.load(f)
+            self.documents = data["documents"]
+            self.metadata = data["metadata"]
+        print(f"[OK] Loaded index with {self.index.ntotal} vectors")
+    
+    def compare_reasoning_modes(self, question: str, k: int = 3) -> Dict[str, Any]:
+        """
+        Compare all reasoning modes for a given question
+        
+        Args:
+            question: User question
+            k: Number of context documents to retrieve
+            
+        Returns:
+            Dictionary with answers from all reasoning modes
+        """
+        # Retrieve context once
+        search_results = self.search(question, k=k)
+        context = [r["document"] for r in search_results]
+        
+        results = {
+            "question": question,
+            "context": context,
+            "sources": [
+                {
+                    "type": r["metadata"].get("type"),
+                    "room_id": r["metadata"].get("room_id"),
+                    "route_id": r["metadata"].get("route_id"),
+                    "relevance_score": 1.0 / (1.0 + r["distance"])
+                }
+                for r in search_results
+            ],
+            "answers": {}
+        }
+        
+        # Save original mode
+        original_mode = self.reasoning_mode
+        
+        # Test each reasoning mode
+        for mode in ReasoningMode:
+            try:
+                self.reasoning_mode = mode
+                reasoning, answer = self.generate_response(question, context, return_reasoning=True)
+                results["answers"][mode.value] = {
+                    "answer": answer,
+                    "reasoning": reasoning,
+                    "length": len(answer)
+                }
+            except Exception as e:
+                results["answers"][mode.value] = {
+                    "error": str(e)
+                }
+        
+        # Restore original mode
+        self.reasoning_mode = original_mode
+        
+        return results
+
+
+def main():
+    """Main function to set up and demonstrate the RAG system"""
+    # ========== Configuration ==========
+    USE_UNSLOTH = True  # Set to True for fastest loading (requires: pip install unsloth)
+    USE_8BIT = False    # Set to True for 8-bit quantization (alternative to Unsloth)
+    
+    # Unsloth model options:
+    # - "unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit" (pre-quantized, requires bitsandbytes)
+    # - "unsloth/Meta-Llama-3.1-8B-Instruct" (non-quantized, no bitsandbytes needed)
+    # - "unsloth/Llama-3.1-8B-Instruct" (alternative non-quantized)
+    # Note: Using non-quantized model by default to avoid bitsandbytes requirement
+    UNSLOTH_MODEL = "unsloth/Meta-Llama-3.1-8B-Instruct"  # Non-quantized (no bitsandbytes needed)
+    # ====================================
+    
+    print("="*80)
+    print("Fire Evacuation RAG System - Llama + FAISS")
+    print("="*80)
+    print()
+    
+    # Step 1: Create fire evacuation system
+    print("Step 1: Creating fire evacuation system...")
+    floor_plan = create_sample_floor_plan()
+    sensor_system = create_sample_fire_scenario(floor_plan)
+    pathfinder = PathFinder(floor_plan, sensor_system)
+    print("[OK] System initialized")
+    print()
+    
+    # Step 2: Export data to JSON
+    print("Step 2: Exporting data to JSON...")
+    exporter = FireEvacuationDataExporter(floor_plan, sensor_system, pathfinder)
+    json_path = "fire_evacuation_data.json"
+    json_data = exporter.export_to_json(json_path, start_location="R1")
+    print()
+    
+    # Step 3: Initialize RAG system
+    print("Step 3: Initializing RAG system...")
+    # Model will be saved in ./models/ directory
+    
+    if USE_UNSLOTH:
+        # Unsloth loading (FASTEST - recommended!)
+        # Install with: pip install unsloth
+        # Note: If you get bitsandbytes error, either:
+        #   1. Install bitsandbytes: pip install bitsandbytes
+        #   2. Use a non-quantized model: "unsloth/Meta-Llama-3.1-8B-Instruct" (without -bnb-4bit)
+        #   3. Set USE_UNSLOTH=False to use standard loading
+        print("[*] Using Unsloth for fast model loading...")
+        
+        rag = FireEvacuationRAG(
+            model_name=UNSLOTH_MODEL,
+            model_dir="./models",
+            use_unsloth=True,      # Enable Unsloth for fast loading
+            load_in_4bit=False,    # Set to False for pre-quantized models (they're already quantized)
+            max_seq_length=2048,   # Maximum sequence length
+            reasoning_mode=ReasoningMode.CHAIN_OF_THOUGHT,  # Use CoT by default
+            decoding_strategy=DecodingStrategy.NUCLEUS      # Use nucleus sampling by default
+        )
+    else:
+        # Standard loading (slower but more compatible)
+        print("Using standard model loading...")
+        rag = FireEvacuationRAG(
+            model_name="nvidia/Llama-3.1-Minitron-4B-Width-Base",
+            model_dir="./models",
+            use_8bit=USE_8BIT,
+            reasoning_mode=ReasoningMode.CHAIN_OF_THOUGHT,  # Use CoT by default
+            decoding_strategy=DecodingStrategy.NUCLEUS      # Use nucleus sampling by default
+        )
+    
+    # Download model
+    rag.download_model()
+    print()
+    
+    # Load embedder
+    rag.load_embedder()
+    print()
+    
+    # Step 4: Build FAISS index
+    print("Step 4: Building FAISS index...")
+    rag.build_index_from_json(json_data)
+    print()
+    
+    # Step 5: Save index
+    print("Step 5: Saving index...")
+    rag.save_index("faiss_index.idx", "faiss_metadata.pkl")
+    print()
+    
+    # Step 6: Interactive Fire Evacuation Query System
+    print("="*80)
+    print("[FIRE] FIRE EVACUATION RESCUE SYSTEM - INTERACTIVE MODE")
+    print("="*80)
+    print()
+    print("You are now connected to the Fire Evacuation RAG System.")
+    print("Ask questions about evacuation routes, building safety, and emergency situations.")
+    print()
+    print("Example questions you can ask:")
+    print("  - 'What is the safest evacuation route from R1?'")
+    print("  - 'Which rooms have fire detected?'")
+    print("  - 'Are there any oxygen cylinders near fire?'")
+    print("  - 'What is the danger level in room R2?'")
+    print("  - 'Which exits are blocked?'")
+    print("  - 'Show me all passable routes from R3'")
+    print("  - 'What rooms have high carbon monoxide levels?'")
+    print("  - 'Find the route with lowest danger score'")
+    print()
+    print("Commands:")
+    print("  - Type 'help' to see example questions")
+    print("  - Type 'status' to see building status summary")
+    print("  - Type 'mode' to see/change reasoning mode")
+    print("  - Type 'decode' to see/change decoding strategy")
+    print("  - Type 'compare' to compare all reasoning modes for your question")
+    print("  - Type 'quit' or 'exit' to exit")
+    print()
+    print("Reasoning Modes Available:")
+    print("  - standard: Basic prompt-based generation")
+    print("  - chain_of_thought: Step-by-step reasoning (CoT)")
+    print("  - tree_of_thoughts: Multiple reasoning paths (ToT)")
+    print("  - reflexion: Self-reflection and improvement")
+    print("  - cot_with_tools: CoT with tool integration")
+    print()
+    print("Decoding Strategies Available:")
+    print("  - greedy: Deterministic, highest probability")
+    print("  - sampling: Random sampling with temperature")
+    print("  - beam_search: Explores multiple paths")
+    print("  - nucleus: Top-p (nucleus) sampling")
+    print("  - temperature: Temperature-based sampling")
+    print("="*80)
+    print()
+    
+    # Interactive question loop
+    while True:
+        try:
+            # Get user input
+            user_input = input("\n[ALERT] FIRE EVACUATION QUERY: ").strip()
+            
+            # Handle empty input
+            if not user_input:
+                continue
+            
+            # Handle exit commands
+            if user_input.lower() in ['quit', 'exit', 'q']:
+                print("\n[OK] Exiting Fire Evacuation System. Stay safe!")
+                break
+            
+            # Handle help command
+            if user_input.lower() == 'help':
+                print("\n[HELP] Example Questions:")
+                print("  - What is the safest evacuation route from [room_id]?")
+                print("  - Which rooms have fire detected?")
+                print("  - Are there any oxygen cylinders near fire?")
+                print("  - What is the danger level in room [room_id]?")
+                print("  - Which exits are blocked?")
+                print("  - Show me all passable routes from [room_id]")
+                print("  - What rooms have high carbon monoxide levels?")
+                print("  - Find the route with lowest danger score")
+                print("  - Which rooms are not passable?")
+                print("  - What is the temperature in room [room_id]?")
+                print("  - Are there any flashover risks?")
+                print("  - Which routes avoid fire zones?")
+                continue
+            
+            # Handle status command
+            if user_input.lower() == 'status':
+                print("\n[STATUS] Building Status Summary:")
+                print(f"  - Total rooms indexed: {len(rag.documents)}")
+                print(f"  - FAISS index size: {rag.index.ntotal if rag.index else 0} vectors")
+                print(f"  - Model: {rag.model_name}")
+                print(f"  - Model loaded: {'[OK]' if rag.pipe else '✗'}")
+                print(f"  - Embedder loaded: {'[OK]' if rag.embedder else '✗'}")
+                print(f"  - Index built: {'[OK]' if rag.index else '✗'}")
+                print(f"  - Current reasoning mode: {rag.reasoning_mode.value}")
+                print(f"  - Current decoding strategy: {rag.decoding_strategy.value}")
+                continue
+            
+            # Handle mode command
+            if user_input.lower() == 'mode':
+                print("\n[REASONING MODES] Available modes:")
+                for mode in ReasoningMode:
+                    current = " (current)" if rag.reasoning_mode == mode else ""
+                    print(f"  - {mode.value}{current}")
+                print("\nTo change mode, type: mode <mode_name>")
+                print("Example: mode chain_of_thought")
+                continue
+            
+            # Handle mode change
+            if user_input.lower().startswith('mode '):
+                mode_name = user_input.lower().replace('mode ', '').strip()
+                try:
+                    new_mode = ReasoningMode(mode_name)
+                    rag.set_reasoning_mode(new_mode)
+                except ValueError:
+                    print(f"[ERROR] Invalid mode: {mode_name}")
+                    print("Valid modes: standard, chain_of_thought, tree_of_thoughts, reflexion, cot_with_tools")
+                continue
+            
+            # Handle decode command
+            if user_input.lower() == 'decode':
+                print("\n[DECODING STRATEGIES] Available strategies:")
+                for strategy in DecodingStrategy:
+                    current = " (current)" if rag.decoding_strategy == strategy else ""
+                    print(f"  - {strategy.value}{current}")
+                print("\nTo change strategy, type: decode <strategy_name>")
+                print("Example: decode nucleus")
+                continue
+            
+            # Handle decode change
+            if user_input.lower().startswith('decode '):
+                strategy_name = user_input.lower().replace('decode ', '').strip()
+                try:
+                    new_strategy = DecodingStrategy(strategy_name)
+                    rag.set_decoding_strategy(new_strategy)
+                except ValueError:
+                    print(f"[ERROR] Invalid strategy: {strategy_name}")
+                    print("Valid strategies: greedy, sampling, beam_search, nucleus, temperature")
+                continue
+            
+            # Handle compare command
+            if user_input.lower() == 'compare':
+                print("\n[COMPARE] Enter a question to compare all reasoning modes:")
+                compare_question = input("Question: ").strip()
+                if compare_question:
+                    print("\n🔍 Comparing all reasoning modes...")
+                    print("-" * 80)
+                    comparison = rag.compare_reasoning_modes(compare_question, k=3)
+                    
+                    print(f"\n[QUESTION] {comparison['question']}")
+                    print("\n[COMPARISON] Answers from different reasoning modes:\n")
+                    
+                    for mode_name, mode_result in comparison['answers'].items():
+                        print(f"--- {mode_name.upper()} ---")
+                        if 'error' in mode_result:
+                            print(f"Error: {mode_result['error']}")
+                        else:
+                            print(f"Length: {mode_result['length']} characters")
+                            print(f"Answer: {mode_result['answer'][:200]}...")
+                        print()
+                    
+                    print("-" * 80)
+                continue
+            
+            # Process the query
+            print("\n🔍 Searching evacuation data and generating response...")
+            print("-" * 80)
+            
+            result = rag.query(user_input, k=3)
+            
+            # Display reasoning info
+            print(f"\n[REASONING] Mode: {result.get('reasoning_mode', 'N/A')} | Strategy: {result.get('decoding_strategy', 'N/A')}")
+            
+            # Display reasoning steps if available
+            if 'reasoning_steps' in result and result.get('reasoning_steps'):
+                print(f"\n[REASONING STEPS] Step-by-step reasoning process:")
+                print("=" * 80)
+                # Format and display reasoning steps
+                reasoning_text = result['reasoning_steps']
+                
+                # Clean up reasoning text - remove verbose parts
+                if "However, please note" in reasoning_text:
+                    reasoning_text = reasoning_text.split("However, please note")[0]
+                if "Additionally," in reasoning_text:
+                    reasoning_text = reasoning_text.split("Additionally,")[0]
+                if "Let me know" in reasoning_text:
+                    reasoning_text = reasoning_text.split("Let me know")[0]
+                
+                # Parse and format reasoning based on mode
+                if result.get('reasoning_mode') == 'chain_of_thought':
+                    # CoT format - look for numbered steps or reasoning sections
+                    lines = [l.strip() for l in reasoning_text.split('\n') if l.strip()]
+                    displayed_lines = []
+                    for line in lines:
+                        # Stop at ANSWER or verbose markers
+                        if any(marker in line.upper() for marker in ['ANSWER', 'HOWEVER', 'ADDITIONALLY', 'LET ME KNOW']):
+                            break
+                        # Show numbered steps or key reasoning lines
+                        if (line.startswith(('1.', '2.', '3.', '4.', '5.', 'Step', 'STEP', '-')) or 
+                            any(keyword in line.lower() for keyword in ['analyze', 'identify', 'evaluate', 'conclude', 'risk', 'safety', 'danger'])):
+                            displayed_lines.append(line)
+                    
+                    if displayed_lines:
+                        for line in displayed_lines[:10]:  # Limit to 10 lines
+                            print(f"  {line}")
+                    else:
+                        # Fallback: show first few meaningful lines
+                        meaningful = [l for l in lines[:5] if len(l) > 20 and not l.startswith('ANSWER')]
+                        for line in meaningful:
+                            print(f"  {line}")
+                
+                elif result.get('reasoning_mode') == 'tree_of_thoughts':
+                    # ToT format - show approaches and evaluation
+                    lines = reasoning_text.split('\n')
+                    in_section = False
+                    for line in lines:
+                        line = line.strip()
+                        if not line:
+                            if in_section:
+                                print()  # Add spacing
+                            continue
+                        if line.startswith("APPROACH"):
+                            print(f"\n  🔍 {line}")
+                            in_section = True
+                        elif line.startswith("EVALUATION"):
+                            print(f"\n  ✅ {line}")
+                            in_section = True
+                        else:
+                            if line and not line.startswith("---"):
+                                print(f"     {line}")
+                
+                elif result.get('reasoning_mode') == 'reflexion':
+                    # Reflexion format - show iterations
+                    lines = reasoning_text.split('\n')
+                    for line in lines:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        if line.startswith("INITIAL ANSWER"):
+                            print(f"\n  📝 {line}")
+                        elif line.startswith("ITERATION"):
+                            print(f"\n  🔄 {line}")
+                        elif line.startswith("REFLECTION"):
+                            print(f"  💭 {line}")
+                        else:
+                            if line and not line.startswith("---"):
+                                print(f"     {line}")
+                
+                elif result.get('reasoning_mode') == 'cot_with_tools':
+                    # CoT with Tools format
+                    lines = reasoning_text.split('\n')
+                    for line in lines:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        if line.startswith("TOOL CALL"):
+                            print(f"\n  🔧 {line}")
+                        elif line.startswith("REASONING WITH TOOLS"):
+                            print(f"\n  🧠 {line}")
+                        else:
+                            if line and not line.startswith("---"):
+                                print(f"     {line}")
+                
+                else:
+                    # Standard or fallback: display with basic formatting
+                    lines = reasoning_text.split('\n')
+                    for line in lines:
+                        line = line.strip()
+                        if line:
+                            print(f"  {line}")
+                
+                print("=" * 80)
+            
+            # Display answer
+            print(f"\n[ANSWER] FINAL ANSWER:")
+            print(result['answer'])
+            
+            # Display sources
+            print(f"\n[SOURCES] SOURCES ({len(result['sources'])} relevant documents found):")
+            for i, source in enumerate(result['sources'], 1):
+                source_type = source.get('type', 'N/A')
+                room_id = source.get('room_id', 'N/A')
+                route_id = source.get('route_id', 'N/A')
+                relevance = source.get('relevance_score', 0)
+                
+                if source_type == 'room':
+                    print(f"  {i}. Room: {room_id} (Relevance: {relevance:.2f})")
+                elif source_type == 'route':
+                    print(f"  {i}. Route: {route_id} (Relevance: {relevance:.2f})")
+                else:
+                    print(f"  {i}. {source_type} (Relevance: {relevance:.2f})")
+            
+            print("-" * 80)
+            
+        except KeyboardInterrupt:
+            print("\n\n[OK] Exiting Fire Evacuation System. Stay safe!")
+            break
+        except Exception as e:
+            print(f"\n[ERROR] Error processing query: {e}")
+            print("Please try again or type 'help' for examples.")
+    
+    print("\n" + "="*80)
+    print("Fire Evacuation System session ended.")
+    print("="*80)
+
+
+if __name__ == "__main__":
+    main()
+

llm_route_decider.py

@@ -0,0 +1,183 @@
+"""
+Realtime LLM-based route decision script for mock sensor data streams.
+
+Designed to run outside the main project. It reads sensor payloads (JSON per line),
+formats a prompt for a Llama-family model (e.g., via Ollama), and logs the AI's
+route recommendation plus warnings/actions for each update.
+"""
+import argparse
+import json
+import sys
+import textwrap
+import time
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+
+import requests
+
+
+PROMPT_TEMPLATE = """You are an emergency evacuation strategist using live sensor and route telemetry.
+Evaluate the candidate routes and choose the safest *passable* option.
+
+Decision rules:
+1. Reject any route marked passable=false or containing simultaneous fire and oxygen-cylinder hazards.
+2. Avoid rooms with biohazard alerts unless respirators are available; penalize heavily if no PPE.
+3. Prefer routes with lower average danger and lower max danger; break ties by shorter path_length.
+4. Flag any oxygen cylinders near heat (>40°C) or fire for operator intervention.
+5. Provide backup route only if it is passable and within 15 danger points of the best route.
+
+Data:
+{data}
+
+Respond in JSON with this schema:
+{{
+  "recommended_route": "<route_id>",
+  "confidence": "high|medium|low",
+  "warnings": ["..."],
+  "actions": ["..."],
+  "backup_route": "<route_id or null>"
+}}
+
+If no safe route exists, set recommended_route=null and explain why in warnings.
+"""
+
+
+def load_event_stream(path: Path):
+    """Yield parsed JSON objects from a file (one JSON object per line)."""
+    with path.open("r", encoding="utf-8") as f:
+        for line_num, line in enumerate(f, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSON on line {line_num}: {exc}") from exc
+
+
+def format_payload(event: Dict[str, Any]) -> str:
+    """Pretty-print the incoming event for the LLM prompt."""
+    return json.dumps(event, indent=2, ensure_ascii=False)
+
+
+def call_llm(model: str, prompt: str, server_url: str) -> str:
+    """
+    Call a Llama-family model via Ollama (or any compatible endpoint).
+
+    server_url defaults to http://localhost:11434/api/generate.
+    """
+    payload = {
+        "model": model,
+        "prompt": prompt,
+        "stream": False,
+    }
+    response = requests.post(server_url, json=payload, timeout=120)
+    response.raise_for_status()
+    data = response.json()
+
+    # Ollama returns {"response": "...", "done": true, ...}
+    if "response" in data:
+        return data["response"]
+    # Fallback for other APIs
+    return data.get("text") or json.dumps(data)
+
+
+def parse_llm_output(text_output: str) -> Dict[str, Any]:
+    """Attempt to parse the LLM JSON; fall back to error record."""
+    text_output = text_output.strip()
+    try:
+        return json.loads(text_output)
+    except json.JSONDecodeError:
+        return {
+            "recommended_route": None,
+            "confidence": "low",
+            "warnings": ["LLM returned non-JSON output", text_output],
+            "actions": [],
+            "backup_route": None,
+        }
+
+
+def process_event(event: Dict[str, Any], args) -> Dict[str, Any]:
+    """Send single event to LLM and return structured decision."""
+    payload_str = format_payload(event)
+    prompt = PROMPT_TEMPLATE.format(data=payload_str)
+    raw_output = call_llm(args.model, prompt, args.server_url)
+    decision = parse_llm_output(raw_output)
+    return {
+        "timestamp": event.get("timestamp_sec"),
+        "decision": decision,
+        "raw_prompt": prompt if args.debug else None,
+        "raw_output": raw_output if args.debug else None,
+    }
+
+
+def log_decision(result: Dict[str, Any]):
+    """Print a concise summary to stdout."""
+    decision = result["decision"]
+    ts = result["timestamp"]
+    header = f"[t={ts}s]" if ts is not None else "[t=?]"
+    print(f"{header} recommended_route={decision.get('recommended_route')} "
+          f"confidence={decision.get('confidence')}")
+    if decision.get("warnings"):
+        print("  warnings:")
+        for warning in decision["warnings"]:
+            wrapped = textwrap.fill(warning, width=78, subsequent_indent="    ")
+            print(f"    - {wrapped}")
+    if decision.get("actions"):
+        print("  actions:")
+        for action in decision["actions"]:
+            wrapped = textwrap.fill(action, width=78, subsequent_indent="    ")
+            print(f"    - {wrapped}")
+    if decision.get("backup_route"):
+        print(f"  backup_route: {decision['backup_route']}")
+    print()
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Stream sensor events to a Llama model for route decisions.")
+    parser.add_argument("--input", required=True,
+                        help="Path to JSONL file containing mock sensor events.")
+    parser.add_argument("--model", default="llama3",
+                        help="Model name served by Ollama (default: llama3).")
+    parser.add_argument("--server-url", default="http://localhost:11434/api/generate",
+                        help="Generation endpoint URL.")
+    parser.add_argument("--delay", type=float, default=0.0,
+                        help="Seconds to wait between events (simulate realtime).")
+    parser.add_argument("--debug", action="store_true",
+                        help="Print raw prompt/output for troubleshooting.")
+    return parser
+
+
+def main(argv: Optional[List[str]] = None):
+    parser = build_arg_parser()
+    args = parser.parse_args(argv)
+
+    input_path = Path(args.input)
+    if not input_path.exists():
+        parser.error(f"Input file not found: {input_path}")
+
+    try:
+        for event in load_event_stream(input_path):
+            result = process_event(event, args)
+            log_decision(result)
+
+            if args.debug:
+                print("----- RAW PROMPT -----")
+                print(result["raw_prompt"])
+                print("----- RAW OUTPUT -----")
+                print(result["raw_output"])
+                print("----------------------\n")
+
+            if args.delay > 0:
+                time.sleep(args.delay)
+    except KeyboardInterrupt:
+        print("\nInterrupted by user.", file=sys.stderr)
+    except Exception as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+

pathfinding.py

@@ -0,0 +1,367 @@
+"""
+Pathfinding and Risk Assessment Module
+Uses A* algorithm with custom risk-based heuristics
+"""
+import heapq
+from typing import Dict, List, Tuple, Optional
+from .floor_plan import FloorPlan
+from .sensor_system import SensorSystem, SensorReading
+
+
+class PathNode:
+    """Node for pathfinding algorithm"""
+    def __init__(self, room_id: str, g_cost: float, h_cost: float, parent=None):
+        self.room_id = room_id
+        self.g_cost = g_cost  # Cost from start
+        self.h_cost = h_cost  # Heuristic cost to goal
+        self.f_cost = g_cost + h_cost  # Total cost
+        self.parent = parent
+        
+    def __lt__(self, other):
+        return self.f_cost < other.f_cost
+    
+    def __eq__(self, other):
+        return self.room_id == other.room_id
+
+
+class RiskAssessment:
+    """Assesses risk for different evacuation routes"""
+    
+    @staticmethod
+    def calculate_path_risk(path: List[str], sensor_system: SensorSystem, 
+                           floor_plan: FloorPlan) -> Dict:
+        """
+        Calculate comprehensive risk assessment for a path
+        
+        Returns dict with:
+        - total_danger: Overall danger score
+        - max_danger: Maximum danger point
+        - avg_danger: Average danger
+        - has_fire: Whether path goes through fire
+        - has_oxygen_hazard: Whether path has oxygen cylinder
+        - passable: Whether path is passable
+        - risk_factors: List of specific risks
+        """
+        if not path:
+            return {"passable": False, "total_danger": 100.0}
+        
+        danger_scores = []
+        risk_factors = []
+        has_fire = False
+        has_oxygen_hazard = False
+        max_danger_location = None
+        max_danger_score = 0.0
+        
+        for room_id in path:
+            sensor = sensor_system.get_sensor_reading(room_id)
+            room = floor_plan.get_room(room_id)
+            
+            if sensor:
+                danger = sensor.calculate_danger_score()
+                danger_scores.append(danger)
+                
+                if danger > max_danger_score:
+                    max_danger_score = danger
+                    max_danger_location = room_id
+                
+                # Check specific hazards
+                if sensor.fire_detected:
+                    has_fire = True
+                    risk_factors.append(f"Fire detected in {room_id}")
+                
+                if room and room.has_oxygen_cylinder:
+                    has_oxygen_hazard = True
+                    # Increase danger if there's heat near oxygen
+                    if sensor.temperature > 40 or sensor.fire_detected:
+                        danger_scores[-1] += 15  # Add explosion risk
+                        risk_factors.append(f"Oxygen cylinder explosion risk in {room_id}")
+                    else:
+                        risk_factors.append(f"Oxygen cylinder present in {room_id}")
+                
+                if sensor.smoke_level > 0.5:
+                    risk_factors.append(f"Heavy smoke in {room_id}")
+                
+                if sensor.temperature > 60:
+                    risk_factors.append(f"High temperature ({sensor.temperature:.1f}°C) in {room_id}")
+                
+                if sensor.oxygen_level < 19.5:
+                    risk_factors.append(f"Low oxygen ({sensor.oxygen_level:.1f}%) in {room_id}")
+                
+                # NEW: Toxic gas warnings
+                if sensor.carbon_monoxide > 50:
+                    risk_factors.append(f"TOXIC CO ({sensor.carbon_monoxide:.0f} ppm) in {room_id}")
+                if sensor.carbon_dioxide > 5000:
+                    risk_factors.append(f"High CO2 ({sensor.carbon_dioxide:.0f} ppm) in {room_id}")
+                if sensor.hydrogen_cyanide > 20:
+                    risk_factors.append(f"TOXIC HCN ({sensor.hydrogen_cyanide:.1f} ppm) in {room_id}")
+                
+                # NEW: Flashover/backdraft warnings
+                if sensor.flashover_risk > 0.7:
+                    risk_factors.append(f"CRITICAL: Flashover risk ({sensor.flashover_risk*100:.0f}%) in {room_id}")
+                if sensor.backdraft_risk > 0.6:
+                    risk_factors.append(f"CRITICAL: Backdraft risk ({sensor.backdraft_risk*100:.0f}%) in {room_id}")
+                
+                # NEW: Crowd density warnings
+                if sensor.occupancy_density > 0.8:
+                    risk_factors.append(f"High crowd density ({sensor.occupancy_density*100:.0f}%) in {room_id}")
+                
+                # NEW: Infrastructure failures
+                if not sensor.exit_accessible:
+                    risk_factors.append(f"Exit BLOCKED in {room_id}")
+                if not sensor.stairwell_clear:
+                    risk_factors.append(f"Stairwell BLOCKED in {room_id}")
+                if not sensor.emergency_lighting:
+                    risk_factors.append(f"No emergency lighting in {room_id}")
+                
+                # NEW: Time pressure
+                if sensor.time_since_fire_start > 300:
+                    risk_factors.append(f"Time pressure: {sensor.time_since_fire_start//60} min elapsed")
+                
+                if not sensor.is_passable():
+                    risk_factors.append(f"Path blocked at {room_id}")
+        
+        total_danger = sum(danger_scores)
+        avg_danger = total_danger / len(danger_scores) if danger_scores else 0
+        
+        # Check if all segments are passable
+        passable = all(sensor_system.get_sensor_reading(rid).is_passable() 
+                      for rid in path if sensor_system.get_sensor_reading(rid))
+        
+        return {
+            "total_danger": total_danger,
+            "max_danger": max_danger_score,
+            "max_danger_location": max_danger_location,
+            "avg_danger": avg_danger,
+            "path_length": len(path),
+            "has_fire": has_fire,
+            "has_oxygen_hazard": has_oxygen_hazard,
+            "passable": passable,
+            "risk_factors": risk_factors,
+            "danger_scores": danger_scores
+        }
+    
+    @staticmethod
+    def get_risk_level(avg_danger: float) -> str:
+        """Get risk level description"""
+        if avg_danger < 20:
+            return "LOW"
+        elif avg_danger < 40:
+            return "MODERATE"
+        elif avg_danger < 60:
+            return "HIGH"
+        else:
+            return "CRITICAL"
+    
+    @staticmethod
+    def recommend_path(paths: List[Tuple[List[str], Dict]]) -> Optional[Tuple[List[str], Dict]]:
+        """
+        Recommend the best path based on risk assessment
+        
+        Args:
+            paths: List of (path, risk_assessment) tuples
+        
+        Returns:
+            Best (path, risk_assessment) tuple or None
+        """
+        if not paths:
+            return None
+        
+        # Filter to only passable paths
+        passable_paths = [(p, r) for p, r in paths if r["passable"]]
+        
+        if not passable_paths:
+            # No fully passable paths, return least dangerous
+            return min(paths, key=lambda x: x[1]["total_danger"])
+        
+        # Score each path (lower is better)
+        def score_path(path_info):
+            path, risk = path_info
+            score = 0
+            
+            # Heavily penalize fire
+            if risk["has_fire"]:
+                score += 100
+            
+            # Add oxygen hazard risk (but less than fire)
+            if risk["has_oxygen_hazard"]:
+                score += 30
+            
+            # Add danger scores
+            score += risk["total_danger"]
+            
+            # Prefer shorter paths (slight preference)
+            score += risk["path_length"] * 2
+            
+            # Penalize high max danger points
+            score += risk["max_danger"] * 0.5
+            
+            return score
+        
+        # Return path with lowest score
+        return min(passable_paths, key=score_path)
+
+
+class PathFinder:
+    """Find optimal evacuation paths using A* algorithm with risk assessment"""
+    
+    def __init__(self, floor_plan: FloorPlan, sensor_system: SensorSystem):
+        self.floor_plan = floor_plan
+        self.sensor_system = sensor_system
+        
+    def find_all_evacuation_routes(self, start: str) -> List[Tuple[str, List[str], Dict]]:
+        """
+        Find evacuation routes to all exits
+        
+        Returns: List of (exit_id, path, risk_assessment) tuples
+        """
+        routes = []
+        exits = self.floor_plan.get_all_exits()
+        
+        for exit_id in exits:
+            path = self.find_path(start, exit_id)
+            if path:
+                risk = RiskAssessment.calculate_path_risk(
+                    path, self.sensor_system, self.floor_plan
+                )
+                routes.append((exit_id, path, risk))
+        
+        return routes
+    
+    def find_path(self, start: str, goal: str) -> Optional[List[str]]:
+        """
+        Find path from start to goal using A* with risk-based costs
+        
+        Returns: List of room IDs representing the path, or None if no path exists
+        """
+        if start not in self.floor_plan.rooms or goal not in self.floor_plan.rooms:
+            return None
+        
+        # Priority queue: (f_cost, node)
+        open_set = []
+        closed_set = set()
+        
+        # Initialize start node
+        start_node = PathNode(start, 0, self._heuristic(start, goal))
+        heapq.heappush(open_set, start_node)
+        
+        # Track best g_cost for each room
+        g_costs = {start: 0}
+        
+        while open_set:
+            current = heapq.heappop(open_set)
+            
+            # Goal reached
+            if current.room_id == goal:
+                return self._reconstruct_path(current)
+            
+            # Skip if already processed
+            if current.room_id in closed_set:
+                continue
+            
+            closed_set.add(current.room_id)
+            
+            # Explore neighbors
+            neighbors = self.floor_plan.get_neighbors(current.room_id)
+            for neighbor_id, base_distance in neighbors:
+                if neighbor_id in closed_set:
+                    continue
+                
+                # Calculate risk-adjusted cost
+                risk_cost = self._calculate_risk_cost(neighbor_id)
+                tentative_g = current.g_cost + base_distance + risk_cost
+                
+                # If this path is better, add to open set
+                if neighbor_id not in g_costs or tentative_g < g_costs[neighbor_id]:
+                    g_costs[neighbor_id] = tentative_g
+                    h_cost = self._heuristic(neighbor_id, goal)
+                    neighbor_node = PathNode(neighbor_id, tentative_g, h_cost, current)
+                    heapq.heappush(open_set, neighbor_node)
+        
+        # No path found
+        return None
+    
+    def _heuristic(self, room_id1: str, room_id2: str) -> float:
+        """
+        Heuristic function for A* (Manhattan distance between room positions)
+        """
+        room1 = self.floor_plan.get_room(room_id1)
+        room2 = self.floor_plan.get_room(room_id2)
+        
+        if not room1 or not room2:
+            return 0
+        
+        x1, y1 = room1.position
+        x2, y2 = room2.position
+        
+        return abs(x2 - x1) + abs(y2 - y1)
+    
+    def _calculate_risk_cost(self, room_id: str) -> float:
+        """
+        Calculate risk-based cost for traversing a room with all real-world factors
+        Higher danger = higher cost
+        """
+        sensor = self.sensor_system.get_sensor_reading(room_id)
+        if not sensor:
+            return 0.0
+        
+        danger_score = sensor.calculate_danger_score()
+        
+        # Convert danger score to cost multiplier
+        # Danger 0-20: minimal cost
+        # Danger 20-50: moderate cost
+        # Danger 50+: high cost
+        risk_cost = danger_score / 10.0
+        
+        # Extra penalty for fire
+        if sensor.fire_detected:
+            risk_cost += 20.0
+        
+        # Extra penalty for oxygen cylinder in dangerous conditions
+        room = self.floor_plan.get_room(room_id)
+        if room and room.has_oxygen_cylinder:
+            if sensor.temperature > 40 or sensor.fire_detected:
+                risk_cost += 10.0
+        
+        # NEW: Extra penalties for critical factors
+        # Toxic gas penalty
+        if sensor.carbon_monoxide > 50:
+            risk_cost += 15.0
+        if sensor.carbon_dioxide > 5000:
+            risk_cost += 10.0
+        
+        # Flashover risk penalty
+        if sensor.flashover_risk > 0.7:
+            risk_cost += 25.0
+        elif sensor.flashover_risk > 0.5:
+            risk_cost += 15.0
+        
+        # Exit blockage penalty
+        if not sensor.exit_accessible:
+            risk_cost += 30.0
+        
+        if not sensor.stairwell_clear:
+            risk_cost += 20.0
+        
+        # Crowd density penalty (slows movement)
+        if sensor.occupancy_density > 0.8:
+            risk_cost += sensor.occupancy_density * 20.0
+        
+        # Infrastructure failure penalty
+        if not sensor.emergency_lighting:
+            risk_cost += 5.0
+        
+        # Make impassable areas very expensive (but not infinite)
+        if not sensor.is_passable():
+            risk_cost += 50.0
+        
+        return risk_cost
+    
+    def _reconstruct_path(self, node: PathNode) -> List[str]:
+        """Reconstruct path from goal node back to start"""
+        path = []
+        current = node
+        while current:
+            path.append(current.room_id)
+            current = current.parent
+        return list(reversed(path))
+

sensor_system.py

@@ -0,0 +1,439 @@
+"""
+Sensor System Module - Simulates and manages sensor data for fire, smoke, temperature, oxygen
+"""
+import random
+import numpy as np
+from typing import Dict, List
+from .floor_plan import FloorPlan
+
+
+class SensorReading:
+    """Represents sensor readings for a specific location"""
+    def __init__(self, location_id: str):
+        self.location_id = location_id
+        
+        # Basic factors (existing)
+        self.fire_detected = False
+        self.smoke_level = 0.0  # 0.0 to 1.0 (0 = no smoke, 1 = heavy smoke)
+        self.temperature = 20.0  # Celsius
+        self.oxygen_level = 21.0  # Percentage (normal is ~21%)
+        self.visibility = 100.0  # Percentage (100 = clear, 0 = no visibility)
+        self.structural_integrity = 100.0  # Percentage
+        
+        # NEW: Fire-specific factors
+        self.fire_growth_rate = 0.0  # m²/min
+        self.flashover_risk = 0.0  # 0.0 to 1.0
+        self.backdraft_risk = 0.0  # 0.0 to 1.0
+        self.heat_radiation = 0.0  # kW/m²
+        self.fire_type = "none"  # electrical, chemical, wood, etc.
+        
+        # NEW: Toxic gas detection
+        self.carbon_monoxide = 0.0  # ppm (normal < 9)
+        self.carbon_dioxide = 400.0  # ppm (normal ~400)
+        self.hydrogen_cyanide = 0.0  # ppm
+        self.hydrogen_chloride = 0.0  # ppm
+        
+        # NEW: Environmental factors
+        self.wind_direction = 0.0  # degrees
+        self.wind_speed = 0.0  # m/s
+        self.air_pressure = 1013.25  # hPa (normal)
+        self.humidity = 50.0  # Percentage
+        
+        # NEW: Human factors
+        self.occupancy_density = 0.0  # 0.0 to 1.0 (0 = empty, 1 = full)
+        self.mobility_limitations = 0  # Count of people with mobility issues
+        self.panic_level = 0.0  # 0.0 to 1.0
+        self.evacuation_progress = 0.0  # Percentage evacuated
+        
+        # NEW: Building infrastructure
+        self.sprinkler_active = False
+        self.emergency_lighting = True
+        self.elevator_available = True
+        self.stairwell_clear = True
+        self.exit_accessible = True
+        self.exit_capacity = 100  # people per minute
+        self.ventilation_active = True
+        
+        # NEW: Time-based factors
+        self.time_since_fire_start = 0  # seconds
+        self.estimated_time_to_exit = 0  # seconds
+        
+        # NEW: Communication
+        self.emergency_comm_working = True
+        self.wifi_signal_strength = 100.0  # Percentage
+        
+        # NEW: External factors
+        self.weather_temperature = 20.0  # Celsius
+        self.weather_rain = False
+        self.time_of_day = 12  # 0-23 hours
+        self.day_of_week = 1  # 0=Monday, 6=Sunday
+        
+    def calculate_danger_score(self) -> float:
+        """
+        Calculate enhanced danger score with all real-world factors
+        Returns: 0.0 (safe) to 100.0 (extremely dangerous)
+        """
+        score = 0.0
+        
+        # === BASIC FACTORS (Existing) ===
+        # Fire presence - highest priority
+        if self.fire_detected:
+            score += 40.0
+        
+        # Smoke level
+        score += self.smoke_level * 20.0
+        
+        # Temperature (dangerous above 60°C)
+        if self.temperature > 60:
+            score += min((self.temperature - 60) / 2, 20.0)
+        
+        # Low oxygen
+        if self.oxygen_level < 19.5:
+            score += (19.5 - self.oxygen_level) * 5.0
+        
+        # Visibility
+        score += (100 - self.visibility) * 0.1
+        
+        # Structural integrity
+        if self.structural_integrity < 80:
+            score += (100 - self.structural_integrity) * 0.2
+        
+        # === NEW: TOXIC GAS RISK ===
+        # Carbon Monoxide (deadly above 50 ppm)
+        if self.carbon_monoxide > 50:
+            score += min(self.carbon_monoxide / 5, 30.0)
+        elif self.carbon_monoxide > 9:
+            score += (self.carbon_monoxide - 9) * 0.5
+        
+        # Carbon Dioxide (dangerous above 5000 ppm)
+        if self.carbon_dioxide > 5000:
+            score += min((self.carbon_dioxide - 5000) / 200, 20.0)
+        
+        # Hydrogen Cyanide (deadly above 20 ppm)
+        if self.hydrogen_cyanide > 20:
+            score += min(self.hydrogen_cyanide * 1.5, 25.0)
+        
+        # Hydrogen Chloride (dangerous above 5 ppm)
+        if self.hydrogen_chloride > 5:
+            score += min(self.hydrogen_chloride * 2, 15.0)
+        
+        # === NEW: FLASHOVER RISK ===
+        if self.flashover_risk > 0.7:
+            score += 25.0
+        elif self.flashover_risk > 0.5:
+            score += 15.0
+        elif self.flashover_risk > 0.3:
+            score += 8.0
+        
+        # === NEW: BACKDRAFT RISK ===
+        if self.backdraft_risk > 0.6:
+            score += 20.0
+        elif self.backdraft_risk > 0.4:
+            score += 10.0
+        
+        # === NEW: CROWD DENSITY PENALTY ===
+        if self.occupancy_density > 0.8:
+            score += (self.occupancy_density - 0.8) * 75.0
+        elif self.occupancy_density > 0.6:
+            score += (self.occupancy_density - 0.6) * 30.0
+        
+        # === NEW: EXIT BLOCKAGE ===
+        if not self.exit_accessible:
+            score += 20.0
+        
+        if not self.stairwell_clear:
+            score += 15.0
+        
+        # === NEW: TIME PRESSURE ===
+        if self.time_since_fire_start > 300:  # 5 minutes
+            score += min((self.time_since_fire_start - 300) / 20, 15.0)
+        
+        # === NEW: INFRASTRUCTURE FAILURES ===
+        if not self.emergency_lighting:
+            score += 5.0
+        
+        if not self.emergency_comm_working:
+            score += 3.0
+        
+        # === NEW: FIRE GROWTH RATE ===
+        if self.fire_growth_rate > 10:  # m²/min
+            score += min(self.fire_growth_rate / 2, 12.0)
+        
+        # === NEW: HEAT RADIATION ===
+        if self.heat_radiation > 2.5:  # kW/m² (dangerous)
+            score += min((self.heat_radiation - 2.5) * 3, 10.0)
+        
+        return min(score, 100.0)
+    
+    def is_passable(self) -> bool:
+        """Determine if this location is passable"""
+        danger = self.calculate_danger_score()
+        # Consider passable if danger score is below 70
+        return danger < 70.0 and self.structural_integrity > 50.0
+    
+    def __repr__(self):
+        return (f"SensorReading({self.location_id}: "
+                f"Fire={self.fire_detected}, "
+                f"Smoke={self.smoke_level:.2f}, "
+                f"Temp={self.temperature:.1f}°C, "
+                f"Danger={self.calculate_danger_score():.1f})")
+
+
+class SensorSystem:
+    """Manages all sensors in the building"""
+    def __init__(self, floor_plan: FloorPlan):
+        self.floor_plan = floor_plan
+        self.sensors: Dict[str, SensorReading] = {}
+        self._initialize_sensors()
+        
+    def _initialize_sensors(self):
+        """Initialize sensors for all rooms with realistic mock data"""
+        import random
+        
+        for room_id in self.floor_plan.rooms:
+            sensor = SensorReading(room_id)
+            
+            # Initialize all rooms with realistic baseline mock data
+            sensor.fire_detected = False
+            sensor.smoke_level = random.uniform(0.0, 0.1)
+            sensor.temperature = random.uniform(18, 25)
+            sensor.oxygen_level = random.uniform(20.5, 21.0)
+            sensor.visibility = random.uniform(95, 100)
+            sensor.structural_integrity = 100.0
+            
+            # Fire factors (none initially)
+            sensor.fire_growth_rate = 0.0
+            sensor.flashover_risk = 0.0
+            sensor.backdraft_risk = 0.0
+            sensor.heat_radiation = 0.0
+            sensor.fire_type = "none"
+            
+            # Toxic gases (normal levels)
+            sensor.carbon_monoxide = random.uniform(0, 5)  # Normal < 9 ppm
+            sensor.carbon_dioxide = random.uniform(350, 450)  # Normal ~400 ppm
+            sensor.hydrogen_cyanide = 0.0
+            sensor.hydrogen_chloride = 0.0
+            
+            # Environmental (normal conditions)
+            sensor.wind_direction = random.uniform(0, 360)
+            sensor.wind_speed = random.uniform(0, 3)  # m/s
+            sensor.air_pressure = random.uniform(1010, 1020)
+            sensor.humidity = random.uniform(40, 60)
+            
+            # Human factors (varies by room type)
+            if "EXIT" in room_id:
+                sensor.occupancy_density = random.uniform(0.1, 0.3)  # Exits less crowded
+            elif "C" in room_id:  # Corridors
+                sensor.occupancy_density = random.uniform(0.2, 0.5)
+            else:  # Rooms
+                sensor.occupancy_density = random.uniform(0.3, 0.7)
+            
+            sensor.mobility_limitations = random.randint(0, 2)
+            sensor.panic_level = random.uniform(0.0, 0.2)  # Low initially
+            sensor.evacuation_progress = 0.0
+            
+            # Infrastructure (mostly working)
+            sensor.sprinkler_active = True
+            sensor.emergency_lighting = True
+            sensor.elevator_available = True
+            sensor.stairwell_clear = True
+            sensor.exit_accessible = True
+            sensor.exit_capacity = random.randint(80, 120)
+            sensor.ventilation_active = True
+            
+            # Time-based
+            sensor.time_since_fire_start = 0
+            sensor.estimated_time_to_exit = random.randint(30, 180)
+            
+            # Communication
+            sensor.emergency_comm_working = True
+            sensor.wifi_signal_strength = random.uniform(70, 100)
+            
+            # External
+            sensor.weather_temperature = random.uniform(15, 25)
+            sensor.weather_rain = random.choice([True, False])
+            sensor.time_of_day = random.randint(8, 18)
+            sensor.day_of_week = random.randint(0, 6)
+            
+            self.sensors[room_id] = sensor
+            
+    def update_sensor(self, location_id: str, **kwargs):
+        """Update sensor readings for a specific location"""
+        if location_id in self.sensors:
+            sensor = self.sensors[location_id]
+            for key, value in kwargs.items():
+                if hasattr(sensor, key):
+                    setattr(sensor, key, value)
+                    
+    def get_sensor_reading(self, location_id: str) -> SensorReading:
+        """Get current sensor reading for a location"""
+        return self.sensors.get(location_id)
+    
+    def simulate_fire_scenario(self, fire_locations: List[str], 
+                               affected_areas: Dict[str, Dict] = None):
+        """
+        Simulate a fire scenario with specified fire locations and affected areas
+        
+        Args:
+            fire_locations: List of room IDs where fire started
+            affected_areas: Dict of room_id -> sensor values for affected areas
+        """
+        # Reset all sensors
+        self._initialize_sensors()
+        
+        # Set fire locations
+        for location in fire_locations:
+            if location in self.sensors:
+                self.update_sensor(
+                    location,
+                    fire_detected=True,
+                    smoke_level=0.9,
+                    temperature=200.0 + random.uniform(-20, 50),
+                    oxygen_level=15.0,
+                    visibility=10.0,
+                    structural_integrity=70.0
+                )
+        
+        # Apply affected areas
+        if affected_areas:
+            for location, values in affected_areas.items():
+                if location in self.sensors:
+                    self.update_sensor(location, **values)
+        
+        # Simulate fire spread effect to adjacent rooms
+        self._simulate_smoke_spread(fire_locations)
+        
+    def _simulate_smoke_spread(self, fire_locations: List[str]):
+        """Simulate smoke spreading to adjacent areas"""
+        for fire_loc in fire_locations:
+            neighbors = self.floor_plan.get_neighbors(fire_loc)
+            for neighbor_id, _ in neighbors:
+                if neighbor_id in self.sensors and not self.sensors[neighbor_id].fire_detected:
+                    # Add smoke and heat to adjacent areas
+                    current = self.sensors[neighbor_id]
+                    self.update_sensor(
+                        neighbor_id,
+                        smoke_level=min(current.smoke_level + random.uniform(0.3, 0.6), 1.0),
+                        temperature=current.temperature + random.uniform(20, 40),
+                        visibility=max(current.visibility - random.uniform(20, 40), 20.0),
+                        oxygen_level=max(current.oxygen_level - random.uniform(1, 3), 16.0)
+                    )
+    
+    def get_all_readings(self) -> Dict[str, SensorReading]:
+        """Get all sensor readings"""
+        return self.sensors
+    
+    def print_status(self):
+        """Print status of all sensors"""
+        print(f"\n{'='*80}")
+        print(f"SENSOR SYSTEM STATUS")
+        print(f"{'='*80}")
+        for location_id, reading in sorted(self.sensors.items()):
+            danger = reading.calculate_danger_score()
+            status = "SAFE" if danger < 30 else "WARNING" if danger < 70 else "DANGER"
+            print(f"{location_id:10} | {status:7} | {reading}")
+
+
+def create_sample_fire_scenario(floor_plan: FloorPlan) -> SensorSystem:
+    """
+    Create a sample fire scenario with 3 routes of varying danger
+    
+    Scenario:
+    - Route 1 (via C1, C4 to EXIT1): Has oxygen cylinder (explosion risk) but less fire
+    - Route 2 (via C2, C5, C6 to EXIT2): Has moderate fire
+    - Route 3 (via C7 to EXIT3): Has heavy fire blocking path
+    """
+    sensor_system = SensorSystem(floor_plan)
+    
+    # Main fire locations
+    fire_locations = ["R2", "C5", "C7"]
+    
+    # Specific affected areas with custom sensor values
+    affected_areas = {
+        # Route 1 - Oxygen cylinder area (explosion risk but less fire)
+        "C1": {
+            "fire_detected": False,
+            "smoke_level": 0.4,
+            "temperature": 45.0,
+            "oxygen_level": 20.5,
+            "visibility": 60.0,
+            "structural_integrity": 95.0
+        },
+        "C4": {
+            "fire_detected": False,
+            "smoke_level": 0.5,
+            "temperature": 50.0,
+            "oxygen_level": 20.0,
+            "visibility": 50.0,
+            "structural_integrity": 90.0
+        },
+        
+        # Route 2 - Moderate fire
+        "C2": {
+            "fire_detected": False,
+            "smoke_level": 0.6,
+            "temperature": 65.0,
+            "oxygen_level": 18.5,
+            "visibility": 40.0,
+            "structural_integrity": 85.0
+        },
+        "C6": {
+            "fire_detected": True,
+            "smoke_level": 0.8,
+            "temperature": 150.0,
+            "oxygen_level": 16.0,
+            "visibility": 20.0,
+            "structural_integrity": 75.0
+        },
+        
+        # Route 3 - Heavy fire (worst option)
+        "R3": {
+            "fire_detected": False,
+            "smoke_level": 0.7,
+            "temperature": 80.0,
+            "oxygen_level": 17.5,
+            "visibility": 30.0,
+            "structural_integrity": 80.0
+        },
+        
+        # Starting point
+        "R1": {
+            "fire_detected": False,
+            "smoke_level": 0.2,
+            "temperature": 35.0,
+            "oxygen_level": 20.5,
+            "visibility": 80.0,
+            "structural_integrity": 100.0
+        },
+        
+        # Exit areas
+        "EXIT1": {
+            "fire_detected": False,
+            "smoke_level": 0.1,
+            "temperature": 25.0,
+            "oxygen_level": 21.0,
+            "visibility": 100.0,
+            "structural_integrity": 100.0
+        },
+        "EXIT2": {
+            "fire_detected": False,
+            "smoke_level": 0.3,
+            "temperature": 40.0,
+            "oxygen_level": 20.0,
+            "visibility": 70.0,
+            "structural_integrity": 100.0
+        },
+        "EXIT3": {
+            "fire_detected": False,
+            "smoke_level": 0.4,
+            "temperature": 45.0,
+            "oxygen_level": 19.5,
+            "visibility": 60.0,
+            "structural_integrity": 100.0
+        }
+    }
+    
+    sensor_system.simulate_fire_scenario(fire_locations, affected_areas)
+    
+    return sensor_system
+