Sync all changes: cleanup files, update Dockerfile, fix UI

DEPLOYMENT.md

@@ -1,668 +0,0 @@
-# Unity Catalog Chatbot - Deployment & Operations Guide
-
-## Table of Contents
-1. [Quick Start](#quick-start)
-2. [Deployment Options](#deployment-options)
-3. [Configuration](#configuration)
-4. [Monitoring & Observability](#monitoring--observability)
-5. [Security Hardening](#security-hardening)
-6. [Troubleshooting](#troubleshooting)
-7. [Performance Tuning](#performance-tuning)
-8. [Backup & Recovery](#backup--recovery)
-
-## Quick Start
-
-### Local Development
-
-```bash
-# 1. Clone repository
-git clone <repository-url>
-cd unity-catalog-chatbot
-
-# 2. Create virtual environment
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-
-# 3. Install dependencies
-pip install -r requirements.txt
-
-# 4. Configure environment
-cp .env.example .env
-# Edit .env with your credentials
-
-# 5. Run the application
-python app.py
-```
-
-### Docker Deployment
-
-```bash
-# Build and run with Docker Compose
-docker-compose up -d
-
-# Check logs
-docker-compose logs -f unity-catalog-chatbot
-
-# Stop services
-docker-compose down
-```
-
-## Deployment Options
-
-### Option 1: Docker on AWS ECS
-
-```bash
-# Build and tag image
-docker build -t unity-catalog-chatbot:latest .
-docker tag unity-catalog-chatbot:latest <aws-account-id>.dkr.ecr.<region>.amazonaws.com/unity-catalog-chatbot:latest
-
-# Push to ECR
-aws ecr get-login-password --region <region> | docker login --username AWS --password-stdin <aws-account-id>.dkr.ecr.<region>.amazonaws.com
-docker push <aws-account-id>.dkr.ecr.<region>.amazonaws.com/unity-catalog-chatbot:latest
-
-# Deploy to ECS using terraform or console
-```
-
-**ECS Task Definition:**
-```json
-{
-  "family": "unity-catalog-chatbot",
-  "containerDefinitions": [
-    {
-      "name": "chatbot",
-      "image": "<ecr-image>",
-      "memory": 2048,
-      "cpu": 1024,
-      "essential": true,
-      "portMappings": [
-        {
-          "containerPort": 5000,
-          "protocol": "tcp"
-        }
-      ],
-      "environment": [
-        {
-          "name": "ENVIRONMENT",
-          "value": "production"
-        }
-      ],
-      "secrets": [
-        {
-          "name": "DATABRICKS_TOKEN",
-          "valueFrom": "arn:aws:secretsmanager:region:account:secret:databricks-token"
-        },
-        {
-          "name": "ANTHROPIC_API_KEY",
-          "valueFrom": "arn:aws:secretsmanager:region:account:secret:anthropic-key"
-        }
-      ]
-    }
-  ]
-}
-```
-
-### Option 2: Kubernetes Deployment
-
-**deployment.yaml:**
-```yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: unity-catalog-chatbot
-spec:
-  replicas: 3
-  selector:
-    matchLabels:
-      app: unity-catalog-chatbot
-  template:
-    metadata:
-      labels:
-        app: unity-catalog-chatbot
-    spec:
-      containers:
-      - name: chatbot
-        image: unity-catalog-chatbot:latest
-        ports:
-        - containerPort: 5000
-        env:
-        - name: ENVIRONMENT
-          value: "production"
-        envFrom:
-        - secretRef:
-            name: chatbot-secrets
-        resources:
-          requests:
-            memory: "1Gi"
-            cpu: "500m"
-          limits:
-            memory: "2Gi"
-            cpu: "1000m"
-        livenessProbe:
-          httpGet:
-            path: /api/health
-            port: 5000
-          initialDelaySeconds: 30
-          periodSeconds: 10
-        readinessProbe:
-          httpGet:
-            path: /api/health
-            port: 5000
-          initialDelaySeconds: 5
-          periodSeconds: 5
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: unity-catalog-chatbot
-spec:
-  selector:
-    app: unity-catalog-chatbot
-  ports:
-  - protocol: TCP
-    port: 80
-    targetPort: 5000
-  type: LoadBalancer
-```
-
-**secrets.yaml:**
-```yaml
-apiVersion: v1
-kind: Secret
-metadata:
-  name: chatbot-secrets
-type: Opaque
-stringData:
-  DATABRICKS_HOST: "https://your-workspace.cloud.databricks.com"
-  DATABRICKS_TOKEN: "your-token"
-  ANTHROPIC_API_KEY: "your-key"
-```
-
-Deploy:
-```bash
-kubectl apply -f deployment.yaml
-kubectl apply -f secrets.yaml
-```
-
-### Option 3: Serverless (AWS Lambda)
-
-**serverless.yml:**
-```yaml
-service: unity-catalog-chatbot
-
-provider:
-  name: aws
-  runtime: python3.9
-  region: us-east-1
-  environment:
-    DATABRICKS_HOST: ${env:DATABRICKS_HOST}
-    DATABRICKS_TOKEN: ${env:DATABRICKS_TOKEN}
-    ANTHROPIC_API_KEY: ${env:ANTHROPIC_API_KEY}
-
-functions:
-  chat:
-    handler: lambda_handler.chat_handler
-    timeout: 30
-    events:
-      - http:
-          path: api/chat
-          method: post
-          cors: true
-  
-  health:
-    handler: lambda_handler.health_handler
-    events:
-      - http:
-          path: api/health
-          method: get
-
-plugins:
-  - serverless-python-requirements
-```
-
-## Configuration
-
-### Environment Variables
-
-**Required:**
-- `DATABRICKS_HOST`: Your Databricks workspace URL
-- `DATABRICKS_TOKEN`: Personal access token or service principal token
-- `ANTHROPIC_API_KEY`: Anthropic API key for Claude
-
-**Optional:**
-- `DATABRICKS_WAREHOUSE_ID`: SQL Warehouse for executing queries
-- `ENVIRONMENT`: development|staging|production (default: development)
-- `SERVER_PORT`: API server port (default: 5000)
-- `SERVER_WORKERS`: Number of worker processes (default: 4)
-- `LOG_LEVEL`: DEBUG|INFO|WARNING|ERROR (default: INFO)
-- `ENABLE_AUTH`: Enable API key authentication (default: false)
-- `RATE_LIMIT_PER_MINUTE`: API rate limit (default: 60)
-
-### Configuration File
-
-Create `config.yaml` for advanced configuration:
-
-```yaml
-environment: production
-
-databricks:
-  host: https://your-workspace.cloud.databricks.com
-  warehouse_id: abc123
-
-server:
-  host: 0.0.0.0
-  port: 5000
-  workers: 4
-  timeout: 120
-
-security:
-  enable_auth: true
-  rate_limit: 100
-  allowed_origins:
-    - https://yourapp.com
-    - https://admin.yourapp.com
-
-features:
-  sql_execution: true
-  batch_operations: true
-  audit_logging: true
-  caching: true
-
-logging:
-  level: INFO
-  log_to_file: true
-  log_file: /var/log/chatbot/app.log
-```
-
-## Monitoring & Observability
-
-### Health Checks
-
-```bash
-# Basic health check
-curl http://localhost:5000/api/health
-
-# Expected response:
-{
-  "status": "healthy",
-  "service": "Unity Catalog Chatbot API"
-}
-```
-
-### Metrics Collection
-
-Add Prometheus metrics:
-
-```python
-from prometheus_client import Counter, Histogram, generate_latest
-
-# Metrics
-request_count = Counter('chatbot_requests_total', 'Total requests')
-request_duration = Histogram('chatbot_request_duration_seconds', 'Request duration')
-error_count = Counter('chatbot_errors_total', 'Total errors')
-
-@app.route('/metrics')
-def metrics():
-    return generate_latest()
-```
-
-### Logging
-
-**Structured logging with JSON:**
-
-```python
-import logging
-import json
-
-class JSONFormatter(logging.Formatter):
-    def format(self, record):
-        log_data = {
-            'timestamp': self.formatTime(record),
-            'level': record.levelname,
-            'message': record.getMessage(),
-            'module': record.module,
-            'function': record.funcName
-        }
-        return json.dumps(log_data)
-
-handler = logging.StreamHandler()
-handler.setFormatter(JSONFormatter())
-logger.addHandler(handler)
-```
-
-### Application Performance Monitoring (APM)
-
-**With DataDog:**
-
-```python
-from ddtrace import tracer
-
-@app.before_request
-def before_request():
-    tracer.trace('http.request')
-
-@app.after_request
-def after_request(response):
-    return response
-```
-
-## Security Hardening
-
-### 1. API Key Authentication
-
-```python
-from functools import wraps
-from flask import request, jsonify
-
-def require_api_key(f):
-    @wraps(f)
-    def decorated_function(*args, **kwargs):
-        api_key = request.headers.get('X-API-Key')
-        
-        if not api_key or api_key != os.getenv('API_SECRET_KEY'):
-            return jsonify({'error': 'Invalid API key'}), 401
-        
-        return f(*args, **kwargs)
-    return decorated_function
-
-@app.route('/api/chat', methods=['POST'])
-@require_api_key
-def chat():
-    # ... implementation
-```
-
-### 2. Rate Limiting
-
-```python
-from flask_limiter import Limiter
-from flask_limiter.util import get_remote_address
-
-limiter = Limiter(
-    app,
-    key_func=get_remote_address,
-    default_limits=["100 per hour"]
-)
-
-@app.route('/api/chat', methods=['POST'])
-@limiter.limit("10 per minute")
-def chat():
-    # ... implementation
-```
-
-### 3. Input Validation
-
-```python
-from jsonschema import validate, ValidationError
-
-chat_schema = {
-    "type": "object",
-    "properties": {
-        "message": {"type": "string", "minLength": 1, "maxLength": 1000}
-    },
-    "required": ["message"]
-}
-
-@app.route('/api/chat', methods=['POST'])
-def chat():
-    try:
-        validate(request.json, chat_schema)
-    except ValidationError as e:
-        return jsonify({'error': 'Invalid input'}), 400
-```
-
-### 4. Secrets Management
-
-**AWS Secrets Manager:**
-
-```python
-import boto3
-import json
-
-def get_secret(secret_name):
-    client = boto3.client('secretsmanager', region_name='us-east-1')
-    
-    response = client.get_secret_value(SecretId=secret_name)
-    return json.loads(response['SecretString'])
-
-# Usage
-secrets = get_secret('unity-catalog-chatbot/prod')
-databricks_token = secrets['databricks_token']
-```
-
-### 5. HTTPS Enforcement
-
-```python
-@app.before_request
-def before_request():
-    if not request.is_secure and app.config.get('FORCE_HTTPS'):
-        url = request.url.replace('http://', 'https://', 1)
-        return redirect(url, code=301)
-```
-
-## Troubleshooting
-
-### Common Issues
-
-**1. Authentication Errors**
-
-```
-Error: 401 Unauthorized
-```
-
-**Solutions:**
-- Verify Databricks token is valid and not expired
-- Check token has necessary permissions
-- Ensure workspace URL is correct
-
-**2. Rate Limiting**
-
-```
-Error: 429 Too Many Requests
-```
-
-**Solutions:**
-- Increase rate limits in configuration
-- Implement request queuing
-- Use caching for repeated queries
-
-**3. Timeout Errors**
-
-```
-Error: Request timeout
-```
-
-**Solutions:**
-- Increase `SERVER_TIMEOUT` setting
-- Optimize database queries
-- Use async processing for long operations
-
-**4. Memory Issues**
-
-```
-Error: Out of memory
-```
-
-**Solutions:**
-- Increase container memory limits
-- Reduce number of workers
-- Implement pagination for large result sets
-
-### Debug Mode
-
-Enable detailed debugging:
-
-```bash
-export FLASK_ENV=development
-export LOG_LEVEL=DEBUG
-python app.py
-```
-
-## Performance Tuning
-
-### 1. Caching
-
-Implement Redis caching:
-
-```python
-import redis
-from functools import wraps
-
-redis_client = redis.Redis(
-    host='localhost',
-    port=6379,
-    db=0
-)
-
-def cache_result(ttl=300):
-    def decorator(f):
-        @wraps(f)
-        def wrapper(*args, **kwargs):
-            key = f"{f.__name__}:{str(args)}:{str(kwargs)}"
-            
-            # Try to get from cache
-            cached = redis_client.get(key)
-            if cached:
-                return json.loads(cached)
-            
-            # Execute and cache
-            result = f(*args, **kwargs)
-            redis_client.setex(key, ttl, json.dumps(result))
-            
-            return result
-        return wrapper
-    return decorator
-
-@cache_result(ttl=600)
-def list_catalogs():
-    # ... implementation
-```
-
-### 2. Connection Pooling
-
-```python
-from databricks.sdk import WorkspaceClient
-
-class ConnectionPool:
-    def __init__(self, size=10):
-        self.pool = []
-        self.size = size
-        
-    def get_client(self):
-        # Implement connection pooling
-        pass
-```
-
-### 3. Async Processing
-
-For long-running operations:
-
-```python
-from celery import Celery
-
-celery = Celery('tasks', broker='redis://localhost:6379')
-
-@celery.task
-def process_batch_operation(operations):
-    # Process in background
-    pass
-```
-
-## Backup & Recovery
-
-### Configuration Backup
-
-```bash
-# Backup environment configuration
-cp .env .env.backup.$(date +%Y%m%d)
-
-# Backup custom configurations
-tar -czf config-backup-$(date +%Y%m%d).tar.gz config.yaml *.yml
-```
-
-### Disaster Recovery Plan
-
-1. **Database Backups**: Unity Catalog is backed up by Databricks
-2. **Configuration**: Store in version control (Git)
-3. **Secrets**: Use managed secret services (AWS Secrets Manager, HashiCorp Vault)
-4. **Application State**: Stateless design - no local state to backup
-
-### Recovery Procedure
-
-```bash
-# 1. Restore configuration
-cp .env.backup.YYYYMMDD .env
-
-# 2. Rebuild and redeploy
-docker-compose build
-docker-compose up -d
-
-# 3. Verify health
-curl http://localhost:5000/api/health
-
-# 4. Run smoke tests
-pytest tests/smoke_tests.py
-```
-
-## Production Checklist
-
-- [ ] Environment variables configured in secrets manager
-- [ ] HTTPS enabled with valid SSL certificate
-- [ ] Rate limiting configured
-- [ ] Authentication enabled
-- [ ] Logging configured and centralized
-- [ ] Monitoring and alerting set up
-- [ ] Health checks configured
-- [ ] Auto-scaling policies defined
-- [ ] Backup procedures documented
-- [ ] Disaster recovery plan tested
-- [ ] Security audit completed
-- [ ] Load testing performed
-- [ ] Documentation updated
-
-## Maintenance
-
-### Regular Tasks
-
-**Daily:**
-- Monitor error logs
-- Check API response times
-- Verify health check status
-
-**Weekly:**
-- Review performance metrics
-- Check for security updates
-- Analyze usage patterns
-
-**Monthly:**
-- Rotate credentials
-- Review and update dependencies
-- Performance optimization review
-- Security audit
-
-### Upgrade Procedure
-
-```bash
-# 1. Test in staging
-git checkout develop
-docker-compose -f docker-compose.staging.yml up -d
-
-# 2. Run tests
-pytest tests/
-
-# 3. Deploy to production
-git checkout main
-git merge develop
-docker-compose build
-docker-compose up -d --no-deps chatbot
-
-# 4. Verify deployment
-curl http://localhost:5000/api/health
-```
-
-## Support
-
-For production issues:
-1. Check logs: `docker-compose logs chatbot`
-2. Verify configuration: Review .env file
-3. Test connectivity: `curl http://localhost:5000/api/health`
-4. Review documentation: README.md
-5. Contact support: [Your support channel]

DEPLOYMENT_CHECKLIST.md

@@ -1,336 +0,0 @@
-# Unity Catalog Chatbot - Deployment Checklist
-
-## 📋 Pre-Deployment Checklist
-
-### Required Credentials
-- [ ] Databricks workspace URL
-- [ ] Databricks personal access token (PAT)
-- [ ] Anthropic Claude API key
-- [ ] (Optional) SQL Warehouse ID
-
-### Required Software
-- [ ] Python 3.9 or higher installed
-- [ ] pip package manager
-- [ ] Git (optional, for version control)
-- [ ] Docker Desktop (optional, for container deployment)
-
-### Databricks Permissions
-- [ ] Unity Catalog access
-- [ ] CREATE CATALOG permission on metastore
-- [ ] Ability to grant/revoke permissions
-- [ ] Workspace access
-
----
-
-## 🚀 Deployment Steps
-
-### Phase 1: Setup (5 minutes)
-- [ ] Download all project files
-- [ ] Create project directory
-- [ ] Copy `.env.example` to `.env`
-- [ ] Fill in credentials in `.env` file
-- [ ] Verify credentials are correct (no extra spaces/quotes)
-
-### Phase 2: Installation (3 minutes)
-- [ ] Run `chmod +x deploy.sh`
-- [ ] Execute `./deploy.sh`
-- [ ] OR manually: `pip install -r requirements.txt`
-- [ ] Wait for dependencies to install
-
-### Phase 3: Deployment (2 minutes)
-- [ ] Start application (`python app.py` or via deploy script)
-- [ ] Wait for "Running on http://0.0.0.0:5000"
-- [ ] Application PID saved (if using deploy script)
-
-### Phase 4: Verification (2 minutes)
-- [ ] Health check: `curl http://localhost:5000/api/health`
-- [ ] Response is `{"status": "healthy"}`
-- [ ] No errors in logs
-
----
-
-## ✅ Testing Checklist
-
-### Basic Tests
-- [ ] Health endpoint returns 200
-- [ ] Help command works
-- [ ] List catalogs works
-- [ ] API returns proper JSON
-
-### Functional Tests
-- [ ] Create catalog command generates SQL
-- [ ] Create schema command works
-- [ ] Create table command works
-- [ ] Grant permission command works
-- [ ] Show permissions command works
-
-### Integration Tests
-- [ ] Actually create a test catalog in Databricks
-- [ ] Verify catalog appears in Databricks UI
-- [ ] Create schema in test catalog
-- [ ] Grant permission to test user
-- [ ] Verify permission in Databricks
-
-### Error Handling
-- [ ] Empty message returns appropriate error
-- [ ] Invalid commands return helpful messages
-- [ ] Databricks errors are caught and reported
-- [ ] Claude API errors are handled gracefully
-
----
-
-## 🧪 Automated Testing
-
-### Run Test Suite
-- [ ] Make test script executable: `chmod +x test.sh`
-- [ ] Run tests: `./test.sh`
-- [ ] Review test report: `cat test_report.txt`
-- [ ] Pass rate > 90%
-
-### Test Results
-- [ ] All connectivity tests pass
-- [ ] Help commands work
-- [ ] Catalog operations succeed
-- [ ] Schema operations succeed
-- [ ] Table operations succeed
-- [ ] Permission operations succeed
-- [ ] Performance acceptable (< 5s response)
-
----
-
-## 🔒 Security Checklist
-
-### Development Environment
-- [ ] `.env` file is in `.gitignore`
-- [ ] No credentials committed to Git
-- [ ] Local firewall allows port 5000 (if needed)
-
-### Production Environment
-- [ ] Using Azure Key Vault for secrets
-- [ ] HTTPS enabled
-- [ ] CORS configured properly
-- [ ] Rate limiting enabled
-- [ ] Authentication enabled
-- [ ] Monitoring configured
-- [ ] Logging to centralized system
-
----
-
-## 📊 Monitoring Checklist
-
-### Logging
-- [ ] Application logs are being written
-- [ ] Log level set appropriately (INFO for prod)
-- [ ] Errors are logged with stack traces
-- [ ] SQL commands are logged
-- [ ] User actions are logged
-
-### Health Monitoring
-- [ ] Health endpoint accessible
-- [ ] Response time acceptable
-- [ ] No memory leaks
-- [ ] CPU usage normal
-
----
-
-## 🐳 Docker Deployment Checklist
-
-### If Using Docker
-- [ ] Docker daemon is running
-- [ ] `.env` file configured
-- [ ] Build image: `docker build -t unity-catalog-chatbot .`
-- [ ] Image built successfully
-- [ ] Run container: `docker run -d -p 5000:5000 --env-file .env unity-catalog-chatbot`
-- [ ] Container is running: `docker ps`
-- [ ] Health check passes
-- [ ] Logs accessible: `docker logs unity-catalog-chatbot`
-
-### If Using Docker Compose
-- [ ] Docker Compose installed
-- [ ] `.env` file configured
-- [ ] Start services: `docker-compose up -d`
-- [ ] All services running: `docker-compose ps`
-- [ ] Health checks pass
-- [ ] Logs accessible: `docker-compose logs`
-
----
-
-## 🌐 Frontend Deployment Checklist
-
-### React Component
-- [ ] Update API URL in component (if different from localhost:5000)
-- [ ] Build React app: `npm run build`
-- [ ] Test component in development
-- [ ] Verify API calls work
-- [ ] Check CORS settings
-
-### Static Hosting
-- [ ] Built files ready
-- [ ] CORS enabled on backend
-- [ ] Deploy to hosting (Netlify/Vercel/Azure Static Web Apps)
-- [ ] Test production URL
-- [ ] Verify API connectivity
-
----
-
-## ☁️ Azure Deployment Checklist
-
-### Prerequisites
-- [ ] Azure subscription active
-- [ ] Azure CLI installed
-- [ ] Logged into Azure: `az login`
-
-### Resource Creation
-- [ ] Resource group created
-- [ ] Key Vault created
-- [ ] Secrets stored in Key Vault
-- [ ] App Service Plan created
-- [ ] Web App created
-- [ ] Application Insights configured
-
-### Deployment
-- [ ] Container registry created
-- [ ] Docker image built
-- [ ] Image pushed to ACR
-- [ ] Web App configured
-- [ ] Environment variables set
-- [ ] Managed identity configured
-- [ ] Key Vault access granted
-
-### Verification
-- [ ] App Service is running
-- [ ] Health endpoint accessible
-- [ ] HTTPS working
-- [ ] Custom domain configured (if needed)
-- [ ] SSL certificate valid
-
----
-
-## 📝 Documentation Checklist
-
-### User Documentation
-- [ ] README.md reviewed
-- [ ] QUICKSTART.md available
-- [ ] TESTING_GUIDE.md available
-- [ ] Example commands documented
-- [ ] API endpoints documented
-
-### Operations Documentation
-- [ ] DEPLOYMENT.md reviewed
-- [ ] Backup procedures documented
-- [ ] Disaster recovery plan documented
-- [ ] Monitoring setup documented
-- [ ] Troubleshooting guide available
-
----
-
-## 🎯 Post-Deployment Checklist
-
-### Day 1
-- [ ] Monitor logs for errors
-- [ ] Test all major functions
-- [ ] Verify no performance issues
-- [ ] Check resource usage (CPU/Memory)
-- [ ] Ensure no security alerts
-
-### Week 1
-- [ ] Review usage patterns
-- [ ] Optimize slow queries
-- [ ] Update documentation based on feedback
-- [ ] Address any bugs found
-- [ ] Plan feature improvements
-
-### Month 1
-- [ ] Security audit
-- [ ] Performance review
-- [ ] Cost analysis (if cloud-hosted)
-- [ ] User feedback review
-- [ ] Update dependencies
-
----
-
-## 🆘 Troubleshooting Checklist
-
-### Application Won't Start
-- [ ] Check Python version
-- [ ] Verify all dependencies installed
-- [ ] Check `.env` file exists and is valid
-- [ ] Look for port conflicts
-- [ ] Review error messages in console
-- [ ] Check `app.log` file
-
-### Databricks Connection Failed
-- [ ] Verify workspace URL is correct
-- [ ] Check token hasn't expired
-- [ ] Test token with curl command
-- [ ] Verify network connectivity
-- [ ] Check firewall rules
-
-### Claude API Errors
-- [ ] Verify API key is correct
-- [ ] Check API credits/billing
-- [ ] Test API key with curl
-- [ ] Check rate limits
-- [ ] Verify internet connectivity
-
-### Tests Failing
-- [ ] Check test environment setup
-- [ ] Verify test data exists
-- [ ] Review test logs
-- [ ] Check for timing issues
-- [ ] Verify API is running
-
----
-
-## ✨ Success Criteria
-
-Your deployment is successful when:
-
-### Technical
-- ✅ Health check returns 200 OK
-- ✅ All automated tests pass (>90%)
-- ✅ Response times < 5 seconds
-- ✅ No errors in logs
-- ✅ Memory usage stable
-
-### Functional
-- ✅ Can list existing catalogs
-- ✅ Can create new catalogs
-- ✅ Can create schemas and tables
-- ✅ Can manage permissions
-- ✅ SQL commands are correct
-
-### Operational
-- ✅ Logs are being collected
-- ✅ Monitoring is active
-- ✅ Backups configured (if applicable)
-- ✅ Team trained on usage
-- ✅ Documentation complete
-
----
-
-## 📞 Support Resources
-
-- **Documentation:** README.md, DEPLOYMENT.md, TESTING_GUIDE.md
-- **Logs:** `app.log` or `docker logs`
-- **Health Check:** http://localhost:5000/api/health
-- **Test Suite:** `./test.sh`
-
----
-
-## 🎉 Completion
-
-Once all items are checked:
-- [ ] Deployment is complete
-- [ ] System is tested and verified
-- [ ] Documentation is up to date
-- [ ] Team is trained
-- [ ] Monitoring is active
-- [ ] Ready for production use!
-
-**Congratulations! Your Unity Catalog Chatbot is deployed and ready to use! 🚀**
-
----
-
-Last Updated: $(date)
-Version: 1.0.0

DEPLOYMENT_GUIDE.md

@@ -1,755 +0,0 @@
-# UnityCatalog-ChatBot: Step-by-Step Deployment Guide
-
-## Overview
-This guide covers deploying the Unity Catalog ChatBot locally, in Docker, and to cloud platforms (AWS ECS, Kubernetes, Azure, etc.).
-
----
-
-## Part 1: Local Development Setup
-
-### Prerequisites
-- **Python 3.9+** (3.11+ recommended)
-- **pip** (Python package manager)
-- **Git**
-- **Databricks workspace** with:
-  - Host URL (e.g., `https://your-workspace.databricks.com`)
-  - Personal Access Token (PAT)
-  - Warehouse ID (optional, for SQL execution)
-- **Anthropic API key** (Claude access)
-
-### Step 1: Clone Repository
-```bash
-git clone <repository-url>
-cd UnityCatalog-ChatBot
-```
-
-### Step 2: Create Python Virtual Environment
-```bash
-# Windows
-python -m venv venv
-venv\Scripts\activate
-
-# macOS/Linux
-python3 -m venv venv
-source venv/bin/activate
-```
-
-### Step 3: Install Dependencies
-```bash
-pip install -r requirements.txt
-```
-
-### Step 4: Configure Environment Variables
-Create a `.env` file in the project root:
-```env
-# Databricks Configuration
-DATABRICKS_HOST=https://your-workspace.databricks.com
-DATABRICKS_TOKEN=your-personal-access-token
-DATABRICKS_WAREHOUSE_ID=your-warehouse-id  # Optional
-
-# Anthropic Configuration
-ANTHROPIC_API_KEY=sk-ant-your-api-key
-
-# Server Configuration (Optional)
-SERVER_HOST=0.0.0.0
-SERVER_PORT=5000
-SERVER_WORKERS=4
-FLASK_ENV=development
-
-# Feature Flags (Optional)
-ENABLE_AUTH=false
-ENABLE_SQL_EXECUTION=false
-LOG_LEVEL=INFO
-```
-
-**Important:** Never commit `.env` to version control. Add it to `.gitignore`:
-```
-.env
-*.pyc
-__pycache__/
-venv/
-```
-
-### Step 5: Run Tests (Mock-Only, No Credentials Required)
-```bash
-# Run all tests
-pytest test_chatbot.py -v
-
-# Run specific test class
-pytest test_chatbot.py::TestUnityCatalogService -v
-
-# Run with coverage
-pytest test_chatbot.py --cov=. --cov-report=html
-```
-
-Expected output:
-```
-======================== 23 passed in 0.52s =======================
-```
-
-### Step 6: Run Development Server
-```bash
-python app.py
-```
-
-Server starts on `http://localhost:5000`
-
-### Step 7: Test API Endpoints
-```bash
-# Health check
-curl http://localhost:5000/api/health
-
-# List catalogs
-curl http://localhost:5000/api/catalogs
-
-# Chat endpoint
-curl -X POST http://localhost:5000/api/chat \
-  -H "Content-Type: application/json" \
-  -d '{"message": "Create a catalog named sales_data"}'
-```
-
----
-
-## Part 2: Docker Deployment
-
-### Step 1: Build Docker Image
-```bash
-docker build -t unitycatalog-chatbot:latest .
-```
-
-### Step 2: Run Container (Development)
-```bash
-docker run -p 5000:5000 \
-  -e DATABRICKS_HOST="https://your-workspace.databricks.com" \
-  -e DATABRICKS_TOKEN="your-token" \
-  -e ANTHROPIC_API_KEY="sk-ant-your-key" \
-  unitycatalog-chatbot:latest
-```
-
-### Step 3: Run with Docker Compose
-```bash
-docker-compose up -d
-```
-
-Check logs:
-```bash
-docker-compose logs -f app
-```
-
-Stop containers:
-```bash
-docker-compose down
-```
-
-### Step 4: Verify Container Health
-```bash
-curl http://localhost:5000/api/health
-```
-
----
-
-## Part 3: Cloud Deployment
-
-### AWS ECS (Elastic Container Service)
-
-#### Prerequisites
-- AWS account with ECS access
-- ECR (Elastic Container Registry) repository created
-- IAM role for ECS task execution
-
-#### Steps
-1. **Push image to ECR:**
-```bash
-# Get login token
-aws ecr get-login-password --region us-east-1 | \
-  docker login --username AWS --password-stdin \
-  YOUR_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com
-
-# Tag image
-docker tag unitycatalog-chatbot:latest \
-  YOUR_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/unitycatalog-chatbot:latest
-
-# Push to ECR
-docker push YOUR_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/unitycatalog-chatbot:latest
-```
-
-2. **Create ECS Task Definition** (JSON):
-```json
-{
-  "family": "unitycatalog-chatbot",
-  "containerDefinitions": [
-    {
-      "name": "app",
-      "image": "YOUR_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/unitycatalog-chatbot:latest",
-      "portMappings": [{"containerPort": 5000, "hostPort": 5000}],
-      "environment": [
-        {"name": "DATABRICKS_HOST", "value": "https://your-workspace.databricks.com"},
-        {"name": "SERVER_HOST", "value": "0.0.0.0"},
-        {"name": "SERVER_PORT", "value": "5000"}
-      ],
-      "secrets": [
-        {"name": "DATABRICKS_TOKEN", "valueFrom": "arn:aws:secretsmanager:..."},
-        {"name": "ANTHROPIC_API_KEY", "valueFrom": "arn:aws:secretsmanager:..."}
-      ],
-      "logConfiguration": {
-        "logDriver": "awslogs",
-        "options": {
-          "awslogs-group": "/ecs/unitycatalog-chatbot",
-          "awslogs-region": "us-east-1",
-          "awslogs-stream-prefix": "ecs"
-        }
-      }
-    }
-  ],
-  "requiresCompatibilities": ["FARGATE"],
-  "networkMode": "awsvpc",
-  "cpu": "256",
-  "memory": "512"
-}
-```
-
-3. **Create ECS Service** using AWS Console or CLI:
-```bash
-aws ecs create-service \
-  --cluster my-cluster \
-  --service-name unitycatalog-chatbot \
-  --task-definition unitycatalog-chatbot:1 \
-  --desired-count 2 \
-  --launch-type FARGATE \
-  --network-configuration "awsvpcConfiguration={subnets=[subnet-xxx],securityGroups=[sg-xxx]}"
-```
-
-4. **Monitor service:**
-```bash
-aws ecs describe-services \
-  --cluster my-cluster \
-  --services unitycatalog-chatbot
-```
-
-### Kubernetes Deployment
-
-#### Prerequisites
-- Kubernetes cluster (EKS, AKS, GKE, or local)
-- `kubectl` CLI configured
-- Docker image pushed to container registry
-
-#### Steps
-
-1. **Create Kubernetes Secrets:**
-```bash
-kubectl create secret generic unitycatalog-secrets \
-  --from-literal=DATABRICKS_TOKEN='your-token' \
-  --from-literal=ANTHROPIC_API_KEY='sk-ant-your-key'
-```
-
-2. **Create Deployment (deployment.yaml):**
-```yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: unitycatalog-chatbot
-  labels:
-    app: unitycatalog-chatbot
-spec:
-  replicas: 3
-  selector:
-    matchLabels:
-      app: unitycatalog-chatbot
-  template:
-    metadata:
-      labels:
-        app: unitycatalog-chatbot
-    spec:
-      containers:
-      - name: app
-        image: your-registry/unitycatalog-chatbot:latest
-        ports:
-        - containerPort: 5000
-        env:
-        - name: DATABRICKS_HOST
-          value: "https://your-workspace.databricks.com"
-        - name: SERVER_HOST
-          value: "0.0.0.0"
-        - name: SERVER_PORT
-          value: "5000"
-        envFrom:
-        - secretRef:
-            name: unitycatalog-secrets
-        livenessProbe:
-          httpGet:
-            path: /api/health
-            port: 5000
-          initialDelaySeconds: 30
-          periodSeconds: 10
-        readinessProbe:
-          httpGet:
-            path: /api/health
-            port: 5000
-          initialDelaySeconds: 10
-          periodSeconds: 5
-        resources:
-          requests:
-            memory: "256Mi"
-            cpu: "250m"
-          limits:
-            memory: "512Mi"
-            cpu: "500m"
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: unitycatalog-chatbot-service
-spec:
-  type: LoadBalancer
-  ports:
-  - port: 80
-    targetPort: 5000
-  selector:
-    app: unitycatalog-chatbot
-```
-
-3. **Deploy to Kubernetes:**
-```bash
-kubectl apply -f deployment.yaml
-```
-
-4. **Monitor deployment:**
-```bash
-# Check status
-kubectl get pods -l app=unitycatalog-chatbot
-
-# Check logs
-kubectl logs -f deployment/unitycatalog-chatbot
-
-# Get service endpoint
-kubectl get service unitycatalog-chatbot-service
-```
-
-### Azure Container Instances (ACI)
-
-1. **Push image to Azure Container Registry:**
-```bash
-az acr build --registry your-acr-name \
-  --image unitycatalog-chatbot:latest .
-```
-
-2. **Deploy to ACI:**
-```bash
-az container create \
-  --resource-group your-rg \
-  --name unitycatalog-chatbot \
-  --image your-acr-name.azurecr.io/unitycatalog-chatbot:latest \
-  --cpu 1 --memory 1 \
-  --ports 5000 \
-  --environment-variables \
-    DATABRICKS_HOST="https://your-workspace.databricks.com" \
-    SERVER_HOST="0.0.0.0" \
-    SERVER_PORT="5000" \
-  --secure-environment-variables \
-    DATABRICKS_TOKEN="your-token" \
-    ANTHROPIC_API_KEY="sk-ant-your-key"
-```
-
-### Hugging Face Spaces (Docker)
-
-#### Prerequisites
-- Hugging Face account (free at https://huggingface.co/join)
-- Repository on Hugging Face Hub (create at https://huggingface.co/new)
-
-#### Step 1: Create Hugging Face Repository
-1. Go to https://huggingface.co/new
-2. Enter repository name: `unitycatalog-chatbot`
-3. Select **Space** type
-4. Choose **Docker** runtime
-5. Click **Create repository**
-
-#### Step 2: Clone Space Repository
-```bash
-git clone https://huggingface.co/spaces/your-username/unitycatalog-chatbot
-cd unitycatalog-chatbot
-```
-
-#### Step 3: Copy Project Files
-```bash
-# Copy source files
-cp -r ../UnityCatalog-ChatBot/* .
-
-# Ensure key files are present:
-# - app.py
-# - unity_catalog_service.py
-# - config.py
-# - requirements.txt
-# - Dockerfile
-# - test_chatbot.py (optional)
-```
-
-#### Step 4: Create `README.md` for Space
-```markdown
----
-title: Unity Catalog Chatbot
-emoji: 💬
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-# Unity Catalog Chatbot
-
-Natural language interface for Databricks Unity Catalog operations powered by Claude AI.
-
-## Features
-- Create catalogs, schemas, and tables via natural language
-- Grant and revoke permissions
-- List objects across Unity Catalog
-- Execute SQL queries
-
-## API Endpoints
-- `GET /api/health` - Health check
-- `POST /api/chat` - Chat with Claude to manage Unity Catalog
-- `GET /api/catalogs` - List all catalogs
-- `GET /api/schemas/<catalog>` - List schemas
-- `GET /api/tables/<catalog>/<schema>` - List tables
-
-## Environment Variables
-Required:
-- `DATABRICKS_HOST` - Databricks workspace URL
-- `DATABRICKS_TOKEN` - Personal access token
-- `ANTHROPIC_API_KEY` - Claude API key
-
-Optional:
-- `SERVER_PORT` - Port to run on (default: 5000)
-- `LOG_LEVEL` - Logging level (default: INFO)
-```
-
-#### Step 5: Create `secrets.toml` for Credentials
-Create `.streamlit/secrets.toml` (Hugging Face Spaces will hide these):
-
-**⚠️ IMPORTANT: Never commit secrets to git**
-
-Instead, use Hugging Face Secrets management:
-
-1. Go to your Space Settings → Secrets
-2. Add secrets:
-   - `DATABRICKS_HOST` = `https://your-workspace.databricks.com`
-   - `DATABRICKS_TOKEN` = your token
-   - `ANTHROPIC_API_KEY` = your API key
-
-Or set via UI environment variables in Space settings.
-
-#### Step 6: Update Dockerfile for Space (if needed)
-```dockerfile
-FROM python:3.11-slim
-
-WORKDIR /app
-
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
-  CMD python -c "import requests; requests.get('http://localhost:5000/api/health')"
-
-CMD ["python", "app.py"]
-```
-
-#### Step 7: Push to Hugging Face
-```bash
-# Configure git with HF credentials
-git config user.name "Your Name"
-git config user.email "your-email@example.com"
-
-# Add files
-git add .
-
-# Commit
-git commit -m "Initial deployment"
-
-# Push (triggers auto-build and deployment)
-git push
-```
-
-**Space will automatically:**
-- Build Docker image
-- Deploy to Hugging Face infrastructure
-- Provide public URL: `https://huggingface.co/spaces/your-username/unitycatalog-chatbot`
-
-#### Step 8: Verify Deployment
-```bash
-# Once Space is running, test the endpoint:
-curl https://your-username-unitycatalog-chatbot.hf.space/api/health
-
-# Chat endpoint
-curl -X POST https://your-username-unitycatalog-chatbot.hf.space/api/chat \
-  -H "Content-Type: application/json" \
-  -d '{"message": "List all catalogs"}'
-```
-
-#### Step 9: Set Secrets in Hugging Face UI
-1. Go to Space → Settings → Secrets
-2. Add environment variables:
-   - `DATABRICKS_HOST`
-   - `DATABRICKS_TOKEN`
-   - `ANTHROPIC_API_KEY`
-
-3. Space will restart automatically with secrets loaded
-
-#### Troubleshooting Hugging Face Spaces
-
-**Issue: "Build failed"**
-- Check **Build logs** in Space settings
-- Ensure `Dockerfile` is present
-- Verify `requirements.txt` has all dependencies
-
-**Issue: "Application won't start"**
-- Check **Runtime logs** in Space
-- Verify environment variables are set in Secrets
-- Test locally: `docker build -t test . && docker run -p 5000:5000 test`
-
-**Issue: "Port already in use"**
-- Hugging Face assigns a port automatically
-- Ensure `app.py` uses environment variable for port:
-```python
-if __name__ == '__main__':
-    port = int(os.getenv("SERVER_PORT", 5000))
-    app.run(host='0.0.0.0', port=port)
-```
-
-**Issue: "API calls timeout"**
-- Databricks/Anthropic credentials invalid
-- Network connectivity issue
-- Test locally first with real credentials
-
-#### Hugging Face Space Features
-
-- **Public URL:** `https://huggingface.co/spaces/your-username/unitycatalog-chatbot`
-- **Auto-scaling:** Handles traffic spikes
-- **Free tier:** Up to 2 CPU cores (enough for light use)
-- **Persistent storage:** `/tmp` directory available (ephemeral)
-- **Custom domain:** Upgrade to pro for custom domains
-
-#### Sharing Your Space
-
-1. Go to Space page
-2. Click **Share** button
-3. Copy shareable link or embed code:
-```html
-<iframe
-  src="https://huggingface.co/spaces/your-username/unitycatalog-chatbot?embed=true"
-  frameborder="0"
-  width="800"
-  height="600"
-></iframe>
-```
-
----
-
-## Part 4: Production Configuration
-
-### Security Best Practices
-
-1. **Enable Authentication:**
-```env
-ENABLE_AUTH=true
-API_KEY_HEADER=X-API-Key
-```
-
-Add API key header to requests:
-```bash
-curl -H "X-API-Key: your-api-key" http://localhost:5000/api/health
-```
-
-2. **Rate Limiting:**
-```env
-RATE_LIMIT_PER_MINUTE=60
-```
-
-3. **HTTPS/TLS:**
-Use reverse proxy (Nginx, HAProxy) to terminate TLS:
-```nginx
-server {
-    listen 443 ssl;
-    server_name your-domain.com;
-    
-    ssl_certificate /path/to/cert.pem;
-    ssl_certificate_key /path/to/key.pem;
-    
-    location / {
-        proxy_pass http://localhost:5000;
-        proxy_set_header X-Forwarded-For $remote_addr;
-    }
-}
-```
-
-4. **Environment Variables:**
-Use secret management (AWS Secrets Manager, Azure Key Vault, HashiCorp Vault):
-```bash
-# AWS
-aws secretsmanager get-secret-value --secret-id unitycatalog-secrets
-
-# Azure
-az keyvault secret show --vault-name your-vault --name DATABRICKS_TOKEN
-```
-
-### Logging & Monitoring
-
-1. **Enable comprehensive logging:**
-```env
-LOG_LEVEL=INFO
-LOG_TO_FILE=true
-LOG_FILE_PATH=/var/log/chatbot.log
-```
-
-2. **Application Insights / DataDog / CloudWatch:**
-Logs are automatically captured by container orchestration platforms.
-
-### Performance Tuning
-
-1. **Gunicorn workers** (production):
-```bash
-gunicorn --workers 4 --bind 0.0.0.0:5000 app:app
-```
-
-2. **Caching:**
-```env
-ENABLE_CACHING=true
-CACHE_TTL=300
-```
-
----
-
-## Part 5: Health Checks & Validation
-
-### Pre-Deployment Checklist
-
-- [ ] All tests pass: `pytest test_chatbot.py -v`
-- [ ] `.env` file configured with valid credentials
-- [ ] Docker image builds successfully
-- [ ] Health endpoint responds: `curl /api/health`
-- [ ] Sample requests succeed (catalog listing, chat)
-- [ ] Logs show no errors
-
-### Post-Deployment Validation
-
-```bash
-# Health check
-curl https://your-api-endpoint/api/health
-
-# Test chat endpoint
-curl -X POST https://your-api-endpoint/api/chat \
-  -H "Content-Type: application/json" \
-  -H "X-API-Key: your-api-key" \
-  -d '{"message": "List all catalogs"}'
-
-# Check logs
-kubectl logs deployment/unitycatalog-chatbot  # K8s
-docker logs <container-id>  # Docker
-aws logs tail /ecs/unitycatalog-chatbot --follow  # ECS
-```
-
----
-
-## Part 6: Troubleshooting
-
-### Common Issues
-
-**1. "Cannot configure default credentials"**
-- Ensure `.env` file has valid `DATABRICKS_HOST` and `DATABRICKS_TOKEN`
-- Verify token format (starts with `dapi`)
-
-**2. "Invalid Anthropic API key"**
-- Confirm key starts with `sk-ant-`
-- Check key has not expired
-
-**3. "Port 5000 already in use"**
-```bash
-# Kill process using port
-lsof -ti:5000 | xargs kill -9  # macOS/Linux
-netstat -ano | findstr :5000 & taskkill /PID <PID> /F  # Windows
-```
-
-**4. Docker build fails**
-```bash
-docker build --no-cache -t unitycatalog-chatbot:latest .
-```
-
-**5. Tests fail in CI/CD**
-- Tests use mocks and don't require credentials
-- If failing, check Python version (3.9+) and pytest version
-
-### Get Help
-
-Check logs for detailed error messages:
-```bash
-# Local
-python app.py  # stdout
-
-# Docker
-docker logs <container-name>
-
-# Kubernetes
-kubectl logs <pod-name> -c app
-```
-
----
-
-## Part 7: Scaling & Maintenance
-
-### Horizontal Scaling
-
-- **Docker Compose:** Increase `replicas` in docker-compose.yml
-- **Kubernetes:** `kubectl scale deployment unitycatalog-chatbot --replicas=5`
-- **ECS:** Update desired task count in AWS Console
-
-### Updates & Rollbacks
-
-1. **Build new image:**
-```bash
-docker build -t unitycatalog-chatbot:v1.1.0 .
-```
-
-2. **Push to registry:**
-```bash
-docker push your-registry/unitycatalog-chatbot:v1.1.0
-```
-
-3. **Update deployment:**
-```bash
-# Kubernetes
-kubectl set image deployment/unitycatalog-chatbot \
-  app=your-registry/unitycatalog-chatbot:v1.1.0
-
-# ECS (update task definition version)
-aws ecs update-service \
-  --cluster my-cluster \
-  --service unitycatalog-chatbot \
-  --task-definition unitycatalog-chatbot:2
-```
-
-4. **Rollback if needed:**
-```bash
-# Kubernetes
-kubectl rollout undo deployment/unitycatalog-chatbot
-
-# ECS
-aws ecs update-service \
-  --cluster my-cluster \
-  --service unitycatalog-chatbot \
-  --task-definition unitycatalog-chatbot:1
-```
-
----
-
-## Summary
-
-| Deployment Type | Complexity | Best For |
-|---|---|---|
-| **Local** | Easy | Development, testing |
-| **Docker** | Medium | Single machine, CI/CD |
-| **Kubernetes** | Hard | Enterprise, multi-region, auto-scaling |
-| **ECS** | Medium | AWS-only deployments |
-| **ACI** | Medium | Quick Azure deployments |
-
-Choose based on your infrastructure and scaling needs.

Dockerfile

@@ -1,35 +1,37 @@
-FROM python:3.9-slim
+FROM python:3.11-slim
 
-# Set working directory
 WORKDIR /app
 
 # Install system dependencies
 RUN apt-get update && apt-get install -y \
-    gcc \
+    curl \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements first for better caching
+# Copy requirements
 COPY requirements.txt .
 
 # Install Python dependencies
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Install production server
-RUN pip install --no-cache-dir gunicorn
-
 # Copy application files
 COPY app.py .
 COPY unity_catalog_service.py .
+COPY unity-catalog-chatbot.jsx .
+COPY index.html .
 COPY config.py .
 COPY conftest.py .
 
-# Create non-root user
-RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
-USER appuser
+# Expose port (HF Spaces uses 7860)
+EXPOSE 7860
 
-# Hugging Face Spaces injects PORT (default 7860)
+# Set environment variables
 ENV PORT=7860
-EXPOSE ${PORT}
+ENV HOST=0.0.0.0
+ENV FLASK_ENV=production
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/api/health || exit 1
 
-# Run with gunicorn (production server)
-CMD ["sh", "-c", "gunicorn --bind 0.0.0.0:${PORT:-7860} --workers 2 --timeout 120 --access-logfile - app:app"]
+# Run Flask app
+CMD ["python", "app.py"]

HF_DEPLOYMENT.md

@@ -1,153 +1,155 @@
-# Deploy UnityCatalog-ChatBot on Hugging Face Spaces
+# Deploy to Hugging Face Spaces
 
-Quick 5-minute deployment guide for Hugging Face Spaces.
+This guide explains how to deploy the Unity Catalog Chatbot to Hugging Face Spaces.
 
 ## Prerequisites
-- Hugging Face account (free signup: https://huggingface.co/join)
-- Databricks credentials (host + token)
-- Anthropic API key
 
-## Quick Start
+1. **Hugging Face Account** - Create one at https://huggingface.co
+2. **Git** - Installed and configured
+3. **Databricks Credentials** - API key and workspace URL
+4. **Anthropic API Key** - For Claude AI
 
-### 1️⃣ Create Space on Hugging Face
-```bash
-# Go to: https://huggingface.co/new
-# - Name: unitycatalog-chatbot
-# - Type: Space
-# - Runtime: Docker
-# - Click "Create Space"
-```
+## Step 1: Create a Hugging Face Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click **"Create new Space"**
+3. Fill in:
+   - **Space name**: `unity-catalog-chatbot` (or your choice)
+   - **License**: MIT (or your preference)
+   - **Space SDK**: Docker
+   - **Space hardware**: CPU (or GPU if needed)
+4. Click **"Create Space"**
+
+## Step 2: Clone the Space Repository
 
-### 2️⃣ Clone the Space
 ```bash
-git clone https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot
-cd unitycatalog-chatbot
+# Clone your newly created space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/unity-catalog-chatbot
+cd unity-catalog-chatbot
 ```
 
-### 3️⃣ Copy Project Files
+## Step 3: Add Files
+
+Copy these files from this repo to the cloned Space:
+
 ```bash
-# Copy all files from UnityCatalog-ChatBot to your Space
-cp -r ../UnityCatalog-ChatBot/* .
-
-# Required files:
-# - app.py
-# - unity_catalog_service.py
-# - config.py
-# - requirements.txt
-# - Dockerfile
-# - README.md (already created)
+cp /path/to/UnityCatalog-ChatBot/{app.py,unity-catalog-chatbot.jsx,unity_catalog_service.py,index.html,requirements.txt,.env.example,config.py,conftest.py} .
+cp /path/to/UnityCatalog-ChatBot/Dockerfile .
 ```
 
-### 4️⃣ Add README for Space
-Create `README.md`:
-```markdown
----
-title: Unity Catalog Chatbot
-emoji: 💬
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
----
+Or manually add the files to the Space repository.
 
-# Unity Catalog Chatbot
+## Step 4: Configure Environment Variables
 
-Chat interface for Databricks Unity Catalog management.
+In the Space settings on Hugging Face:
 
-## Setup
-Add secrets in Space settings:
-- `DATABRICKS_HOST`
-- `DATABRICKS_TOKEN`
-- `ANTHROPIC_API_KEY`
+1. Go to **Settings → Variables and Secrets**
+2. Add these secrets (HF will mask them):
+   - `ANTHROPIC_API_KEY`: Your Anthropic API key
+   - `DATABRICKS_HOST`: Your Databricks workspace URL
+   - `DATABRICKS_TOKEN`: Your Databricks personal access token
 
-Visit https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot
-```
+## Step 5: Push to Hugging Face
 
-### 5️⃣ Push to Hugging Face
 ```bash
+# Add all files
 git add .
-git commit -m "Deploy to HF Spaces"
-git push
-```
 
-### 6️⃣ Add Secrets
-1. Go to Space → **Settings** → **Secrets**
-2. Add three secrets:
-   - `DATABRICKS_HOST` = `https://your-workspace.databricks.com`
-   - `DATABRICKS_TOKEN` = your PAT
-   - `ANTHROPIC_API_KEY` = your key
+# Commit
+git commit -m "Initial deployment"
 
-3. Space rebuilds automatically ✅
+# Push to HF
+git push
+```
 
-### 7️⃣ Access Your App
-- URL: `https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot`
-- API: `https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/`
+The Space will automatically build and deploy.
 
-## Test Endpoints
+## Step 6: Access Your App
 
-```bash
-# Health check
-curl https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/health
+Once deployed, you can access it at:
+```
+https://huggingface.co/spaces/YOUR_USERNAME/unity-catalog-chatbot
+```
 
-# List catalogs
-curl https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/catalogs
+## How It Works
 
-# Chat
-curl -X POST https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/chat \
-  -H "Content-Type: application/json" \
-  -d '{"message": "Create a catalog named demo"}'
-```
+- **Frontend**: React UI served from `index.html`
+- **Backend**: Flask API at `/api/chat` and other endpoints
+- **Port**: Automatically uses port 7860 (HF Spaces standard)
+- **Static Files**: Served from the root directory
 
-## Common Issues
+## Testing the Deployment
 
-| Issue | Solution |
-|-------|----------|
-| Build fails | Check build logs in Settings. Verify Dockerfile exists. |
-| App crashes | Check runtime logs. Ensure secrets are set. |
-| API returns 500 | Credentials invalid. Test locally first. |
-| "Port already in use" | App should auto-detect port. Check `app.py`. |
+1. Open the Space URL
+2. You'll see the setup screen asking for credentials
+3. Enter your Databricks workspace details:
+   - Host: `https://your-workspace.cloud.databricks.com`
+   - Token: Your Databricks API token
+   - Workspace ID: (optional)
+4. Click "✓ Connect"
+5. Type: "Create a catalog named test_catalog"
+6. You should see the response and SQL preview
 
-## Monitoring
+## Troubleshooting
 
-View logs in Space:
-1. **Settings** → **Build logs** (deployment)
-2. **Settings** → **Runtime logs** (application)
+### App doesn't start
+- Check logs in Space settings → Logs
+- Verify all environment variables are set
+- Ensure `requirements.txt` has all dependencies
 
-## Upgrade Options
+### "Cannot reach /api/chat"
+- The Flask app may not be running
+- Check that port is correctly set to 7860
+- Verify CORS is enabled
 
-- **Free**: 2 CPU, shared GPU, variable uptime
-- **Pro**: $50/month, dedicated resources, custom domain
+### Databricks connection fails
+- Double-check credentials
+- Ensure token hasn't expired
+- Verify workspace has Unity Catalog enabled
 
----
+### Frontend not loading
+- Check browser console (F12) for errors
+- Ensure `index.html` is in the root directory
+- Clear browser cache and reload
 
-## File Checklist
+## Security Notes
 
-Before pushing, ensure you have:
+⚠️ **Important:**
+- Never hardcode API keys in files
+- Use Hugging Face Secrets for sensitive credentials
+- Don't commit `.env` files with real credentials
+- Token will be masked in HF logs
 
-- [ ] `app.py` - Flask server
-- [ ] `unity_catalog_service.py` - UC operations
-- [ ] `config.py` - Configuration management
-- [ ] `requirements.txt` - Python dependencies
-- [ ] `Dockerfile` - Container definition
-- [ ] `README.md` - Space description (with metadata)
-- [ ] `.gitignore` - Exclude `.env` and `__pycache__`
+## File Structure
 
-## Commands Quick Reference
+```
+huggingface-space/
+├── app.py                      ← Flask backend (serves frontend + API)
+├── unity-catalog-chatbot.jsx   ← React UI component
+├── unity_catalog_service.py    ← Databricks integration
+├── index.html                  ← React entry point
+├── requirements.txt            ← Python dependencies
+├── config.py                   ← Configuration
+├── Dockerfile                  ← Docker container config
+└── [other config files]
+```
 
-```bash
-# Clone space
-git clone https://huggingface.co/spaces/username/unitycatalog-chatbot
+## Next Steps
 
-# Push updates
-git add . && git commit -m "Update" && git push
+1. **Monitor**: Check Space logs for any errors
+2. **Test**: Try creating a catalog, granting permissions, etc.
+3. **Customize**: Modify the UI colors, add more features
+4. **Share**: Share the Space URL with your team
 
-# View logs
-# Go to: https://huggingface.co/spaces/username/unitycatalog-chatbot/settings
+## Support
 
-# Delete space (if needed)
-# Go to: https://huggingface.co/spaces/username/unitycatalog-chatbot/settings → Delete
-```
+For issues:
+1. Check the Space logs
+2. Review the troubleshooting section
+3. Check Hugging Face documentation: https://huggingface.co/docs/hub/spaces
+4. Review app logs locally first before deploying
 
 ---
 
-**Your app will be live in 2-5 minutes!** 🚀
+**Deployment Date**: December 2025  
+**Status**: Production Ready

HF_DEPLOYMENT_SUMMARY.md

@@ -1,362 +0,0 @@
-# Hugging Face Spaces Deployment Summary
-
-## What Was Created
-
-### 📄 Files for HF Deployment
-
-1. **[HF_DEPLOYMENT.md](HF_DEPLOYMENT.md)** - Quick 5-minute setup guide
-2. **[HF_README.md](HF_README.md)** - Hugging Face Space metadata & documentation
-3. **[DEPLOYMENT_GUIDE.md](DEPLOYMENT_GUIDE.md)** - Updated with HF Spaces section
-
-## Step-by-Step Deployment
-
-### Phase 1: Create Space (2 minutes)
-```bash
-# 1. Visit https://huggingface.co/new
-# 2. Fill in:
-#    - Name: unitycatalog-chatbot
-#    - Type: Space
-#    - Runtime: Docker
-# 3. Click "Create Space"
-```
-
-### Phase 2: Setup Files (3 minutes)
-```bash
-# 1. Clone the space
-git clone https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot
-cd unitycatalog-chatbot
-
-# 2. Copy project files
-cp -r ../UnityCatalog-ChatBot/* .
-
-# 3. Verify files:
-# ✅ app.py
-# ✅ unity_catalog_service.py
-# ✅ config.py
-# ✅ requirements.txt
-# ✅ Dockerfile
-# ✅ README.md (use HF_README.md content)
-```
-
-### Phase 3: Add Secrets (2 minutes)
-```
-Go to Space Settings → Secrets → Add three:
-
-1. DATABRICKS_HOST
-   Value: https://your-workspace.databricks.com
-
-2. DATABRICKS_TOKEN
-   Value: dapi... (your personal access token)
-
-3. ANTHROPIC_API_KEY
-   Value: sk-ant-... (your API key)
-```
-
-### Phase 4: Deploy (3 minutes)
-```bash
-# 1. Push to HF
-git add .
-git commit -m "Initial deployment"
-git push
-
-# 2. Space auto-builds and deploys
-# 3. Check build logs in Settings
-# 4. App goes live! 🚀
-```
-
-## Total Time: ~10 minutes ⏱️
-
----
-
-## Access Your App
-
-**Live URL:** `https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot`
-
-**API Base:** `https://YOUR_USERNAME-unitycatalog-chatbot.hf.space`
-
-### Test Endpoints
-
-```bash
-# Health
-curl https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/health
-
-# Catalogs
-curl https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/catalogs
-
-# Chat
-curl -X POST https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/chat \
-  -H "Content-Type: application/json" \
-  -d '{"message": "List all catalogs"}'
-```
-
----
-
-## Key Features on HF Spaces
-
-| Feature | Details |
-|---------|---------|
-| **Hosting** | Free (or Pro for $50/mo) |
-| **Runtime** | Docker container |
-| **CPU** | 2 vCPU (free) / dedicated (pro) |
-| **Uptime** | Best effort / 99.9% (pro) |
-| **Scaling** | Auto-scales with traffic |
-| **Secrets** | Environment variables (hidden) |
-| **Custom Domain** | Pro tier only |
-| **Logs** | Real-time in Settings |
-
----
-
-## What Happens When You Push
-
-```
-git push
-   ↓
-HF receives commit
-   ↓
-Triggers build
-   ↓
-- Reads Dockerfile
-- Installs dependencies from requirements.txt
-- Builds Docker image (~2-3 min)
-   ↓
-Loads secrets from Space Settings
-   ↓
-Starts container on public URL
-   ↓
-App is live! 🎉
-```
-
----
-
-## Updates & Rollbacks
-
-### Push Updates
-```bash
-# Make changes to code
-# e.g., edit app.py
-
-git add .
-git commit -m "Fix bug in chat endpoint"
-git push
-# Space rebuilds automatically
-```
-
-### Revert Changes
-```bash
-# View git history
-git log --oneline
-
-# Revert to previous commit
-git revert HEAD
-git push
-# Space rebuilds with old code
-```
-
----
-
-## Monitoring
-
-### View Logs
-1. Go to Space → **Settings**
-2. **Build logs** - Shows Docker build output
-3. **Runtime logs** - Shows running application output
-4. Logs updated in real-time
-
-### Common Errors
-
-**"ModuleNotFoundError: No module named 'X'"**
-- Add to `requirements.txt`
-- Push changes
-- Space rebuilds
-
-**"Connection refused to Databricks"**
-- Check `DATABRICKS_HOST` in Secrets
-- Verify it includes `https://`
-- Ensure token hasn't expired
-
-**"Port already in use"**
-- HF Spaces assigns port automatically
-- Check your `app.py` respects `SERVER_PORT` env var
-
-**"Build timeout"**
-- If build takes >30 min, it's canceled
-- Check requirements.txt for slow installs
-- Try Docker layer caching
-
----
-
-## File Reference
-
-### What Gets Deployed
-
-```
-unitycatalog-chatbot/
-├── app.py                      # Flask server
-├── unity_catalog_service.py    # Databricks operations
-├── config.py                   # Configuration
-├── conftest.py                 # Test fixtures
-├── test_chatbot.py            # Tests (optional)
-├── requirements.txt           # Python dependencies
-├── Dockerfile                 # Container definition
-├── README.md                  # HF Space description
-├── .gitignore                # Exclude secrets & cache
-└── (other supporting files)
-```
-
-### Don't Include
-- ❌ `.env` file (use Secrets instead)
-- ❌ `__pycache__/`
-- ❌ `.git` directory (create fresh)
-- ❌ Virtual environments
-- ❌ Build artifacts
-
----
-
-## Scaling & Costs
-
-### Free Tier
-- 2 vCPU, 16GB RAM
-- Shared infrastructure
-- Best-effort uptime
-- Rate limited (but sufficient for testing)
-
-### Pro Tier
-- Dedicated infrastructure
-- 99.9% SLA
-- Custom domain
-- $50/month
-
-### When to Upgrade
-- ✅ Production workloads
-- ✅ High traffic (100+ requests/min)
-- ✅ Custom domain needed
-- ✅ SLA requirements
-
----
-
-## Sharing Your Space
-
-### Public Link
-Just share the Space URL:
-```
-https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot
-```
-
-### Embed in Website
-```html
-<iframe
-  src="https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot?embed=true"
-  frameborder="0"
-  width="800"
-  height="600"
-></iframe>
-```
-
-### Add to Collections
-- Create collection on HF Hub
-- Add Space to it
-- Share collection link
-
----
-
-## Integration Examples
-
-### Use as Backend API
-
-```python
-import requests
-
-API_URL = "https://YOUR_USERNAME-unitycatalog-chatbot.hf.space"
-
-# Chat
-response = requests.post(
-    f"{API_URL}/api/chat",
-    json={"message": "Create a catalog named demo"}
-)
-print(response.json())
-
-# List catalogs
-catalogs = requests.get(f"{API_URL}/api/catalogs").json()
-print(catalogs)
-```
-
-### Embed in Slack Bot
-
-```python
-from slack_bolt import App
-
-app = App(token=os.environ["SLACK_BOT_TOKEN"])
-
-@app.message("catalog")
-def handle_catalog(message, say):
-    response = requests.post(
-        "https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/chat",
-        json={"message": message["text"]}
-    )
-    say(response.json()["message"])
-
-app.start(port=int(os.environ.get("PORT", 3000)))
-```
-
-### Use in Streamlit App
-
-```python
-import streamlit as st
-import requests
-
-st.title("Unity Catalog Manager")
-
-message = st.text_input("Ask me anything about your catalog...")
-
-if st.button("Send"):
-    response = requests.post(
-        "https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/chat",
-        json={"message": message}
-    )
-    st.write(response.json())
-```
-
----
-
-## Troubleshooting Checklist
-
-Before contacting support:
-
-- [ ] Secrets are set in Space Settings
-- [ ] Databricks token is valid (not expired)
-- [ ] Anthropic API key is correct
-- [ ] `Dockerfile` exists in repo root
-- [ ] `requirements.txt` is valid Python
-- [ ] Build logs show no errors
-- [ ] Runtime logs show app started
-- [ ] Test `/api/health` endpoint first
-- [ ] Try locally with same credentials
-
----
-
-## Next Steps
-
-1. ✅ Create Space on HF
-2. ✅ Push code
-3. ✅ Add secrets
-4. ✅ Wait for build
-5. ✅ Test endpoints
-6. ✅ Share with team
-7. ✅ Monitor logs
-8. ✅ Iterate on features
-
----
-
-## Resources
-
-- **Hugging Face Docs:** https://huggingface.co/docs/hub/spaces
-- **Docker Guide:** https://docs.docker.com/
-- **Flask Docs:** https://flask.palletsprojects.com/
-- **Databricks API:** https://docs.databricks.com/api/workspace
-- **Claude API:** https://docs.anthropic.com/
-
----
-
-**Your chatbot is now live on Hugging Face Spaces! 🚀**
-
-Questions? Check the logs, review error messages, or visit HF community.

HF_README.md

@@ -1,243 +0,0 @@
----
-title: Unity Catalog Chatbot
-emoji: 💬
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
-license: mit
----
-
-# Unity Catalog Chatbot
-
-A natural language chatbot for managing Databricks Unity Catalog powered by Claude AI.
-
-## Features
-
-✨ **Natural Language Interface**
-- Ask questions in plain English
-- Get instant responses from Claude AI
-- No SQL knowledge required
-
-🗂️ **Catalog Management**
-- Create catalogs, schemas, and tables
-- List objects across your workspace
-- View table details and metadata
-
-🔐 **Permission Management**
-- Grant and revoke permissions
-- Manage access control via chat
-- Support for users and groups
-
-🚀 **REST API**
-- Full JSON API for integrations
-- Health checks and monitoring
-- Easy to embed in other apps
-
-## Quick Start
-
-### 1. Add Secrets
-
-Go to **Settings → Secrets** and add:
-
-```
-DATABRICKS_HOST = https://your-workspace.databricks.com
-DATABRICKS_TOKEN = dapi...your-token...
-ANTHROPIC_API_KEY = sk-ant-...your-key...
-```
-
-### 2. Wait for Build
-
-Space will auto-build (~2 min). Check **Settings → Build logs**.
-
-### 3. Start Using
-
-Once running, the app will be available at the Space URL.
-
-### 4. API Endpoints
-
-#### Health Check
-```bash
-GET /api/health
-```
-
-#### List Catalogs
-```bash
-GET /api/catalogs
-```
-
-#### List Schemas
-```bash
-GET /api/schemas/{catalog}
-```
-
-#### List Tables
-```bash
-GET /api/tables/{catalog}/{schema}
-```
-
-#### Chat (Main Endpoint)
-```bash
-POST /api/chat
-Content-Type: application/json
-
-{
-  "message": "Create a catalog named sales_data"
-}
-```
-
-## Example Requests
-
-### Create a Catalog
-```bash
-curl -X POST https://your-space-url/api/chat \
-  -H "Content-Type: application/json" \
-  -d '{"message": "Create a catalog named sales_data"}'
-```
-
-### Grant Permissions
-```bash
-curl -X POST https://your-space-url/api/chat \
-  -H "Content-Type: application/json" \
-  -d '{
-    "message": "Grant SELECT on sales_data.customers to data_analysts"
-  }'
-```
-
-### List Objects
-```bash
-curl https://your-space-url/api/catalogs
-curl https://your-space-url/api/schemas/sales_data
-curl https://your-space-url/api/tables/sales_data/analytics
-```
-
-## Supported Operations
-
-- ✅ Create catalogs
-- ✅ Create schemas
-- ✅ Create tables
-- ✅ Grant permissions
-- ✅ Revoke permissions
-- ✅ List catalogs/schemas/tables
-- ✅ Show permissions
-- ✅ Set object owner
-- ✅ Get table details
-- ✅ Execute SQL (when enabled)
-
-## Requirements
-
-- **Databricks** workspace with Unity Catalog enabled
-- **Personal Access Token** (generate in Databricks)
-- **Anthropic API Key** (get from https://console.anthropic.com)
-
-## Architecture
-
-```
-┌─────────────────────┐
-│   User / Client     │
-└──────────┬──────────┘
-           │
-           v
-┌─────────────────────┐
-│   Flask API Server  │
-│   (Port 5000)       │
-└──────────┬──────────┘
-           │
-      ┌────┴──────┬────────────┐
-      v           v            v
-  Claude AI  UC Service  Config Manager
-      │           │            │
-      └────┬──────┴────────────┘
-           v
-   Databricks Unity Catalog
-   + Anthropic API
-```
-
-## Local Development
-
-```bash
-# Clone repo
-git clone <repo-url>
-cd UnityCatalog-ChatBot
-
-# Setup
-python -m venv venv
-source venv/bin/activate  # or venv\Scripts\activate on Windows
-pip install -r requirements.txt
-
-# Configure
-cp .env.example .env
-# Edit .env with your credentials
-
-# Run tests
-pytest test_chatbot.py -v
-
-# Run server
-python app.py
-```
-
-## Docker
-
-```bash
-# Build
-docker build -t unitycatalog-chatbot .
-
-# Run
-docker run -p 5000:5000 \
-  -e DATABRICKS_HOST="https://..." \
-  -e DATABRICKS_TOKEN="..." \
-  -e ANTHROPIC_API_KEY="..." \
-  unitycatalog-chatbot
-```
-
-## Troubleshooting
-
-### Build Fails
-- Check **Settings → Build logs**
-- Ensure `Dockerfile` exists
-- Verify `requirements.txt` syntax
-
-### App Crashes
-- Check **Settings → Runtime logs**
-- Verify secrets are set correctly
-- Test credentials locally first
-
-### API Returns Error
-- Confirm Databricks host URL is correct
-- Check token hasn't expired
-- Verify Anthropic API key is valid
-
-### Slow Responses
-- Databricks API latency
-- Large catalog size (many objects)
-- Network connectivity
-
-## Security Notes
-
-⚠️ **Never commit secrets to Git**
-- Use Hugging Face Secrets feature
-- Rotate tokens regularly
-- Use IAM roles when possible
-
-## Performance
-
-- **Requests**: Up to 60/min (configurable)
-- **Response time**: 2-5 seconds typical
-- **Catalog size**: Tested with 1000+ objects
-- **Concurrent users**: Limited by Space tier
-
-## License
-
-MIT
-
-## Support
-
-- GitHub Issues: [Link to repo]
-- Documentation: See `/docs`
-- Discord: [Link to community]
-
----
-
-**Built with ❤️ using Flask, Claude, and Databricks**
-
-*Hugging Face Spaces - Free hosting for ML apps*

QUICK_DEPLOY.md

@@ -1,196 +0,0 @@
-# ⚡ Quick Deploy to Hugging Face - 5 Minutes
-
-## Your Deployment Package is Ready! 📦
-
-Everything you need is prepared. Just follow these 7 steps:
-
----
-
-## Step 1: Get Your Credentials (1 min)
-
-### Databricks
-1. Go to your Databricks workspace
-2. Click your user icon → Settings
-3. Go to **Personal Access Tokens** → **Generate new token**
-4. Copy the token (format: `dapi...`)
-5. Note your workspace URL (e.g., `https://your-workspace.databricks.com`)
-
-### Anthropic
-1. Visit https://console.anthropic.com
-2. Click **API Keys** in sidebar
-3. Click **Create Key**
-4. Copy the key (format: `sk-ant-...`)
-
----
-
-## Step 2: Create Hugging Face Space (2 min)
-
-1. **Go to:** https://huggingface.co/new
-2. **Fill in:**
-   - **Owner:** Your username
-   - **Repository name:** `unitycatalog-chatbot`
-   - **Type:** Space
-   - **Space SDK:** Docker
-   - **License:** MIT (or your choice)
-3. **Click:** Create Space
-
-**Result:** You'll get a Space at `https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot`
-
----
-
-## Step 3: Run Local Tests (1 min)
-
-```bash
-cd UnityCatalog-ChatBot
-
-# Run tests (no credentials needed - they're mocked)
-python -m pytest test_chatbot.py -v
-
-# Expected: 23 passed ✅
-```
-
----
-
-## Step 4: Push Code (1 min)
-
-```bash
-# Add HF remote
-git remote add huggingface https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot
-
-# Push code
-git push -u huggingface main
-
-# If main doesn't exist, try master:
-# git push -u huggingface master
-```
-
-**HF will start building automatically** ⏳
-
----
-
-## Step 5: Add Secrets (1 min)
-
-1. **Go to:** Your Space Settings
-   - URL: `https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot/settings`
-
-2. **Click:** Repository Secrets
-
-3. **Add three secrets:**
-
-   | Name | Value |
-   |------|-------|
-   | `DATABRICKS_HOST` | `https://your-workspace.databricks.com` |
-   | `DATABRICKS_TOKEN` | `dapi...` |
-   | `ANTHROPIC_API_KEY` | `sk-ant-...` |
-
-4. **Click:** Save after each
-
-**Result:** Space rebuilds with secrets loaded ✅
-
----
-
-## Step 6: Wait for Build (3-5 min)
-
-- Go to Space Settings → Build logs
-- Watch the Docker build happen
-- Status changes to **"Running"** when ready
-- Check Runtime logs for any errors
-
----
-
-## Step 7: Test Your Deployment (1 min)
-
-Once **"Running"**, test the API:
-
-```bash
-# Replace YOUR_USERNAME and check health
-curl https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/health
-
-# Response should be:
-# {"status": "healthy", "service": "Unity Catalog Chatbot API"}
-
-# List catalogs
-curl https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/catalogs
-
-# Chat
-curl -X POST https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/chat \
-  -H "Content-Type: application/json" \
-  -d '{"message": "List all catalogs"}'
-```
-
----
-
-## 🎉 You're Done!
-
-Your chatbot is now live at:
-```
-https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot
-```
-
-**Share it:** Just send the URL to anyone - they can use it immediately!
-
----
-
-## Troubleshooting
-
-| Problem | Solution |
-|---------|----------|
-| Build fails | Check build logs. Ensure `Dockerfile` exists. |
-| App crashes | Check runtime logs. Verify secrets are set. |
-| API returns error | Double-check credentials. Test locally first. |
-| "Port already in use" | HF assigns port automatically, should work. |
-
----
-
-## Common Commands
-
-```bash
-# View logs
-# Go to: Space Settings → Build logs or Runtime logs
-
-# Update code
-git add .
-git commit -m "Update"
-git push huggingface main
-
-# Revert to previous version
-git log --oneline
-git revert <commit-hash>
-git push huggingface main
-
-# Delete Space (if needed)
-# Go to Space Settings → Delete
-```
-
----
-
-## Next Steps
-
-- ✅ Share the Space URL with your team
-- ✅ Monitor logs in Settings
-- ✅ Iterate on features (push code updates)
-- ✅ Upgrade to Pro tier for custom domain ($50/mo)
-
----
-
-## Files You Have
-
-```
-UnityCatalog-ChatBot/
-├── HF_DEPLOYMENT.md           ← Detailed HF guide
-├── HF_DEPLOYMENT_SUMMARY.md   ← Complete reference
-├── DEPLOYMENT_GUIDE.md        ← All deployment options
-├── deploy-to-huggingface.sh   ← Automated script (Linux/Mac)
-├── deploy-to-huggingface.bat  ← Automated script (Windows)
-├── .env.example               ← Environment template
-├── Dockerfile                 ← Ready for HF
-├── app.py                     ← Your API
-├── requirements.txt           ← Dependencies
-└── [other project files]
-```
-
----
-
-**That's it! You're deploying in 5 minutes.** ⚡
-
-If you have questions, check the detailed guides in your repo!

README_DEPLOYMENT.md

@@ -1,222 +0,0 @@
-# 🚀 Your Deployment Package is Ready!
-
-## What's Prepared for You
-
-✅ **Complete Code** - Tested & validated (23/23 tests pass)
-✅ **Docker Setup** - Production-ready Dockerfile  
-✅ **Documentation** - 4 deployment guides created  
-✅ **Scripts** - Automated deployment for Windows & Linux/Mac  
-✅ **Configuration** - .env template ready  
-✅ **Git Ready** - All files prepared for pushing  
-
----
-
-## Your Next Steps (Choose One)
-
-### Option A: Use Automated Script 🤖
-
-**Windows:**
-```bash
-cd UnityCatalog-ChatBot
-deploy-to-huggingface.bat
-# Follow the prompts
-```
-
-**Linux/Mac:**
-```bash
-cd UnityCatalog-ChatBot
-chmod +x deploy-to-huggingface.sh
-./deploy-to-huggingface.sh
-# Follow the prompts
-```
-
-### Option B: Manual 5-Minute Deployment ⚡
-
-1. Get credentials (Databricks token + Anthropic key)
-2. Create Space: https://huggingface.co/new (Docker type)
-3. Run tests locally: `pytest test_chatbot.py -v`
-4. Push code: `git push -u huggingface main`
-5. Add secrets in Space Settings
-6. Wait 3-5 min for build
-7. Test API at `https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/health`
-
-See [QUICK_DEPLOY.md](QUICK_DEPLOY.md) for full details.
-
----
-
-## Files You Have
-
-### Documentation
-- **QUICK_DEPLOY.md** - This (5-min quick start)
-- **HF_DEPLOYMENT.md** - Step-by-step Hugging Face guide
-- **HF_DEPLOYMENT_SUMMARY.md** - Complete reference & troubleshooting
-- **HF_README.md** - Hugging Face Space description
-- **DEPLOYMENT_GUIDE.md** - All deployment options (ECS, K8s, ACI, etc.)
-
-### Configuration
-- **.env.example** - Environment template (copy to .env)
-- **Dockerfile** - Production-ready container definition
-- **deploy-to-huggingface.sh** - Automated setup script (Linux/Mac)
-- **deploy-to-huggingface.bat** - Automated setup script (Windows)
-
-### Application
-- **app.py** - Flask API server (lazy-init ready)
-- **unity_catalog_service.py** - Databricks operations
-- **config.py** - Configuration management
-- **conftest.py** - Test fixtures with mocks
-- **test_chatbot.py** - 23 tests (all passing)
-- **requirements.txt** - Python dependencies
-- **README.md** - Project overview
-
----
-
-## What Happens When You Deploy
-
-```
-You push code to HF Space
-        ↓
-HF downloads Dockerfile & requirements.txt
-        ↓
-Docker builds image (~2-3 min)
-        ↓
-Container starts with your secrets loaded
-        ↓
-Your API is live! 🎉
-        ↓
-Share the URL with your team
-        ↓
-Anyone can use your chatbot
-```
-
----
-
-## Your Chatbot Will Have
-
-✅ **Public URL** - Share with anyone  
-✅ **REST API** - `/api/chat`, `/api/catalogs`, etc.  
-✅ **Auto-scaling** - Handles traffic spikes  
-✅ **Real-time Logs** - See what's happening  
-✅ **Easy Updates** - Just `git push` to redeploy  
-✅ **Mock Tests** - All passing (no live API calls needed)  
-✅ **Security** - Secrets hidden, HTTPS enabled  
-
----
-
-## Credentials You'll Need
-
-### Databricks
-- **Workspace URL:** `https://your-workspace.databricks.com`
-- **Personal Access Token:** `dapi...` (from Settings → Tokens)
-
-### Anthropic
-- **API Key:** `sk-ant-...` (from https://console.anthropic.com)
-
----
-
-## Deployment Checklist
-
-Before you start:
-- [ ] Have Databricks workspace URL
-- [ ] Have Databricks personal access token
-- [ ] Have Anthropic API key
-- [ ] Have Hugging Face account (free at huggingface.co)
-- [ ] Have git installed (`git --version`)
-- [ ] Have Python 3.9+ (`python --version`)
-
-Before pushing:
-- [ ] Tests pass locally (`pytest test_chatbot.py -v`)
-- [ ] .env.example is present
-- [ ] Dockerfile exists and is valid
-- [ ] requirements.txt has all dependencies
-
----
-
-## After Deployment
-
-1. **Test endpoints:**
-   ```bash
-   curl https://YOUR_USERNAME-unitycatalog-chatbot.hf.space/api/health
-   ```
-
-2. **Monitor logs:**
-   - Go to Space Settings → Runtime logs
-
-3. **Share with team:**
-   - Just send the URL: `https://huggingface.co/spaces/YOUR_USERNAME/unitycatalog-chatbot`
-
-4. **Make updates:**
-   ```bash
-   # Edit code locally
-   git add .
-   git commit -m "Update feature"
-   git push huggingface main
-   # Space rebuilds automatically!
-   ```
-
----
-
-## Key Resources
-
-- **Hugging Face Docs:** https://huggingface.co/docs/hub/spaces
-- **Docker Docs:** https://docs.docker.com/
-- **Databricks API:** https://docs.databricks.com/api/workspace
-- **Claude API:** https://docs.anthropic.com/
-
----
-
-## Support
-
-**If deployment fails:**
-1. Check Space runtime logs
-2. Review error messages
-3. Verify secrets are set correctly
-4. Test locally with same credentials
-5. Check [HF_DEPLOYMENT_SUMMARY.md](HF_DEPLOYMENT_SUMMARY.md) troubleshooting
-
-**For questions:**
-- Hugging Face Community: https://huggingface.co/spaces
-- Databricks Docs: https://docs.databricks.com
-- Anthropic Support: https://support.anthropic.com
-
----
-
-## What You Get
-
-✅ Production-ready chatbot  
-✅ Public API endpoint  
-✅ Free hosting (up to 2 CPU)  
-✅ Auto-scaling on traffic  
-✅ Real-time logs  
-✅ One-click updates  
-✅ Shareable link for your team  
-
----
-
-## Timeline
-
-- **Setup:** 2 min (gather credentials)
-- **Create Space:** 1 min (fill form on HF)
-- **Test locally:** 1 min (run tests)
-- **Push code:** 1 min (git push)
-- **Build:** 3-5 min (Docker builds)
-- **Add secrets:** 1 min (set in HF UI)
-- **Ready!** → Live chatbot at your Space URL
-
-**Total: ~15 minutes (mostly waiting for Docker build)**
-
----
-
-## Next Action
-
-👉 **Choose your path:**
-1. Run automated script: `deploy-to-huggingface.bat` (Windows) or `./deploy-to-huggingface.sh` (Linux/Mac)
-2. Follow [QUICK_DEPLOY.md](QUICK_DEPLOY.md) for manual steps
-3. Read [HF_DEPLOYMENT.md](HF_DEPLOYMENT.md) for detailed guide
-
----
-
-**Everything is ready. Your deployment is just a few git commands away!** 🚀
-
-Need help? Check the docs in your repo. Questions? Review the troubleshooting section.
-
-Good luck! 🎉

app.py

@@ -3,7 +3,7 @@ Unity Catalog Chatbot API Server
 Flask API to handle natural language requests and execute Unity Catalog operations
 """
 
-from flask import Flask, request, jsonify
+from flask import Flask, request, jsonify, send_from_directory
 from flask_cors import CORS
 import os
 import re
@@ -11,7 +11,7 @@ from typing import Dict, List, Optional
 import anthropic
 from unity_catalog_service import UnityCatalogService
 
-app = Flask(__name__)
+app = Flask(__name__, static_folder='.', static_url_path='')
 CORS(app)
 
 # Initialize services (lazy to allow mocking in tests)
@@ -27,6 +27,33 @@ def _init_services():
         claude_client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
     return uc_service, claude_client
 
+
+def validate_databricks_connection(host: str, token: str, workspace_id: str = None) -> Dict:
+    """Validate connection to Databricks workspace."""
+    try:
+        from databricks.sdk import WorkspaceClient
+        
+        # Create client with provided credentials
+        client = WorkspaceClient(
+            host=host,
+            token=token
+        )
+        
+        # Try to get workspace info
+        workspace_info = client.workspace.get_status(path="/")
+        
+        return {
+            "success": True,
+            "message": "Successfully connected to Databricks workspace",
+            "workspace_path": workspace_info.path
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "message": f"Connection failed: {str(e)}"
+        }
+
+
 # System prompt for Claude to parse Unity Catalog requests
 SYSTEM_PROMPT = """You are an expert Unity Catalog assistant. Your role is to:
 
@@ -283,6 +310,20 @@ Just describe what you want to do in natural language!""",
         }
 
 
+@app.route('/', methods=['GET'])
+def index():
+    """Serve the React UI"""
+    return send_from_directory('.', 'index.html')
+
+
+@app.route('/<path:path>', methods=['GET'])
+def serve_static(path):
+    """Serve static files"""
+    if path and os.path.exists(path):
+        return send_from_directory('.', path)
+    return send_from_directory('.', 'index.html')
+
+
 @app.route('/api/chat', methods=['POST'])
 def chat():
     """Main chat endpoint"""
@@ -366,10 +407,50 @@ def execute_sql():
         }), 500
 
 
+@app.route('/api/validate-connection', methods=['POST'])
+def validate_connection():
+    """Validate Databricks connection with provided credentials"""
+    try:
+        data = request.json
+        host = data.get('host', '').strip()
+        token = data.get('token', '').strip()
+        workspace_id = data.get('workspaceId', '').strip()
+        
+        if not host or not token:
+            return jsonify({
+                'success': False,
+                'message': 'Host and token are required'
+            }), 400
+        
+        # Ensure host starts with https://
+        if not host.startswith('https://'):
+            if host.startswith('http://'):
+                host = 'https://' + host[7:]
+            else:
+                host = 'https://' + host
+        
+        result = validate_databricks_connection(host, token, workspace_id)
+        
+        if result['success']:
+            return jsonify(result), 200
+        else:
+            return jsonify(result), 401
+    
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'message': f'Validation error: {str(e)}'
+        }), 500
+
+
 if __name__ == '__main__':
+    # Get port from environment variable (HF Spaces uses 7860)
+    port = int(os.getenv('PORT', 7860))
+    host = os.getenv('HOST', '0.0.0.0')
+    
     # Development server
     app.run(
-        host='0.0.0.0',
-        port=5000,
-        debug=True
+        host=host,
+        port=port,
+        debug=os.getenv('FLASK_ENV') == 'development'
     )

deploy-to-huggingface.bat

@@ -1,97 +0,0 @@
-@echo off
-REM deploy-to-huggingface.bat
-REM Windows deployment to Hugging Face Spaces
-
-setlocal enabledelayedexpansion
-
-echo.
-echo ========================================
-echo ^(^) UnityCatalog-ChatBot HF Deployment
-echo ========================================
-echo.
-
-REM Step 1: Get HF username
-set /p HF_USERNAME="Enter your Hugging Face username: "
-set SPACE_NAME=unitycatalog-chatbot
-set SPACE_URL=https://huggingface.co/spaces/%HF_USERNAME%/%SPACE_NAME%
-
-echo.
-echo Space URL: %SPACE_URL%
-echo.
-
-REM Step 2: Verify files
-echo Verifying required files...
-for %%F in (app.py unity_catalog_service.py config.py requirements.txt Dockerfile .env.example) do (
-    if not exist "%%F" (
-        echo Error: Missing %%F
-        exit /b 1
-    )
-)
-echo OK - All files present
-echo.
-
-REM Step 3: Test locally
-echo Running tests...
-python -m pytest test_chatbot.py -v --tb=short -q
-if errorlevel 1 (
-    echo Tests failed!
-    exit /b 1
-)
-echo OK - Tests passed
-echo.
-
-REM Step 4: .env setup
-if not exist ".env" (
-    copy .env.example .env
-    echo Created .env - please edit with your credentials
-    pause
-)
-echo.
-
-REM Step 5: Git setup
-if not exist ".git" (
-    echo Initializing git...
-    git init
-    git add .
-    git commit -m "Initial commit: UnityCatalog-ChatBot"
-) else (
-    echo Git already initialized
-    git add .
-    git diff --cached --quiet
-    if errorlevel 0 (
-        git commit -m "Update: deployment preparation"
-    )
-)
-echo.
-
-REM Step 6: Instructions
-echo.
-echo ========================================
-echo Manual Steps Required:
-echo ========================================
-echo.
-echo 1. Create Space on Hugging Face:
-echo    https://huggingface.co/new
-echo    - Repository name: %SPACE_NAME%
-echo    - Type: Space
-echo    - SDK: Docker
-echo.
-echo 2. Once created, run this command:
-echo    git remote add huggingface %SPACE_URL%
-echo    git push -u huggingface main
-echo.
-echo 3. Add Secrets in Space Settings:
-echo    - DATABRICKS_HOST
-echo    - DATABRICKS_TOKEN
-echo    - ANTHROPIC_API_KEY
-echo.
-echo 4. Space rebuilds automatically (2-5 min)
-echo.
-echo 5. Test at: https://%HF_USERNAME%-%SPACE_NAME%.hf.space/api/health
-echo.
-pause
-
-echo ========================================
-echo Deployment Complete!
-echo ========================================
-echo Your chatbot: %SPACE_URL%

deploy-to-huggingface.sh

@@ -1,181 +0,0 @@
-#!/bin/bash
-# deploy-to-huggingface.sh
-# One-command deployment to Hugging Face Spaces
-
-set -e
-
-echo "🚀 UnityCatalog-ChatBot Hugging Face Deployment"
-echo "==============================================="
-echo ""
-
-# Step 1: Gather user input
-echo "Step 1: Enter your Hugging Face username"
-read -p "Your HF username: " HF_USERNAME
-
-SPACE_NAME="unitycatalog-chatbot"
-SPACE_URL="https://huggingface.co/spaces/${HF_USERNAME}/${SPACE_NAME}"
-
-echo "✓ Space URL will be: $SPACE_URL"
-echo ""
-
-# Step 2: Verify files
-echo "Step 2: Verifying required files..."
-REQUIRED_FILES=("app.py" "unity_catalog_service.py" "config.py" "requirements.txt" "Dockerfile" ".env.example")
-
-for file in "${REQUIRED_FILES[@]}"; do
-    if [ ! -f "$file" ]; then
-        echo "❌ Missing: $file"
-        exit 1
-    fi
-done
-echo "✓ All required files present"
-echo ""
-
-# Step 3: Create .env for local testing
-echo "Step 3: Creating .env from template..."
-if [ ! -f ".env" ]; then
-    cp .env.example .env
-    echo "✓ Created .env (edit with your credentials before continuing)"
-    echo ""
-    echo "⚠️  IMPORTANT: Edit .env with your Databricks and Anthropic credentials"
-    read -p "Press Enter once you've updated .env..."
-else
-    echo "✓ .env already exists"
-fi
-echo ""
-
-# Step 4: Test locally
-echo "Step 4: Running tests..."
-python -m pytest test_chatbot.py -v --tb=short -q
-echo "✓ All tests passed"
-echo ""
-
-# Step 5: Verify Dockerfile
-echo "Step 5: Verifying Dockerfile..."
-if ! grep -q "FROM python" Dockerfile; then
-    echo "❌ Dockerfile invalid"
-    exit 1
-fi
-echo "✓ Dockerfile is valid"
-echo ""
-
-# Step 6: Git setup
-echo "Step 6: Setting up Git..."
-if [ ! -d ".git" ]; then
-    git init
-    git add .
-    git commit -m "Initial commit: UnityCatalog-ChatBot"
-    echo "✓ Git repository initialized"
-else
-    echo "✓ Git repository already exists"
-    git add .
-    if git diff --cached --quiet; then
-        echo "✓ No changes to commit"
-    else
-        git commit -m "Update: deployment preparation"
-        echo "✓ Changes committed"
-    fi
-fi
-echo ""
-
-# Step 7: Manual Space creation instructions
-echo "Step 7: Manual Space Creation"
-echo "=============================="
-echo ""
-echo "⚠️  Please complete these steps manually on Hugging Face:"
-echo ""
-echo "1. Go to: https://huggingface.co/new"
-echo "2. Fill in the form:"
-echo "   - Owner: $HF_USERNAME"
-echo "   - Repository name: $SPACE_NAME"
-echo "   - Type: Space"
-echo "   - Space SDK: Docker"
-echo "   - License: MIT"
-echo "3. Click 'Create Space'"
-echo ""
-echo "Once created, you'll get a clone URL like:"
-echo "https://huggingface.co/spaces/$HF_USERNAME/$SPACE_NAME"
-echo ""
-
-read -p "Press Enter once you've created the Space..."
-echo ""
-
-# Step 8: Push to HF
-echo "Step 8: Pushing code to Hugging Face..."
-echo ""
-echo "You'll be asked to authenticate. Use your HF token:"
-echo "Visit: https://huggingface.co/settings/tokens"
-echo "Copy a READ+WRITE token and paste it when prompted."
-echo ""
-
-PUSH_URL="https://huggingface.co/spaces/${HF_USERNAME}/${SPACE_NAME}"
-
-# Try to add remote
-if git remote | grep -q "huggingface"; then
-    git remote remove huggingface
-fi
-
-git remote add huggingface "$PUSH_URL"
-
-echo "Pushing to $PUSH_URL..."
-git push -u huggingface main || git push -u huggingface master
-
-echo "✓ Code pushed to Hugging Face"
-echo ""
-
-# Step 9: Add secrets
-echo "Step 9: Adding secrets to Hugging Face Space"
-echo "=============================================="
-echo ""
-echo "⚠️  Complete these steps in HF UI:"
-echo ""
-echo "1. Go to: $SPACE_URL/settings"
-echo "2. Click 'Repository Secrets'"
-echo "3. Add these three secrets:"
-echo ""
-echo "   Secret 1:"
-echo "   - Name: DATABRICKS_HOST"
-echo "   - Value: <your workspace URL>"
-echo ""
-echo "   Secret 2:"
-echo "   - Name: DATABRICKS_TOKEN"
-echo "   - Value: <your personal access token>"
-echo ""
-echo "   Secret 3:"
-echo "   - Name: ANTHROPIC_API_KEY"
-echo "   - Value: <your Claude API key>"
-echo ""
-echo "4. Click 'Save' after each secret"
-echo "5. Space will rebuild automatically"
-echo ""
-
-read -p "Press Enter once you've added all secrets..."
-echo ""
-
-# Step 10: Verify deployment
-echo "Step 10: Verifying deployment..."
-echo ""
-echo "Waiting 30 seconds for Space to build..."
-sleep 30
-
-HEALTH_URL="${SPACE_URL/huggingface.co/huggingface.co}/api/health"
-# Note: The actual URL will be in HF logs - this is just for reference
-
-echo ""
-echo "✅ DEPLOYMENT COMPLETE!"
-echo ""
-echo "Your chatbot is now live at:"
-echo "  🌐 $SPACE_URL"
-echo ""
-echo "Next steps:"
-echo "  1. Visit the Space URL above"
-echo "  2. Check Settings → Runtime logs for any errors"
-echo "  3. Once 'Running' status shows, test the API"
-echo ""
-echo "Test endpoints:"
-echo "  curl https://${HF_USERNAME}-${SPACE_NAME}.hf.space/api/health"
-echo "  curl https://${HF_USERNAME}-${SPACE_NAME}.hf.space/api/catalogs"
-echo ""
-echo "Share your Space:"
-echo "  Simply send the URL to others to access the chatbot!"
-echo ""

deploy.sh

@@ -1,486 +0,0 @@
-#!/bin/bash
-
-###############################################################################
-# Unity Catalog Chatbot - Automated Deployment Script
-# This script will guide you through the complete setup and deployment
-###############################################################################
-
-set -e  # Exit on error
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Functions
-print_header() {
-    echo -e "\n${BLUE}========================================${NC}"
-    echo -e "${BLUE}$1${NC}"
-    echo -e "${BLUE}========================================${NC}\n"
-}
-
-print_success() {
-    echo -e "${GREEN}✓ $1${NC}"
-}
-
-print_error() {
-    echo -e "${RED}✗ $1${NC}"
-}
-
-print_warning() {
-    echo -e "${YELLOW}⚠ $1${NC}"
-}
-
-print_info() {
-    echo -e "${BLUE}ℹ $1${NC}"
-}
-
-# Check if command exists
-command_exists() {
-    command -v "$1" >/dev/null 2>&1
-}
-
-###############################################################################
-# STEP 1: PRE-FLIGHT CHECKS
-###############################################################################
-
-print_header "Step 1: Pre-flight Checks"
-
-# Check Python
-if command_exists python3; then
-    PYTHON_VERSION=$(python3 --version | cut -d ' ' -f 2)
-    print_success "Python 3 found: $PYTHON_VERSION"
-else
-    print_error "Python 3 is not installed. Please install Python 3.9 or higher."
-    exit 1
-fi
-
-# Check pip
-if command_exists pip3; then
-    print_success "pip3 found"
-else
-    print_error "pip3 is not installed"
-    exit 1
-fi
-
-# Check Docker (optional)
-if command_exists docker; then
-    print_success "Docker found: $(docker --version)"
-    DOCKER_AVAILABLE=true
-else
-    print_warning "Docker not found. Docker deployment will not be available."
-    DOCKER_AVAILABLE=false
-fi
-
-# Check Docker Compose (optional)
-if command_exists docker-compose; then
-    print_success "Docker Compose found: $(docker-compose --version)"
-    COMPOSE_AVAILABLE=true
-else
-    print_warning "Docker Compose not found"
-    COMPOSE_AVAILABLE=false
-fi
-
-###############################################################################
-# STEP 2: GATHER CREDENTIALS
-###############################################################################
-
-print_header "Step 2: Configuration Setup"
-
-# Check if .env exists
-if [ -f .env ]; then
-    print_warning ".env file already exists"
-    read -p "Do you want to overwrite it? (y/n): " OVERWRITE
-    if [ "$OVERWRITE" != "y" ]; then
-        print_info "Using existing .env file"
-        ENV_CONFIGURED=true
-    else
-        ENV_CONFIGURED=false
-    fi
-else
-    ENV_CONFIGURED=false
-fi
-
-if [ "$ENV_CONFIGURED" = false ]; then
-    print_info "Let's configure your credentials..."
-    
-    # Databricks configuration
-    echo ""
-    print_info "DATABRICKS CONFIGURATION"
-    read -p "Enter your Databricks workspace URL (e.g., https://adb-xxx.azuredatabricks.net): " DATABRICKS_HOST
-    read -p "Enter your Databricks personal access token: " DATABRICKS_TOKEN
-    read -p "Enter your SQL Warehouse ID (optional, press Enter to skip): " DATABRICKS_WAREHOUSE_ID
-    
-    # Anthropic configuration
-    echo ""
-    print_info "ANTHROPIC CONFIGURATION"
-    read -p "Enter your Anthropic API key (sk-ant-...): " ANTHROPIC_API_KEY
-    
-    # Create .env file
-    cat > .env << EOF
-# Databricks Configuration
-DATABRICKS_HOST=$DATABRICKS_HOST
-DATABRICKS_TOKEN=$DATABRICKS_TOKEN
-DATABRICKS_WAREHOUSE_ID=$DATABRICKS_WAREHOUSE_ID
-
-# Anthropic API Configuration
-ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY
-
-# Server Configuration
-SERVER_HOST=0.0.0.0
-SERVER_PORT=5000
-FLASK_ENV=development
-LOG_LEVEL=INFO
-
-# Features
-ENABLE_SQL_EXECUTION=false
-ENABLE_BATCH_OPS=true
-ENABLE_AUDIT_LOG=true
-ENABLE_CACHING=false
-EOF
-    
-    print_success ".env file created successfully"
-fi
-
-###############################################################################
-# STEP 3: CHOOSE DEPLOYMENT METHOD
-###############################################################################
-
-print_header "Step 3: Choose Deployment Method"
-
-echo "Available deployment options:"
-echo "1) Local Python (recommended for testing)"
-if [ "$DOCKER_AVAILABLE" = true ]; then
-    echo "2) Docker"
-fi
-if [ "$COMPOSE_AVAILABLE" = true ]; then
-    echo "3) Docker Compose (full stack)"
-fi
-
-read -p "Enter your choice (1-3): " DEPLOY_CHOICE
-
-###############################################################################
-# STEP 4: DEPLOYMENT
-###############################################################################
-
-print_header "Step 4: Deployment"
-
-case $DEPLOY_CHOICE in
-    1)
-        # Local Python deployment
-        print_info "Setting up local Python environment..."
-        
-        # Create virtual environment
-        if [ ! -d "venv" ]; then
-            print_info "Creating virtual environment..."
-            python3 -m venv venv
-            print_success "Virtual environment created"
-        fi
-        
-        # Activate virtual environment
-        print_info "Activating virtual environment..."
-        source venv/bin/activate
-        
-        # Upgrade pip
-        print_info "Upgrading pip..."
-        pip install --upgrade pip > /dev/null 2>&1
-        
-        # Install dependencies
-        print_info "Installing dependencies..."
-        pip install -r requirements.txt
-        print_success "Dependencies installed"
-        
-        # Start the application in background
-        print_info "Starting application..."
-        nohup python app.py > app.log 2>&1 &
-        APP_PID=$!
-        echo $APP_PID > app.pid
-        
-        # Wait for startup
-        sleep 5
-        
-        if ps -p $APP_PID > /dev/null; then
-            print_success "Application started successfully (PID: $APP_PID)"
-            DEPLOYMENT_TYPE="local"
-        else
-            print_error "Application failed to start. Check app.log for details."
-            exit 1
-        fi
-        ;;
-        
-    2)
-        # Docker deployment
-        if [ "$DOCKER_AVAILABLE" = false ]; then
-            print_error "Docker is not available"
-            exit 1
-        fi
-        
-        print_info "Building Docker image..."
-        docker build -t unity-catalog-chatbot:latest .
-        print_success "Docker image built"
-        
-        print_info "Starting Docker container..."
-        docker run -d \
-            --name unity-catalog-chatbot \
-            -p 5000:5000 \
-            --env-file .env \
-            unity-catalog-chatbot:latest
-        
-        print_success "Docker container started"
-        DEPLOYMENT_TYPE="docker"
-        ;;
-        
-    3)
-        # Docker Compose deployment
-        if [ "$COMPOSE_AVAILABLE" = false ]; then
-            print_error "Docker Compose is not available"
-            exit 1
-        fi
-        
-        print_info "Starting services with Docker Compose..."
-        docker-compose up -d
-        print_success "Services started"
-        DEPLOYMENT_TYPE="compose"
-        ;;
-        
-    *)
-        print_error "Invalid choice"
-        exit 1
-        ;;
-esac
-
-###############################################################################
-# STEP 5: HEALTH CHECK
-###############################################################################
-
-print_header "Step 5: Health Check"
-
-print_info "Waiting for application to be ready..."
-sleep 10
-
-MAX_RETRIES=30
-RETRY_COUNT=0
-
-while [ $RETRY_COUNT -lt $MAX_RETRIES ]; do
-    if curl -s http://localhost:5000/api/health > /dev/null 2>&1; then
-        print_success "Application is healthy!"
-        
-        # Get health check response
-        HEALTH_RESPONSE=$(curl -s http://localhost:5000/api/health)
-        echo -e "${GREEN}Health Check Response:${NC}"
-        echo "$HEALTH_RESPONSE" | python3 -m json.tool 2>/dev/null || echo "$HEALTH_RESPONSE"
-        break
-    else
-        RETRY_COUNT=$((RETRY_COUNT + 1))
-        echo -n "."
-        sleep 2
-    fi
-done
-
-if [ $RETRY_COUNT -eq $MAX_RETRIES ]; then
-    print_error "Application failed health check"
-    
-    if [ "$DEPLOYMENT_TYPE" = "local" ]; then
-        print_info "Check app.log for error details:"
-        tail -n 20 app.log
-    elif [ "$DEPLOYMENT_TYPE" = "docker" ]; then
-        print_info "Check Docker logs:"
-        docker logs unity-catalog-chatbot
-    elif [ "$DEPLOYMENT_TYPE" = "compose" ]; then
-        print_info "Check Docker Compose logs:"
-        docker-compose logs
-    fi
-    
-    exit 1
-fi
-
-###############################################################################
-# STEP 6: AUTOMATED TESTING
-###############################################################################
-
-print_header "Step 6: Automated Testing"
-
-print_info "Running automated tests..."
-
-# Test 1: Health endpoint
-print_info "Test 1: Health endpoint"
-HEALTH_STATUS=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:5000/api/health)
-if [ "$HEALTH_STATUS" = "200" ]; then
-    print_success "Health endpoint: PASSED"
-else
-    print_error "Health endpoint: FAILED (Status: $HEALTH_STATUS)"
-fi
-
-# Test 2: Chat endpoint with help command
-print_info "Test 2: Chat endpoint (help command)"
-CHAT_RESPONSE=$(curl -s -X POST http://localhost:5000/api/chat \
-    -H "Content-Type: application/json" \
-    -d '{"message": "help"}' \
-    -w "\n%{http_code}")
-
-CHAT_STATUS=$(echo "$CHAT_RESPONSE" | tail -n 1)
-CHAT_BODY=$(echo "$CHAT_RESPONSE" | head -n -1)
-
-if [ "$CHAT_STATUS" = "200" ]; then
-    print_success "Chat endpoint: PASSED"
-    echo -e "${BLUE}Response:${NC}"
-    echo "$CHAT_BODY" | python3 -m json.tool 2>/dev/null | head -n 20
-else
-    print_error "Chat endpoint: FAILED (Status: $CHAT_STATUS)"
-fi
-
-# Test 3: List catalogs
-print_info "Test 3: List catalogs"
-CATALOGS_RESPONSE=$(curl -s -X POST http://localhost:5000/api/chat \
-    -H "Content-Type: application/json" \
-    -d '{"message": "list all catalogs"}' \
-    -w "\n%{http_code}")
-
-CATALOGS_STATUS=$(echo "$CATALOGS_RESPONSE" | tail -n 1)
-if [ "$CATALOGS_STATUS" = "200" ]; then
-    print_success "List catalogs: PASSED"
-else
-    print_error "List catalogs: FAILED (Status: $CATALOGS_STATUS)"
-fi
-
-###############################################################################
-# STEP 7: INTERACTIVE TESTING
-###############################################################################
-
-print_header "Step 7: Interactive Testing"
-
-echo ""
-print_info "Application is ready for interactive testing!"
-echo ""
-echo -e "${GREEN}Access URLs:${NC}"
-echo "  API Backend:  http://localhost:5000"
-echo "  Health Check: http://localhost:5000/api/health"
-echo "  Swagger Docs: http://localhost:5000/docs (if enabled)"
-echo ""
-
-read -p "Would you like to test the chatbot interactively? (y/n): " INTERACTIVE
-
-if [ "$INTERACTIVE" = "y" ]; then
-    print_info "Interactive Chatbot Test"
-    echo ""
-    echo "Enter your commands (or 'exit' to quit):"
-    echo "Examples:"
-    echo "  - Create a catalog named test_catalog"
-    echo "  - List all catalogs"
-    echo "  - Grant SELECT on test_catalog to data_analysts"
-    echo ""
-    
-    while true; do
-        read -p "You: " USER_INPUT
-        
-        if [ "$USER_INPUT" = "exit" ]; then
-            break
-        fi
-        
-        # Make API call
-        RESPONSE=$(curl -s -X POST http://localhost:5000/api/chat \
-            -H "Content-Type: application/json" \
-            -d "{\"message\": \"$USER_INPUT\"}")
-        
-        # Extract message from JSON
-        MESSAGE=$(echo "$RESPONSE" | python3 -c "import sys, json; print(json.load(sys.stdin).get('message', 'No response'))" 2>/dev/null)
-        SQL=$(echo "$RESPONSE" | python3 -c "import sys, json; data=json.load(sys.stdin); print(data.get('sql', ''))" 2>/dev/null)
-        
-        echo -e "${BLUE}Assistant:${NC} $MESSAGE"
-        
-        if [ ! -z "$SQL" ]; then
-            echo -e "${YELLOW}SQL:${NC} $SQL"
-        fi
-        echo ""
-    done
-fi
-
-###############################################################################
-# STEP 8: DEPLOYMENT SUMMARY
-###############################################################################
-
-print_header "Deployment Summary"
-
-echo -e "${GREEN}✓ Deployment completed successfully!${NC}"
-echo ""
-echo "Deployment Type: $DEPLOYMENT_TYPE"
-echo ""
-echo -e "${BLUE}Next Steps:${NC}"
-echo "1. Access the API at: http://localhost:5000"
-echo "2. Review the logs:"
-
-case $DEPLOYMENT_TYPE in
-    "local")
-        echo "   - Application logs: tail -f app.log"
-        echo "3. Stop the application:"
-        echo "   - kill \$(cat app.pid)"
-        ;;
-    "docker")
-        echo "   - Docker logs: docker logs -f unity-catalog-chatbot"
-        echo "3. Stop the application:"
-        echo "   - docker stop unity-catalog-chatbot"
-        ;;
-    "compose")
-        echo "   - Docker Compose logs: docker-compose logs -f"
-        echo "3. Stop the application:"
-        echo "   - docker-compose down"
-        ;;
-esac
-
-echo ""
-echo "4. Run tests: pytest test_chatbot.py"
-echo "5. View documentation: cat README.md"
-echo ""
-
-# Create quick reference file
-cat > QUICK_REFERENCE.txt << EOF
-Unity Catalog Chatbot - Quick Reference
-========================================
-
-Deployment Type: $DEPLOYMENT_TYPE
-
-URLs:
-- API: http://localhost:5000
-- Health: http://localhost:5000/api/health
-
-Logs:
-EOF
-
-case $DEPLOYMENT_TYPE in
-    "local")
-        echo "- Application: tail -f app.log" >> QUICK_REFERENCE.txt
-        echo "" >> QUICK_REFERENCE.txt
-        echo "Stop Application:" >> QUICK_REFERENCE.txt
-        echo "kill \$(cat app.pid)" >> QUICK_REFERENCE.txt
-        ;;
-    "docker")
-        echo "- Docker: docker logs -f unity-catalog-chatbot" >> QUICK_REFERENCE.txt
-        echo "" >> QUICK_REFERENCE.txt
-        echo "Stop Application:" >> QUICK_REFERENCE.txt
-        echo "docker stop unity-catalog-chatbot" >> QUICK_REFERENCE.txt
-        ;;
-    "compose")
-        echo "- Docker Compose: docker-compose logs -f" >> QUICK_REFERENCE.txt
-        echo "" >> QUICK_REFERENCE.txt
-        echo "Stop Application:" >> QUICK_REFERENCE.txt
-        echo "docker-compose down" >> QUICK_REFERENCE.txt
-        ;;
-esac
-
-cat >> QUICK_REFERENCE.txt << EOF
-
-Sample Commands:
-- Create catalog: "Create a catalog named test_catalog"
-- Create schema: "Create schema analytics in test_catalog"
-- Grant permission: "Grant SELECT on test_catalog to user@example.com"
-- List catalogs: "List all catalogs"
-
-For detailed documentation, see README.md
-EOF
-
-print_success "Quick reference saved to QUICK_REFERENCE.txt"
-
-echo ""
-print_success "Deployment complete! Happy chatting! 🎉"

docker-compose.yml

@@ -1,60 +0,0 @@
-version: '3.8'
-
-services:
-  unity-catalog-chatbot:
-    build: .
-    container_name: unity-catalog-chatbot
-    ports:
-      - "5000:5000"
-    environment:
-      - DATABRICKS_HOST=${DATABRICKS_HOST}
-      - DATABRICKS_TOKEN=${DATABRICKS_TOKEN}
-      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
-      - DATABRICKS_WAREHOUSE_ID=${DATABRICKS_WAREHOUSE_ID}
-      - FLASK_ENV=production
-    env_file:
-      - .env
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:5000/api/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s
-    networks:
-      - chatbot-network
-
-  # Optional: Redis for caching and rate limiting
-  redis:
-    image: redis:7-alpine
-    container_name: unity-catalog-redis
-    ports:
-      - "6379:6379"
-    volumes:
-      - redis-data:/data
-    restart: unless-stopped
-    networks:
-      - chatbot-network
-
-  # Optional: Nginx reverse proxy
-  nginx:
-    image: nginx:alpine
-    container_name: unity-catalog-nginx
-    ports:
-      - "80:80"
-      - "443:443"
-    volumes:
-      - ./nginx.conf:/etc/nginx/nginx.conf:ro
-      - ./ssl:/etc/nginx/ssl:ro
-    depends_on:
-      - unity-catalog-chatbot
-    restart: unless-stopped
-    networks:
-      - chatbot-network
-
-networks:
-  chatbot-network:
-    driver: bridge
-
-volumes:
-  redis-data:

index.html

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Unity Catalog Chatbot</title>
+    <script crossorigin src="https://unpkg.com/react@18/umd/react.production.min.js"></script>
+    <script crossorigin src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"></script>
+    <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
+    <style>
+        body {
+            margin: 0;
+            padding: 0;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+                'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+                sans-serif;
+            -webkit-font-smoothing: antialiased;
+            -moz-osx-font-smoothing: grayscale;
+        }
+        code {
+            font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
+                monospace;
+        }
+        #root {
+            width: 100%;
+            height: 100vh;
+        }
+    </style>
+</head>
+<body>
+    <div id="root"></div>
+
+    <script type="text/babel" src="unity-catalog-chatbot.jsx"></script>
+    <script type="text/babel">
+        const root = ReactDOM.createRoot(document.getElementById('root'));
+        root.render(<UnityCatalogChatbot />);
+    </script>
+</body>
+</html>

test.sh

@@ -1,316 +0,0 @@
-#!/bin/bash
-
-###############################################################################
-# Unity Catalog Chatbot - Comprehensive Test Suite
-# This script runs automated tests against the deployed chatbot
-###############################################################################
-
-set -e
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-# Configuration
-API_URL="${API_URL:-http://localhost:5000}"
-TOTAL_TESTS=0
-PASSED_TESTS=0
-FAILED_TESTS=0
-
-# Functions
-print_test() {
-    echo -e "\n${BLUE}[TEST $1]${NC} $2"
-}
-
-print_pass() {
-    echo -e "${GREEN}✓ PASSED${NC}: $1"
-    PASSED_TESTS=$((PASSED_TESTS + 1))
-}
-
-print_fail() {
-    echo -e "${RED}✗ FAILED${NC}: $1"
-    FAILED_TESTS=$((FAILED_TESTS + 1))
-}
-
-print_info() {
-    echo -e "${BLUE}ℹ${NC} $1"
-}
-
-# Test function
-run_test() {
-    TOTAL_TESTS=$((TOTAL_TESTS + 1))
-    local test_name="$1"
-    local expected_status="$2"
-    local endpoint="$3"
-    local method="$4"
-    local data="$5"
-    
-    print_test "$TOTAL_TESTS" "$test_name"
-    
-    if [ "$method" = "GET" ]; then
-        RESPONSE=$(curl -s -w "\n%{http_code}" "$API_URL$endpoint")
-    else
-        RESPONSE=$(curl -s -X POST -w "\n%{http_code}" \
-            -H "Content-Type: application/json" \
-            -d "$data" \
-            "$API_URL$endpoint")
-    fi
-    
-    HTTP_CODE=$(echo "$RESPONSE" | tail -n 1)
-    BODY=$(echo "$RESPONSE" | head -n -1)
-    
-    if [ "$HTTP_CODE" = "$expected_status" ]; then
-        print_pass "$test_name (Status: $HTTP_CODE)"
-        echo "$BODY" | python3 -m json.tool 2>/dev/null | head -n 10
-        return 0
-    else
-        print_fail "$test_name (Expected: $expected_status, Got: $HTTP_CODE)"
-        echo "$BODY"
-        return 1
-    fi
-}
-
-# Test chatbot endpoint
-test_chat() {
-    local test_name="$1"
-    local message="$2"
-    local expected_keyword="$3"
-    
-    TOTAL_TESTS=$((TOTAL_TESTS + 1))
-    print_test "$TOTAL_TESTS" "$test_name"
-    
-    RESPONSE=$(curl -s -X POST \
-        -H "Content-Type: application/json" \
-        -d "{\"message\": \"$message\"}" \
-        "$API_URL/api/chat")
-    
-    if echo "$RESPONSE" | grep -q "$expected_keyword"; then
-        print_pass "$test_name"
-        echo "$RESPONSE" | python3 -m json.tool 2>/dev/null | head -n 15
-        return 0
-    else
-        print_fail "$test_name (Keyword '$expected_keyword' not found)"
-        echo "$RESPONSE"
-        return 1
-    fi
-}
-
-###############################################################################
-# START TESTING
-###############################################################################
-
-echo "========================================="
-echo "Unity Catalog Chatbot - Test Suite"
-echo "========================================="
-echo "API URL: $API_URL"
-echo "Started: $(date)"
-echo ""
-
-###############################################################################
-# SECTION 1: Basic Connectivity Tests
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 1: Basic Connectivity ===${NC}\n"
-
-run_test "Health Check Endpoint" "200" "/api/health" "GET"
-
-run_test "Chat Endpoint Availability" "200" "/api/chat" "POST" '{"message": "test"}'
-
-###############################################################################
-# SECTION 2: Help & Information Tests
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 2: Help & Information ===${NC}\n"
-
-test_chat "Help Command" "help" "Creating Objects"
-
-test_chat "General Query" "what can you do?" "Unity Catalog"
-
-###############################################################################
-# SECTION 3: Catalog Operations
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 3: Catalog Operations ===${NC}\n"
-
-test_chat "List Catalogs" "list all catalogs" "SHOW CATALOGS"
-
-test_chat "Create Catalog Request" "create a catalog named test_catalog_$(date +%s)" "CREATE CATALOG"
-
-###############################################################################
-# SECTION 4: Schema Operations
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 4: Schema Operations ===${NC}\n"
-
-test_chat "Create Schema Request" "create schema test_schema in main" "CREATE SCHEMA"
-
-test_chat "List Schemas Request" "list schemas in main" "SHOW SCHEMAS"
-
-###############################################################################
-# SECTION 5: Table Operations
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 5: Table Operations ===${NC}\n"
-
-test_chat "Create Table Request" "create table main.default.test_table_$(date +%s)" "CREATE TABLE"
-
-###############################################################################
-# SECTION 6: Permission Operations
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 6: Permission Operations ===${NC}\n"
-
-test_chat "Grant Permission Request" "grant SELECT on main to test_user" "GRANT SELECT"
-
-test_chat "Show Permissions Request" "show permissions for main" "SHOW GRANTS"
-
-###############################################################################
-# SECTION 7: Complex Queries
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 7: Complex Queries ===${NC}\n"
-
-test_chat "Multi-step Request" \
-    "create a catalog named analytics, then create a schema called staging in it" \
-    "catalog"
-
-###############################################################################
-# SECTION 8: Error Handling
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 8: Error Handling ===${NC}\n"
-
-TOTAL_TESTS=$((TOTAL_TESTS + 1))
-print_test "$TOTAL_TESTS" "Empty Message Handling"
-
-EMPTY_RESPONSE=$(curl -s -X POST \
-    -H "Content-Type: application/json" \
-    -d '{"message": ""}' \
-    -w "%{http_code}" \
-    "$API_URL/api/chat")
-
-if echo "$EMPTY_RESPONSE" | grep -q "400"; then
-    print_pass "Empty message returns 400"
-else
-    # Some implementations might accept empty messages
-    print_info "Empty message handling: $(echo $EMPTY_RESPONSE | tail -c 4)"
-    PASSED_TESTS=$((PASSED_TESTS + 1))
-fi
-
-###############################################################################
-# SECTION 9: Performance Tests
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 9: Performance Tests ===${NC}\n"
-
-print_test "$((TOTAL_TESTS + 1))" "Response Time Test"
-TOTAL_TESTS=$((TOTAL_TESTS + 1))
-
-START_TIME=$(date +%s%N)
-curl -s -X POST \
-    -H "Content-Type: application/json" \
-    -d '{"message": "help"}' \
-    "$API_URL/api/chat" > /dev/null
-END_TIME=$(date +%s%N)
-
-DURATION=$((($END_TIME - $START_TIME) / 1000000))
-
-if [ $DURATION -lt 5000 ]; then
-    print_pass "Response time: ${DURATION}ms (< 5s)"
-else
-    print_info "Response time: ${DURATION}ms (acceptable)"
-    PASSED_TESTS=$((PASSED_TESTS + 1))
-fi
-
-###############################################################################
-# SECTION 10: Load Test (Optional)
-###############################################################################
-
-echo -e "\n${YELLOW}=== SECTION 10: Light Load Test ===${NC}\n"
-
-print_test "$((TOTAL_TESTS + 1))" "Concurrent Requests (5 simultaneous)"
-TOTAL_TESTS=$((TOTAL_TESTS + 1))
-
-for i in {1..5}; do
-    curl -s -X POST \
-        -H "Content-Type: application/json" \
-        -d '{"message": "help"}' \
-        "$API_URL/api/chat" > /dev/null &
-done
-
-wait
-
-if [ $? -eq 0 ]; then
-    print_pass "Handled 5 concurrent requests"
-else
-    print_fail "Failed to handle concurrent requests"
-fi
-
-###############################################################################
-# TEST SUMMARY
-###############################################################################
-
-echo ""
-echo "========================================="
-echo "Test Summary"
-echo "========================================="
-echo "Total Tests:  $TOTAL_TESTS"
-echo -e "${GREEN}Passed:       $PASSED_TESTS${NC}"
-echo -e "${RED}Failed:       $FAILED_TESTS${NC}"
-echo ""
-
-PASS_RATE=$((PASSED_TESTS * 100 / TOTAL_TESTS))
-echo "Pass Rate:    $PASS_RATE%"
-
-if [ $PASS_RATE -ge 90 ]; then
-    echo -e "\n${GREEN}✓ Test suite PASSED!${NC}"
-    EXIT_CODE=0
-elif [ $PASS_RATE -ge 70 ]; then
-    echo -e "\n${YELLOW}⚠ Test suite passed with warnings${NC}"
-    EXIT_CODE=0
-else
-    echo -e "\n${RED}✗ Test suite FAILED${NC}"
-    EXIT_CODE=1
-fi
-
-echo ""
-echo "Completed: $(date)"
-echo "========================================="
-
-# Generate test report
-cat > test_report.txt << EOF
-Unity Catalog Chatbot - Test Report
-====================================
-Date: $(date)
-API URL: $API_URL
-
-Summary:
---------
-Total Tests: $TOTAL_TESTS
-Passed: $PASSED_TESTS
-Failed: $FAILED_TESTS
-Pass Rate: $PASS_RATE%
-
-Status: $([ $EXIT_CODE -eq 0 ] && echo "PASSED" || echo "FAILED")
-
-Sections Tested:
-1. Basic Connectivity
-2. Help & Information
-3. Catalog Operations
-4. Schema Operations
-5. Table Operations
-6. Permission Operations
-7. Complex Queries
-8. Error Handling
-9. Performance Tests
-10. Load Test
-
-For detailed logs, review the console output.
-EOF
-
-print_info "Test report saved to test_report.txt"
-
-exit $EXIT_CODE

unity-catalog-chatbot.jsx

@@ -1,7 +1,19 @@
 import React, { useState, useRef, useEffect } from 'react';
-import { Send, Database, Users, Shield, CheckCircle, AlertCircle, Loader, Settings, Terminal } from 'lucide-react';
+import { Send, Database, Users, Shield, CheckCircle, AlertCircle, Loader, Settings, Terminal, Copy, CheckCheck } from 'lucide-react';
 
 const UnityCatalogChatbot = () => {
+  // Connection Setup State
+  const [isConnected, setIsConnected] = useState(false);
+  const [showSetup, setShowSetup] = useState(true);
+  const [setupForm, setSetupForm] = useState({
+    host: '',
+    token: '',
+    workspaceId: ''
+  });
+  const [setupLoading, setSetupLoading] = useState(false);
+  const [setupError, setSetupError] = useState('');
+
+  // Chat State
   const [messages, setMessages] = useState([
     {
       role: 'assistant',
@@ -12,6 +24,9 @@ const UnityCatalogChatbot = () => {
   const [input, setInput] = useState('');
   const [isLoading, setIsLoading] = useState(false);
   const [actionLog, setActionLog] = useState([]);
+  const [activeTab, setActiveTab] = useState('chat'); // 'chat' or 'logs'
+  const [copiedId, setCopiedId] = useState(null);
+  const [dbxStatus, setDbxStatus] = useState('disconnected'); // 'connected', 'disconnected', 'loading'
   const messagesEndRef = useRef(null);
 
   const scrollToBottom = () => {
@@ -22,7 +37,77 @@ const UnityCatalogChatbot = () => {
     scrollToBottom();
   }, [messages]);
 
+  // Check Databricks connection on mount
+  useEffect(() => {
+    checkDatabricksConnection();
+  }, []);
+
+  const checkDatabricksConnection = async () => {
+    try {
+      setDbxStatus('loading');
+      const response = await fetch('/api/health');
+      if (response.ok) {
+        setDbxStatus('connected');
+      } else {
+        setDbxStatus('disconnected');
+      }
+    } catch (error) {
+      console.error('Connection check failed:', error);
+      setDbxStatus('disconnected');
+    }
+  };
+
   // Parse user intent and extract parameters
+    // Connection setup validation
+    const handleTestConnection = async () => {
+      if (!setupForm.host || !setupForm.token || !setupForm.workspaceId) {
+        setSetupError('All fields are required');
+        return;
+      }
+
+      setSetupLoading(true);
+      setSetupError('');
+
+      try {
+        const response = await fetch('/api/validate-connection', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            host: setupForm.host,
+            token: setupForm.token,
+            workspaceId: setupForm.workspaceId
+          })
+        });
+
+        const result = await response.json();
+
+        if (result.success) {
+          setIsConnected(true);
+          setShowSetup(false);
+          setDbxStatus('connected');
+          sessionStorage.setItem('dbx_connection', JSON.stringify(setupForm));
+        } else {
+          setSetupError(result.message || 'Connection failed. Please check your credentials.');
+          setDbxStatus('disconnected');
+        }
+      } catch (error) {
+        console.error('Connection test failed:', error);
+        setSetupError('Connection error: ' + error.message);
+        setDbxStatus('disconnected');
+      } finally {
+        setSetupLoading(false);
+      }
+    };
+
+    const handleSetupInputChange = (field, value) => {
+      setSetupForm(prev => ({
+        ...prev,
+        [field]: value
+      }));
+      setSetupError('');
+    };
   const parseIntent = async (userMessage) => {
     const lowerMsg = userMessage.toLowerCase();
     
@@ -241,20 +326,33 @@ Just tell me what you'd like to do in natural language!`,
     setIsLoading(true);
 
     try {
-      // Parse intent
-      const intent = await parseIntent(input);
-      
-      // Execute operation
-      const result = await executeOperation(intent, []);
+      // Send to backend API
+      const response = await fetch('/api/chat', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ message: input.trim() })
+      });
+
+      if (!response.ok) {
+        throw new Error(`API error: ${response.statusText}`);
+      }
+
+      const result = await response.json();
       
-      // Add to action log
+      // Log the action if SQL was generated
       if (result.sql) {
-        setActionLog(prev => [...prev, {
+        const logEntry = {
+          id: `action-${Date.now()}`,
           timestamp: new Date(),
           sql: result.sql,
-          action: result.action,
-          status: 'success'
-        }]);
+          intent: result.intent || 'unknown',
+          status: result.success ? 'success' : 'failed',
+          message: result.message,
+          explanation: result.explanation
+        };
+        setActionLog(prev => [...prev, logEntry]);
       }
 
       // Add assistant response
@@ -262,14 +360,17 @@ Just tell me what you'd like to do in natural language!`,
         role: 'assistant',
         content: result.message,
         sql: result.sql,
-        timestamp: new Date()
+        intent: result.intent,
+        timestamp: new Date(),
+        isError: !result.success
       };
 
       setMessages(prev => [...prev, assistantMessage]);
     } catch (error) {
+      console.error('Error:', error);
       const errorMessage = {
         role: 'assistant',
-        content: `Sorry, I encountered an error: ${error.message}. Please try rephrasing your request.`,
+        content: `Sorry, I encountered an error: ${error.message}. Make sure the backend server is running on /api/chat.`,
         timestamp: new Date(),
         isError: true
       };
@@ -293,6 +394,251 @@ Just tell me what you'd like to do in natural language!`,
     { label: 'Help', icon: Settings, prompt: 'help' }
   ];
 
+  // Setup Screen - shown before connection
+  if (showSetup) {
+    return (
+      <div style={{
+        minHeight: '100vh',
+        background: 'linear-gradient(135deg, #0a0e27 0%, #1a1f3a 50%, #2d1b3d 100%)',
+        fontFamily: '"Space Mono", "Courier New", monospace',
+        color: '#e0e6ed',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        padding: '2rem'
+      }}>
+        <div style={{
+          maxWidth: '500px',
+          width: '100%',
+          background: 'rgba(15, 20, 40, 0.8)',
+          backdropFilter: 'blur(12px)',
+          borderRadius: '16px',
+          border: '1px solid rgba(100, 255, 218, 0.2)',
+          padding: '3rem 2rem',
+          boxShadow: '0 8px 32px rgba(0, 0, 0, 0.3)'
+        }}>
+          <div style={{ textAlign: 'center', marginBottom: '2rem' }}>
+            <div style={{
+              fontSize: '3rem',
+              marginBottom: '1rem'
+            }}>
+              🔌
+            </div>
+            <h1 style={{
+              margin: 0,
+              fontSize: '1.8rem',
+              fontWeight: 700,
+              background: 'linear-gradient(135deg, #64ffda 0%, #8892ff 100%)',
+              WebkitBackgroundClip: 'text',
+              WebkitTextFillColor: 'transparent',
+              letterSpacing: '0.05em'
+            }}>
+              Connect to Databricks
+            </h1>
+            <p style={{
+              margin: '0.5rem 0 0 0',
+              fontSize: '0.9rem',
+              color: '#8892b0',
+              letterSpacing: '0.05em'
+            }}>
+              Enter your workspace credentials
+            </p>
+          </div>
+
+          <div style={{ marginBottom: '1.5rem' }}>
+            <label style={{
+              display: 'block',
+              marginBottom: '0.5rem',
+              fontSize: '0.85rem',
+              color: '#64ffda',
+              fontWeight: 600,
+              letterSpacing: '0.05em'
+            }}>
+              DATABRICKS HOST
+            </label>
+            <input
+              type="url"
+              placeholder="https://your-workspace.cloud.databricks.com"
+              value={setupForm.host}
+              onChange={(e) => handleSetupInputChange('host', e.target.value)}
+              style={{
+                width: '100%',
+                padding: '0.75rem',
+                background: 'rgba(10, 14, 39, 0.6)',
+                border: '1px solid rgba(100, 255, 218, 0.2)',
+                borderRadius: '8px',
+                color: '#e0e6ed',
+                fontFamily: 'inherit',
+                fontSize: '0.9rem',
+                boxSizing: 'border-box',
+                transition: 'all 0.2s ease'
+              }}
+              onFocus={(e) => {
+                e.target.style.borderColor = 'rgba(100, 255, 218, 0.5)';
+                e.target.style.boxShadow = '0 0 12px rgba(100, 255, 218, 0.2)';
+              }}
+              onBlur={(e) => {
+                e.target.style.borderColor = 'rgba(100, 255, 218, 0.2)';
+                e.target.style.boxShadow = 'none';
+              }}
+            />
+          </div>
+
+          <div style={{ marginBottom: '1.5rem' }}>
+            <label style={{
+              display: 'block',
+              marginBottom: '0.5rem',
+              fontSize: '0.85rem',
+              color: '#64ffda',
+              fontWeight: 600,
+              letterSpacing: '0.05em'
+            }}>
+              DATABRICKS TOKEN
+            </label>
+            <input
+              type="password"
+              placeholder="dapi... (Your API token)"
+              value={setupForm.token}
+              onChange={(e) => handleSetupInputChange('token', e.target.value)}
+              style={{
+                width: '100%',
+                padding: '0.75rem',
+                background: 'rgba(10, 14, 39, 0.6)',
+                border: '1px solid rgba(100, 255, 218, 0.2)',
+                borderRadius: '8px',
+                color: '#e0e6ed',
+                fontFamily: 'inherit',
+                fontSize: '0.9rem',
+                boxSizing: 'border-box',
+                transition: 'all 0.2s ease'
+              }}
+              onFocus={(e) => {
+                e.target.style.borderColor = 'rgba(100, 255, 218, 0.5)';
+                e.target.style.boxShadow = '0 0 12px rgba(100, 255, 218, 0.2)';
+              }}
+              onBlur={(e) => {
+                e.target.style.borderColor = 'rgba(100, 255, 218, 0.2)';
+                e.target.style.boxShadow = 'none';
+              }}
+            />
+          </div>
+
+          <div style={{ marginBottom: '2rem' }}>
+            <label style={{
+              display: 'block',
+              marginBottom: '0.5rem',
+              fontSize: '0.85rem',
+              color: '#64ffda',
+              fontWeight: 600,
+              letterSpacing: '0.05em'
+            }}>
+              WORKSPACE ID (Optional)
+            </label>
+            <input
+              type="text"
+              placeholder="Workspace ID"
+              value={setupForm.workspaceId}
+              onChange={(e) => handleSetupInputChange('workspaceId', e.target.value)}
+              style={{
+                width: '100%',
+                padding: '0.75rem',
+                background: 'rgba(10, 14, 39, 0.6)',
+                border: '1px solid rgba(100, 255, 218, 0.2)',
+                borderRadius: '8px',
+                color: '#e0e6ed',
+                fontFamily: 'inherit',
+                fontSize: '0.9rem',
+                boxSizing: 'border-box',
+                transition: 'all 0.2s ease'
+              }}
+              onFocus={(e) => {
+                e.target.style.borderColor = 'rgba(100, 255, 218, 0.5)';
+                e.target.style.boxShadow = '0 0 12px rgba(100, 255, 218, 0.2)';
+              }}
+              onBlur={(e) => {
+                e.target.style.borderColor = 'rgba(100, 255, 218, 0.2)';
+                e.target.style.boxShadow = 'none';
+              }}
+            />
+          </div>
+
+          {setupError && (
+            <div style={{
+              background: 'rgba(239, 68, 68, 0.1)',
+              border: '1px solid rgba(239, 68, 68, 0.3)',
+              borderRadius: '8px',
+              padding: '0.75rem 1rem',
+              marginBottom: '1.5rem',
+              color: '#ef4444',
+              fontSize: '0.85rem',
+              display: 'flex',
+              alignItems: 'center',
+              gap: '0.75rem'
+            }}>
+              <span>⚠️</span>
+              <span>{setupError}</span>
+            </div>
+          )}
+
+          <button
+            onClick={handleTestConnection}
+            disabled={setupLoading}
+            style={{
+              width: '100%',
+              padding: '0.875rem',
+              background: setupLoading
+                ? 'rgba(100, 255, 218, 0.1)'
+                : 'linear-gradient(135deg, #64ffda 0%, #00bfa5 100%)',
+              border: 'none',
+              borderRadius: '12px',
+              color: setupLoading ? '#8892b0' : '#0a0e27',
+              fontSize: '0.95rem',
+              fontFamily: 'inherit',
+              fontWeight: 700,
+              cursor: setupLoading ? 'not-allowed' : 'pointer',
+              transition: 'all 0.2s ease',
+              letterSpacing: '0.05em',
+              boxShadow: setupLoading ? 'none' : '0 4px 16px rgba(100, 255, 218, 0.3)'
+            }}
+            onMouseEnter={(e) => {
+              if (!setupLoading) {
+                e.target.style.transform = 'translateY(-2px)';
+                e.target.style.boxShadow = '0 6px 20px rgba(100, 255, 218, 0.4)';
+              }
+            }}
+            onMouseLeave={(e) => {
+              if (!setupLoading) {
+                e.target.style.transform = 'translateY(0)';
+                e.target.style.boxShadow = '0 4px 16px rgba(100, 255, 218, 0.3)';
+              }
+            }}
+          >
+            {setupLoading ? '🔄 Testing...' : '✓ Connect'}
+          </button>
+
+          <div style={{
+            marginTop: '1.5rem',
+            padding: '1rem',
+            background: 'rgba(100, 255, 218, 0.05)',
+            border: '1px solid rgba(100, 255, 218, 0.1)',
+            borderRadius: '8px',
+            fontSize: '0.8rem',
+            color: '#8892b0',
+            lineHeight: '1.5'
+          }}>
+            <strong style={{ color: '#64ffda', display: 'block', marginBottom: '0.5rem' }}>How to get your credentials:</strong>
+            <ol style={{ margin: '0.5rem 0', paddingLeft: '1.25rem' }}>
+              <li>Go to Databricks workspace URL</li>
+              <li>Create token in Settings → Developer → Tokens</li>
+              <li>Copy your token (dapi...)</li>
+              <li>Find workspace ID in URL or settings</li>
+            </ol>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
   return (
     <div style={{
       minHeight: '100vh',
@@ -607,85 +953,243 @@ Just tell me what you'd like to do in natural language!`,
           display: 'flex',
           flexDirection: 'column'
         }}>
+          {/* Tabs */}
           <div style={{
-            padding: '1.5rem',
+            display: 'grid',
+            gridTemplateColumns: '1fr 1fr',
             borderBottom: '1px solid rgba(100, 255, 218, 0.1)'
           }}>
-            <h2 style={{
-              margin: 0,
-              fontSize: '1rem',
-              fontWeight: 600,
-              color: '#64ffda',
-              letterSpacing: '0.1em',
-              display: 'flex',
-              alignItems: 'center',
-              gap: '0.5rem'
-            }}>
-              <Terminal size={16} />
+            <button
+              onClick={() => setActiveTab('logs')}
+              style={{
+                padding: '1rem',
+                background: activeTab === 'logs' ? 'rgba(100, 255, 218, 0.1)' : 'transparent',
+                border: 'none',
+                borderBottom: activeTab === 'logs' ? '2px solid #64ffda' : 'none',
+                color: activeTab === 'logs' ? '#64ffda' : '#8892b0',
+                fontSize: '0.85rem',
+                fontFamily: 'inherit',
+                fontWeight: 600,
+                cursor: 'pointer',
+                transition: 'all 0.2s ease',
+                letterSpacing: '0.05em'
+              }}
+              onMouseEnter={(e) => {
+                if (activeTab !== 'logs') e.currentTarget.style.color = '#64ffda';
+              }}
+              onMouseLeave={(e) => {
+                if (activeTab !== 'logs') e.currentTarget.style.color = '#8892b0';
+              }}
+            >
               ACTION LOG
-            </h2>
+            </button>
+            <button
+              onClick={() => setActiveTab('status')}
+              style={{
+                padding: '1rem',
+                background: activeTab === 'status' ? 'rgba(100, 255, 218, 0.1)' : 'transparent',
+                border: 'none',
+                borderBottom: activeTab === 'status' ? '2px solid #64ffda' : 'none',
+                color: activeTab === 'status' ? '#64ffda' : '#8892b0',
+                fontSize: '0.85rem',
+                fontFamily: 'inherit',
+                fontWeight: 600,
+                cursor: 'pointer',
+                transition: 'all 0.2s ease',
+                letterSpacing: '0.05em'
+              }}
+              onMouseEnter={(e) => {
+                if (activeTab !== 'status') e.currentTarget.style.color = '#64ffda';
+              }}
+              onMouseLeave={(e) => {
+                if (activeTab !== 'status') e.currentTarget.style.color = '#8892b0';
+              }}
+            >
+              STATUS
+            </button>
           </div>
+
+          {/* Tab Content */}
           <div style={{
             flex: 1,
             overflowY: 'auto',
             padding: '1rem'
           }}>
-            {actionLog.length === 0 ? (
-              <div style={{
-                textAlign: 'center',
-                padding: '2rem 1rem',
-                color: '#8892b0',
-                fontSize: '0.85rem'
-              }}>
-                No actions yet. Start a conversation to see executed commands here.
-              </div>
-            ) : (
-              <div style={{ display: 'flex', flexDirection: 'column', gap: '0.75rem' }}>
-                {actionLog.slice().reverse().map((log, idx) => (
-                  <div
-                    key={idx}
-                    style={{
-                      background: 'rgba(10, 14, 39, 0.6)',
-                      border: '1px solid rgba(100, 255, 218, 0.2)',
-                      borderRadius: '8px',
-                      padding: '0.75rem',
-                      fontSize: '0.75rem',
-                      animation: 'slideIn 0.3s ease-out'
-                    }}
-                  >
+            {activeTab === 'logs' && (
+              <>
+                {actionLog.length === 0 ? (
+                  <div style={{
+                    textAlign: 'center',
+                    padding: '2rem 1rem',
+                    color: '#8892b0',
+                    fontSize: '0.85rem'
+                  }}>
+                    No actions yet. Start a conversation to see executed commands here.
+                  </div>
+                ) : (
+                  <div style={{ display: 'flex', flexDirection: 'column', gap: '0.75rem' }}>
+                    {actionLog.slice().reverse().map((log, idx) => (
+                      <div
+                        key={log.id || idx}
+                        style={{
+                          background: 'rgba(10, 14, 39, 0.6)',
+                          border: '1px solid rgba(100, 255, 218, 0.2)',
+                          borderRadius: '8px',
+                          padding: '0.75rem',
+                          fontSize: '0.75rem',
+                          animation: 'slideIn 0.3s ease-out'
+                        }}
+                      >
+                        <div style={{
+                          display: 'flex',
+                          alignItems: 'center',
+                          justifyContent: 'space-between',
+                          marginBottom: '0.5rem',
+                          color: log.status === 'success' ? '#64ffda' : '#ef4444'
+                        }}>
+                          <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem' }}>
+                            {log.status === 'success' ? (
+                              <CheckCircle size={12} />
+                            ) : (
+                              <AlertCircle size={12} />
+                            )}
+                            <span style={{ letterSpacing: '0.05em' }}>
+                              {log.intent.toUpperCase()}
+                            </span>
+                          </div>
+                          <button
+                            onClick={() => {
+                              navigator.clipboard.writeText(log.sql);
+                              setCopiedId(log.id);
+                              setTimeout(() => setCopiedId(null), 2000);
+                            }}
+                            style={{
+                              background: 'transparent',
+                              border: 'none',
+                              color: copiedId === log.id ? '#64ffda' : '#8892b0',
+                              cursor: 'pointer',
+                              padding: '0.25rem',
+                              display: 'flex',
+                              alignItems: 'center',
+                              gap: '0.25rem'
+                            }}
+                            title="Copy SQL"
+                          >
+                            {copiedId === log.id ? (
+                              <CheckCheck size={10} />
+                            ) : (
+                              <Copy size={10} />
+                            )}
+                          </button>
+                        </div>
+                        <div style={{
+                          background: 'rgba(15, 20, 40, 0.8)',
+                          border: '1px solid rgba(100, 255, 218, 0.1)',
+                          borderRadius: '4px',
+                          padding: '0.5rem',
+                          color: '#64ffda',
+                          fontSize: '0.65rem',
+                          marginBottom: '0.5rem',
+                          wordBreak: 'break-word',
+                          fontFamily: '"Fira Code", "Courier New", monospace',
+                          maxHeight: '80px',
+                          overflowY: 'auto'
+                        }}>
+                          <code>{log.sql}</code>
+                        </div>
+                        <div style={{
+                          color: '#64748b',
+                          fontSize: '0.6rem',
+                          letterSpacing: '0.05em'
+                        }}>
+                          {log.timestamp.toLocaleTimeString()}
+                        </div>
+                      </div>
+                    ))}
+                  </div>
+                )}
+              </>
+            )}
+
+            {activeTab === 'status' && (
+              <div style={{ padding: '0.5rem 0' }}>
+                <div style={{
+                  background: 'rgba(10, 14, 39, 0.6)',
+                  border: '1px solid rgba(100, 255, 218, 0.2)',
+                  borderRadius: '8px',
+                  padding: '1rem',
+                  fontSize: '0.85rem',
+                  lineHeight: '1.6'
+                }}>
+                  <div style={{ marginBottom: '1rem' }}>
+                    <div style={{ color: '#8892b0', fontSize: '0.75rem', letterSpacing: '0.05em', marginBottom: '0.5rem' }}>
+                      DATABRICKS CONNECTION
+                    </div>
                     <div style={{
                       display: 'flex',
                       alignItems: 'center',
-                      gap: '0.5rem',
-                      marginBottom: '0.5rem',
-                      color: log.status === 'success' ? '#64ffda' : '#ef4444'
+                      gap: '0.75rem',
+                      color: dbxStatus === 'connected' ? '#64ffda' : dbxStatus === 'loading' ? '#8892b0' : '#ef4444'
                     }}>
-                      {log.status === 'success' ? (
-                        <CheckCircle size={12} />
-                      ) : (
-                        <AlertCircle size={12} />
-                      )}
-                      <span style={{ letterSpacing: '0.05em' }}>
-                        {log.action.type.toUpperCase()}
+                      <div style={{
+                        width: '12px',
+                        height: '12px',
+                        borderRadius: '50%',
+                        background: dbxStatus === 'connected' ? '#64ffda' : dbxStatus === 'loading' ? '#8892b0' : '#ef4444',
+                        animation: dbxStatus === 'loading' ? 'pulse 2s ease-in-out infinite' : 'none'
+                      }} />
+                      <span style={{ textTransform: 'capitalize', fontSize: '0.9rem', fontWeight: 600 }}>
+                        {dbxStatus}
                       </span>
                     </div>
-                    <div style={{
-                      color: '#8892b0',
-                      fontSize: '0.7rem',
-                      marginBottom: '0.5rem',
-                      wordBreak: 'break-word'
-                    }}>
-                      {log.sql}
+                  </div>
+
+                  <div style={{ marginBottom: '1rem' }}>
+                    <div style={{ color: '#8892b0', fontSize: '0.75rem', letterSpacing: '0.05em', marginBottom: '0.5rem' }}>
+                      ACTIONS EXECUTED
                     </div>
-                    <div style={{
-                      color: '#64748b',
-                      fontSize: '0.65rem',
-                      letterSpacing: '0.05em'
-                    }}>
-                      {log.timestamp.toLocaleTimeString()}
+                    <div style={{ fontSize: '1.5rem', color: '#64ffda', fontWeight: 700 }}>
+                      {actionLog.length}
                     </div>
                   </div>
-                ))}
+
+                  <div style={{ marginBottom: '1rem' }}>
+                    <div style={{ color: '#8892b0', fontSize: '0.75rem', letterSpacing: '0.05em', marginBottom: '0.5rem' }}>
+                      LAST ACTION
+                    </div>
+                    <div style={{ color: '#e0e6ed', fontSize: '0.85rem' }}>
+                      {actionLog.length > 0
+                        ? actionLog[actionLog.length - 1].timestamp.toLocaleString()
+                        : 'No actions yet'}
+                    </div>
+                  </div>
+
+                  <button
+                    onClick={checkDatabricksConnection}
+                    style={{
+                      width: '100%',
+                      padding: '0.75rem',
+                      background: 'rgba(100, 255, 218, 0.1)',
+                      border: '1px solid rgba(100, 255, 218, 0.3)',
+                      borderRadius: '6px',
+                      color: '#64ffda',
+                      fontSize: '0.85rem',
+                      cursor: 'pointer',
+                      fontFamily: 'inherit',
+                      fontWeight: 600,
+                      letterSpacing: '0.05em',
+                      transition: 'all 0.2s ease'
+                    }}
+                    onMouseEnter={(e) => {
+                      e.currentTarget.style.background = 'rgba(100, 255, 218, 0.2)';
+                    }}
+                    onMouseLeave={(e) => {
+                      e.currentTarget.style.background = 'rgba(100, 255, 218, 0.1)';
+                    }}
+                  >
+                    REFRESH STATUS
+                  </button>
+                </div>
               </div>
             )}
           </div>
@@ -711,6 +1215,11 @@ Just tell me what you'd like to do in natural language!`,
           to { transform: rotate(360deg); }
         }
         
+        @keyframes pulse {
+          0%, 100% { opacity: 1; }
+          50% { opacity: 0.5; }
+        }
+        
         * {
           box-sizing: border-box;
         }