Add GitHub Actions CI/CD for auto-sync to Hugging Face Spaces

.env.example

@@ -0,0 +1,43 @@
+# SegmentoPulse Backend - Environment Configuration
+
+Copy this file to `.env` and add your API keys.
+
+# Environment
+ENVIRONMENT=development
+
+# Multi-Provider News APIs
+# Sign up for free API keys at:
+# - GNews: https://gnews.io (100 requests/day)
+# - NewsAPI: https://newsapi.org (100 requests/day)
+# - NewsData: https://newsdata.io (200 requests/day)
+
+GNEWS_API_KEY=your_gnews_api_key_here
+NEWSAPI_API_KEY=your_newsapi_key_here
+NEWSDATA_API_KEY=your_newsdata_key_here
+
+# Provider Priority (comma-separated, in order of preference)
+# Options: gnews, newsapi, newsdata, google_rss
+NEWS_PROVIDER_PRIORITY=gnews,newsapi,newsdata,google_rss
+
+# Legacy News API (optional)
+NEWS_API_KEY=your_newsapi_key_here
+
+# Firebase (from seg-pulse project)
+# Database and Project ID are pre-configured
+# You need to download firebase-credentials.json from Firebase Console
+# See FIREBASE_SETUP.md for instructions
+FIREBASE_DATABASE_URL=https://dbsegpulse-fbc35-default-rtdb.asia-southeast1.firebasedatabase.app
+FIREBASE_PROJECT_ID=dbsegpulse-fbc35
+FIREBASE_CREDENTIALS_PATH=./firebase-credentials.json
+
+# Redis (optional - for caching)
+REDIS_URL=redis://localhost:6379
+REDIS_PASSWORD=
+
+# Server
+HOST=0.0.0.0
+PORT=8000
+CORS_ORIGINS=http://localhost:3000,https://segmento.in
+
+# Cache Settings
+CACHE_TTL=120  # seconds

.github/workflows/deploy-to-hf.yml

@@ -0,0 +1,37 @@
+name: Sync to Hugging Face Spaces
+
+on:
+  push:
+    branches:
+      - main
+      - master
+  workflow_dispatch:
+
+jobs:
+  sync-to-huggingface:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      
+      - name: Push to Hugging Face Spaces
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+          
+          # Add Hugging Face remote
+          git remote add hf https://WORKWITHSHAFISK:$HF_TOKEN@huggingface.co/spaces/WORKWITHSHAFISK/segmentopulse-backend || true
+          
+          # Force push to Hugging Face (main branch)
+          git push --force hf HEAD:main
+      
+      - name: Deployment status
+        run: |
+          echo "✅ Successfully synced to Hugging Face Spaces!"
+          echo "🔗 Space URL: https://huggingface.co/spaces/WORKWITHSHAFISK/segmentopulse-backend"

.gitignore

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+ENV/
+.venv
+
+# Environment
+.env
+.env.local
+
+# Firebase
+firebase-credentials.json
+*-firebase-adminsdk-*.json
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Distribution
+dist/
+build/
+*.egg-info/

DEPLOY_TO_HF_SPACES.md

@@ -0,0 +1,269 @@
+# SegmentoPulse Backend - Hugging Face Spaces Deployment Guide
+
+Complete guide to deploying the SegmentoPulse news aggregation backend to Hugging Face Spaces.
+
+## Prerequisites
+
+✅ Hugging Face account (free)  
+✅ News API keys (GNews, NewsAPI, NewsData.io)  
+✅ Git installed on your machine
+
+## Step 1: Create a New Space on Hugging Face
+
+1. **Go to**: https://huggingface.co/new-space
+
+2. **Configure your Space**:
+   - **Space name**: `segmentopulse-backend` (or your choice)
+   - **License**: MIT
+   - **SDK**: Select **Docker** 🐳
+   - **Visibility**: Public or Private (your choice)
+
+3. **Click "Create Space"**
+
+## Step 2: Clone the Space Repository
+
+```bash
+# Clone your new Space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/segmentopulse-backend
+cd segmentopulse-backend
+```
+
+## Step 3: Copy Backend Files
+
+Copy the entire SegmentoPulse backend to your Space directory:
+
+**On Windows (PowerShell)**:
+```powershell
+# Navigate to your Space directory
+cd path\to\segmentopulse-backend
+
+# Copy all backend files
+Copy-Item -Path "C:\Users\Dell\Desktop\Segmento-app-website-dev\SegmentoPulse\backend\*" -Destination "." -Recurse -Force
+
+# Remove .env file (don't commit secrets!)
+Remove-Item -Path ".env" -ErrorAction SilentlyContinue
+
+# Remove __pycache__ directories
+Get-ChildItem -Path "." -Recurse -Directory -Filter "__pycache__" | Remove-Item -Recurse -Force
+```
+
+**Your Space structure should look like**:
+```
+segmentopulse-backend/
+├── .git/
+├── .gitignore
+├── Dockerfile              ✅ HF Spaces compatible
+├── README.md               ✅ Space description
+├── requirements.txt
+├── app/
+│   ├── __init__.py
+│   ├── main.py
+│   ├── config.py
+│   ├── models.py
+│   ├── routes/
+│   └── services/
+└── ...
+```
+
+## Step 4: Configure Environment Secrets
+
+1. **Go to your Space settings**: https://huggingface.co/spaces/YOUR_USERNAME/segmentopulse-backend/settings
+
+2. **Add Repository Secrets** (under "Variables and secrets" tab):
+
+```bash
+# News API Keys (REQUIRED)
+GNEWS_API_KEY=4a3a51ecd8bed1d10dc2201c86207729
+NEWSAPI_API_KEY=fb8702e8ff9f45b4ab8f2508890d505f
+NEWSDATA_API_KEY=pub_9a26c29ebbdf46a1abde2fbfe05e4196
+
+# Provider Priority (OPTIONAL - uses default if not set)
+NEWS_PROVIDER_PRIORITY=gnews,newsapi,newsdata,google_rss
+
+# Firebase (OPTIONAL)
+FIREBASE_DATABASE_URL=https://dbsegpulse-fbc35-default-rtdb.asia-southeast1.firebasedatabase.app
+FIREBASE_PROJECT_ID=dbsegpulse-fbc35
+
+# Server Config (OPTIONAL - uses defaults)
+ENVIRONMENT=production
+HOST=0.0.0.0
+PORT=7860
+CORS_ORIGINS=http://localhost:3000,https://segmento.in
+CACHE_TTL=120
+```
+
+**Important Notes**:
+- ⚠️ Never commit API keys to Git - always use Spaces Secrets!
+- ✅ The app will work with just the 3 news API keys
+- ✅ Firebase and Redis are optional
+
+## Step 5: Push to Hugging Face
+
+```bash
+# Add all files
+git add .
+
+# Commit
+git commit -m "Initial SegmentoPulse backend deployment"
+
+# Push to Hugging Face
+git push
+```
+
+## Step 6: Monitor Deployment
+
+1. **Go to your Space**: https://huggingface.co/spaces/YOUR_USERNAME/segmentopulse-backend
+
+2. **Watch the build logs** in the "Logs" tab
+
+3. **Build time**: ~2-5 minutes (first time)
+
+4. **Look for**: 
+```
+Application startup complete.
+Uvicorn running on http://0.0.0.0:7860
+```
+
+## Step 7: Test Your Deployment
+
+Once deployed, your backend will be live at:
+```
+https://YOUR_USERNAME-segmentopulse-backend.hf.space
+```
+
+**Test endpoints**:
+
+```bash
+# Health check
+curl https://YOUR_USERNAME-segmentopulse-backend.hf.space/health
+
+# Provider statistics
+curl https://YOUR_USERNAME-segmentopulse-backend.hf.space/api/news/system/stats
+
+# Fetch AI news
+curl https://YOUR_USERNAME-segmentopulse-backend.hf.space/api/news/ai
+```
+
+## Step 8: Update Frontend Environment Variable
+
+Once your backend is deployed and working:
+
+### For Vercel/Netlify Production:
+
+Add environment variable:
+```bash
+NEXT_PUBLIC_PULSE_API_URL=https://YOUR_USERNAME-segmentopulse-backend.hf.space
+```
+
+### Example URLs:
+```bash
+# If your username is "workwithshafisk" and space is "segmentopulse-backend"
+NEXT_PUBLIC_PULSE_API_URL=https://workwithshafisk-segmentopulse-backend.hf.space
+```
+
+## Troubleshooting
+
+### Build Fails
+
+**Check**:
+1. Dockerfile syntax
+2. All files copied correctly
+3. requirements.txt is valid
+
+**Solution**: Check build logs in HF Spaces for specific errors
+
+### App Starts But No News
+
+**Check**:
+1. API keys are set in Spaces Secrets
+2. API keys are valid (not expired)
+3. Check provider stats endpoint: `/api/news/system/stats`
+
+**Solution**: Verify secrets are set correctly in Space settingsimportância
+
+### CORS Errors
+
+**Check**: `CORS_ORIGINS` in Spaces Secrets includes your frontend domain
+
+**Solution**: Add your production domain:
+```bash
+CORS_ORIGINS=https://segmento.in,http://localhost:3000
+```
+
+### 429 Rate Limit Errors
+
+**This is NORMAL!** The hybrid system will:
+1. Detect rate limit (HTTP 429)
+2. Automatically switch to next provider
+3. Continue serving news seamlessly
+
+**Check**: `/api/news/system/stats` to see which providers are active
+
+## Maintenance
+
+### Update Deployment
+
+```bash
+# Make changes locally
+# Commit and push
+git add .
+git commit -m "Update backend"
+git push
+```
+
+HF Spaces will **automatically rebuild** and deploy!
+
+### Monitor Usage
+
+- Check `/api/news/system/stats` for provider health
+- Monitor HF Spaces logs for errors
+- Track rate limit usage
+
+### Update API Keys
+
+If a provider hits limits:
+1. Get new API key
+2. Update in Spaces Secrets
+3. Restart Space (automatic)
+
+## Performance Tips
+
+✅ **Enable caching**: Redis optional but recommended  
+✅ **Use provider priority**: Put fastest providers first  
+✅ **Monitor stats**: Check which providers are used most  
+✅ **Scale up**: Upgrade HF Spaces tier if needed
+
+## Cost
+
+🎉 **FREE TIER**:
+- Hugging Face Spaces: FREE for Docker Spaces
+- News APIs: All have free tiers (400 total requests/day)
+- Total cost: **$0/month** ✨
+
+## Next Steps
+
+After deployment:
+
+1. ✅ Test all API endpoints
+2. ✅ Update frontend with new backend URL
+3. ✅ Push frontend to production
+4. ✅ Monitor provider statistics
+5. ✅ Enjoy your live news aggregation platform! 🚀
+
+## Support
+
+- HF Spaces Docs: https://huggingface.co/docs/hub/spaces
+- SegmentoPulse Backend GitHub: [Your repo]
+- Issues: Create issue in your repository
+
+---
+
+**Deployment checklist**:
+- [ ] Create HF Space (Docker SDK)
+- [ ] Copy backend files
+- [ ] Add API keys to Secrets
+- [ ] Push to HF
+- [ ] Test endpoints
+- [ ] Update frontend env var
+- [ ] Deploy frontend
+- [ ] 🎉 Go live!

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY app ./app
+
+# Expose Hugging Face Spaces default port
+EXPOSE 7860
+
+# Run application on port 7860 (HF Spaces standard)
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

