dao-ai 0.1.3__tar.gz → 0.1.4__tar.gz

{dao_ai-0.1.3 → dao_ai-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.1.3
+Version: 0.1.4
 Summary: DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML.
 Project-URL: Homepage, https://github.com/natefleming/dao-ai
 Project-URL: Documentation, https://natefleming.github.io/dao-ai
@@ -293,6 +293,16 @@ This single command:
 3. Deploys it to Databricks
 4. Creates a serving endpoint
 
+**Deploying to a specific workspace:**
+
+```bash
+# Deploy to AWS workspace
+dao-ai bundle --deploy --run -c config/my_agent.yaml --profile aws-field-eng
+
+# Deploy to Azure workspace
+dao-ai bundle --deploy --run -c config/my_agent.yaml --profile azure-retail
+```
+
 **Step 5: Interact with your agent**
 
 Once deployed, you can chat with your agent using Python:
@@ -422,10 +432,34 @@ dao-ai graph -c config/my_config.yaml -o workflow.png
 # Deploy with Databricks Asset Bundles
 dao-ai bundle --deploy --run -c config/my_config.yaml
 
+# Deploy to a specific workspace (multi-cloud support)
+dao-ai bundle --deploy -c config/my_config.yaml --profile aws-field-eng
+dao-ai bundle --deploy -c config/my_config.yaml --profile azure-retail
+
 # Interactive chat with agent
 dao-ai chat -c config/my_config.yaml
 ```
 
+### Multi-Cloud Deployment
+
+DAO AI supports deploying to Azure, AWS, and GCP workspaces with automatic cloud detection:
+
+```bash
+# Deploy to AWS workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile aws-prod
+
+# Deploy to Azure workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile azure-prod
+
+# Deploy to GCP workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile gcp-prod
+```
+
+The CLI automatically:
+- Detects the cloud provider from your profile's workspace URL
+- Selects appropriate compute node types for each cloud
+- Creates isolated deployment state per profile
+
 👉 **Learn more:** [CLI Reference Documentation](docs/cli-reference.md)
 
 ---

{dao_ai-0.1.3 → dao_ai-0.1.4}/README.md

@@ -214,6 +214,16 @@ This single command:
 3. Deploys it to Databricks
 4. Creates a serving endpoint
 
+**Deploying to a specific workspace:**
+
+```bash
+# Deploy to AWS workspace
+dao-ai bundle --deploy --run -c config/my_agent.yaml --profile aws-field-eng
+
+# Deploy to Azure workspace
+dao-ai bundle --deploy --run -c config/my_agent.yaml --profile azure-retail
+```
+
 **Step 5: Interact with your agent**
 
 Once deployed, you can chat with your agent using Python:
@@ -343,10 +353,34 @@ dao-ai graph -c config/my_config.yaml -o workflow.png
 # Deploy with Databricks Asset Bundles
 dao-ai bundle --deploy --run -c config/my_config.yaml
 
+# Deploy to a specific workspace (multi-cloud support)
+dao-ai bundle --deploy -c config/my_config.yaml --profile aws-field-eng
+dao-ai bundle --deploy -c config/my_config.yaml --profile azure-retail
+
 # Interactive chat with agent
 dao-ai chat -c config/my_config.yaml
 ```
 
+### Multi-Cloud Deployment
+
+DAO AI supports deploying to Azure, AWS, and GCP workspaces with automatic cloud detection:
+
+```bash
+# Deploy to AWS workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile aws-prod
+
+# Deploy to Azure workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile azure-prod
+
+# Deploy to GCP workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile gcp-prod
+```
+
+The CLI automatically:
+- Detects the cloud provider from your profile's workspace URL
+- Selects appropriate compute node types for each cloud
+- Creates isolated deployment state per profile
+
 👉 **Learn more:** [CLI Reference Documentation](docs/cli-reference.md)
 
 ---

{dao_ai-0.1.3 → dao_ai-0.1.4}/databricks.yaml.template

@@ -13,8 +13,9 @@ variables:
   config_path:
     description: Path to the configuration file for the job.
   node_type: 
-    description: The job compute node type
-    default: Standard_D4ads_v5
+    description: The job compute node type (cloud-specific, set per target)
+  cloud:
+    description: Cloud provider (azure, aws, gcp) - auto-detected or set per target
 
 resources:
   jobs:
@@ -93,12 +94,23 @@ resources:
               config-path: ${var.config_path}
           environment_key: dao-ai-env
           
+# Cloud-specific targets with appropriate node types
+# The CLI auto-selects the target based on workspace cloud detection
 targets:
-  __APP_NAME__:
+  azure:
     mode: development
-    default: true
-
-
-
-
-
+    variables:
+      cloud: azure
+      node_type: Standard_D4ads_v5
+  
+  aws:
+    mode: development
+    variables:
+      cloud: aws
+      node_type: i3.xlarge
+  
+  gcp:
+    mode: development
+    variables:
+      cloud: gcp
+      node_type: n1-standard-4

dao_ai-0.1.4/docs/cli-reference.md

@@ -0,0 +1,237 @@
+# CLI Reference
+
+## Validate Configuration
+
+Check your configuration for errors:
+
+```bash
+dao-ai validate -c config/my_config.yaml
+```
+
+## Generate JSON Schema
+
+Generate JSON schema for IDE support and validation:
+
+```bash
+dao-ai schema > schemas/model_config_schema.json
+```
+
+## Visualize Agent Workflow
+
+Generate a diagram showing how your agent works:
+
+```bash
+dao-ai graph -c config/my_config.yaml -o workflow.png
+```
+
+## Deploy with Databricks Asset Bundles
+
+Deploy your agent to Databricks. The CLI supports multi-cloud deployments with automatic cloud detection.
+
+### Basic Deployment
+
+```bash
+# Deploy using default profile or environment
+dao-ai bundle --deploy -c config/my_config.yaml
+```
+
+### Multi-Cloud Deployment
+
+The CLI automatically detects the cloud provider from your Databricks workspace and selects the appropriate configuration (node types, etc.):
+
+```bash
+# Deploy to AWS workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile aws-field-eng
+
+# Deploy to Azure workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile azure-retail
+
+# Deploy to GCP workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile gcp-analytics
+```
+
+### Deploy and Run
+
+```bash
+# Deploy and immediately run the job
+dao-ai bundle --deploy --run -c config/my_config.yaml --profile aws-field-eng
+```
+
+### Explicit Cloud Override
+
+If cloud auto-detection doesn't work, you can specify the cloud explicitly:
+
+```bash
+dao-ai bundle --deploy -c config/my_config.yaml --cloud aws
+```
+
+### Dry Run
+
+Preview commands without executing:
+
+```bash
+dao-ai bundle --deploy -c config/my_config.yaml --profile aws-field-eng --dry-run
+```
+
+## Interactive Chat
+
+Start an interactive chat session with your agent:
+
+```bash
+dao-ai chat -c config/my_config.yaml
+```
+
+## Verbose Output
+
+Increase verbosity for debugging (use `-v` through `-vvvv`):
+
+```bash
+dao-ai -vvvv validate -c config/my_config.yaml
+```
+
+---
+
+## Command Options
+
+### Common Options
+
+| Option | Description |
+|--------|-------------|
+| `-c, --config FILE` | Path to configuration file (required) |
+| `-p, --profile NAME` | Databricks CLI profile to use |
+| `-v, --verbose` | Increase verbosity (can be repeated up to 4 times) |
+| `--help` | Show help message |
+
+### Validate Options
+
+```bash
+dao-ai validate -c config/my_config.yaml [OPTIONS]
+```
+
+### Graph Options
+
+```bash
+dao-ai graph -c config/my_config.yaml -o output.png [OPTIONS]
+```
+
+| Option | Description |
+|--------|-------------|
+| `-o, --output FILE` | Output file path (supports .png, .pdf, .svg) |
+
+### Bundle Options
+
+```bash
+dao-ai bundle -c config/my_config.yaml [OPTIONS]
+```
+
+| Option | Description |
+|--------|-------------|
+| `-d, --deploy` | Deploy the bundle to Databricks |
+| `-r, --run` | Run the deployment job after deploying |
+| `--destroy` | Destroy the deployed bundle |
+| `-p, --profile NAME` | Databricks CLI profile to use |
+| `--cloud {azure,aws,gcp}` | Cloud provider (auto-detected if not specified) |
+| `-t, --target NAME` | Bundle target name (auto-generated if not specified) |
+| `--dry-run` | Preview commands without executing |
+
+### Chat Options
+
+```bash
+dao-ai chat -c config/my_config.yaml [OPTIONS]
+```
+
+Starts an interactive REPL session where you can chat with your agent locally.
+
+---
+
+## Multi-Cloud Support
+
+DAO AI supports deploying to Azure, AWS, and GCP Databricks workspaces. The CLI handles cloud-specific configurations automatically.
+
+### How It Works
+
+1. **Cloud Detection**: When you specify a `--profile`, the CLI detects the cloud provider from the workspace URL
+2. **Target Selection**: The CLI uses the profile name as the deployment target for per-profile isolation
+3. **Node Types**: Cloud-appropriate compute node types are automatically selected:
+   - Azure: `Standard_D4ads_v5`
+   - AWS: `i3.xlarge`
+   - GCP: `n1-standard-4`
+
+### Profile Configuration
+
+Profiles are configured in `~/.databrickscfg`:
+
+```ini
+[aws-field-eng]
+host = https://my-workspace.cloud.databricks.com
+token = dapi...
+
+[azure-retail]
+host = https://adb-123456789.azuredatabricks.net
+token = dapi...
+
+[gcp-analytics]
+host = https://my-workspace.gcp.databricks.com
+token = dapi...
+```
+
+### Deployment Isolation
+
+Each profile gets its own isolated deployment state:
+
+```
+/.bundle/my_app/aws-field-eng/files    # AWS deployment
+/.bundle/my_app/azure-retail/files     # Azure deployment
+/.bundle/my_app/gcp-analytics/files    # GCP deployment
+```
+
+This allows you to deploy the same application to multiple workspaces without conflicts.
+
+---
+
+## Examples
+
+### Deploy to Multiple Clouds
+
+```bash
+# Deploy to AWS
+dao-ai bundle --deploy -c config/hardware_store.yaml --profile aws-prod
+
+# Deploy same app to Azure
+dao-ai bundle --deploy -c config/hardware_store.yaml --profile azure-prod
+
+# Deploy same app to GCP
+dao-ai bundle --deploy -c config/hardware_store.yaml --profile gcp-prod
+```
+
+### Development vs Production
+
+```bash
+# Deploy to development workspace
+dao-ai bundle --deploy -c config/my_app.yaml --profile aws-dev
+
+# Deploy to production workspace
+dao-ai bundle --deploy -c config/my_app.yaml --profile aws-prod
+```
+
+### Full Deployment Pipeline
+
+```bash
+# Validate configuration
+dao-ai validate -c config/my_app.yaml
+
+# Generate workflow diagram
+dao-ai graph -c config/my_app.yaml -o workflow.png
+
+# Deploy and run
+dao-ai bundle --deploy --run -c config/my_app.yaml --profile aws-field-eng
+```
+
+---
+
+## Navigation
+
+- [← Previous: Examples](examples.md)
+- [↑ Back to Documentation Index](../README.md#-documentation)
+- [Next: Python API →](python-api.md)
+

{dao_ai-0.1.3 → dao_ai-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dao-ai"
-version = "0.1.3"
+version = "0.1.4"
 description = "DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML."
 readme = "README.md"
 license = { text = "MIT" }

{dao_ai-0.1.3 → dao_ai-0.1.4}/requirements.txt

@@ -63,6 +63,7 @@ grandalf==0.8
 graphene==3.4.3
 graphql-core==3.2.7
 graphql-relay==3.2.0
+greenlet==3.3.0
 grpcio==1.76.0
 grpcio-status==1.76.0
 gunicorn==23.0.0

{dao_ai-0.1.3 → dao_ai-0.1.4}/src/dao_ai/cli.py

@@ -47,6 +47,57 @@ def get_default_user_id() -> str:
         return local_user
 
 
+def detect_cloud_provider(profile: Optional[str] = None) -> Optional[str]:
+    """
+    Detect the cloud provider from the Databricks workspace URL.
+    
+    The cloud provider is determined by the workspace URL pattern:
+    - Azure: *.azuredatabricks.net
+    - AWS: *.cloud.databricks.com (without gcp subdomain)
+    - GCP: *.gcp.databricks.com
+    
+    Args:
+        profile: Optional Databricks CLI profile name
+        
+    Returns:
+        Cloud provider string ('azure', 'aws', 'gcp') or None if detection fails
+    """
+    try:
+        from databricks.sdk import WorkspaceClient
+        
+        # Create workspace client with optional profile
+        if profile:
+            w = WorkspaceClient(profile=profile)
+        else:
+            w = WorkspaceClient()
+        
+        # Get the workspace URL from config
+        host = w.config.host
+        if not host:
+            logger.warning("Could not determine workspace URL for cloud detection")
+            return None
+            
+        host_lower = host.lower()
+        
+        if "azuredatabricks.net" in host_lower:
+            logger.debug(f"Detected Azure cloud from workspace URL: {host}")
+            return "azure"
+        elif ".gcp.databricks.com" in host_lower:
+            logger.debug(f"Detected GCP cloud from workspace URL: {host}")
+            return "gcp"
+        elif ".cloud.databricks.com" in host_lower or "databricks.com" in host_lower:
+            # AWS uses *.cloud.databricks.com or regional patterns
+            logger.debug(f"Detected AWS cloud from workspace URL: {host}")
+            return "aws"
+        else:
+            logger.warning(f"Could not determine cloud provider from URL: {host}")
+            return None
+            
+    except Exception as e:
+        logger.warning(f"Could not detect cloud provider: {e}")
+        return None
+
+
 env_path: str = find_dotenv()
 if env_path:
     logger.info(f"Loading environment variables from: {env_path}")
@@ -220,6 +271,13 @@ Examples:
         "-t",
         "--target",
         type=str,
+        help="Bundle target name (default: auto-generated from app name and cloud)",
+    )
+    bundle_parser.add_argument(
+        "--cloud",
+        type=str,
+        choices=["azure", "aws", "gcp"],
+        help="Cloud provider (auto-detected from workspace URL if not specified)",
     )
     bundle_parser.add_argument(
         "--dry-run",
@@ -676,7 +734,7 @@ def generate_bundle_from_template(config_path: Path, app_name: str) -> Path:
     4. Returns the path to the generated file
 
     The generated databricks.yaml is overwritten on each deployment and is not tracked in git.
-    Schema reference remains pointing to ./schemas/bundle_config_schema.json.
+    The template contains cloud-specific targets (azure, aws, gcp) with appropriate node types.
 
     Args:
         config_path: Path to the app config file
@@ -713,15 +771,17 @@ def run_databricks_command(
     profile: Optional[str] = None,
     config: Optional[str] = None,
     target: Optional[str] = None,
+    cloud: Optional[str] = None,
     dry_run: bool = False,
 ) -> None:
-    """Execute a databricks CLI command with optional profile and target.
+    """Execute a databricks CLI command with optional profile, target, and cloud.
     
     Args:
         command: The databricks CLI command to execute (e.g., ["bundle", "deploy"])
         profile: Optional Databricks CLI profile name
         config: Optional path to the configuration file
-        target: Optional bundle target name
+        target: Optional bundle target name (if not provided, auto-generated from app name and cloud)
+        cloud: Optional cloud provider ('azure', 'aws', 'gcp'). Auto-detected if not specified.
         dry_run: If True, print the command without executing
     """
     config_path = Path(config) if config else None
@@ -730,22 +790,30 @@ def run_databricks_command(
         logger.error(f"Configuration file {config_path} does not exist.")
         sys.exit(1)
 
-    # Load app config and generate bundle from template
+    # Load app config
     app_config: AppConfig = AppConfig.from_file(config_path) if config_path else None
     normalized_name: str = normalize_name(app_config.app.name) if app_config else None
 
+    # Auto-detect cloud provider if not specified
+    if not cloud:
+        cloud = detect_cloud_provider(profile)
+        if cloud:
+            logger.info(f"Auto-detected cloud provider: {cloud}")
+        else:
+            logger.warning("Could not detect cloud provider. Defaulting to 'azure'.")
+            cloud = "azure"
+
     # Generate app-specific bundle from template (overwrites databricks.yaml temporarily)
     if config_path and app_config:
         generate_bundle_from_template(config_path, normalized_name)
 
-    # Use app name as target if not explicitly provided
-    # This ensures each app gets its own Terraform state in .databricks/bundle/<app-name>/
-    if not target and normalized_name:
-        target = normalized_name
-        logger.debug(f"Using app-specific target: {target}")
+    # Use cloud as target (azure, aws, gcp) - can be overridden with explicit --target
+    if not target:
+        target = cloud
+        logger.debug(f"Using cloud-based target: {target}")
 
-    # Build databricks command (no -c flag needed, uses databricks.yaml in current dir)
-    # Note: --profile is a global flag, but --target is a subcommand flag for 'bundle'
+    # Build databricks command
+    # --profile is a global flag, --target is a subcommand flag for 'bundle'
     cmd = ["databricks"]
     if profile:
         cmd.extend(["--profile", profile])
@@ -810,30 +878,38 @@ def handle_bundle_command(options: Namespace) -> None:
     profile: Optional[str] = options.profile
     config: Optional[str] = options.config
     target: Optional[str] = options.target
+    cloud: Optional[str] = options.cloud
     dry_run: bool = options.dry_run
 
     if options.deploy:
         logger.info("Deploying DAO AI asset bundle...")
         run_databricks_command(
-            ["bundle", "deploy"], profile, config, target, dry_run=dry_run
+            ["bundle", "deploy"],
+            profile=profile,
+            config=config,
+            target=target,
+            cloud=cloud,
+            dry_run=dry_run,
         )
     if options.run:
         logger.info("Running DAO AI system with current configuration...")
         # Use static job resource key that matches databricks.yaml (resources.jobs.deploy_job)
         run_databricks_command(
             ["bundle", "run", "deploy_job"],
-            profile,
-            config,
-            target,
+            profile=profile,
+            config=config,
+            target=target,
+            cloud=cloud,
             dry_run=dry_run,
         )
     if options.destroy:
         logger.info("Destroying DAO AI system with current configuration...")
         run_databricks_command(
             ["bundle", "destroy", "--auto-approve"],
-            profile,
-            config,
-            target,
+            profile=profile,
+            config=config,
+            target=target,
+            cloud=cloud,
             dry_run=dry_run,
         )
     else: