@saibolla/ada 0.1.2

package/skills/pylabrobot/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: pylabrobot
+description: Vendor-agnostic lab automation framework. Use when controlling multiple equipment types (Hamilton, Tecan, Opentrons, plate readers, pumps) or needing unified programming across different vendors. Best for complex workflows, multi-vendor setups, simulation. For Opentrons-only protocols with official API, opentrons-integration may be simpler.
+license: MIT license
+metadata:
+    skill-author: K-Dense Inc.
+---
+
+# PyLabRobot
+
+## Overview
+
+PyLabRobot is a hardware-agnostic, pure Python Software Development Kit for automated and autonomous laboratories. Use this skill to control liquid handling robots, plate readers, pumps, heater shakers, incubators, centrifuges, and other laboratory automation equipment through a unified Python interface that works across platforms (Windows, macOS, Linux).
+
+## When to Use This Skill
+
+Use this skill when:
+- Programming liquid handling robots (Hamilton STAR/STARlet, Opentrons OT-2, Tecan EVO)
+- Automating laboratory workflows involving pipetting, sample preparation, or analytical measurements
+- Managing deck layouts and laboratory resources (plates, tips, containers, troughs)
+- Integrating multiple lab devices (liquid handlers, plate readers, heater shakers, pumps)
+- Creating reproducible laboratory protocols with state management
+- Simulating protocols before running on physical hardware
+- Reading plates using BMG CLARIOstar or other supported plate readers
+- Controlling temperature, shaking, centrifugation, or other material handling operations
+- Working with laboratory automation in Python
+
+## Core Capabilities
+
+PyLabRobot provides comprehensive laboratory automation through six main capability areas, each detailed in the references/ directory:
+
+### 1. Liquid Handling (`references/liquid-handling.md`)
+
+Control liquid handling robots for aspirating, dispensing, and transferring liquids. Key operations include:
+- **Basic Operations**: Aspirate, dispense, transfer liquids between wells
+- **Tip Management**: Pick up, drop, and track pipette tips automatically
+- **Advanced Techniques**: Multi-channel pipetting, serial dilutions, plate replication
+- **Volume Tracking**: Automatic tracking of liquid volumes in wells
+- **Hardware Support**: Hamilton STAR/STARlet, Opentrons OT-2, Tecan EVO, and others
+
+### 2. Resource Management (`references/resources.md`)
+
+Manage laboratory resources in a hierarchical system:
+- **Resource Types**: Plates, tip racks, troughs, tubes, carriers, and custom labware
+- **Deck Layout**: Assign resources to deck positions with coordinate systems
+- **State Management**: Track tip presence, liquid volumes, and resource states
+- **Serialization**: Save and load deck layouts and states from JSON files
+- **Resource Discovery**: Access wells, tips, and containers through intuitive APIs
+
+### 3. Hardware Backends (`references/hardware-backends.md`)
+
+Connect to diverse laboratory equipment through backend abstraction:
+- **Liquid Handlers**: Hamilton STAR (full support), Opentrons OT-2, Tecan EVO
+- **Simulation**: ChatterboxBackend for protocol testing without hardware
+- **Platform Support**: Works on Windows, macOS, Linux, and Raspberry Pi
+- **Backend Switching**: Change robots by swapping backend without rewriting protocols
+
+### 4. Analytical Equipment (`references/analytical-equipment.md`)
+
+Integrate plate readers and analytical instruments:
+- **Plate Readers**: BMG CLARIOstar for absorbance, luminescence, fluorescence
+- **Scales**: Mettler Toledo integration for mass measurements
+- **Integration Patterns**: Combine liquid handlers with analytical equipment
+- **Automated Workflows**: Move plates between devices automatically
+
+### 5. Material Handling (`references/material-handling.md`)
+
+Control environmental and material handling equipment:
+- **Heater Shakers**: Hamilton HeaterShaker, Inheco ThermoShake
+- **Incubators**: Inheco and Thermo Fisher incubators with temperature control
+- **Centrifuges**: Agilent VSpin with bucket positioning and spin control
+- **Pumps**: Cole Parmer Masterflex for fluid pumping operations
+- **Temperature Control**: Set and monitor temperatures during protocols
+
+### 6. Visualization & Simulation (`references/visualization.md`)
+
+Visualize and simulate laboratory protocols:
+- **Browser Visualizer**: Real-time 3D visualization of deck state
+- **Simulation Mode**: Test protocols without physical hardware
+- **State Tracking**: Monitor tip presence and liquid volumes visually
+- **Deck Editor**: Graphical tool for designing deck layouts
+- **Protocol Validation**: Verify protocols before running on hardware
+
+## Quick Start
+
+To get started with PyLabRobot, install the package and initialize a liquid handler:
+
+```python
+# Install PyLabRobot
+# uv pip install pylabrobot
+
+# Basic liquid handling setup
+from pylabrobot.liquid_handling import LiquidHandler
+from pylabrobot.liquid_handling.backends import STAR
+from pylabrobot.resources import STARLetDeck
+
+# Initialize liquid handler
+lh = LiquidHandler(backend=STAR(), deck=STARLetDeck())
+await lh.setup()
+
+# Basic operations
+await lh.pick_up_tips(tip_rack["A1:H1"])
+await lh.aspirate(plate["A1"], vols=100)
+await lh.dispense(plate["A2"], vols=100)
+await lh.drop_tips()
+```
+
+## Working with References
+
+This skill organizes detailed information across multiple reference files. Load the relevant reference when:
+- **Liquid Handling**: Writing pipetting protocols, tip management, transfers
+- **Resources**: Defining deck layouts, managing plates/tips, custom labware
+- **Hardware Backends**: Connecting to specific robots, switching platforms
+- **Analytical Equipment**: Integrating plate readers, scales, or analytical devices
+- **Material Handling**: Using heater shakers, incubators, centrifuges, pumps
+- **Visualization**: Simulating protocols, visualizing deck states
+
+All reference files can be found in the `references/` directory and contain comprehensive examples, API usage patterns, and best practices.
+
+## Best Practices
+
+When creating laboratory automation protocols with PyLabRobot:
+
+1. **Start with Simulation**: Use ChatterboxBackend and the visualizer to test protocols before running on hardware
+2. **Enable Tracking**: Turn on tip tracking and volume tracking for accurate state management
+3. **Resource Naming**: Use clear, descriptive names for all resources (plates, tip racks, containers)
+4. **State Serialization**: Save deck layouts and states to JSON for reproducibility
+5. **Error Handling**: Implement proper async error handling for hardware operations
+6. **Temperature Control**: Set temperatures early as heating/cooling takes time
+7. **Modular Protocols**: Break complex workflows into reusable functions
+8. **Documentation**: Reference official docs at https://docs.pylabrobot.org for latest features
+
+## Common Workflows
+
+### Liquid Transfer Protocol
+
+```python
+# Setup
+lh = LiquidHandler(backend=STAR(), deck=STARLetDeck())
+await lh.setup()
+
+# Define resources
+tip_rack = TIP_CAR_480_A00(name="tip_rack")
+source_plate = Cos_96_DW_1mL(name="source")
+dest_plate = Cos_96_DW_1mL(name="dest")
+
+lh.deck.assign_child_resource(tip_rack, rails=1)
+lh.deck.assign_child_resource(source_plate, rails=10)
+lh.deck.assign_child_resource(dest_plate, rails=15)
+
+# Transfer protocol
+await lh.pick_up_tips(tip_rack["A1:H1"])
+await lh.transfer(source_plate["A1:H12"], dest_plate["A1:H12"], vols=100)
+await lh.drop_tips()
+```
+
+### Plate Reading Workflow
+
+```python
+# Setup plate reader
+from pylabrobot.plate_reading import PlateReader
+from pylabrobot.plate_reading.clario_star_backend import CLARIOstarBackend
+
+pr = PlateReader(name="CLARIOstar", backend=CLARIOstarBackend())
+await pr.setup()
+
+# Set temperature and read
+await pr.set_temperature(37)
+await pr.open()
+# (manually or robotically load plate)
+await pr.close()
+data = await pr.read_absorbance(wavelength=450)
+```
+
+## Additional Resources
+
+- **Official Documentation**: https://docs.pylabrobot.org
+- **GitHub Repository**: https://github.com/PyLabRobot/pylabrobot
+- **Community Forum**: https://discuss.pylabrobot.org
+- **PyPI Package**: https://pypi.org/project/PyLabRobot/
+
+For detailed usage of specific capabilities, refer to the corresponding reference file in the `references/` directory.
+