FIREBASE_SETUP.md

@@ -0,0 +1,44 @@
+# Firebase Admin SDK Credentials for SegmentoPulse Backend
+
+## Overview
+The SegmentoPulse backend uses Firebase Realtime Database from the `dbsegpulse-fbc35` project (same as seg-pulse).
+
+## Configuration Status
+✅ **Database URL**: `https://dbsegpulse-fbc35-default-rtdb.asia-southeast1.firebasedatabase.app`  
+✅ **Project ID**: `dbsegpulse-fbc35`  
+
+## Service Account Credentials (Optional)
+
+For the backend to work with Firebase Admin SDK, you need a service account credentials JSON file.
+
+### How to Get Your Service Account Key:
+
+1. **Go to Firebase Console**: https://console.firebase.google.com/
+2. **Select your project**: `dbsegpulse-fbc35`
+3. **Navigate to**: Project Settings (⚙️ gear icon) → Service Accounts
+4. **Click**: "Generate new private key" button
+5. **Download** the JSON file
+6. **Rename** it to `firebase-credentials.json`
+7. **Place** it in the backend directory: `c:\Users\Dell\Desktop\Segmento-app-website-dev\SegmentoPulse\backend\firebase-credentials.json`
+
+### Important Security Notes:
+
+> ⚠️ **DO NOT commit** `firebase-credentials.json` to Git  
+> ⚠️ This file contains sensitive credentials  
+> ⚠️ It should already be in `.gitignore`
+
+## Current Status
+
+The backend is configured to use Firebase but will show a warning if the credentials file is missing:
+```
+Firebase initialization error: [Errno 2] No such file or directory: './firebase-credentials.json'
+```
+
+This is **optional** - the backend will continue to work without Firebase. Firebase is only needed if you're using:
+- User authentication tracking
+- View count persistence
+- Analytics data storage
+
+## Alternative: Use Frontend Firebase Config Only
+
+The seg-pulse and frontend already have Firebase initialized with client-side SDK credentials. If you don't need server-side Firebase features, the backend can work without the credentials file.

GITHUB_TO_HF_CICD.md

