Upload 7 files

QUICK_START_HF_SPACES.md

@@ -0,0 +1,186 @@
+# Quick Start: Deploy to HuggingFace Spaces
+
+## ⚡ Super Quick Start (5 Minutes)
+
+### 1. Create Space
+1. Go to https://huggingface.co/spaces
+2. Click **"Create new Space"**
+3. Name: `conversai` (or your choice)
+4. SDK: **Gradio**
+5. **Visibility: PUBLIC** ⚠️ (Required for auto HF_TOKEN)
+6. Click **"Create Space"**
+
+**⚠️ IMPORTANT:** The Space MUST be PUBLIC for HF_TOKEN to work automatically!
+
+### 2. Upload Files
+
+Upload these files to your Space (drag and drop or use Git):
+
+**Required:**
+- `app.py`
+- `llm_backend.py`
+- `survey_generator.py`
+- `survey_translator.py`
+- `data_analyzer.py`
+- `export_utils.py`
+- `requirements.txt`
+- `README.md`
+
+**Optional (recommended):**
+- `USAGE_GUIDE.md`
+- `test_hf_backend.py`
+
+### 3. Wait for Build
+
+- Space will auto-build (2-3 minutes)
+- Watch the "Logs" tab for progress
+- When you see "Running on local URL", it's ready!
+
+### 4. Test It!
+
+**That's it!** No configuration needed. The app automatically uses HuggingFace's free Inference API.
+
+**Try these:**
+1. Go to "Generate Survey" tab
+2. Enter: "I want to understand customer satisfaction with our product"
+3. Click "Generate Survey"
+4. Wait ~30 seconds for the first generation
+
+## 🎯 What Works Out of the Box
+
+✅ **Survey Generation** - Create professional surveys from outlines
+✅ **Translation** - Translate to 18+ languages
+✅ **Data Analysis** - Analyze survey responses with AI
+✅ **Export** - Download results as JSON
+
+## ⚙️ Optional: Upgrade to Premium LLMs
+
+For faster, better results, add environment variables in Space Settings:
+
+### OpenAI (Recommended)
+```
+LLM_PROVIDER=openai
+OPENAI_API_KEY=sk-your-key-here
+```
+
+### Anthropic Claude
+```
+LLM_PROVIDER=anthropic
+ANTHROPIC_API_KEY=your-key-here
+```
+
+## 🐛 Troubleshooting
+
+### "LLM backend not configured"
+
+**Cause:** Your Space can't access `HF_TOKEN`.
+
+**Solutions:**
+
+1. **Make Space PUBLIC** (easiest):
+   - Go to Space Settings
+   - Change visibility from Private → Public
+   - Restart the Space
+
+2. **Add token manually** (if Space must be private):
+   - Go to https://huggingface.co/settings/tokens
+   - Create/copy a token with "Read" permission
+   - Go to Space Settings → Variables
+   - Add: `HUGGINGFACE_API_KEY` = your token
+   - Restart the Space
+
+3. **Use different provider**:
+   - Add `OPENAI_API_KEY` in Variables
+   - Or add `ANTHROPIC_API_KEY`
+
+### "Generation takes too long"
+
+**Cause:** Free HuggingFace Inference API can be slow during high usage.
+
+**Solutions:**
+1. **Wait longer** - First request can take 30-60 seconds
+2. **Try again** - May hit a faster server
+3. **Upgrade to OpenAI** - Much faster (costs ~$0.01 per survey)
+
+### "Model returned error"
+
+**Common causes:**
+- Rate limit hit (wait a few minutes)
+- Model is loading (first request after idle)
+- Input too long (reduce outline length)
+
+**Solutions:**
+- Wait 2-3 minutes and retry
+- Use shorter, simpler outlines
+- Upgrade to paid provider (OpenAI/Anthropic)
+
+## 📊 Performance Comparison
+
+| Provider | Speed | Quality | Cost | Setup |
+|----------|-------|---------|------|-------|
+| **HuggingFace (Free)** | Slow | Good | Free | Auto |
+| **OpenAI** | Fast | Excellent | ~$0.01-0.05/survey | Need API key |
+| **Anthropic** | Fast | Excellent | ~$0.01-0.05/survey | Need API key |
+
+## 🔍 Testing Your Deployment
+
+Run the test script:
+
+1. Add `test_hf_backend.py` to your Space
+2. Open the Space's terminal (if available) or check logs
+3. Look for "✅ ALL TESTS PASSED!"
+
+## 💡 Pro Tips
+
+1. **First Request is Slow** - HuggingFace models "cold start". First request may take 60+ seconds.
+
+2. **Keep It Simple** - For free tier, use:
+   - Shorter outlines (2-3 sentences)
+   - Fewer questions (5-10)
+   - One language at a time
+
+3. **Monitor Usage** - Check HuggingFace usage limits at https://huggingface.co/settings/billing
+
+4. **Upgrade When Ready** - For production, switch to OpenAI:
+   ```
+   LLM_PROVIDER=openai
+   OPENAI_API_KEY=sk-your-key
+   ```
+
+## 🎓 Next Steps
+
+Once deployed:
+
+1. ✅ **Test all features** - Generation, Translation, Analysis
+2. ✅ **Read USAGE_GUIDE.md** - Learn best practices
+3. ✅ **Try examples** - Use the built-in example data
+4. ✅ **Share your Space** - Get feedback from users
+5. ✅ **Upgrade when ready** - Add premium LLM for production
+
+## 📚 Additional Resources
+
+- **Full Documentation**: See `USAGE_GUIDE.md`
+- **Deployment Guide**: See `DEPLOYMENT.md`
+- **HuggingFace Docs**: https://huggingface.co/docs/hub/spaces
+- **Gradio Docs**: https://gradio.app/docs
+
+## ❓ FAQ
+
+**Q: Is it really free?**
+A: Yes! HuggingFace provides free inference API access. Limits apply.
+
+**Q: Can I use my own model?**
+A: Yes! Set `LLM_MODEL=your/model-name` environment variable.
+
+**Q: How do I upgrade to OpenAI?**
+A: Add `OPENAI_API_KEY` in Space Settings, set `LLM_PROVIDER=openai`.
+
+**Q: Can I make it private?**
+A: Yes, but you may need to configure `HF_TOKEN` manually.
+
+**Q: How much does OpenAI cost?**
+A: Typically $0.01-0.05 per survey with GPT-4o-mini.
+
+---
+
+Happy researching! 🔬 Need help? Check USAGE_GUIDE.md or open an issue.

