21. Cloud/Local ArchitecturePremium

class BaseClient(ABC):
    @abstractmethod
    def query(self, user_input: str, stream: bool = False) -> str:
        """Execute user query."""

    @abstractmethod
    def get_status(self) -> Dict[str, Any]:
        """Get current system status."""

    @abstractmethod
    def export_session(self) -> Dict[str, Any]:
        """Export current session."""

class AgentClient(BaseClient):
    """Local processing with LangGraph agents."""

    def __init__(self, data_manager: DataManagerV2):
        self.data_manager = data_manager
        self.graph = create_bioinformatics_graph(data_manager)

class CloudLobsterClient(BaseClient):
    """Cloud processing via REST API."""

    def __init__(self, api_key: str, base_url: str):
        self.api_key = api_key
        self.session = httpx.Client(base_url=base_url)

def init_client() -> BaseClient:
    """Initialize appropriate client based on environment."""

    cloud_key = os.getenv('LOBSTER_CLOUD_KEY')

    if cloud_key:
        try:
            client = CloudLobsterClient(api_key=cloud_key)
            client.get_status()  # Verify connection
            return client
        except Exception as e:
            logger.warning(f"Cloud unavailable: {e}. Falling back to local.")

    # Default to local mode
    data_manager = DataManagerV2()
    return AgentClient(data_manager=data_manager)

# AWS Bedrock (recommended)
export AWS_BEDROCK_ACCESS_KEY=your-access-key
export AWS_BEDROCK_SECRET_ACCESS_KEY=your-secret-key

# Or OpenAI
export OPENAI_API_KEY=your-openai-key

export LOBSTER_CLOUD_KEY=your-cloud-api-key

User Query
  ↓
Lobster CLI
  ↓
AgentClient (Local)
  ↓
LangGraph Multi-Agent System
  ↓
DataManagerV2 (Local Storage)
  ↓
Analysis Results

User Query
  ↓
Lobster CLI
  ↓
CloudLobsterClient (HTTP)
  ↓
Cloud API (REST)
  ↓
Cloud LangGraph System
  ↓
Cloud Storage & Compute
  ↓
Analysis Results (Streamed)

class LobsterClientAdapter:
    """Adapter for seamless cloud/local switching."""

    def __init__(self):
        self.client = init_client()

    def query(self, user_input: str) -> str:
        return self.client.query(user_input)

    @property
    def mode(self) -> str:
        if isinstance(self.client, CloudLobsterClient):
            return "cloud"
        return "local"

{
    "mode": "local",  # or "cloud"
    "data_loaded": true,
    "modalities": ["geo_gse12345"],
    "workspace": "/path/to/.lobster_workspace"
}

# Export session from local
lobster export-session --output session.zip

# Upload to cloud (future feature)
lobster cloud upload session.zip

# Set cloud key
export LOBSTER_CLOUD_KEY=your-key

# Resume work
lobster chat

# Download session from cloud (future feature)
lobster cloud download session-id --output session.zip

# Clear cloud key
unset LOBSTER_CLOUD_KEY

# Import locally
lobster import-session session.zip

# Resume work locally
lobster chat

# System automatically falls back to local
# Check cloud key:
echo $LOBSTER_CLOUD_KEY

# Test connection:
lobster status

# Check memory usage:
lobster status

# Consider cloud mode for large datasets:
export LOBSTER_CLOUD_KEY=your-key