@@ -0,0 +1,294 @@
+# GitHub ↔ Hugging Face Spaces CI/CD Setup Guide
+
+Complete guide to set up automatic deployment from GitHub to Hugging Face Spaces.
+
+## Overview
+
+This setup allows you to:
+1. ✅ Push code to GitHub (your organization repo)
+2. ✅ GitHub Actions automatically syncs to HF Spaces
+3. ✅ HF Spaces rebuilds and deploys automatically
+
+## Prerequisites
+
+- ✅ GitHub repository: `https://github.com/Segmento-in/SegmentoPulse-Backend`
+- ✅ HF Space: `https://huggingface.co/spaces/WORKWITHSHAFISK/segmentopulse-backend`
+- ✅ Hugging Face account
+
+## Step 1: Get Your Hugging Face Token
+
+1. **Go to Hugging Face Settings**:
+   - Navigate to: https://huggingface.co/settings/tokens
+
+2. **Create a new token**:
+   - Click "New token"
+   - **Name**: `github-actions-segmentopulse`
+   - **Type**: Select "Write" access
+   - Click "Generate a token"
+
+3. **Copy the token** (you'll need it in Step 3)
+   - Format: `hf_xxxxxxxxxxxxxxxxxxxxx`
+   - ⚠️ Save it somewhere safe - you can't see it again!
+
+## Step 2: Push Backend to GitHub
+
+```powershell
+# Navigate to your backend directory
+cd C:\Users\Dell\Desktop\Segmento-app-website-dev\SegmentoPulse\backend
+
+# Initialize git (if not already done)
+git init
+
+# Add GitHub remote
+git remote add origin https://github.com/Segmento-in/SegmentoPulse-Backend.git
+
+# Add all files
+git add .
+
+# Commit
+git commit -m "Initial commit: SegmentoPulse Backend"
+
+# Push to GitHub
+git push -u origin main
+```
+
+**If branch is 'master' instead of 'main'**:
+```powershell
+git branch -M main
+git push -u origin main
+```
+
+## Step 3: Add HF Token to GitHub Secrets
+
+1. **Go to your GitHub repository**:
+   - https://github.com/Segmento-in/SegmentoPulse-Backend
+
+2. **Navigate to Settings**:
+   - Click "Settings" tab → "Secrets and variables" → "Actions"
+
+3. **Add Repository Secret**:
+   - Click "New repository secret"
+   - **Name**: `HF_TOKEN`
+   - **Value**: Paste your Hugging Face token from Step 1
+   - Click "Add secret"
+
+## Step 4: GitHub Actions Workflow (Already Created!)
+
+The workflow file is already created at:
+```
+.github/workflows/deploy-to-hf.yml
+```
+
+This workflow:
+- ✅ Triggers on every push to `main` branch
+- ✅ Checks out your code
+- ✅ Pushes to Hugging Face Spaces
+- ✅ Can be manually triggered from GitHub Actions tab
+
+## Step 5: Test the CI/CD Pipeline
+
+### Initial Test
+
+```powershell
+# Make a small change
+cd C:\Users\Dell\Desktop\Segmento-app-website-dev\SegmentoPulse\backend
+
+# Edit a file (e.g., README.md)
+Add-Content -Path README.md -Value "`n## Updated via GitHub"
+
+# Commit and push
+git add .
+git commit -m "Test CI/CD pipeline"
+git push
+```
+
+### Monitor Deployment
+
+1. **Watch GitHub Actions**:
+   - Go to: https://github.com/Segmento-in/SegmentoPulse-Backend/actions
+   - You'll see "Sync to Hugging Face Spaces" workflow running
+
+2. **Check HF Spaces**:
+   - Go to: https://huggingface.co/spaces/WORKWITHSHAFISK/segmentopulse-backend
+   - Click "Logs" tab to watch the rebuild
+
+## How It Works
+
+```mermaid
+graph LR
+    A[Developer] -->|git push| B[GitHub Repo]
+    B -->|GitHub Actions| C[CI/CD Workflow]
+    C -->|Sync Code| D[HF Spaces]
+    D -->|Auto Rebuild| E[Live Backend API]
+```
+
+### Workflow Steps
+
+1. **You push to GitHub**:
+   ```bash
+   git push origin main
+   ```
+
+2. **GitHub Actions triggers**:
+   - Checks out your code
+   - Configures git with HF token
+   - Force pushes to HF Spaces
+
+3. **HF Spaces detects changes**:
+   - Automatically triggers rebuild
+   - Runs Dockerfile
+   - Deploys updated backend
+
+4. **Your API is live**:
+   - Updated code is running at: `https://workwithshafisk-segmentopulse-backend.hf.space`
+
+## Workflow File Explanation
+
+```yaml
+name: Sync to Hugging Face Spaces
+
+on:
+  push:
+    branches:
+      - main          # Triggers on push to main
+      - master        # Also triggers on master (if used)
+  workflow_dispatch:   # Allows manual trigger
+
+jobs:
+  sync-to-huggingface:
+    runs-on: ubuntu-latest
+    
+    steps:
+      # Checkout your code
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0  # Full history for proper sync
+      
+      # Sync to HF Spaces
+      - env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}  # Uses secret
+        run: |
+          # Configure git
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+          
+          # Add HF remote with token
+          git remote add hf https://WORKWITHSHAFISK:$HF_TOKEN@huggingface.co/spaces/WORKWITHSHAFISK/segmentopulse-backend
+          
+          # Push to HF
+          git push --force hf HEAD:main
+```
+
+## Development Workflow
+
+### Daily Development Cycle
+
+```powershell
+# 1. Make changes
+code app/main.py
+
+# 2. Test locally
+uvicorn app.main:app --reload
+
+# 3. Commit changes
+git add .
+git commit -m "Add new feature"
+
+# 4. Push to GitHub
+git push
+
+# 5. ✨ Automatic deployment!
+# - GitHub Actions syncs to HF
+# - HF Spaces rebuilds
+# - New version goes live
+```
+
+### Manual Trigger
+
+If you need to trigger deployment without pushing:
+
+1. Go to: https://github.com/Segmento-in/SegmentoPulse-Backend/actions
+2. Select "Sync to Hugging Face Spaces"
+3. Click "Run workflow" → "Run workflow"
+
+## Benefits
+
+✅ **Single Source of Truth**: GitHub is your primary repository  
+✅ **Automatic Deployment**: Push once, deploys everywhere  
+✅ **Version Control**: Full Git history on GitHub  
+✅ **Team Collaboration**: Multiple developers can contribute  
+✅ **CI/CD Best Practices**: Automated testing and deployment  
+✅ **Rollback Capability**: Easy to revert to previous versions  
+
+## Troubleshooting
+
+### Workflow Fails: "remote: Permission denied"
+
+**Solution**: Check HF_TOKEN secret
+- Ensure token has "Write" access
+- Verify token hasn't expired
+- Re-create token if needed
+
+### Workflow Succeeds But HF Doesn't Update
+
+**Solution**: Check HF Space logs
+- Space may have build errors
+- Check Dockerfile syntax
+- Verify all files are committed
+
+### Push Rejected: "Updates were rejected"
+
+**Solution**: Force push from workflow
+- Already configured in workflow with `--force`
+- Ensures HF Spaces always matches GitHub
+
+## Security Best Practices
+
+✅ **Never commit tokens**: Use GitHub Secrets only  
+✅ **Use write token only for CI/CD**: Don't use admin tokens  
+✅ **Rotate tokens periodically**: Change tokens every 90 days  
+✅ **Don't commit .env files**: Already in .gitignore  
+
+## Monitoring
+
+### GitHub Actions Dashboard
+- **URL**: https://github.com/Segmento-in/SegmentoPulse-Backend/actions
+- **Shows**: All workflow runs, status, logs
+
+### HF Spaces Logs
+- **URL**: https://huggingface.co/spaces/WORKWITHSHAFISK/segmentopulse-backend
+- **Shows**: Build logs, runtime logs, errors
+
+## Complete Setup Checklist
+
+- [ ] Created HF token with write access
+- [ ] Added HF_TOKEN to GitHub secrets
+- [ ] Created .github/workflows/deploy-to-hf.yml
+- [ ] Pushed code to GitHub
+- [ ] Verified GitHub Actions workflow runs
+- [ ] Confirmed HF Spaces rebuilds
+- [ ] Tested backend API endpoint
+- [ ] Updated frontend with backend URL
+
+## Alternative: Hugging Face Can Also Sync FROM GitHub
+
+Instead of GitHub → HF sync, you can also set up HF → Pull from GitHub:
+
+1. Go to your HF Space settings
+2. Under "Repository" → Click "Link to a GitHub repository"
+3. Authorize and select your GitHub repo
+
+**This creates bidirectional sync!**
+
+## Next Steps
+
+After setup:
+
+1. ✅ **Test the workflow**: Make a small change and push
+2. ✅ **Add branch protection**: Protect main branch on GitHub
+3. ✅ **Add status badge**: Show build status in README
+4. ✅ **Set up PR checks**: Run tests before merging
+
+---
+
+**You're all set!** Every push to GitHub will now automatically deploy to Hugging Face Spaces! 🚀

README.md

@@ -0,0 +1,61 @@
+---
+title: SegmentoPulse Backend
+emoji: 📰
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+---
+
+# SegmentoPulse Backend API
+
+Real-time technology intelligence platform powered by hybrid multi-provider news aggregation.
+
+## Features
+
+- 🔄 **Hybrid News API System**: Automatic failover between GNews, NewsAPI, NewsData.io, and Google News RSS
+- 🚀 **Ultra-Low Latency**: Multi-provider approach ensures fast response times
+- 📊 **Smart Caching**: Redis-backed caching for optimal performance
+- 🔥 **Firebase Integration**: Real-time database support for view counting
+- 📡 **Multiple Categories**: AI, Data Security, Cloud Computing, and more
+
+## API Endpoints
+
+- `GET /api/news/{category}` - Fetch news by category
+- `GET /api/news/system/stats` - Monitor provider health and statistics
+- `GET /api/search?q={query}` - Search news articles
+- `GET /health` - Health check endpoint
+
+## Configuration
+
+This Space requires environment secrets for news API providers:
+
+1. **GNEWS_API_KEY** - Get from https://gnews.io
+2. **NEWSAPI_API_KEY** - Get from https://newsapi.org
+3. **NEWSDATA_API_KEY** - Get from https://newsdata.io
+
+Firebase credentials (optional):
+- **FIREBASE_DATABASE_URL**
+- **FIREBASE_PROJECT_ID**
+
+## Usage
+
+```bash
+# Fetch AI news
+curl https://your-space-name.hf.space/api/news/ai
+
+# Check provider stats
+curl https://your-space-name.hf.space/api/news/system/stats
+```
+
+## Local Development
+
+```bash
+pip install -r requirements.txt
+uvicorn app.main:app --reload --port 8000
+```
+
+---
+
+Built with FastAPI | Deployed on Hugging Face Spaces

app/__init__.py

@@ -0,0 +1,6 @@
+"""
+Segmento Pulse Backend API
+FastAPI application for real-time technology news aggregation
+"""
+
+__version__ = "1.0.0"

app/config.py

@@ -0,0 +1,55 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import field_validator
+from typing import List, Union
+
+class Settings(BaseSettings):
+    """Application settings"""
+    
+    # Environment
+    ENVIRONMENT: str = "development"
+    
+    # Server
+    HOST: str = "0.0.0.0"
+    PORT: int = 8000
+    
+    # CORS
+    CORS_ORIGINS: List[str] = ["http://localhost:3000", "https://segmento.in"]
+    
+    # News API
+    NEWS_API_KEY: str = ""
+    
+    # Multi-Provider News APIs
+    GNEWS_API_KEY: str = ""
+    NEWSAPI_API_KEY: str = ""
+    NEWSDATA_API_KEY: str = ""
+    
+    # Provider priority (will try in order until successful)
+    NEWS_PROVIDER_PRIORITY: List[str] = ["gnews", "newsapi", "newsdata", "google_rss"]
+    
+    # Firebase
+    FIREBASE_DATABASE_URL: str = ""
+    FIREBASE_PROJECT_ID: str = ""
+    FIREBASE_CREDENTIALS_PATH: str = "./firebase-credentials.json"
+    
+    # Redis
+    REDIS_URL: str = "redis://localhost:6379"
+    REDIS_PASSWORD: str = ""
+    
+    # Cache
+    CACHE_TTL: int = 120  # seconds
+    
+    @field_validator('CORS_ORIGINS', 'NEWS_PROVIDER_PRIORITY', mode='before')
+    @classmethod
+    def parse_comma_separated(cls, v: Union[str, List[str]]) -> List[str]:
+        """Parse comma-separated string into list (for HF Spaces secrets)"""
+        if isinstance(v, str):
+            return [item.strip() for item in v.split(',') if item.strip()]
+        return v
+    
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=True
+    )
+
+settings = Settings()