README.md

@@ -51,10 +51,17 @@ Battle the blank page, reach global audiences, and uncover insights with AI assi
 
 **No configuration needed!** The app automatically uses HuggingFace's Inference API.
 
-- Uses built-in `HF_TOKEN` (automatically available in Spaces)
+- Uses built-in `HF_TOKEN` (automatically available in **PUBLIC** Spaces)
 - Default model: `mistralai/Mixtral-8x7B-Instruct-v0.1`
 - Free tier available
 
+**⚠️ Important:** Your Space must be **PUBLIC** for HF_TOKEN to be automatically available.
+
+**If your Space is PRIVATE**, add `HUGGINGFACE_API_KEY` manually:
+1. Go to https://huggingface.co/settings/tokens
+2. Copy your token
+3. Add it in Space Settings → Variables → `HUGGINGFACE_API_KEY`
+
 ### Optional: Use Other LLM Providers
 
 For better performance, you can configure alternative providers via environment variables:
@@ -82,7 +89,13 @@ The app automatically detects which provider to use based on available credentia
 ## 📦 Installation
 
 ```bash
+# Install dependencies
 pip install -r requirements.txt
+
+# Check environment setup (optional but recommended)
+python check_env.py
+
+# Run the app
 python app.py
 ```
 

TROUBLESHOOTING.md