package/skills/pylabrobot/references/analytical-equipment.md

@@ -0,0 +1,464 @@
+# Analytical Equipment in PyLabRobot
+
+## Overview
+
+PyLabRobot integrates with analytical equipment including plate readers, scales, and other measurement devices. This allows automated workflows that combine liquid handling with analytical measurements.
+
+## Plate Readers
+
+### BMG CLARIOstar (Plus)
+
+The BMG Labtech CLARIOstar and CLARIOstar Plus are microplate readers that measure absorbance, luminescence, and fluorescence.
+
+#### Hardware Setup
+
+**Physical Connections:**
+1. IEC C13 power cord to mains power
+2. USB-B cable to computer (with security screws on device end)
+3. Optional: RS-232 port for plate stacking units
+
+**Communication:**
+- Serial connection through FTDI/USB-A at firmware level
+- Cross-platform support (Windows, macOS, Linux)
+
+#### Software Setup
+
+```python
+from pylabrobot.plate_reading import PlateReader
+from pylabrobot.plate_reading.clario_star_backend import CLARIOstarBackend
+
+# Create backend
+backend = CLARIOstarBackend()
+
+# Initialize plate reader
+pr = PlateReader(
+    name="CLARIOstar",
+    backend=backend,
+    size_x=0.0,    # Physical dimensions not critical for plate readers
+    size_y=0.0,
+    size_z=0.0
+)
+
+# Setup (initializes device)
+await pr.setup()
+
+# When done
+await pr.stop()
+```
+
+#### Basic Operations
+
+**Opening and Closing:**
+
+```python
+# Open loading tray
+await pr.open()
+
+# (Load plate manually or robotically)
+
+# Close loading tray
+await pr.close()
+```
+
+**Temperature Control:**
+
+```python
+# Set temperature (in Celsius)
+await pr.set_temperature(37)
+
+# Note: Reaching temperature is slow
+# Set temperature early in protocol
+```
+
+**Reading Measurements:**
+
+```python
+# Absorbance reading
+data = await pr.read_absorbance(wavelength=450)  # nm
+
+# Luminescence reading
+data = await pr.read_luminescence()
+
+# Fluorescence reading
+data = await pr.read_fluorescence(
+    excitation_wavelength=485,  # nm
+    emission_wavelength=535     # nm
+)
+```
+
+#### Data Format
+
+Plate reader methods return array data:
+
+```python
+import numpy as np
+
+# Read absorbance
+data = await pr.read_absorbance(wavelength=450)
+
+# data is typically a 2D array (8x12 for 96-well plate)
+print(f"Data shape: {data.shape}")
+print(f"Well A1: {data[0][0]}")
+print(f"Well H12: {data[7][11]}")
+
+# Convert to DataFrame for easier handling
+import pandas as pd
+df = pd.DataFrame(data)
+```
+
+#### Integration with Liquid Handler
+
+Combine plate reading with liquid handling:
+
+```python
+from pylabrobot.liquid_handling import LiquidHandler
+from pylabrobot.liquid_handling.backends import STAR
+from pylabrobot.resources import STARLetDeck
+from pylabrobot.plate_reading import PlateReader
+from pylabrobot.plate_reading.clario_star_backend import CLARIOstarBackend
+
+# Initialize liquid handler
+lh = LiquidHandler(backend=STAR(), deck=STARLetDeck())
+await lh.setup()
+
+# Initialize plate reader
+pr = PlateReader(name="CLARIOstar", backend=CLARIOstarBackend())
+await pr.setup()
+
+# Set temperature early
+await pr.set_temperature(37)
+
+try:
+    # Prepare samples with liquid handler
+    tip_rack = TIP_CAR_480_A00(name="tips")
+    reagent_plate = Cos_96_DW_1mL(name="reagents")
+    assay_plate = Cos_96_DW_1mL(name="assay")
+
+    lh.deck.assign_child_resource(tip_rack, rails=1)
+    lh.deck.assign_child_resource(reagent_plate, rails=10)
+    lh.deck.assign_child_resource(assay_plate, rails=15)
+
+    # Transfer samples
+    await lh.pick_up_tips(tip_rack["A1:H1"])
+    await lh.transfer(
+        reagent_plate["A1:H12"],
+        assay_plate["A1:H12"],
+        vols=100
+    )
+    await lh.drop_tips()
+
+    # Move plate to reader (manual or robotic arm)
+    print("Move assay plate to plate reader")
+    input("Press Enter when plate is loaded...")
+
+    # Read plate
+    await pr.open()
+    # (plate loaded here)
+    await pr.close()
+
+    data = await pr.read_absorbance(wavelength=450)
+    print(f"Absorbance data: {data}")
+
+finally:
+    await lh.stop()
+    await pr.stop()
+```
+
+#### Advanced Features
+
+**Development Status:**
+
+Some CLARIOstar features are under development:
+- Spectral scanning
+- Injector needle control
+- Detailed measurement parameter configuration
+- Well-specific reading patterns
+
+Check current documentation for latest feature support.
+
+#### Best Practices
+
+1. **Temperature Control**: Set temperature early as heating is slow
+2. **Plate Loading**: Ensure plate is properly seated before closing
+3. **Measurement Selection**: Choose appropriate wavelengths for your assay
+4. **Data Validation**: Check measurement quality and expected ranges
+5. **Error Handling**: Handle timeout and communication errors
+6. **Maintenance**: Keep optics clean per manufacturer guidelines
+
+#### Example: Complete Plate Reading Workflow
+
+```python
+async def run_plate_reading_assay():
+    """Complete workflow with sample prep and reading"""
+
+    # Initialize equipment
+    lh = LiquidHandler(backend=STAR(), deck=STARLetDeck())
+    pr = PlateReader(name="CLARIOstar", backend=CLARIOstarBackend())
+
+    await lh.setup()
+    await pr.setup()
+
+    # Set plate reader temperature
+    await pr.set_temperature(37)
+
+    try:
+        # Define resources
+        tip_rack = TIP_CAR_480_A00(name="tips")
+        samples = Cos_96_DW_1mL(name="samples")
+        assay_plate = Cos_96_DW_1mL(name="assay")
+        substrate = Trough_100ml(name="substrate")
+
+        lh.deck.assign_child_resource(tip_rack, rails=1)
+        lh.deck.assign_child_resource(substrate, rails=5)
+        lh.deck.assign_child_resource(samples, rails=10)
+        lh.deck.assign_child_resource(assay_plate, rails=15)
+
+        # Transfer samples
+        await lh.pick_up_tips(tip_rack["A1:H1"])
+        await lh.transfer(
+            samples["A1:H12"],
+            assay_plate["A1:H12"],
+            vols=50
+        )
+        await lh.drop_tips()
+
+        # Add substrate
+        await lh.pick_up_tips(tip_rack["A2:H2"])
+        for col in range(1, 13):
+            await lh.transfer(
+                substrate["channel_1"],
+                assay_plate[f"A{col}:H{col}"],
+                vols=50
+            )
+        await lh.drop_tips()
+
+        # Incubate (if needed)
+        # await asyncio.sleep(300)  # 5 minutes
+
+        # Move to plate reader
+        print("Transfer assay plate to CLARIOstar")
+        input("Press Enter when ready...")
+
+        await pr.open()
+        input("Press Enter when plate is loaded...")
+        await pr.close()
+
+        # Read absorbance
+        data = await pr.read_absorbance(wavelength=450)
+
+        # Process results
+        import pandas as pd
+        df = pd.DataFrame(
+            data,
+            index=[f"{r}" for r in "ABCDEFGH"],
+            columns=[f"{c}" for c in range(1, 13)]
+        )
+
+        print("Absorbance Results:")
+        print(df)
+
+        # Save results
+        df.to_csv("plate_reading_results.csv")
+
+        return df
+
+    finally:
+        await lh.stop()
+        await pr.stop()
+
+# Run assay
+results = await run_plate_reading_assay()
+```
+
+## Scales
+
+### Mettler Toledo Scales
+
+PyLabRobot supports Mettler Toledo scales for mass measurements.
+
+#### Setup
+
+```python
+from pylabrobot.scales import Scale
+from pylabrobot.scales.mettler_toledo_backend import MettlerToledoBackend
+
+# Create scale
+scale = Scale(
+    name="analytical_scale",
+    backend=MettlerToledoBackend()
+)
+
+await scale.setup()
+```
+
+#### Operations
+
+```python
+# Get weight measurement
+weight = await scale.get_weight()  # Returns weight in grams
+print(f"Weight: {weight} g")
+
+# Tare (zero) the scale
+await scale.tare()
+
+# Get multiple measurements
+weights = []
+for i in range(5):
+    w = await scale.get_weight()
+    weights.append(w)
+    await asyncio.sleep(1)
+
+average_weight = sum(weights) / len(weights)
+print(f"Average weight: {average_weight} g")
+```
+
+#### Integration with Liquid Handler
+
+```python
+# Weigh samples during protocol
+lh = LiquidHandler(backend=STAR(), deck=STARLetDeck())
+scale = Scale(name="scale", backend=MettlerToledoBackend())
+
+await lh.setup()
+await scale.setup()
+
+try:
+    # Tare scale
+    await scale.tare()
+
+    # Dispense liquid
+    await lh.pick_up_tips(tip_rack["A1"])
+    await lh.aspirate(reagent["A1"], vols=1000)
+
+    # (Move to scale position)
+
+    # Dispense and weigh
+    await lh.dispense(container, vols=1000)
+    weight = await scale.get_weight()
+
+    print(f"Dispensed weight: {weight} g")
+
+    # Calculate actual volume (assuming density = 1 g/mL for water)
+    actual_volume = weight * 1000  # Convert g to µL
+    print(f"Actual volume: {actual_volume} µL")
+
+    await lh.drop_tips()
+
+finally:
+    await lh.stop()
+    await scale.stop()
+```
+
+## Other Analytical Devices
+
+### Flow Cytometers
+
+Some flow cytometer integrations are in development. Check current documentation for support status.
+
+### Spectrophotometers
+
+Additional spectrophotometer models may be supported. Check documentation for current device compatibility.
+
+## Multi-Device Workflows
+
+### Coordinating Multiple Devices
+
+```python
+async def multi_device_workflow():
+    """Coordinate liquid handler, plate reader, and scale"""
+
+    # Initialize all devices
+    lh = LiquidHandler(backend=STAR(), deck=STARLetDeck())
+    pr = PlateReader(name="CLARIOstar", backend=CLARIOstarBackend())
+    scale = Scale(name="scale", backend=MettlerToledoBackend())
+
+    await lh.setup()
+    await pr.setup()
+    await scale.setup()
+
+    try:
+        # 1. Weigh reagent
+        await scale.tare()
+        # (place container on scale)
+        reagent_weight = await scale.get_weight()
+
+        # 2. Prepare samples with liquid handler
+        await lh.pick_up_tips(tip_rack["A1:H1"])
+        await lh.transfer(source["A1:H12"], dest["A1:H12"], vols=100)
+        await lh.drop_tips()
+
+        # 3. Read plate
+        await pr.open()
+        # (load plate)
+        await pr.close()
+        data = await pr.read_absorbance(wavelength=450)
+
+        return {
+            "reagent_weight": reagent_weight,
+            "absorbance_data": data
+        }
+
+    finally:
+        await lh.stop()
+        await pr.stop()
+        await scale.stop()
+```
+
+## Best Practices
+
+1. **Device Initialization**: Setup all devices at start of protocol
+2. **Error Handling**: Handle communication errors gracefully
+3. **Cleanup**: Always call `stop()` on all devices
+4. **Timing**: Account for device-specific timing (temperature equilibration, measurement time)
+5. **Calibration**: Follow manufacturer calibration procedures
+6. **Data Validation**: Verify measurements are within expected ranges
+7. **Documentation**: Record device settings and parameters
+8. **Integration Testing**: Test multi-device workflows thoroughly
+9. **Concurrent Operations**: Use async to overlap operations when possible
+10. **Data Storage**: Save raw data with metadata (timestamps, settings)
+
+## Common Patterns
+
+### Kinetic Plate Reading
+
+```python
+async def kinetic_reading(num_reads: int, interval: int):
+    """Perform kinetic plate reading"""
+
+    pr = PlateReader(name="CLARIOstar", backend=CLARIOstarBackend())
+    await pr.setup()
+
+    try:
+        await pr.set_temperature(37)
+        await pr.open()
+        # (load plate)
+        await pr.close()
+
+        results = []
+        for i in range(num_reads):
+            data = await pr.read_absorbance(wavelength=450)
+            timestamp = time.time()
+            results.append({
+                "read_number": i + 1,
+                "timestamp": timestamp,
+                "data": data
+            })
+
+            if i < num_reads - 1:
+                await asyncio.sleep(interval)
+
+        return results
+
+    finally:
+        await pr.stop()
+
+# Read every 30 seconds for 10 minutes
+results = await kinetic_reading(num_reads=20, interval=30)
+```
+
+## Additional Resources
+
+- Plate Reading Documentation: https://docs.pylabrobot.org/user_guide/02_analytical/
+- BMG CLARIOstar Guide: https://docs.pylabrobot.org/user_guide/02_analytical/plate-reading/bmg-clariostar.html
+- API Reference: https://docs.pylabrobot.org/api/pylabrobot.plate_reading.html
+- Supported Equipment: https://docs.pylabrobot.org/user_guide/machines.html