app/main.py

@@ -0,0 +1,50 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.config import settings
+from app.routes import news, search, analytics
+
+app = FastAPI(
+    title="Segmento Pulse API",
+    description="Real-Time Technology Intelligence Platform API",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(news.router, prefix="/api/news", tags=["News"])
+app.include_router(search.router, prefix="/api/search", tags=["Search"])
+app.include_router(analytics.router, prefix="/api/analytics", tags=["Analytics"])
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "Segmento Pulse API",
+        "version": "1.0.0",
+        "status": "operational",
+        "docs": "/docs"
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app.main:app",
+        host=settings.HOST,
+        port=settings.PORT,
+        reload=settings.ENVIRONMENT == "development"
+    )

app/models.py

@@ -0,0 +1,70 @@
+from pydantic import BaseModel, HttpUrl, field_validator
+from typing import Optional, List
+from datetime import datetime
+from email.utils import parsedate_to_datetime
+
+class Article(BaseModel):
+    """News article model"""
+    title: str
+    description: Optional[str] = ""
+    url: HttpUrl
+    image: Optional[str] = ""
+    publishedAt: datetime
+    source: Optional[str] = ""
+    category: Optional[str] = ""
+    
+    @field_validator('publishedAt', mode='before')
+    @classmethod
+    def parse_datetime(cls, v):
+        """Parse datetime from various formats including RFC 2822 (RSS feeds)"""
+        if isinstance(v, datetime):
+            return v
+        if isinstance(v, str):
+            try:
+                # Try RFC 2822 format (used by RSS feeds like Google News)
+                # Example: "Tue, 06 Jan 2026 19:14:27 GMT"
+                return parsedate_to_datetime(v)
+            except:
+                try:
+                    # Try ISO format
+                    return datetime.fromisoformat(v.replace('Z', '+00:00'))
+                except:
+                    try:
+                        # Fallback to dateutil parser
+                        from dateutil import parser
+                        return parser.parse(v)
+                    except:
+                        # Last resort: return current time
+                        return datetime.now()
+        return v
+
+class NewsResponse(BaseModel):
+    """Response model for news endpoints"""
+    success: bool
+    category: str
+    count: int
+    articles: List[Article]
+    cached: bool = False
+
+class SearchResponse(BaseModel):
+    """Response model for search endpoints"""
+    success: bool
+    query: str
+    count: int
+    articles: List[Article]
+
+class ViewCountRequest(BaseModel):
+    """Request model for view count increment"""
+    article_url: HttpUrl
+
+class ViewCountResponse(BaseModel):
+    """Response model for view count"""
+    success: bool
+    article_url: str
+    view_count: int
+
+class ErrorResponse(BaseModel):
+    """Error response model"""
+    success: bool = False
+    error: str
+    detail: Optional[str] = None

app/routes/__init__.py

@@ -0,0 +1 @@
+"""Routes package"""

app/routes/analytics.py