@@ -0,0 +1,347 @@
+# Troubleshooting Guide
+
+## Common Issues and Solutions
+
+### ❌ "LLM backend not configured" Error
+
+**Symptom:** App shows warning banner, features don't work
+
+**Cause:** No LLM provider credentials found
+
+**Solutions:**
+
+#### On HuggingFace Spaces
+
+**Option 1: Make Space Public (Easiest)**
+1. Go to your Space Settings
+2. Change Visibility: Private → **Public**
+3. Refresh/Restart the Space
+4. HF_TOKEN will automatically be available
+
+**Option 2: Add Token Manually (for Private Spaces)**
+1. Get your token: https://huggingface.co/settings/tokens
+2. Create token with "Read" permission (if you don't have one)
+3. Go to Space Settings → Variables
+4. Add variable:
+   - Name: `HUGGINGFACE_API_KEY`
+   - Value: your_token_here
+5. Restart the Space
+
+**Option 3: Use Premium Provider**
+1. Get API key from OpenAI or Anthropic
+2. Go to Space Settings → Variables
+3. Add:
+   - `LLM_PROVIDER=openai`
+   - `OPENAI_API_KEY=sk-your-key`
+4. Restart Space
+
+#### Running Locally
+
+**Check your environment:**
+```bash
+python check_env.py
+```
+
+**Set credentials:**
+```bash
+# For OpenAI (recommended)
+export OPENAI_API_KEY="sk-your-key-here"
+
+# OR for Anthropic
+export ANTHROPIC_API_KEY="your-key-here"
+
+# OR for HuggingFace
+export HUGGINGFACE_API_KEY="your-token-here"
+
+# Then run
+python app.py
+```
+
+---
+
+### ⏱️ Generation Takes Too Long
+
+**Symptom:** Waiting 30+ seconds for survey generation
+
+**Cause:** HuggingFace free tier can be slow, especially during high usage
+
+**Solutions:**
+
+1. **Be patient on first request** - Models "cold start", can take 60+ seconds
+2. **Try again** - You might hit a faster server
+3. **Simplify requests:**
+   - Use shorter outlines (2-3 sentences)
+   - Request fewer questions (5-10)
+   - Translate one language at a time
+4. **Upgrade to paid provider:**
+   ```bash
+   LLM_PROVIDER=openai
+   OPENAI_API_KEY=sk-your-key
+   ```
+   Much faster, costs ~$0.01-0.05 per survey
+
+---
+
+### 🔴 "AttributeError: 'NoneType' object has no attribute..."
+
+**Symptom:** App crashes on startup
+
+**Cause:** Interface trying to use backend before it's initialized
+
+**Solution:** Update to latest version - this has been fixed
+
+**If still happening:**
+1. Check `app.py` has the latest code
+2. Verify `get_language_choices()` doesn't depend on `survey_trans` instance
+3. Make sure all functions check `if survey_gen:` before using it
+
+---
+
+### 📊 Analysis Returns Empty/Poor Results
+
+**Symptom:** Analysis doesn't find themes or gives generic insights
+
+**Causes & Solutions:**
+
+1. **Too few responses:**
+   - Need 10-20+ responses for meaningful analysis
+   - Add more sample data
+
+2. **Low-quality model:**
+   - Free HF models may struggle with complex analysis
+   - Upgrade to OpenAI GPT-4 or Claude for better analysis
+
+3. **Responses too short:**
+   - Analysis works best with detailed, paragraph-length responses
+   - Encourage respondents to elaborate
+
+4. **Wrong format:**
+   - Make sure responses are properly formatted JSON
+   - Use the "Load Example" button to see correct format
+
+---
+
+### 🌍 Translation Failed
+
+**Symptom:** Translation returns error or garbled text
+
+**Causes & Solutions:**
+
+1. **No survey generated:**
+   - Generate a survey first before translating
+   - Or upload a valid survey JSON
+
+2. **Model limitations:**
+   - Free HF models may struggle with some languages
+   - Use OpenAI or Anthropic for better translations
+   - Try more common languages (Spanish, French) first
+
+3. **Rate limit:**
+   - Wait a few minutes
+   - Translate fewer languages at once
+
+---
+
+### 💾 Downloads Don't Work
+
+**Symptom:** Can't download survey/analysis files
+
+**Cause:** Browser/Gradio issues
+
+**Solutions:**
+
+1. **Check browser console** for errors (F12)
+2. **Try different browser** (Chrome, Firefox)
+3. **Copy-paste data** manually from the output box
+4. **Check Gradio version** - update to latest:
+   ```bash
+   pip install --upgrade gradio
+   ```
+
+---
+
+### 🔒 Private Space Issues
+
+**Symptom:** Works in public Space but not private
+
+**Cause:** HF_TOKEN not available in private Spaces
+
+**Solution:**
+
+Add token manually:
+1. https://huggingface.co/settings/tokens
+2. Copy token with "Read" permission
+3. Space Settings → Variables → Add `HUGGINGFACE_API_KEY`
+4. Restart
+
+---
+
+### 🚫 Rate Limit Errors
+
+**Symptom:** "Rate limit exceeded" or 429 errors
+
+**HuggingFace Free Tier:**
+- Wait 5-10 minutes
+- Reduce request frequency
+- Upgrade to Pro: https://huggingface.co/pricing
+
+**OpenAI:**
+- Check usage: https://platform.openai.com/usage
+- Add credits or wait for reset
+- Use GPT-3.5 instead of GPT-4 (cheaper)
+
+**Anthropic:**
+- Check console: https://console.anthropic.com
+- Add credits or upgrade plan
+
+---
+
+### 📱 Mobile/Responsive Issues
+
+**Symptom:** UI doesn't work well on mobile
+
+**Cause:** Gradio has some mobile limitations
+
+**Solutions:**
+- Use landscape orientation
+- Use tablet or desktop for best experience
+- Some features may be limited on mobile
+
+---
+
+## Debugging Steps
+
+### 1. Check Environment
+```bash
+python check_env.py
+```
+
+Look for:
+- ✅ At least one API key is SET
+- ✅ All dependencies installed
+- ✅ Provider will be detected
+
+### 2. Check Logs
+
+**On HuggingFace Spaces:**
+- Go to "Logs" tab
+- Look for "=== LLM Backend Initialization ==="
+- Check which credentials are found
+
+**Running locally:**
+- Check terminal output
+- Look for initialization messages
+- Check for errors/warnings
+
+### 3. Test Backend
+```bash
+python test_hf_backend.py
+```
+
+Should show:
+- ✅ Backend initialized
+- ✅ Generation successful
+- ✅ ALL TESTS PASSED
+
+### 4. Start Simple
+
+If issues persist:
+1. **Test with OpenAI first** (most reliable)
+2. **Use example data** from the UI
+3. **Try one feature at a time** (generation only)
+4. **Check network connectivity**
+
+---
+
+## Getting Help
+
+### Before Asking for Help
+
+1. ✅ Run `python check_env.py`
+2. ✅ Check logs for error messages
+3. ✅ Try with example data
+4. ✅ Update to latest code
+5. ✅ Read this troubleshooting guide
+
+### Where to Get Help
+
+1. **Check documentation:**
+   - `README.md` - Overview
+   - `USAGE_GUIDE.md` - How to use
+   - `DEPLOYMENT.md` - Setup instructions
+   - `QUICK_START_HF_SPACES.md` - Fast deployment
+
+2. **Common resources:**
+   - Gradio docs: https://gradio.app/docs
+   - HuggingFace docs: https://huggingface.co/docs
+   - OpenAI docs: https://platform.openai.com/docs
+
+3. **Report issues:**
+   - Include output from `check_env.py`
+   - Include relevant logs
+   - Describe what you tried
+
+---
+
+## Performance Tips
+
+### For Best Results
+
+**Model Selection:**
+- **Best Quality:** OpenAI GPT-4 or Anthropic Claude 3.5 Sonnet
+- **Best Value:** OpenAI GPT-4o-mini
+- **Free:** HuggingFace (slower, lower quality)
+
+**Request Optimization:**
+- Keep outlines concise (2-4 sentences)
+- Request 10-15 questions (not 25)
+- Translate common languages first
+- Provide 20+ responses for analysis
+
+**Cost Control:**
+- Use GPT-4o-mini instead of GPT-4 ($0.15 vs $5 per 1M tokens)
+- Cache common surveys
+- Batch operations when possible
+- Monitor usage dashboards
+
+---
+
+## Emergency Fixes
+
+### App Won't Start At All
+
+```bash
+# 1. Clean install
+rm -rf venv
+python -m venv venv
+source venv/bin/activate  # or venv\Scripts\activate on Windows
+pip install -r requirements.txt
+
+# 2. Check environment
+python check_env.py
+
+# 3. Try with minimal config
+export OPENAI_API_KEY="sk-your-key"
+python app.py
+```
+
+### App Starts But Nothing Works
+
+```bash
+# 1. Verify backend
+python test_hf_backend.py
+
+# 2. Check imports
+python -c "from llm_backend import LLMBackend; print('OK')"
+python -c "from survey_generator import SurveyGenerator; print('OK')"
+
+# 3. Test manually
+python
+>>> from llm_backend import LLMBackend, LLMProvider
+>>> backend = LLMBackend(provider=LLMProvider.OPENAI)
+>>> backend.generate([{"role": "user", "content": "Hello"}], max_tokens=10)
+```
+
+---
+
+**Still stuck?** Make sure you're using the latest version of all files and have followed the setup instructions carefully.

app.py

@@ -23,26 +23,39 @@ current_responses = []
 def initialize_backend():
     """Initialize LLM backend based on environment"""
     try:
+        # Debug: Print all environment variables related to LLM
+        print("=== LLM Backend Initialization ===")
+        print(f"HF_TOKEN: {'SET' if os.getenv('HF_TOKEN') else 'NOT SET'}")
+        print(f"HUGGINGFACE_API_KEY: {'SET' if os.getenv('HUGGINGFACE_API_KEY') else 'NOT SET'}")
+        print(f"OPENAI_API_KEY: {'SET' if os.getenv('OPENAI_API_KEY') else 'NOT SET'}")
+        print(f"ANTHROPIC_API_KEY: {'SET' if os.getenv('ANTHROPIC_API_KEY') else 'NOT SET'}")
+        print(f"LLM_PROVIDER: {os.getenv('LLM_PROVIDER', 'NOT SET')}")
+
         # Check for explicit provider setting
         provider_env = os.getenv("LLM_PROVIDER", "").lower()
 
         # Priority 1: Explicitly set provider
         if provider_env == "openai" and os.getenv("OPENAI_API_KEY"):
+            print("Using OpenAI (explicit)")
             return LLMBackend(provider=LLMProvider.OPENAI)
         elif provider_env == "anthropic" and os.getenv("ANTHROPIC_API_KEY"):
+            print("Using Anthropic (explicit)")
             return LLMBackend(provider=LLMProvider.ANTHROPIC)
         elif provider_env == "huggingface" and (os.getenv("HUGGINGFACE_API_KEY") or os.getenv("HF_TOKEN")):
             api_key = os.getenv("HUGGINGFACE_API_KEY") or os.getenv("HF_TOKEN")
+            print("Using HuggingFace (explicit)")
             return LLMBackend(provider=LLMProvider.HUGGINGFACE, api_key=api_key)
         elif provider_env == "lm_studio":
+            print("Using LM Studio (explicit)")
             return LLMBackend(provider=LLMProvider.LM_STUDIO)
 
         # Priority 2: Auto-detect based on available credentials
         # HF_TOKEN is automatically available in HF Spaces, so check it first
-        if os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_API_KEY"):
-            api_key = os.getenv("HUGGINGFACE_API_KEY") or os.getenv("HF_TOKEN")
+        hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_API_KEY")
+        if hf_token:
             print(f"Auto-detected HuggingFace credentials, using HF Inference API")
-            return LLMBackend(provider=LLMProvider.HUGGINGFACE, api_key=api_key)
+            print(f"Token preview: {hf_token[:10]}...")
+            return LLMBackend(provider=LLMProvider.HUGGINGFACE, api_key=hf_token)
         elif os.getenv("OPENAI_API_KEY"):
             print(f"Auto-detected OpenAI credentials")
             return LLMBackend(provider=LLMProvider.OPENAI)
@@ -51,8 +64,19 @@ def initialize_backend():
             return LLMBackend(provider=LLMProvider.ANTHROPIC)
         else:
             # No credentials found - return None to show error in UI
+            print("="*60)
             print("WARNING: No LLM provider credentials found!")
-            print("Please set one of: OPENAI_API_KEY, ANTHROPIC_API_KEY, HUGGINGFACE_API_KEY, or HF_TOKEN")
+            print("="*60)
+            print("For HuggingFace Spaces:")
+            print("  - HF_TOKEN should be automatically available")
+            print("  - Make sure your Space is PUBLIC")
+            print("  - Or add HUGGINGFACE_API_KEY in Settings")
+            print("")
+            print("For other providers, set one of:")
+            print("  - OPENAI_API_KEY")
+            print("  - ANTHROPIC_API_KEY")
+            print("  - HUGGINGFACE_API_KEY")
+            print("="*60)
             return None
 
     except Exception as e:
@@ -226,7 +250,9 @@ def translate_current_survey(target_languages: List[str]):
 
 def get_language_choices():
     """Get language choices for dropdown"""
-    langs = survey_trans.get_supported_languages()
+    # Get languages directly from SurveyTranslator class (static list)
+    from survey_translator import SurveyTranslator
+    langs = SurveyTranslator.SUPPORTED_LANGUAGES
     return [f"{code} - {name}" for code, name in langs.items()]
 
 
@@ -332,12 +358,20 @@ def create_interface():
         # Show backend status
         if llm_backend:
             status_msg = f"✅ **Active LLM Provider:** {llm_backend.provider.value.upper()} | Model: {llm_backend.model}"
-            status_color = "green"
+            bg_color = "rgba(0, 255, 0, 0.1)"
         else:
-            status_msg = "⚠️ **No LLM Provider Configured** - Please set API credentials (see About tab for instructions)"
-            status_color = "orange"
+            status_msg = """⚠️ **LLM Provider Not Configured**
+
+**To use this app, you need to configure an LLM provider:**
+
+1. **Easiest (HuggingFace Spaces):** Make sure your Space is PUBLIC and HF_TOKEN will be auto-available
+2. **Best Quality:** Add `OPENAI_API_KEY` in Space Settings → Variables
+3. **Alternative:** Add `ANTHROPIC_API_KEY` or `HUGGINGFACE_API_KEY`
+
+See the **About** tab for detailed instructions."""
+            bg_color = "rgba(255, 165, 0, 0.2)"
 
-        gr.Markdown(f'<div style="background-color: rgba(255, 165, 0, 0.1); padding: 10px; border-radius: 5px; margin: 10px 0;">{status_msg}</div>')
+        gr.Markdown(f'<div style="background-color: {bg_color}; padding: 15px; border-radius: 5px; margin: 10px 0; border-left: 4px solid #FF6B6B;">{status_msg}</div>')
 
         with gr.Tabs() as tabs:
 

check_env.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""
+Environment Check Script for ConversAI
+Run this to diagnose configuration issues
+"""
+import os
+import sys
+
+
+def check_environment():
+    """Check environment variables and configuration"""
+    print("="*70)
+    print("ConversAI Environment Check")
+    print("="*70)
+    print()
+
+    # Check Python version
+    print(f"Python Version: {sys.version}")
+    print()
+
+    # Check environment variables
+    print("Environment Variables:")
+    print("-" * 70)
+
+    env_vars = {
+        "HF_TOKEN": "HuggingFace Token (auto in PUBLIC Spaces)",
+        "HUGGINGFACE_API_KEY": "HuggingFace API Key (manual)",
+        "OPENAI_API_KEY": "OpenAI API Key",
+        "ANTHROPIC_API_KEY": "Anthropic API Key",
+        "LLM_PROVIDER": "Explicit LLM Provider",
+        "LLM_MODEL": "Custom Model Name",
+        "SPACE_ID": "HuggingFace Space ID (if in Space)"
+    }
+
+    has_any_key = False
+    for var, description in env_vars.items():
+        value = os.getenv(var)
+        if value:
+            has_any_key = True
+            # Show first 10 chars for security
+            preview = value[:10] + "..." if len(value) > 10 else value
+            print(f"✅ {var:<25} SET ({preview})")
+        else:
+            print(f"❌ {var:<25} NOT SET")
+
+    print()
+    print("-" * 70)
+    print()
+
+    # Determine what will happen
+    print("Configuration Status:")
+    print("-" * 70)
+
+    if not has_any_key:
+        print("❌ NO CREDENTIALS FOUND")
+        print()
+        print("The app will NOT work without LLM credentials.")
+        print()
+        print("Solutions:")
+        print("1. If on HuggingFace Spaces:")
+        print("   → Make sure Space is PUBLIC (Settings → Visibility)")
+        print("   → Or add HUGGINGFACE_API_KEY in Settings → Variables")
+        print()
+        print("2. If running locally:")
+        print("   → Set OPENAI_API_KEY environment variable")
+        print("   → Or set ANTHROPIC_API_KEY")
+        print("   → Or set HUGGINGFACE_API_KEY")
+        print()
+        return False
+
+    # Check which provider will be used
+    provider = os.getenv("LLM_PROVIDER", "").lower()
+
+    if provider == "openai" and os.getenv("OPENAI_API_KEY"):
+        print("✅ Will use: OpenAI (explicit)")
+    elif provider == "anthropic" and os.getenv("ANTHROPIC_API_KEY"):
+        print("✅ Will use: Anthropic Claude (explicit)")
+    elif provider == "huggingface" and (os.getenv("HUGGINGFACE_API_KEY") or os.getenv("HF_TOKEN")):
+        print("✅ Will use: HuggingFace Inference API (explicit)")
+    elif os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_API_KEY"):
+        print("✅ Will use: HuggingFace Inference API (auto-detected)")
+    elif os.getenv("OPENAI_API_KEY"):
+        print("✅ Will use: OpenAI (auto-detected)")
+    elif os.getenv("ANTHROPIC_API_KEY"):
+        print("✅ Will use: Anthropic Claude (auto-detected)")
+    else:
+        print("⚠️  Unknown configuration")
+
+    print()
+
+    # Check if in HuggingFace Spaces
+    if os.getenv("SPACE_ID"):
+        print(f"📍 Running in HuggingFace Space: {os.getenv('SPACE_ID')}")
+        if not (os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_API_KEY")):
+            print("⚠️  WARNING: In HF Space but no HF token found!")
+            print("   This Space might be PRIVATE. Consider:")
+            print("   1. Making it PUBLIC, or")
+            print("   2. Adding HUGGINGFACE_API_KEY manually")
+    else:
+        print("📍 Running locally (not in HuggingFace Space)")
+
+    print()
+    print("-" * 70)
+    print()
+
+    # Check imports
+    print("Checking Python Dependencies:")
+    print("-" * 70)
+
+    dependencies = {
+        "gradio": "Gradio UI framework",
+        "requests": "HTTP library",
+        "pandas": "Data processing (optional)"
+    }
+
+    all_imports_ok = True
+    for module, description in dependencies.items():
+        try:
+            __import__(module)
+            print(f"✅ {module:<20} OK")
+        except ImportError:
+            print(f"❌ {module:<20} NOT INSTALLED")
+            all_imports_ok = False
+
+    print()
+
+    if not all_imports_ok:
+        print("⚠️  Some dependencies missing. Run:")
+        print("   pip install -r requirements.txt")
+        print()
+
+    print("="*70)
+
+    if has_any_key and all_imports_ok:
+        print("✅ Environment looks good! You should be able to run the app.")
+        print()
+        print("Start the app with:")
+        print("   python app.py")
+        return True
+    else:
+        print("❌ Environment has issues. Fix the problems above.")
+        return False
+
+
+if __name__ == "__main__":
+    success = check_environment()
+    sys.exit(0 if success else 1)

test_hf_backend.py

@@ -0,0 +1,109 @@
+"""
+Quick test to verify HuggingFace Inference API works
+Run this on HF Spaces to debug LLM connection issues
+"""
+import os
+from llm_backend import LLMBackend, LLMProvider
+
+def test_hf_connection():
+    """Test HuggingFace Inference API connection"""
+    print("="*60)
+    print("Testing HuggingFace Inference API Connection")
+    print("="*60)
+
+    # Check for token
+    hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_API_KEY")
+    if hf_token:
+        print(f"✓ HF Token found: {hf_token[:10]}...")
+    else:
+        print("✗ No HF Token found")
+        print("  Set HF_TOKEN or HUGGINGFACE_API_KEY environment variable")
+        return False
+
+    # Initialize backend
+    try:
+        backend = LLMBackend(provider=LLMProvider.HUGGINGFACE, api_key=hf_token)
+        print(f"✓ Backend initialized")
+        print(f"  Provider: {backend.provider.value}")
+        print(f"  Model: {backend.model}")
+        print(f"  API URL: {backend.api_url}")
+    except Exception as e:
+        print(f"✗ Backend initialization failed: {e}")
+        return False
+
+    # Test simple generation
+    print("\nTesting simple message generation...")
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Say 'Hello, World!' and nothing else."}
+    ]
+
+    try:
+        response = backend.generate(messages, max_tokens=50, temperature=0.3)
+        print(f"✓ Generation successful!")
+        print(f"  Response: {response[:100]}")
+        return True
+    except Exception as e:
+        print(f"✗ Generation failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_survey_generation():
+    """Test actual survey generation"""
+    print("\n" + "="*60)
+    print("Testing Survey Generation")
+    print("="*60)
+
+    from survey_generator import SurveyGenerator
+
+    hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_API_KEY")
+    if not hf_token:
+        print("✗ No HF Token, skipping")
+        return False
+
+    try:
+        backend = LLMBackend(provider=LLMProvider.HUGGINGFACE, api_key=hf_token)
+        generator = SurveyGenerator(backend)
+
+        print("Generating a small test survey...")
+        survey = generator.generate_survey(
+            outline="Understand user satisfaction with a mobile app",
+            survey_type="qualitative",
+            num_questions=3,
+            target_audience="Mobile app users"
+        )
+
+        print(f"✓ Survey generated!")
+        print(f"  Title: {survey.get('title', 'N/A')}")
+        print(f"  Questions: {len(survey.get('questions', []))}")
+        return True
+
+    except Exception as e:
+        print(f"✗ Survey generation failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    # Run tests
+    connection_ok = test_hf_connection()
+
+    if connection_ok:
+        survey_ok = test_survey_generation()
+        if survey_ok:
+            print("\n" + "="*60)
+            print("✅ ALL TESTS PASSED!")
+            print("="*60)
+        else:
+            print("\n" + "="*60)
+            print("⚠️  Basic connection works but survey generation failed")
+            print("    This may be due to model limitations or rate limits")
+            print("="*60)
+    else:
+        print("\n" + "="*60)
+        print("❌ CONNECTION FAILED")
+        print("   Check your HF_TOKEN and network connectivity")
+        print("="*60)