fastapi hf deployment

ai-experiments/hf_models/DEPLOYMENT_GUIDE.md

@@ -0,0 +1,245 @@
+# Deployment Guide: Hugging Face Spaces
+
+This guide will help you deploy your Career Prep LLM Services to Hugging Face Spaces and test it with user prompts.
+
+## Table of Contents
+1. [Prerequisites](#prerequisites)
+2. [Best Deployment Methods](#best-deployment-methods)
+3. [Step-by-Step Deployment](#step-by-step-deployment)
+4. [Testing Your Deployment](#testing-your-deployment)
+5. [Troubleshooting](#troubleshooting)
+
+## Prerequisites
+
+1. **Hugging Face Account**
+   - Sign up at https://huggingface.co/join
+   - Verify your email
+
+2. **Hugging Face Access Token**
+   - Go to https://huggingface.co/settings/tokens
+   - Create a new token with "Write" permissions
+   - Save it securely (you'll need it for Git operations)
+
+3. **Git Repository**
+   - Your code should be in a Git repository (GitHub, GitLab, or Hugging Face's Git)
+   - Make sure all files are committed
+
+4. **Model Selection**
+   - Choose a model that fits your hardware budget
+   - See [Model Recommendations](#model-recommendations) below
+
+## Best Deployment Methods
+
+### Method 1: Docker SDK (Recommended for FastAPI)
+✅ **Best for**: FastAPI applications, custom dependencies, full control
+- Uses Dockerfile for deployment
+- Full control over environment
+- Supports complex applications
+
+### Method 2: Gradio SDK
+❌ **Not recommended** for this project (FastAPI-based)
+
+### Method 3: Static SDK
+❌ **Not recommended** for this project (API service)
+
+## Step-by-Step Deployment
+
+### Step 1: Prepare Your Repository
+
+1. **Ensure all files are committed:**
+   ```bash
+   cd ai-experiments/hf_models
+   git status
+   git add .
+   git commit -m "Prepare for Hugging Face Spaces deployment"
+   ```
+
+2. **Verify key files exist:**
+   - ✅ `app.py` (main FastAPI application)
+   - ✅ `requirements.txt` (Python dependencies)
+   - ✅ `Dockerfile` (Docker configuration)
+   - ✅ `services/` directory (all service files)
+
+### Step 2: Create Hugging Face Space
+
+1. **Go to Hugging Face Spaces:**
+   - Visit https://huggingface.co/spaces
+   - Click **"Create new Space"**
+
+2. **Configure Space:**
+   - **Space name**: `career-prep-llm-services` (or your preferred name)
+   - **SDK**: Select **"Docker"**
+   - **Visibility**: Choose Public or Private
+   - **Hardware**: 
+     - For small models (GPT-2, DialoGPT-small): `CPU basic`
+     - For medium models (DialoGPT-medium): `CPU upgrade` or `T4 small`
+     - For large models (Mistral-7B): `GPU` or `GPU small`
+   - Click **"Create Space"**
+
+### Step 3: Connect Git Repository
+
+**Option A: Push to Hugging Face Git (Recommended)**
+
+1. **Add Hugging Face as remote:**
+   ```bash
+   cd ai-experiments/hf_models
+   git remote add hf https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+   # Replace YOUR_USERNAME and YOUR_SPACE_NAME with your actual values
+   ```
+
+2. **Push to Hugging Face:**
+   ```bash
+   git push hf main
+   # You'll be prompted for username and password (use your HF token as password)
+   ```
+
+**Option B: Connect External Git Repository**
+
+1. In your Space settings, go to **"Repository"** tab
+2. Click **"Connect repository"**
+3. Select your Git provider (GitHub, GitLab, etc.)
+4. Authorize and select your repository
+5. Set the branch (usually `main` or `master`)
+
+### Step 4: Configure Environment Variables
+
+1. **Go to Space Settings:**
+   - Click on your Space
+   - Go to **"Settings"** tab
+   - Scroll to **"Environment variables"**
+
+2. **Add Required Variables:**
+   - `HF_MODEL_NAME`: Your model name (e.g., `gpt2`, `microsoft/DialoGPT-medium`, `mistralai/Mistral-7B-Instruct-v0.2`)
+   - `PORT`: `7860` (usually auto-set, but can specify)
+
+3. **Save Settings**
+
+### Step 5: Wait for Build
+
+- Hugging Face will automatically build your Docker image
+- This can take 5-15 minutes depending on model size
+- Monitor progress in the **"Logs"** tab
+- You'll see build logs and then runtime logs
+
+### Step 6: Verify Deployment
+
+1. **Check Health Endpoint:**
+   - Visit: `https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/health`
+   - Should return: `{"status": "healthy", ...}`
+
+2. **Check Root Endpoint:**
+   - Visit: `https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/`
+   - Should show service information
+
+## Testing Your Deployment
+
+### Quick Test with cURL
+
+```bash
+# Health check
+curl https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/health
+
+# Generic LLM test
+curl -X POST https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/api/v1/llm \
+  -H "Content-Type: application/json" \
+  -d '{
+    "prompt": "What are the top 5 skills for a data scientist?",
+    "max_tokens": 200,
+    "temperature": 0.7
+  }'
+```
+
+### Use the Test Script
+
+See `test_deployment.py` for an interactive testing script.
+
+## Model Recommendations
+
+### Small Models (CPU Basic - Free Tier)
+- `gpt2` - Fast, lightweight
+- `microsoft/DialoGPT-small` - Conversational
+- **Pros**: Fast startup, low cost
+- **Cons**: Lower quality responses
+
+### Medium Models (CPU Upgrade / T4 Small)
+- `microsoft/DialoGPT-medium` - Better quality
+- `EleutherAI/gpt-neo-125M` - Good balance
+- **Pros**: Better quality, reasonable speed
+- **Cons**: Slower than small models
+
+### Large Models (GPU Required)
+- `mistralai/Mistral-7B-Instruct-v0.2` - High quality
+- `meta-llama/Llama-2-7b-chat-hf` - Excellent (requires request)
+- **Pros**: Best quality responses
+- **Cons**: Requires GPU, slower, more expensive
+
+### Recommended Starting Point
+Start with `gpt2` or `microsoft/DialoGPT-medium` to test deployment, then upgrade to larger models if needed.
+
+## Hardware Selection Guide
+
+| Model Size | Recommended Hardware | Cost |
+|------------|---------------------|------|
+| < 1B params | CPU basic | Free |
+| 1-3B params | CPU upgrade / T4 small | Low |
+| 3-7B params | T4 medium / GPU small | Medium |
+| 7B+ params | GPU / GPU large | High |
+
+## Testing Best Practices
+
+1. **Start with Health Check**: Always verify `/health` first
+2. **Test Simple Prompts**: Use `/api/v1/llm` with simple prompts
+3. **Test Each Endpoint**: Verify all endpoints work
+4. **Monitor Logs**: Check Space logs for errors
+5. **Test with Real Data**: Use realistic user prompts
+6. **Load Testing**: Test with multiple concurrent requests (if needed)
+
+## Troubleshooting
+
+### Build Fails
+- **Check Dockerfile**: Ensure it's correct
+- **Check requirements.txt**: Verify all dependencies are listed
+- **Check logs**: Look for specific error messages
+
+### Model Loading Fails
+- **Check model name**: Verify `HF_MODEL_NAME` is correct
+- **Check hardware**: Ensure hardware is sufficient for model size
+- **Check logs**: Look for model loading errors
+
+### API Returns 500 Errors
+- **Check logs**: Look for Python errors
+- **Check model**: Ensure model loaded successfully
+- **Check memory**: Large models may need more memory
+
+### Slow Responses
+- **Model too large**: Consider smaller model
+- **Hardware insufficient**: Upgrade hardware tier
+- **First request slow**: Normal (model loads on first request)
+
+## Security Considerations
+
+1. **CORS**: Update CORS settings in `app.py` for production
+2. **Rate Limiting**: Consider adding rate limiting
+3. **Authentication**: Add API keys if needed
+4. **Input Validation**: Already handled by Pydantic models
+
+## Cost Optimization
+
+1. **Use appropriate hardware**: Don't over-provision
+2. **Choose right model**: Balance quality vs. cost
+3. **Monitor usage**: Track API calls and costs
+4. **Consider caching**: Cache common responses if possible
+
+## Next Steps
+
+1. ✅ Deploy to Hugging Face Spaces
+2. ✅ Test all endpoints
+3. ✅ Monitor performance
+4. ✅ Optimize model/hardware selection
+5. ✅ Set up monitoring/alerting (optional)
+
+## Support
+
+- Hugging Face Spaces Docs: https://huggingface.co/docs/hub/spaces
+- FastAPI Docs: https://fastapi.tiangolo.com/
+- Transformers Docs: https://huggingface.co/docs/transformers

ai-experiments/hf_models/QUICK_START.md

@@ -0,0 +1,96 @@
+# Quick Start: Deploy to Hugging Face Spaces
+
+## 🚀 Fast Deployment (5 minutes)
+
+### 1. Prepare Your Code
+```bash
+cd ai-experiments/hf_models
+git add .
+git commit -m "Ready for HF Spaces deployment"
+```
+
+### 2. Create Hugging Face Space
+1. Go to https://huggingface.co/spaces
+2. Click **"Create new Space"**
+3. Fill in:
+   - **Name**: `career-prep-llm-services`
+   - **SDK**: `Docker`
+   - **Hardware**: `CPU basic` (for testing) or `T4 small` (for better models)
+   - **Visibility**: Your choice
+
+### 3. Push Code to Hugging Face
+```bash
+# Add HF as remote (replace YOUR_USERNAME and YOUR_SPACE_NAME)
+git remote add hf https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+
+# Push code
+git push hf main
+# Username: YOUR_USERNAME
+# Password: YOUR_HF_TOKEN (get from https://huggingface.co/settings/tokens)
+```
+
+### 4. Configure Environment
+1. In Space settings → **Environment variables**
+2. Add: `HF_MODEL_NAME` = `gpt2` (or your preferred model)
+3. Save
+
+### 5. Wait for Build
+- Check **Logs** tab
+- Wait 5-15 minutes
+- Look for "Application startup complete"
+
+### 6. Test It!
+```bash
+# Run the test script
+python test_deployment.py
+
+# Or test manually
+curl https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/health
+```
+
+## 📝 Quick Test Commands
+
+### Health Check
+```bash
+curl https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/health
+```
+
+### Test LLM with Custom Prompt
+```bash
+curl -X POST https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/api/v1/llm \
+  -H "Content-Type: application/json" \
+  -d '{
+    "prompt": "What are the top 5 skills for a data scientist?",
+    "max_tokens": 300,
+    "temperature": 0.7
+  }'
+```
+
+## 🎯 Model Recommendations
+
+| Use Case | Model | Hardware |
+|----------|-------|----------|
+| Quick testing | `gpt2` | CPU basic (free) |
+| Better quality | `microsoft/DialoGPT-medium` | CPU upgrade / T4 small |
+| Best quality | `mistralai/Mistral-7B-Instruct-v0.2` | GPU / GPU small |
+
+## ⚡ Common Issues
+
+**Build fails?**
+- Check Dockerfile exists
+- Check requirements.txt is correct
+- Check logs for specific errors
+
+**Model won't load?**
+- Verify `HF_MODEL_NAME` is correct
+- Check hardware is sufficient
+- Try smaller model first
+
+**API returns 500?**
+- Check Space logs
+- Verify model loaded (check `/health`)
+- Check memory usage
+
+## 📚 Full Documentation
+
+See `DEPLOYMENT_GUIDE.md` for detailed instructions.

ai-experiments/hf_models/SETUP.md

@@ -0,0 +1,112 @@
+# Setup Guide
+
+## Quick Setup
+
+### 1. Activate Virtual Environment
+
+**On macOS/Linux:**
+```bash
+cd ai-experiments/hf_models
+source venv/bin/activate
+```
+
+**On Windows:**
+```bash
+cd ai-experiments/hf_models
+venv\Scripts\activate
+```
+
+### 2. Install Dependencies
+
+If dependencies aren't installed yet:
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Verify Installation
+
+```bash
+python -c "import fastapi; print('FastAPI installed successfully!')"
+```
+
+### 4. Run the Application
+
+```bash
+python app.py
+```
+
+The server will start on `http://localhost:7860`
+
+## Common Issues
+
+### "No module named fastapi"
+
+**Solution:** Make sure you've activated the virtual environment and installed dependencies:
+
+```bash
+# Activate venv
+source venv/bin/activate  # macOS/Linux
+# or
+venv\Scripts\activate     # Windows
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+### "Command not found: python"
+
+**Solution:** Use `python3` instead:
+```bash
+python3 app.py
+```
+
+### Virtual Environment Not Working
+
+**Solution:** Create a new virtual environment:
+
+```bash
+# Remove old venv (optional)
+rm -rf venv
+
+# Create new venv
+python3 -m venv venv
+
+# Activate it
+source venv/bin/activate  # macOS/Linux
+# or
+venv\Scripts\activate     # Windows
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+## Testing
+
+After setup, test the application:
+
+```bash
+# In one terminal - start the server
+python app.py
+
+# In another terminal - run tests
+python test_deployment.py
+```
+
+## Environment Variables
+
+You can set environment variables before running:
+
+```bash
+export HF_MODEL_NAME="gpt2"  # macOS/Linux
+# or
+set HF_MODEL_NAME=gpt2       # Windows
+
+python app.py
+```
+
+## Next Steps
+
+1. ✅ Setup complete
+2. ✅ Test locally with `python app.py`
+3. ✅ Run `python test_deployment.py` to test endpoints
+4. ✅ Deploy to Hugging Face Spaces (see `DEPLOYMENT_GUIDE.md`)

ai-experiments/hf_models/app.py

@@ -14,6 +14,7 @@ from services.llm_service import LLMService
 from services.diagnosis_service import DiagnosisService
 from services.breakthrough_service import BreakthroughService
 from services.roadmap_service import RoadmapService
+from services.resume_service import ResumeService
 
 app = FastAPI(
     title="Career Prep LLM Services",

ai-experiments/hf_models/test_deployment.py

@@ -0,0 +1,375 @@
+"""
+Interactive Test Script for Hugging Face Spaces Deployment
+Tests all endpoints with user prompts
+"""
+
+import requests
+import json
+import sys
+from typing import Optional
+
+# Configuration
+DEFAULT_BASE_URL = "http://localhost:7860"  # For local testing
+HF_SPACE_URL_TEMPLATE = "https://{username}-{space_name}.hf.space"
+
+def get_base_url() -> str:
+    """Get the base URL from user input or use default"""
+    print("\n" + "="*70)
+    print("Career Prep LLM Services - Deployment Test Script")
+    print("="*70)
+    
+    print("\nSelect deployment to test:")
+    print("1. Local (http://localhost:7860)")
+    print("2. Hugging Face Space (enter URL)")
+    print("3. Custom URL")
+    
+    choice = input("\nEnter choice (1-3) [default: 1]: ").strip() or "1"
+    
+    if choice == "1":
+        return DEFAULT_BASE_URL
+    elif choice == "2":
+        username = input("Enter your Hugging Face username: ").strip()
+        space_name = input("Enter your Space name: ").strip()
+        return HF_SPACE_URL_TEMPLATE.format(username=username, space_name=space_name)
+    elif choice == "3":
+        url = input("Enter custom URL: ").strip()
+        return url.rstrip('/')
+    else:
+        print("Invalid choice, using local URL")
+        return DEFAULT_BASE_URL
+
+
+def test_health(base_url: str) -> bool:
+    """Test health check endpoint"""
+    print("\n" + "-"*70)
+    print("1. Testing Health Check")
+    print("-"*70)
+    
+    try:
+        response = requests.get(f"{base_url}/health", timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        print("✅ Health check passed!")
+        print(f"   Status: {data.get('status')}")
+        print(f"   LLM Loaded: {data.get('llm_loaded', 'Unknown')}")
+        print(f"   Timestamp: {data.get('timestamp')}")
+        return True
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Health check failed: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"   Response: {e.response.text}")
+        return False
+
+
+def test_generic_llm(base_url: str, prompt: Optional[str] = None) -> bool:
+    """Test generic LLM endpoint with user prompt"""
+    print("\n" + "-"*70)
+    print("2. Testing Generic LLM Endpoint")
+    print("-"*70)
+    
+    if prompt is None:
+        prompt = input("\nEnter your prompt (or press Enter for default): ").strip()
+        if not prompt:
+            prompt = "What are the top 5 skills needed for a data scientist role? Explain each briefly."
+    
+    payload = {
+        "prompt": prompt,
+        "max_tokens": 500,
+        "temperature": 0.7
+    }
+    
+    print(f"\n📝 Prompt: {prompt}")
+    print("⏳ Sending request...")
+    
+    try:
+        response = requests.post(
+            f"{base_url}/api/v1/llm",
+            json=payload,
+            timeout=120  # LLM requests can take time
+        )
+        response.raise_for_status()
+        data = response.json()
+        print("\n✅ LLM response received!")
+        print(f"\n📄 Response:\n{data.get('response', 'No response')}")
+        print(f"\n⏰ Timestamp: {data.get('timestamp')}")
+        return True
+    except requests.exceptions.RequestException as e:
+        print(f"\n❌ LLM request failed: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"   Status Code: {e.response.status_code}")
+            print(f"   Response: {e.response.text}")
+        return False
+
+
+def test_diagnosis(base_url: str) -> bool:
+    """Test diagnosis endpoint"""
+    print("\n" + "-"*70)
+    print("3. Testing Career Diagnosis Endpoint")
+    print("-"*70)
+    
+    print("\nEnter user information for diagnosis:")
+    current_role = input("Current role [default: Software Engineer]: ").strip() or "Software Engineer"
+    years_exp = input("Years of experience [default: 3]: ").strip() or "3"
+    skills_input = input("Skills (comma-separated) [default: Python, JavaScript]: ").strip() or "Python, JavaScript"
+    skills = [s.strip() for s in skills_input.split(",")]
+    career_goals = input("Career goals [default: Senior Engineer at FAANG]: ").strip() or "Senior Engineer at FAANG"
+    
+    payload = {
+        "user_status": {
+            "current_role": current_role,
+            "years_of_experience": float(years_exp),
+            "skills": skills,
+            "career_goals": career_goals
+        },
+        "additional_context": "User wants to advance their career"
+    }
+    
+    print(f"\n📝 Analyzing career situation for: {current_role} with {years_exp} years experience")
+    print("⏳ Sending request...")
+    
+    try:
+        response = requests.post(
+            f"{base_url}/api/v1/diagnose",
+            json=payload,
+            timeout=120
+        )
+        response.raise_for_status()
+        data = response.json()
+        print("\n✅ Diagnosis received!")
+        print(f"\n📊 Diagnosis:\n{data.get('diagnosis', 'N/A')}")
+        print(f"\n✨ Strengths: {', '.join(data.get('strengths', []))}")
+        print(f"⚠️  Weaknesses: {', '.join(data.get('weaknesses', []))}")
+        print(f"💡 Recommendations: {len(data.get('recommendations', []))} items")
+        return True
+    except requests.exceptions.RequestException as e:
+        print(f"\n❌ Diagnosis request failed: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"   Response: {e.response.text}")
+        return False
+
+
+def test_breakthrough(base_url: str) -> bool:
+    """Test breakthrough analysis endpoint"""
+    print("\n" + "-"*70)
+    print("4. Testing Breakthrough Analysis Endpoint")
+    print("-"*70)
+    
+    current_role = input("\nCurrent role [default: Software Engineer]: ").strip() or "Software Engineer"
+    target_companies_input = input("Target companies (comma-separated) [default: Google, Microsoft]: ").strip() or "Google, Microsoft"
+    target_companies = [c.strip() for c in target_companies_input.split(",")]
+    
+    payload = {
+        "user_status": {
+            "current_role": current_role,
+            "years_of_experience": 3.5,
+            "skills": ["Python", "JavaScript"],
+            "career_goals": f"Senior role at {target_companies[0]}"
+        },
+        "target_companies": target_companies,
+        "target_roles": ["Senior Software Engineer"]
+    }
+    
+    print(f"\n📝 Analyzing breakthrough opportunities for: {current_role}")
+    print("⏳ Sending request...")
+    
+    try:
+        response = requests.post(
+            f"{base_url}/api/v1/breakthrough",
+            json=payload,
+            timeout=120
+        )
+        response.raise_for_status()
+        data = response.json()
+        print("\n✅ Breakthrough analysis received!")
+        print(f"\n🔍 Analysis:\n{data.get('breakthrough_analysis', 'N/A')[:200]}...")
+        print(f"\n🎯 Opportunities: {len(data.get('opportunities', []))} found")
+        print(f"📋 Action Items: {len(data.get('action_items', []))} items")
+        return True
+    except requests.exceptions.RequestException as e:
+        print(f"\n❌ Breakthrough request failed: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"   Response: {e.response.text}")
+        return False
+
+
+def test_roadmap(base_url: str) -> bool:
+    """Test roadmap generation endpoint"""
+    print("\n" + "-"*70)
+    print("5. Testing Roadmap Generation Endpoint")
+    print("-"*70)
+    
+    target_company = input("\nTarget company [default: Google]: ").strip() or "Google"
+    target_role = input("Target role [default: Senior Software Engineer]: ").strip() or "Senior Software Engineer"
+    timeline = input("Timeline in weeks [default: 16]: ").strip() or "16"
+    
+    payload = {
+        "user_status": {
+            "current_role": "Software Engineer",
+            "years_of_experience": 3.5,
+            "skills": ["Python", "JavaScript"]
+        },
+        "target_company": target_company,
+        "target_role": target_role,
+        "timeline_weeks": int(timeline)
+    }
+    
+    print(f"\n📝 Generating roadmap for: {target_role} at {target_company}")
+    print("⏳ Sending request...")
+    
+    try:
+        response = requests.post(
+            f"{base_url}/api/v1/roadmap",
+            json=payload,
+            timeout=120
+        )
+        response.raise_for_status()
+        data = response.json()
+        print("\n✅ Roadmap generated!")
+        print(f"\n🗺️  Roadmap Overview:\n{data.get('roadmap', 'N/A')[:300]}...")
+        print(f"\n📅 Milestones: {len(data.get('milestones', []))} milestones")
+        print(f"🎯 Skill Gaps: {len(data.get('skill_gaps', []))} identified")
+        print(f"📊 Estimated Readiness: {data.get('estimated_readiness', 'N/A')}")
+        return True
+    except requests.exceptions.RequestException as e:
+        print(f"\n❌ Roadmap request failed: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"   Response: {e.response.text}")
+        return False
+
+
+def test_resume_analysis(base_url: str) -> bool:
+    """Test resume analysis endpoint"""
+    print("\n" + "-"*70)
+    print("6. Testing Resume Analysis Endpoint")
+    print("-"*70)
+    
+    print("\nEnter resume text (or press Enter for sample):")
+    resume_text = input().strip()
+    
+    if not resume_text:
+        resume_text = """
+        John Doe
+        Software Engineer
+        
+        EXPERIENCE
+        Software Engineer | Tech Corp | 2020-Present
+        - Developed web applications using Python and React
+        - Led team of 3 developers
+        - Improved system performance by 40%
+        
+        SKILLS
+        Python, JavaScript, React, Node.js, SQL
+        
+        EDUCATION
+        Bachelor's in Computer Science | State University | 2020
+        """
+    
+    target_role = input("\nTarget role [default: Senior Software Engineer]: ").strip() or "Senior Software Engineer"
+    
+    payload = {
+        "resume_text": resume_text,
+        "target_role": target_role
+    }
+    
+    print(f"\n📝 Analyzing resume for: {target_role}")
+    print("⏳ Sending request...")
+    
+    try:
+        response = requests.post(
+            f"{base_url}/api/v1/resume/analyze",
+            json=payload,
+            timeout=120
+        )
+        response.raise_for_status()
+        data = response.json()
+        print("\n✅ Resume analysis received!")
+        ats_score = data.get('ats_score', {})
+        print(f"\n📊 ATS Score: {ats_score.get('score', 'N/A')}/100 ({ats_score.get('grade', 'N/A')})")
+        print(f"✨ Strengths: {len(data.get('strengths', []))} identified")
+        print(f"⚠️  Weaknesses: {len(data.get('weaknesses', []))} identified")
+        print(f"💡 Improvement Suggestions: {len(data.get('improvement_suggestions', []))} items")
+        return True
+    except requests.exceptions.RequestException as e:
+        print(f"\n❌ Resume analysis failed: {e}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"   Response: {e.response.text}")
+        return False
+
+
+def run_all_tests(base_url: str):
+    """Run all tests interactively"""
+    results = {}
+    
+    # Test 1: Health check (always run first)
+    results['health'] = test_health(base_url)
+    
+    if not results['health']:
+        print("\n⚠️  Health check failed. Please check your deployment.")
+        return
+    
+    # Ask which tests to run
+    print("\n" + "="*70)
+    print("Select tests to run:")
+    print("1. Generic LLM (with custom prompt)")
+    print("2. Career Diagnosis")
+    print("3. Breakthrough Analysis")
+    print("4. Roadmap Generation")
+    print("5. Resume Analysis")
+    print("6. Run all tests")
+    print("0. Exit")
+    
+    choice = input("\nEnter choice (0-6): ").strip()
+    
+    if choice == "0":
+        print("Exiting...")
+        return
+    elif choice == "1":
+        results['llm'] = test_generic_llm(base_url)
+    elif choice == "2":
+        results['diagnosis'] = test_diagnosis(base_url)
+    elif choice == "3":
+        results['breakthrough'] = test_breakthrough(base_url)
+    elif choice == "4":
+        results['roadmap'] = test_roadmap(base_url)
+    elif choice == "5":
+        results['resume'] = test_resume_analysis(base_url)
+    elif choice == "6":
+        # Run all tests
+        results['llm'] = test_generic_llm(base_url, "What are the top 5 skills for a data scientist?")
+        results['diagnosis'] = test_diagnosis(base_url)
+        results['breakthrough'] = test_breakthrough(base_url)
+        results['roadmap'] = test_roadmap(base_url)
+        results['resume'] = test_resume_analysis(base_url)
+    else:
+        print("Invalid choice")
+        return
+    
+    # Summary
+    print("\n" + "="*70)
+    print("Test Summary")
+    print("="*70)
+    for test_name, passed in results.items():
+        status = "✅ PASSED" if passed else "❌ FAILED"
+        print(f"{test_name.upper():20} {status}")
+    
+    print("\n" + "="*70)
+
+
+def main():
+    """Main function"""
+    try:
+        base_url = get_base_url()
+        print(f"\n🌐 Testing deployment at: {base_url}")
+        
+        run_all_tests(base_url)
+        
+    except KeyboardInterrupt:
+        print("\n\n⚠️  Interrupted by user")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()