@@ -0,0 +1,37 @@
+from fastapi import APIRouter, HTTPException
+from app.models import ViewCountRequest, ViewCountResponse
+from app.services.firebase_service import FirebaseService
+
+router = APIRouter()
+firebase_service = FirebaseService()
+
+@router.post("/view", response_model=ViewCountResponse)
+async def increment_view_count(request: ViewCountRequest):
+    """
+    Increment view count for an article
+    """
+    try:
+        view_count = await firebase_service.increment_view(str(request.article_url))
+        return ViewCountResponse(
+            success=True,
+            article_url=str(request.article_url),
+            view_count=view_count
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/views")
+async def get_view_count(article_url: str):
+    """
+    Get view count for an article
+    """
+    try:
+        view_count = await firebase_service.get_view_count(article_url)
+        return ViewCountResponse(
+            success=True,
+            article_url=article_url,
+            view_count=view_count
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/routes/news.py

@@ -0,0 +1,112 @@
+from fastapi import APIRouter, HTTPException
+from app.models import NewsResponse, ErrorResponse
+from app.services.news_aggregator import NewsAggregator
+from app.services.cache_service import CacheService
+
+router = APIRouter()
+news_aggregator = NewsAggregator()
+cache_service = CacheService()
+
+@router.get("/{category}", response_model=NewsResponse)
+async def get_news_by_category(category: str):
+    """
+    Get news articles by category
+    
+    Categories:
+    - ai: Artificial Intelligence
+    - data-security: Data Security
+    - data-governance: Data Governance
+    - data-privacy: Data Privacy
+    - data-engineering: Data Engineering
+    - business-intelligence: Business Intelligence
+    - business-analytics: Business Analytics
+    - customer-data-platform: Customer Data Platform
+    - data-centers: Data Centers
+    - cloud-computing: Cloud Computing
+    - magazines: Tech Magazines
+    """
+    try:
+        # Check cache first
+        cached_data = await cache_service.get(f"news:{category}")
+        if cached_data:
+            return NewsResponse(
+                success=True,
+                category=category,
+                count=len(cached_data),
+                articles=cached_data,
+                cached=True
+            )
+        
+        # Fetch fresh data
+        articles = await news_aggregator.fetch_by_category(category)
+        
+        # Cache the results
+        await cache_service.set(f"news:{category}", articles)
+        
+        return NewsResponse(
+            success=True,
+            category=category,
+            count=len(articles),
+            articles=articles,
+            cached=False
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/rss/{provider}")
+async def get_rss_feed(provider: str):
+    """
+    Get RSS feed from cloud providers
+    
+    Providers: aws, gcp, azure, ibm, oracle, digitalocean
+    """
+    try:
+        # Check cache
+        cached_data = await cache_service.get(f"rss:{provider}")
+        if cached_data:
+            return NewsResponse(
+                success=True,
+                category=f"cloud-{provider}",
+                count=len(cached_data),
+                articles=cached_data,
+                cached=True
+            )
+        
+        # Fetch RSS
+        articles = await news_aggregator.fetch_rss(provider)
+        
+        # Cache
+        await cache_service.set(f"rss:{provider}", articles)
+        
+        return NewsResponse(
+            success=True,
+            category=f"cloud-{provider}",
+            count=len(articles),
+            articles=articles,
+            cached=False
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/system/stats")
+async def get_provider_stats():
+    """
+    Get statistics about news provider usage and health
+    
+    Returns information about:
+    - Total requests
+    - Provider usage counts
+    - Failover counts
+    - Available providers
+    - Provider status and rate limits
+    """
+    try:
+        stats = news_aggregator.get_stats()
+        return {
+            "success": True,
+            **stats
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/routes/search.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, HTTPException, Query
+from app.models import SearchResponse
+from app.services.news_aggregator import NewsAggregator
+from app.services.cache_service import CacheService
+
+router = APIRouter()
+news_aggregator = NewsAggregator()
+cache_service = CacheService()
+
+@router.get("/", response_model=SearchResponse)
+async def search_news(q: str = Query(..., min_length=2, description="Search query")):
+    """
+    Search news articles by keyword
+    """
+    try:
+        # Check cache
+        cache_key = f"search:{q.lower()}"
+        cached_data = await cache_service.get(cache_key)
+        if cached_data:
+            return SearchResponse(
+                success=True,
+                query=q,
+                count=len(cached_data),
+                articles=cached_data
+            )
+        
+        # Search articles
+        articles = await news_aggregator.search(q)
+        
+        # Cache results
+        await cache_service.set(cache_key, articles, ttl=300)  # 5 min cache for searches
+        
+        return SearchResponse(
+            success=True,
+            query=q,
+            count=len(articles),
+            articles=articles
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/services/__init__.py

@@ -0,0 +1 @@
+"""Services package"""

app/services/cache_service.py

@@ -0,0 +1,100 @@
+try:
+    import redis.asyncio as redis
+    REDIS_AVAILABLE = True
+except ImportError:
+    REDIS_AVAILABLE = False
+    print("Redis not available - caching disabled")
+
+from typing import Any, Optional
+import json
+from app.config import settings
+
+class CacheService:
+    """Redis caching service (optional)"""
+    
+    def __init__(self):
+        self.redis_client: Optional[redis.Redis] = None if not REDIS_AVAILABLE else None
+        self.ttl = settings.CACHE_TTL if hasattr(settings, 'CACHE_TTL') else 120
+    
+    async def connect(self):
+        """Connect to Redis (if available)"""
+        if not REDIS_AVAILABLE:
+            return
+        
+        try:
+            self.redis_client = await redis.from_url(
+                settings.REDIS_URL if hasattr(settings, 'REDIS_URL') else 'redis://localhost:6379',
+                password=settings.REDIS_PASSWORD if hasattr(settings, 'REDIS_PASSWORD') and settings.REDIS_PASSWORD else None,
+                encoding="utf-8",
+                decode_responses=True
+            )
+        except Exception as e:
+            print(f"Redis connection failed: {e}")
+            self.redis_client = None
+    
+    async def get(self, key: str) -> Optional[Any]:
+        """Get cached value"""
+        if not self.redis_client:
+            await self.connect()
+        
+        if not self.redis_client:
+            return None
+        
+        try:
+            value = await self.redis_client.get(key)
+            if value:
+                return json.loads(value)
+            return None
+        except Exception as e:
+            print(f"Cache get error: {e}")
+            return None
+    
+    async def set(self, key: str, value: Any, ttl: Optional[int] = None):
+        """Set cached value"""
+        if not self.redis_client:
+            await self.connect()
+        
+        if not self.redis_client:
+            return False
+        
+        try:
+            cache_ttl = ttl if ttl is not None else self.ttl
+            # Convert Pydantic models to dict
+            if hasattr(value, 'model_dump'):
+                value = [item.model_dump() for item in value]
+            
+            await self.redis_client.setex(
+                key,
+                cache_ttl,
+                json.dumps(value, default=str)
+            )
+            return True
+        except Exception as e:
+            print(f"Cache set error: {e}")
+            return False
+    
+    async def delete(self, key: str):
+        """Delete cached value"""
+        if not self.redis_client:
+            return False
+        
+        try:
+            await self.redis_client.delete(key)
+            return True
+        except Exception as e:
+            print(f"Cache delete error: {e}")
+            return False
+    
+    async def clear_pattern(self, pattern: str):
+        """Clear all keys matching pattern"""
+        if not self.redis_client:
+            return False
+        
+        try:
+            keys = await self.redis_client.keys(pattern)
+            if keys:
+                await self.redis_client.delete(*keys)
+            return True
+        except Exception as e:
+            print(f"Cache clear error: {e}")
+            return False

app/services/firebase_service.py

@@ -0,0 +1,96 @@
+try:
+    import firebase_admin
+    from firebase_admin import credentials, db
+    FIREBASE_AVAILABLE = True
+except ImportError:
+    FIREBASE_AVAILABLE = False
+    print("Firebase not available - analytics disabled")
+
+from typing import Optional
+import base64
+from app.config import settings
+
+class FirebaseService:
+    """Firebase Realtime Database service for analytics (optional)"""
+    
+    def __init__(self):
+        self.initialized = False
+        self.db_ref = None
+        if FIREBASE_AVAILABLE:
+            self._initialize()
+    
+    def _initialize(self):
+        """Initialize Firebase Admin SDK"""
+        if not FIREBASE_AVAILABLE:
+            return
+        
+        try:
+            if not firebase_admin._apps:
+                cred = credentials.Certificate(settings.FIREBASE_CREDENTIALS_PATH if hasattr(settings, 'FIREBASE_CREDENTIALS_PATH') else './firebase-credentials.json')
+                firebase_admin.initialize_app(cred, {
+                    'databaseURL': settings.FIREBASE_DATABASE_URL if hasattr(settings, 'FIREBASE_DATABASE_URL') else ''
+                })
+            
+            self.db_ref = db.reference('pulse/article_views')
+            self.initialized = True
+        except Exception as e:
+            print(f"Firebase initialization error: {e}")
+            self.initialized = False
+    
+    def _get_article_id(self, article_url: str) -> str:
+        """Generate article ID from URL"""
+        # Base64 encode and sanitize
+        encoded = base64.b64encode(article_url.encode()).decode()
+        # Remove non-alphanumeric characters and limit length
+        sanitized = ''.join(c for c in encoded if c.isalnum())[:100]
+        return sanitized
+    
+    async def increment_view(self, article_url: str) -> int:
+        """Increment view count for an article"""
+        if not self.initialized:
+            return 0
+        
+        try:
+            article_id = self._get_article_id(article_url)
+            article_ref = self.db_ref.child(article_id)
+            
+            # Get current data
+            current_data = article_ref.get()
+            
+            if current_data:
+                # Increment existing count
+                new_count = current_data.get('viewCount', 0) + 1
+                article_ref.update({
+                    'viewCount': new_count,
+                    'url': article_url,
+                    'lastUpdated': {'.sv': 'timestamp'}
+                })
+                return new_count
+            else:
+                # Create new entry
+                article_ref.set({
+                    'url': article_url,
+                    'viewCount': 1,
+                    'lastUpdated': {'.sv': 'timestamp'}
+                })
+                return 1
+        except Exception as e:
+            print(f"Error incrementing view: {e}")
+            return 0
+    
+    async def get_view_count(self, article_url: str) -> int:
+        """Get view count for an article"""
+        if not self.initialized:
+            return 0
+        
+        try:
+            article_id = self._get_article_id(article_url)
+            article_ref = self.db_ref.child(article_id)
+            data = article_ref.get()
+            
+            if data:
+                return data.get('viewCount', 0)
+            return 0
+        except Exception as e:
+            print(f"Error getting view count: {e}")
+            return 0

app/services/news_aggregator.py

@@ -0,0 +1,160 @@
+import httpx
+from typing import List, Dict, Optional
+from datetime import datetime
+from app.models import Article
+from app.services.rss_parser import RSSParser
+from app.services.news_providers import (
+    NewsProvider, 
+    GNewsProvider, 
+    NewsAPIProvider, 
+    NewsDataProvider, 
+    GoogleNewsRSSProvider
+)
+from app.config import settings
+
+class NewsAggregator:
+    """Service for aggregating news from multiple sources with automatic failover"""
+    
+    def __init__(self):
+        self.rss_parser = RSSParser()
+        
+        # Initialize all available providers
+        self.providers: Dict[str, NewsProvider] = {}
+        
+        # Initialize GNews if API key is available
+        if settings.GNEWS_API_KEY:
+            self.providers['gnews'] = GNewsProvider(settings.GNEWS_API_KEY)
+        
+        # Initialize NewsAPI if API key is available
+        if settings.NEWSAPI_API_KEY:
+            self.providers['newsapi'] = NewsAPIProvider(settings.NEWSAPI_API_KEY)
+        
+        # Initialize NewsData if API key is available
+        if settings.NEWSDATA_API_KEY:
+            self.providers['newsdata'] = NewsDataProvider(settings.NEWSDATA_API_KEY)
+        
+        # Always include Google News RSS as fallback (no API key needed)
+        self.providers['google_rss'] = GoogleNewsRSSProvider()
+        
+        # Provider priority order
+        self.provider_priority = settings.NEWS_PROVIDER_PRIORITY
+        
+        # Cloud provider RSS feeds
+        self.cloud_rss_urls = {
+            "aws": "https://aws.amazon.com/blogs/aws/feed/",
+            "gcp": "https://cloudblog.withgoogle.com/rss/",
+            "azure": "https://azure.microsoft.com/en-us/blog/feed/",
+            "ibm": "https://www.ibm.com/blog/rss",
+            "oracle": "https://blogs.oracle.com/cloud-infrastructure/rss",
+            "digitalocean": "https://www.digitalocean.com/blog/rss.xml"
+        }
+        
+        # Statistics tracking
+        self.stats = {
+            'total_requests': 0,
+            'provider_usage': {},
+            'failover_count': 0
+        }
+    
+    async def fetch_by_category(self, category: str) -> List[Article]:
+        """
+        Fetch news by category using hybrid approach with automatic failover
+        Tries providers in priority order until successful
+        """
+        self.stats['total_requests'] += 1
+        
+        # Try each provider in priority order
+        for provider_name in self.provider_priority:
+            provider = self.providers.get(provider_name)
+            
+            # Skip if provider not configured
+            if not provider:
+                continue
+            
+            # Skip if provider is not available (rate limited)
+            if not provider.is_available():
+                print(f"Provider {provider_name} is not available (rate limited), trying next...")
+                self.stats['failover_count'] += 1
+                continue
+            
+            try:
+                print(f"Fetching news for '{category}' from {provider_name}...")
+                articles = await provider.fetch_news(category, limit=20)
+                
+                # If we got articles, return them
+                if articles:
+                    print(f"✓ Successfully fetched {len(articles)} articles from {provider_name}")
+                    
+                    # Track usage statistics
+                    if provider_name not in self.stats['provider_usage']:
+                        self.stats['provider_usage'][provider_name] = 0
+                    self.stats['provider_usage'][provider_name] += 1
+                    
+                    return articles
+                else:
+                    print(f"Provider {provider_name} returned no articles, trying next...")
+                    
+            except Exception as e:
+                print(f"Error with provider {provider_name}: {e}, trying next...")
+                self.stats['failover_count'] += 1
+                continue
+        
+        # If all providers failed, return empty list
+        print(f"⚠ All providers exhausted for category '{category}'")
+        return []
+    
+    async def fetch_rss(self, provider: str) -> List[Article]:
+        """Fetch RSS from cloud providers"""
+        url = self.cloud_rss_urls.get(provider)
+        if not url:
+            return []
+        
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(url)
+                if response.status_code == 200:
+                    content = response.text
+                    return await self.rss_parser.parse_provider_rss(content, provider)
+                return []
+        except Exception as e:
+            print(f"Error fetching RSS for {provider}: {e}")
+            return []
+    
+    async def search(self, query: str) -> List[Article]:
+        """
+        Search news articles using hybrid approach
+        Currently uses Google News RSS for search functionality
+        """
+        # Use Google News RSS for search
+        google_rss = self.providers.get('google_rss')
+        if google_rss:
+            try:
+                # Create a custom search URL
+                search_url = f"https://news.google.com/rss/search?q={query}&hl=en-US&gl=US&ceid=US:en"
+                
+                async with httpx.AsyncClient(timeout=10.0) as client:
+                    response = await client.get(search_url)
+                    if response.status_code == 200:
+                        return await self.rss_parser.parse_google_news(response.text, "search")
+            except Exception as e:
+                print(f"Error searching news: {e}")
+        
+        return []
+    
+    def get_stats(self) -> Dict:
+        """Get usage statistics for monitoring"""
+        return {
+            **self.stats,
+            'available_providers': [
+                name for name, provider in self.providers.items() 
+                if provider.is_available()
+            ],
+            'provider_status': {
+                name: {
+                    'status': provider.status.value,
+                    'request_count': provider.request_count,
+                    'daily_limit': provider.daily_limit
+                }
+                for name, provider in self.providers.items()
+            }
+        }

app/services/news_providers.py

@@ -0,0 +1,322 @@
+import httpx
+from typing import List, Optional, Dict
+from datetime import datetime
+from abc import ABC, abstractmethod
+from app.models import Article
+import os
+from enum import Enum
+
+class ProviderStatus(Enum):
+    """Provider status enum"""
+    ACTIVE = "active"
+    RATE_LIMITED = "rate_limited"
+    ERROR = "error"
+
+class NewsProvider(ABC):
+    """Abstract base class for news providers"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key
+        self.status = ProviderStatus.ACTIVE
+        self.request_count = 0
+        self.daily_limit = 0
+        self.name = self.__class__.__name__
+    
+    @abstractmethod
+    async def fetch_news(self, category: str, limit: int = 20) -> List[Article]:
+        """Fetch news articles for a given category"""
+        pass
+    
+    def is_available(self) -> bool:
+        """Check if provider is available"""
+        return self.status == ProviderStatus.ACTIVE and (
+            self.daily_limit == 0 or self.request_count < self.daily_limit
+        )
+    
+    def mark_rate_limited(self):
+        """Mark provider as rate limited"""
+        self.status = ProviderStatus.RATE_LIMITED
+    
+    def reset_daily_quota(self):
+        """Reset daily quota"""
+        self.request_count = 0
+        self.status = ProviderStatus.ACTIVE
+
+
+class GNewsProvider(NewsProvider):
+    """GNews.io API provider"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        super().__init__(api_key)
+        self.base_url = "https://gnews.io/api/v4"
+        self.daily_limit = 100
+        
+        # Category mapping
+        self.category_map = {
+            'ai': 'artificial intelligence machine learning',
+            'data-security': 'data security cybersecurity',
+            'data-governance': 'data governance compliance',
+            'data-privacy': 'data privacy GDPR',
+            'data-engineering': 'data engineering pipeline',
+            'business-intelligence': 'business intelligence BI',
+            'business-analytics': 'business analytics',
+            'customer-data-platform': 'customer data platform CDP',
+            'data-centers': 'data centers infrastructure',
+            'cloud-computing': 'cloud computing',
+            'magazines': 'technology news',
+        }
+    
+    async def fetch_news(self, category: str, limit: int = 20) -> List[Article]:
+        """Fetch news from GNews API"""
+        if not self.api_key:
+            return []
+        
+        try:
+            query = self.category_map.get(category, category)
+            url = f"{self.base_url}/search"
+            params = {
+                'q': query,
+                'lang': 'en',
+                'country': 'us',
+                'max': min(limit, 10),  # GNews free tier max 10
+                'apikey': self.api_key
+            }
+            
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(url, params=params)
+                
+                if response.status_code == 429:
+                    self.mark_rate_limited()
+                    return []
+                
+                if response.status_code == 200:
+                    self.request_count += 1
+                    data = response.json()
+                    return self._parse_response(data, category)
+                
+                return []
+        except Exception as e:
+            print(f"GNews API error: {e}")
+            return []
+    
+    def _parse_response(self, data: Dict, category: str) -> List[Article]:
+        """Parse GNews API response"""
+        articles = []
+        for item in data.get('articles', []):
+            try:
+                article = Article(
+                    title=item.get('title', ''),
+                    description=item.get('description', ''),
+                    url=item.get('url', ''),
+                    image=item.get('image', ''),
+                    publishedAt=item.get('publishedAt', datetime.now().isoformat()),
+                    source=item.get('source', {}).get('name', 'GNews'),
+                    category=category
+                )
+                articles.append(article)
+            except Exception as e:
+                print(f"Error parsing GNews article: {e}")
+                continue
+        return articles
+
+
+class NewsAPIProvider(NewsProvider):
+    """NewsAPI.org provider"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        super().__init__(api_key)
+        self.base_url = "https://newsapi.org/v2"
+        self.daily_limit = 100
+        
+        # Category keywords
+        self.category_keywords = {
+            'ai': 'artificial intelligence OR "machine learning" OR "deep learning"',
+            'data-security': '"data security" OR cybersecurity OR "data breach"',
+            'data-governance': '"data governance" OR "data management" OR compliance',
+            'data-privacy': '"data privacy" OR GDPR OR "privacy regulation"',
+            'data-engineering': '"data engineering" OR "data pipeline" OR "big data"',
+            'business-intelligence': '"business intelligence" OR "BI tools"',
+            'business-analytics': '"business analytics" OR analytics',
+            'customer-data-platform': '"customer data platform" OR CDP',
+            'data-centers': '"data centers" OR "data centre"',
+            'cloud-computing': '"cloud computing" OR cloud',
+            'magazines': 'technology',
+        }
+    
+    async def fetch_news(self, category: str, limit: int = 20) -> List[Article]:
+        """Fetch news from NewsAPI"""
+        if not self.api_key:
+            return []
+        
+        try:
+            query = self.category_keywords.get(category, category)
+            url = f"{self.base_url}/everything"
+            params = {
+                'q': query,
+                'language': 'en',
+                'sortBy': 'publishedAt',
+                'pageSize': min(limit, 20),
+                'apiKey': self.api_key
+            }
+            
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(url, params=params)
+                
+                if response.status_code == 429 or response.status_code == 426:
+                    self.mark_rate_limited()
+                    return []
+                
+                if response.status_code == 200:
+                    self.request_count += 1
+                    data = response.json()
+                    return self._parse_response(data, category)
+                
+                return []
+        except Exception as e:
+            print(f"NewsAPI error: {e}")
+            return []
+    
+    def _parse_response(self, data: Dict, category: str) -> List[Article]:
+        """Parse NewsAPI response"""
+        articles = []
+        for item in data.get('articles', []):
+            try:
+                article = Article(
+                    title=item.get('title', ''),
+                    description=item.get('description', ''),
+                    url=item.get('url', ''),
+                    image=item.get('urlToImage', ''),
+                    publishedAt=item.get('publishedAt', datetime.now().isoformat()),
+                    source=item.get('source', {}).get('name', 'NewsAPI'),
+                    category=category
+                )
+                articles.append(article)
+            except Exception as e:
+                print(f"Error parsing NewsAPI article: {e}")
+                continue
+        return articles
+
+
+class NewsDataProvider(NewsProvider):
+    """NewsData.io provider"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        super().__init__(api_key)
+        self.base_url = "https://newsdata.io/api/1"
+        self.daily_limit = 200
+        
+        # Category keywords
+        self.category_keywords = {
+            'ai': 'artificial intelligence,machine learning',
+            'data-security': 'data security,cybersecurity',
+            'data-governance': 'data governance,compliance',
+            'data-privacy': 'data privacy,GDPR',
+            'data-engineering': 'data engineering,big data',
+            'business-intelligence': 'business intelligence',
+            'business-analytics': 'business analytics',
+            'customer-data-platform': 'customer data platform',
+            'data-centers': 'data centers',
+            'cloud-computing': 'cloud computing',
+            'magazines': 'technology',
+        }
+    
+    async def fetch_news(self, category: str, limit: int = 20) -> List[Article]:
+        """Fetch news from NewsData.io"""
+        if not self.api_key:
+            return []
+        
+        try:
+            query = self.category_keywords.get(category, category)
+            url = f"{self.base_url}/news"
+            params = {
+                'q': query,
+                'language': 'en',
+                'country': 'us',
+                'apikey': self.api_key
+            }
+            
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(url, params=params)
+                
+                if response.status_code == 429:
+                    self.mark_rate_limited()
+                    return []
+                
+                if response.status_code == 200:
+                    self.request_count += 1
+                    data = response.json()
+                    return self._parse_response(data, category, limit)
+                
+                return []
+        except Exception as e:
+            print(f"NewsData.io error: {e}")
+            return []
+    
+    def _parse_response(self, data: Dict, category: str, limit: int) -> List[Article]:
+        """Parse NewsData.io response"""
+        articles = []
+        for item in data.get('results', [])[:limit]:
+            try:
+                article = Article(
+                    title=item.get('title', ''),
+                    description=item.get('description', ''),
+                    url=item.get('link', ''),
+                    image=item.get('image_url', ''),
+                    publishedAt=item.get('pubDate', datetime.now().isoformat()),
+                    source=item.get('source_id', 'NewsData'),
+                    category=category
+                )
+                articles.append(article)
+            except Exception as e:
+                print(f"Error parsing NewsData article: {e}")
+                continue
+        return articles
+
+
+class GoogleNewsRSSProvider(NewsProvider):
+    """Google News RSS provider (no API key needed)"""
+    
+    def __init__(self):
+        super().__init__(None)
+        self.daily_limit = 0  # Unlimited (but rate limited by Google)
+        
+        # RSS feed URLs by category
+        self.feed_urls = {
+            'ai': 'https://news.google.com/rss/search?q=artificial+intelligence+OR+machine+learning&hl=en-US&gl=US&ceid=US:en',
+            'data-security': 'https://news.google.com/rss/search?q=data+security+OR+cybersecurity+OR+data+breach&hl=en-US&gl=US&ceid=US:en',
+            'data-governance': 'https://news.google.com/rss/search?q=data+governance+OR+data+management&hl=en-US&gl=US&ceid=US:en',
+            'data-privacy': 'https://news.google.com/rss/search?q=data+privacy+OR+GDPR+OR+privacy+regulation&hl=en-US&gl=US&ceid=US:en',
+            'data-engineering': 'https://news.google.com/rss/search?q=data+engineering+OR+data+pipeline+OR+big+data&hl=en-US&gl=US&ceid=US:en',
+            'business-intelligence': 'https://news.google.com/rss/search?q=business+intelligence+OR+BI+tools&hl=en-US&gl=US&ceid=US:en',
+            'business-analytics': 'https://news.google.com/rss/search?q=business+analytics&hl=en-US&gl=US&ceid=US:en',
+            'customer-data-platform': 'https://news.google.com/rss/search?q=customer+data+platform+OR+CDP&hl=en-US&gl=US&ceid=US:en',
+            'data-centers': 'https://news.google.com/rss/search?q=data+centers+OR+data+centre&hl=en-US&gl=US&ceid=US:en',
+            'cloud-computing': 'https://news.google.com/rss/search?q=cloud+computing&hl=en-US&gl=US&ceid=US:en',
+            'magazines': 'https://news.google.com/rss/headlines/section/topic/TECHNOLOGY?hl=en-US&gl=US&ceid=US:en',
+        }
+    
+    async def fetch_news(self, category: str, limit: int = 20) -> List[Article]:
+        """Fetch news from Google News RSS"""
+        from app.services.rss_parser import RSSParser
+        
+        feed_url = self.feed_urls.get(category)
+        if not feed_url:
+            return []
+        
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(feed_url)
+                
+                if response.status_code == 429:
+                    self.mark_rate_limited()
+                    return []
+                
+                if response.status_code == 200:
+                    self.request_count += 1
+                    parser = RSSParser()
+                    return await parser.parse_google_news(response.text, category)
+                
+                return []
+        except Exception as e:
+            print(f"Google News RSS error: {e}")
+            return []

app/services/rss_parser.py

@@ -0,0 +1,206 @@
+import feedparser
+from typing import List
+from datetime import datetime
+from app.models import Article
+import re
+
+class RSSParser:
+    """RSS feed parser for news sources"""
+    
+    async def parse_google_news(self, content: str, category: str) -> List[Article]:
+        """Parse Google News RSS feed with advanced XML parsing"""
+        try:
+            articles = []
+            
+            # Extract items from XML using regex
+            item_regex = r'<item>([\s\S]*?)</item>'
+            matches = re.findall(item_regex, content)
+            
+            for item in matches[:20]:  # Limit to 20 articles
+                title = self._extract_tag(item, 'title') or 'No title'
+                link = self._extract_tag(item, 'link') or self._extract_tag(item, 'guid') or ''
+                description = self._extract_tag(item, 'description') or self._extract_tag(item, 'content:encoded') or ''
+                pub_date = self._extract_tag(item, 'pubDate') or self._extract_tag(item, 'published') or datetime.now().isoformat()
+                creator = self._extract_tag(item, 'dc:creator') or self._extract_tag(item, 'author') or 'Google News'
+                
+                # Extract image from multiple sources
+                image = self._extract_image_from_xml(item, description, category, title)
+                
+                # Extract source name from description (Google News format: <a href="...">Source</a>)
+                source_match = re.search(r'<a[^>]*>([^<]+)</a>', description)
+                article_source = source_match.group(1) if source_match else 'Google News'
+                
+                # Clean description (Google News RSS only contains links, not actual content)
+                cleaned_description = self._clean_google_news_description(description)
+                
+                article = Article(
+                    title=self._clean_html(title),
+                    description=cleaned_description,
+                    url=link,
+                    image=image,
+                    publishedAt=pub_date,
+                    source=self._clean_html(article_source),
+                    category=category
+                )
+                articles.append(article)
+            
+            return articles
+        except Exception as e:
+            print(f"Error parsing Google News: {e}")
+            return []
+    
+    def _extract_image_from_xml(self, item: str, description: str, category: str, title: str) -> str:
+        """Extract image from multiple XML sources with fallbacks"""
+        # 1. Try enclosure tag
+        enclosure_match = re.search(r'<enclosure[^>]*url="([^"]+)"', item)
+        if enclosure_match:
+            return enclosure_match.group(1)
+        
+        # 2. Try media:content or media:thumbnail
+        media_match = re.search(r'<media:(content|thumbnail)[^>]*url="([^"]+)"', item)
+        if media_match:
+            return media_match.group(2)
+        
+        # 3. Try img tag in description
+        img_match = re.search(r'<img[^>]*src="([^"]+)"', description)
+        if img_match:
+            return img_match.group(1)
+        
+        # 4. Category-specific fallback images
+        fallbacks = {
+            'ai': 'https://images.unsplash.com/photo-1677442136019-21780ecad995?w=400&h=200&fit=crop',
+            'data-security': 'https://images.unsplash.com/photo-1563986768494-4dee2763ff3f?w=400&h=200&fit=crop',
+            'data-governance': 'https://images.unsplash.com/photo-1551288049-bebda4e38f71?w=400&h=200&fit=crop',
+            'data-privacy': 'https://images.unsplash.com/photo-1614064641938-3bbee52942c7?w=400&h=200&fit=crop',
+            'data-engineering': 'https://images.unsplash.com/photo-1558494949-ef010cbdcc31?w=400&h=200&fit=crop',
+            'business-intelligence': 'https://images.unsplash.com/photo-1551288049-bebda4e38f71?w=400&h=200&fit=crop',
+            'business-analytics': 'https://images.unsplash.com/photo-1460925895917-afdab827c52f?w=400&h=200&fit=crop',
+            'customer-data-platform': 'https://images.unsplash.com/photo-1432888622747-4eb9a8d82266?w=400&h=200&fit=crop',
+            'data-centers': 'https://images.unsplash.com/photo-1544197150-b99a580bb7a8?w=400&h=200&fit=crop',
+            'magazines': 'https://images.unsplash.com/photo-1504711434969-e33886168f5c?w=400&h=200&fit=crop',
+        }
+        
+        # Use hash of title for consistent fallback selection
+        default_images = list(fallbacks.values())
+        index = abs(hash(title)) % len(default_images)
+        return default_images[index]
+    
+    def _clean_google_news_description(self, description: str) -> str:
+        """Clean Google News description - they typically only contain links, not actual content"""
+        # Check if this is a Google News link-only description
+        if 'news.google.com/rss/articles' in description:
+            return ''  # No real content, just redirect links
+        
+        # Try to extract content after the link
+        after_link_match = re.search(r'</a>([\s\S]*)', description)
+        if after_link_match:
+            extracted = self._clean_html(after_link_match.group(1))
+            if len(extracted) > 30:
+                return extracted[:200]
+        
+        # Fallback: clean entire description if meaningful
+        full_clean = self._clean_html(description)
+        if len(full_clean) > 30 and not full_clean.startswith('http'):
+            return full_clean[:200]
+        
+        return ''
+    
+    def _extract_tag(self, xml: str, tag_name: str) -> str:
+        """Extract XML tag content"""
+        pattern = f'<{tag_name}[^>]*>([\\s\\S]*?)</{tag_name}>'
+        match = re.search(pattern, xml, re.IGNORECASE)
+        return match.group(1).strip() if match else ''
+    
+    def _clean_html(self, html: str) -> str:
+        """Remove HTML tags and decode entities"""
+        text = html
+        
+        # Remove CDATA
+        text = re.sub(r'<!\[CDATA\[([\s\S]*?)\]\]>', r'\1', text)
+        
+        # Remove HTML tags (multiple passes for nested tags)
+        text = re.sub(r'<[^>]+>', '', text)
+        text = re.sub(r'<[^>]*', '', text)
+        text = re.sub(r'>', '', text)
+        
+        # Decode HTML entities
+        entities = {
+            '&nbsp;': ' ', '&amp;': '&', '&lt;': '<', '&gt;': '>',
+            '&quot;': '"', '&#39;': "'", '&apos;': "'",
+            '&hellip;': '...', '&mdash;': '—', '&ndash;': '–'
+        }
+        for entity, char in entities.items():
+            text = text.replace(entity, char)
+        
+        # Remove numeric entities
+        text = re.sub(r'&#\d+;', '', text)
+        
+        # Clean whitespace
+        text = re.sub(r'\s+', ' ', text).strip()
+        
+        return text
+    
+    async def parse_provider_rss(self, content: str, provider: str) -> List[Article]:
+        """Parse cloud provider RSS feed"""
+        try:
+            feed = feedparser.parse(content)
+            articles = []
+            
+            for entry in feed.entries[:20]:
+                # Extract image
+                image_url = self._extract_image_from_entry(entry)
+                
+                # Parse date
+                published_at = self._parse_date(entry.get('published', ''))
+                
+                # Get description
+                description = entry.get('summary', '')
+                if description:
+                    # Strip HTML tags
+                    description = re.sub(r'<[^>]+>', '', description)
+                    description = description[:200] + '...' if len(description) > 200 else description
+                
+                article = Article(
+                    title=entry.get('title', ''),
+                    description=description,
+                    url=entry.get('link', ''),
+                    image=image_url,
+                    publishedAt=published_at,
+                    source=provider.upper(),
+                    category=f'cloud-{provider}'
+                )
+                articles.append(article)
+            
+            return articles
+        except Exception as e:
+            print(f"Error parsing provider RSS: {e}")
+            return []
+    
+    def _extract_image_from_entry(self, entry) -> str:
+        """Extract image URL from feed entry"""
+        # Try media:content
+        if hasattr(entry, 'media_content') and entry.media_content:
+            return entry.media_content[0].get('url', '')
+        
+        # Try media:thumbnail
+        if hasattr(entry, 'media_thumbnail') and entry.media_thumbnail:
+            return entry.media_thumbnail[0].get('url', '')
+        
+        # Try enclosures
+        if hasattr(entry, 'enclosures') and entry.enclosures:
+            for enclosure in entry.enclosures:
+                if enclosure.get('type', '').startswith('image'):
+                    return enclosure.get('href', '')
+        
+        # Default fallback image
+        return "https://via.placeholder.com/400x300/4F46E5/ffffff?text=Segmento+Pulse"
+    
+    def _parse_date(self, date_str: str) -> datetime:
+        """Parse date string to datetime"""
+        try:
+            # feedparser usually provides a parsed date
+            # but we'll handle string parsing as fallback
+            from dateutil import parser
+            return parser.parse(date_str)
+        except:
+            return datetime.now()

app/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility functions"""

app/utils/helpers.py

@@ -0,0 +1,25 @@
+"""Helper utilities"""
+
+import hashlib
+from datetime import datetime
+from typing import Optional
+
+def generate_id(text: str) -> str:
+    """Generate unique ID from text"""
+    return hashlib.md5(text.encode()).hexdigest()
+
+def sanitize_filename(filename: str) -> str:
+    """Sanitize filename for safe storage"""
+    return "".join(c for c in filename if c.isalnum() or c in (' ', '.', '_')).rstrip()
+
+def format_datetime(dt: Optional[datetime] = None) -> str:
+    """Format datetime to ISO string"""
+    if dt is None:
+        dt = datetime.now()
+    return dt.isoformat()
+
+def truncate_text(text: str, max_length: int = 200) -> str:
+    """Truncate text to max length"""
+    if len(text) <= max_length:
+        return text
+    return text[:max_length-3] + "..."

deploy.ps1

@@ -0,0 +1,70 @@
+# Quick Deployment Script for Hugging Face Spaces
+# Run this after cloning your HF Space repository
+
+Write-Host "🚀 SegmentoPulse Backend - Hugging Face Spaces Deployment" -ForegroundColor Cyan
+Write-Host ""
+
+# Check if we're in the right directory
+if (-not (Test-Path "app/main.py")) {
+    Write-Host "❌ Error: app/main.py not found. Make sure you're in the SegmentoPulse/backend directory" -ForegroundColor Red
+    exit 1
+}
+
+# Check for .env file and warn
+if (Test-Path ".env") {
+    Write-Host "⚠️  Warning: .env file found. This should NOT be committed to Git!" -ForegroundColor Yellow
+    Write-Host "   Make sure .env is in .gitignore" -ForegroundColor Yellow
+    Write-Host ""
+}
+
+# Clean up unnecessary files
+Write-Host "🧹 Cleaning up..." -ForegroundColor Green
+Get-ChildItem -Path "." -Recurse -Directory -Filter "__pycache__" | Remove-Item -Recurse -Force -ErrorAction SilentlyContinue
+Get-ChildItem -Path "." -Recurse -Filter "*.pyc" | Remove-Item -Force -ErrorAction SilentlyContinue
+Remove-Item -Path ".env" -ErrorAction SilentlyContinue
+
+# Check required files
+Write-Host "✅ Checking required files..." -ForegroundColor Green
+$required = @("Dockerfile", "README.md", "requirements.txt", "app/main.py", "app/config.py")
+foreach ($file in $required) {
+    if (Test-Path $file) {
+        Write-Host "  ✓ $file" -ForegroundColor Green
+    } else {
+        Write-Host "  ✗ $file MISSING" -ForegroundColor Red
+    }
+}
+Write-Host ""
+
+# Git status
+Write-Host "📦 Preparing for deployment..." -ForegroundColor Cyan
+git status --short
+
+Write-Host ""
+Write-Host "📋 Pre-Deployment Checklist:" -ForegroundColor Yellow
+Write-Host "  [ ] Created HF Space with Docker SDK" -ForegroundColor White
+Write-Host "  [ ] Cloned Space repository" -ForegroundColor White
+Write-Host "  [ ] Copied backend files to Space directory" -ForegroundColor White
+Write-Host "  [ ] Added API keys to HF Spaces Secrets" -ForegroundColor White
+Write-Host ""
+
+$confirm = Read-Host "Ready to commit and push to Hugging Face? (y/n)"
+if ($confirm -eq 'y' -or $confirm -eq 'Y') {
+    Write-Host ""
+    Write-Host "🚀 Deploying to Hugging Face..." -ForegroundColor Cyan
+    
+    git add .
+    git commit -m "Deploy SegmentoPulse backend to HF Spaces"
+    git push
+    
+    Write-Host ""
+    Write-Host "✅ Deployment initiated!" -ForegroundColor Green
+    Write-Host ""
+    Write-Host "📊 Next steps:" -ForegroundColor Cyan
+    Write-Host "  1. Monitor build logs in your HF Space" -ForegroundColor White
+    Write-Host "  2. Test endpoints once deployed" -ForegroundColor White
+    Write-Host "  3. Update frontend environment variable" -ForegroundColor White
+    Write-Host "  4. Deploy frontend to production" -ForegroundColor White
+    Write-Host ""
+} else {
+    Write-Host "Deployment cancelled." -ForegroundColor Yellow
+}

requirements.txt

@@ -0,0 +1,27 @@
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+pydantic==2.5.3
+pydantic-settings==2.1.0
+python-dotenv==1.0.0
+
+# News & RSS
+feedparser==6.0.11
+requests==2.31.0
+beautifulsoup4==4.12.3
+
+# HTTP client (replaces aiohttp)
+httpx==0.26.0
+
+# Caching (optional - can work without Redis)
+# redis==5.0.1
+# hiredis==2.3.2
+
+# Firebase
+firebase-admin==6.4.0
+
+# Data processing
+python-dateutil==2.8.2
+
+# CORS & Security
+python-multipart==0.0.6
+email-validator==2.1.0

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests package"""