Upload folder using huggingface_hub

.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:95ec775c1970593485.gradio.live)",
+      "WebFetch(domain:www.gradio.app)",
+      "WebFetch(domain:docs.railway.com)"
+    ],
+    "deny": []
+  }
+}

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,69 @@
+# Environment files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Gradio
+.gradio/
+gradio_cached_examples/
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.temp
+temp/
+tmp/

CLAUDE.md

@@ -0,0 +1,125 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a **SEO Article Generator** - a Gradio-based web application that generates SEO-optimized articles using OpenAI's GPT models. The application allows users to input context and keywords, then generates articles that match the style and quality of reference articles stored in `articles.txt`.
+
+## Key Files and Structure
+
+- **`app.py`** - Main application file containing the entire Gradio interface and business logic
+- **`articles.txt`** - Reference articles database used to guide writing style and quality
+- **`.env`** - Environment variables (contains `OPENAI_API_KEY`)
+
+## Development Commands
+
+### Running the Application
+```bash
+python app.py
+```
+
+### Environment Setup
+```bash
+# Create .env file with:
+echo "OPENAI_API_KEY=your_openai_key_here" > .env
+
+# Install dependencies (if requirements.txt exists):
+pip install -r requirements.txt
+
+# Otherwise install manually:
+pip install gradio requests python-dotenv
+```
+
+### Testing
+- **Manual Testing**: Run the app and test through the Gradio interface at `http://localhost:7862`
+- **API Testing**: Test OpenAI API connectivity by running article generation
+
+## Code Architecture
+
+### Core Classes
+
+1. **`Config`** (`app.py:16-28`) - Central configuration management
+   - OpenAI API key handling
+   - Model configurations (`gpt-4o-mini`, `gpt-4o`, `gpt-4-turbo-preview`)
+   - File path constants
+
+2. **`ArticleKnowledgeBase`** (`app.py:30-52`) - Reference articles management
+   - Loads and manages content from `articles.txt`
+   - Provides context for AI article generation
+   - Handles file reading errors gracefully
+
+3. **`SEOArticleGenerator`** (`app.py:54-209`) - Core article generation logic
+   - OpenAI API integration
+   - Prompt engineering for SEO optimization
+   - Article editing functionality
+   - Keyword tracking and analysis
+
+4. **`SEOArticleBot`** (`app.py:211-274`) - Application interface layer
+   - Gradio interface integration
+   - User input validation
+   - Response formatting and status reporting
+
+### Key Features
+
+- **Article Generation**: Creates SEO-optimized articles based on context and keywords
+- **Article Editing**: Allows users to refine existing articles with specific instructions
+- **Keyword Tracking**: Monitors keyword usage and density
+- **Reference Style Matching**: Uses articles.txt content to maintain consistent writing style
+- **Multiple AI Models**: Supports different OpenAI GPT models with quality/speed tradeoffs
+
+### Prompt Engineering
+
+The system uses sophisticated prompt engineering (`app.py:84-124`) with:
+- **System prompts** defining expert SEO writer persona
+- **Writing guidelines** for style, SEO requirements, structure, and quality
+- **Context integration** from reference articles
+- **Keyword optimization** with natural incorporation requirements
+
+### Error Handling
+
+- **API Key Validation**: Checks for OpenAI API key before requests
+- **File Loading**: Graceful handling of missing `articles.txt`
+- **API Error Handling**: Comprehensive error reporting for OpenAI API failures
+- **Input Validation**: Ensures required fields are provided
+
+## Reference Articles System
+
+The `articles.txt` file contains reference articles that guide the AI's writing style. Current articles focus on:
+- Video marketing strategies
+- Small business video needs
+- OTT advertising benefits
+- Business video types
+- Brand awareness and conversions
+
+When adding new reference articles, maintain the format:
+```
+## Article [Number]
+
+[Article Title]
+[Article Content]
+```
+
+## Configuration Notes
+
+- **Default Model**: `gpt-4o` (balanced quality/speed)
+- **Server Configuration**: Runs on `0.0.0.0:7862` with sharing enabled
+- **Article Length**: Targets 800-1500 words
+- **Keyword Density**: Maintains 1-2% without stuffing
+- **Temperature**: 0.7 for balanced creativity and consistency
+
+## Development Tips
+
+- Test OpenAI API connectivity before making changes
+- The reference articles significantly impact output quality - update them regularly
+- Keyword tracking helps optimize SEO performance
+- Use the edit feature for iterative improvements rather than regenerating
+- Monitor API usage and costs when testing
+
+## Deployment Considerations
+
+- Ensure `.env` file is properly configured and secure
+- `articles.txt` should be populated with high-quality reference content
+- Consider rate limiting for production usage
+- Monitor OpenAI API usage and costs
+- The app auto-generates sharing links - may need to disable for production

CLAUDE_DEPLOYMENT.md

@@ -0,0 +1,461 @@
+# Comprehensive Railway Deployment Plan - Platform-Agnostic Docker Approach
+
+## Executive Summary
+
+**Yes, using Docker is the perfect approach for platform portability.** After comprehensive research, here's a complete deployment strategy that keeps you platform-independent while optimizing for Railway initially.
+
+## Core Architecture Strategy
+
+### 1. **Docker-First Approach (Platform Agnostic)**
+- **Multi-stage Dockerfile** for optimized production builds
+- **Standard environment variable patterns** (works on Railway, Render, AWS, GCP, etc.)
+- **Portable configuration** using Docker Compose for local development
+- **Zero vendor lock-in** - same container runs anywhere
+
+### 2. **FastAPI + Gradio Integration (2025 Best Practices)**
+```python
+# main.py - FastAPI wrapper
+from fastapi import FastAPI
+import gradio as gr
+from your_app import create_interface
+
+app = FastAPI()
+gradio_app = create_interface()
+
+# Mount Gradio with authentication
+app = gr.mount_gradio_app(
+    app, gradio_app, 
+    path="/", 
+    auth_dependency=authenticate_user
+)
+```
+
+## Complete Tech Stack (2025 Production Ready)
+
+### Core Dependencies
+```txt
+fastapi==0.104.1
+gradio==4.44.0
+uvicorn[standard]==0.24.0
+slowapi==0.1.9           # Rate limiting
+redis==5.0.1             # For production rate limiting
+python-multipart==0.0.6  # File uploads
+pydantic==2.5.0          # Data validation
+python-dotenv==1.0.0     # Environment variables
+```
+
+### Production Security Stack
+```txt
+bcrypt==4.1.2           # Password hashing
+python-jose[cryptography]==3.3.0  # JWT tokens
+passlib[bcrypt]==1.7.4  # Password validation
+```
+
+## Docker Configuration (Platform Portable)
+
+### Multi-Stage Dockerfile
+```dockerfile
+# Stage 1: Build stage
+FROM python:3.11-slim as builder
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# Stage 2: Production stage
+FROM python:3.11-slim
+
+# Create non-root user for security
+RUN useradd --create-home --shell /bin/bash app
+
+# Copy installed packages from builder
+COPY --from=builder /root/.local /home/app/.local
+COPY . /app
+
+# Set ownership and switch to non-root user
+RUN chown -R app:app /app
+USER app
+WORKDIR /app
+
+# Make sure local packages are in PATH
+ENV PATH=/home/app/.local/bin:$PATH
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:8000/health || exit 1
+
+# Start command
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+### Docker Compose (Local Development)
+```yaml
+version: '3.8'
+services:
+  app:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - AUTH_USERNAME=${AUTH_USERNAME}
+      - AUTH_PASSWORD=${AUTH_PASSWORD}
+    volumes:
+      - ./articles.txt:/app/articles.txt
+    depends_on:
+      - redis
+  
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+```
+
+## Authentication System (Production Ready)
+
+### Simple Session-Based Auth
+```python
+from fastapi import Request, HTTPException, Depends
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+import secrets
+import os
+
+security = HTTPBasic()
+
+def authenticate_user(request: Request) -> str:
+    """Authentication for Gradio mount"""
+    auth_header = request.headers.get("authorization")
+    if not auth_header:
+        return None
+    
+    # Extract credentials from Basic auth
+    try:
+        credentials = HTTPBasicCredentials(
+            username=extract_username(auth_header),
+            password=extract_password(auth_header)
+        )
+        
+        if (credentials.username == os.getenv("AUTH_USERNAME") and 
+            credentials.password == os.getenv("AUTH_PASSWORD")):
+            return credentials.username
+    except:
+        pass
+    
+    return None
+```
+
+## Rate Limiting (Production Ready)
+
+### SlowAPI with Redis Backend
+```python
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+import redis
+
+# Redis connection for production
+redis_client = redis.Redis(
+    host=os.getenv("REDIS_HOST", "localhost"),
+    port=int(os.getenv("REDIS_PORT", "6379")),
+    decode_responses=True
+)
+
+limiter = Limiter(
+    key_func=get_remote_address,
+    storage_uri=f"redis://{os.getenv('REDIS_HOST', 'localhost')}:6379",
+    default_limits=["100/hour"]
+)
+
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+@app.post("/generate")
+@limiter.limit("10/hour")
+async def generate_article(request: Request):
+    # Your generation logic
+    pass
+```
+
+## Environment Variables (Platform Portable)
+
+### Production Environment Variables
+```bash
+# Core Application
+OPENAI_API_KEY=your_openai_key_here
+AUTH_USERNAME=your_username
+AUTH_PASSWORD=your_secure_password
+
+# Rate Limiting
+REDIS_HOST=localhost
+REDIS_PORT=6379
+RATE_LIMIT_PER_HOUR=10
+
+# Server Configuration
+PORT=8000
+HOST=0.0.0.0
+WORKERS=1
+
+# Security
+SECRET_KEY=your-secret-key-here
+ENVIRONMENT=production
+```
+
+## Platform Deployment Configs
+
+### 1. Railway (Primary)
+```json
+{
+  "$schema": "https://railway.app/railway.schema.json",
+  "build": {
+    "builder": "DOCKERFILE"
+  },
+  "deploy": {
+    "startCommand": "uvicorn main:app --host 0.0.0.0 --port $PORT"
+  }
+}
+```
+
+### 2. Render (Backup)
+```yaml
+services:
+  - type: web
+    name: seo-workflow
+    env: docker
+    dockerfilePath: ./Dockerfile
+    envVars:
+      - key: OPENAI_API_KEY
+        sync: false
+      - key: AUTH_USERNAME
+        sync: false
+```
+
+### 3. AWS ECS/Fargate (Enterprise)
+```json
+{
+  "family": "seo-workflow",
+  "networkMode": "awsvpc",
+  "requiresCompatibilities": ["FARGATE"],
+  "cpu": "256",
+  "memory": "512",
+  "containerDefinitions": [
+    {
+      "name": "seo-app",
+      "image": "your-registry/seo-workflow:latest",
+      "portMappings": [{"containerPort": 8000}]
+    }
+  ]
+}
+```
+
+## Security Best Practices (Production)
+
+### 1. Secrets Management
+- **Railway**: Use Railway's sealed variables for sensitive data
+- **Generic**: Environment variables only, never hardcoded
+- **Docker**: Multi-stage builds to avoid secrets in final image
+
+### 2. Network Security
+- **HTTPS**: Railway provides automatic SSL
+- **CORS**: Configure for your domain only
+- **Rate Limiting**: Protect against API abuse
+
+### 3. Application Security
+- **Non-root user**: Container runs as non-root user
+- **Health checks**: Built-in health monitoring
+- **Input validation**: Pydantic models for API validation
+
+## Migration Strategy
+
+### From Railway to Any Platform
+1. **Same Docker image** works everywhere
+2. **Environment variables** are standard across platforms
+3. **Database/Redis** connection strings are configurable
+4. **Zero code changes** required
+
+### Platform Comparison
+| Feature | Railway | Render | AWS | GCP |
+|---------|---------|---------|-----|-----|
+| Docker Support | ✅ | ✅ | ✅ | ✅ |
+| Auto SSL | ✅ | ✅ | ➕ | ➕ |
+| Environment Variables | ✅ | ✅ | ✅ | ✅ |
+| Redis | ➕ | ➕ | ✅ | ✅ |
+| Cost (Monthly) | $5+ | $7+ | $10+ | $10+ |
+
+## Implementation Timeline
+
+### Phase 1: Containerization (2 hours)
+- Create FastAPI wrapper with authentication
+- Implement rate limiting with SlowAPI
+- Build Docker configuration
+
+### Phase 2: Production Setup (1 hour)
+- Environment variable configuration
+- Security hardening
+- Health checks and monitoring
+
+### Phase 3: Deployment (30 minutes)
+- Railway deployment
+- Environment variable setup
+- Testing and validation
+
+### Phase 4: Platform Portability (30 minutes)
+- Document migration process
+- Create deployment configs for backup platforms
+- Test portability
+
+## Key Benefits
+
+✅ **Platform Independent**: Docker runs anywhere  
+✅ **Production Ready**: Authentication, rate limiting, security  
+✅ **Cost Effective**: Protects OpenAI API usage  
+✅ **Scalable**: Easy to add features or migrate  
+✅ **Maintainable**: Standard Docker/FastAPI patterns  
+✅ **Secure**: Industry-standard security practices  
+
+This approach gives you maximum flexibility while starting with Railway as your primary platform. You can migrate to any other platform with minimal effort since everything is containerized and uses standard patterns.
+
+---
+
+## Multi-App Deployment Strategy
+
+### Option 1: Single Container (Consolidated)
+**Architecture**: One FastAPI app with multiple Gradio apps mounted at different paths
+
+```python
+# main.py - Consolidated approach
+from fastapi import FastAPI
+import gradio as gr
+from seo_app import create_seo_interface
+from image_app import create_image_interface
+from chat_app import create_chat_interface
+
+app = FastAPI()
+
+# Mount multiple Gradio apps
+seo_app = create_seo_interface()
+image_app = create_image_interface()
+chat_app = create_chat_interface()
+
+app = gr.mount_gradio_app(app, seo_app, path="/seo", auth_dependency=auth_seo)
+app = gr.mount_gradio_app(app, image_app, path="/image", auth_dependency=auth_image)
+app = gr.mount_gradio_app(app, chat_app, path="/chat", auth_dependency=auth_chat)
+```
+
+**Pros**:
+- ✅ **Cheapest**: Single Railway service ($5/month)
+- ✅ **Shared resources**: Redis, authentication, monitoring
+- ✅ **Easy management**: One deployment, one domain
+- ✅ **Resource efficient**: Shared FastAPI server overhead
+
+**Cons**:
+- ❌ **Coupling**: One app failure affects all
+- ❌ **Scaling limitations**: Can't scale apps individually
+- ❌ **Dependency conflicts**: All apps share same environment
+
+### Option 2: Independent Containers (Microservices)
+**Architecture**: Separate FastAPI + Gradio deployment for each app
+
+```bash
+# Three separate Railway services
+seo-workflow-app      # $5/month
+image-generator-app   # $5/month
+chat-assistant-app    # $5/month
+```
+
+**Pros**:
+- ✅ **Independence**: Apps can fail/scale independently
+- ✅ **Technology flexibility**: Different Python versions, dependencies
+- ✅ **User isolation**: Separate authentication and rate limiting
+- ✅ **Easier debugging**: Clear separation of concerns
+
+**Cons**:
+- ❌ **Higher cost**: 3x Railway services ($15/month)
+- ❌ **Management overhead**: Multiple deployments, domains
+- ❌ **Resource duplication**: Separate Redis, auth systems
+
+### Cost Analysis (Railway Pricing)
+
+| Approach | Monthly Cost | Resource Usage | Scalability |
+|----------|-------------|----------------|-------------|
+| **Single Container** | $5 | 512MB RAM, 1 CPU | Limited |
+| **Independent Containers** | $15 | 3x 512MB RAM, 3x CPU | High |
+| **Hybrid** | $10 | 2 services (critical + non-critical) | Moderate |
+
+### Recommendation: **Single Container for Your Use Case**
+
+**Why Single Container is Best for You:**
+
+1. **Cost Effective**: $5/month vs $15/month (3x savings)
+2. **Low Traffic**: "Handful of users" doesn't justify microservices overhead
+3. **Shared Resources**: All apps can share rate limiting, Redis, auth
+4. **Easy Management**: One deployment, one domain, one set of environment variables
+5. **Resource Efficient**: FastAPI can handle multiple Gradio apps easily
+
+### Implementation Strategy
+
+```python
+# main.py - Multi-app architecture
+from fastapi import FastAPI, Request
+import gradio as gr
+
+app = FastAPI()
+
+# Different auth functions for different apps
+def auth_seo(request: Request) -> str:
+    return authenticate_user(request, "seo_users")
+
+def auth_image(request: Request) -> str:
+    return authenticate_user(request, "image_users")
+
+# Mount apps with different authentication
+app = gr.mount_gradio_app(app, seo_app, path="/seo", auth_dependency=auth_seo)
+app = gr.mount_gradio_app(app, image_app, path="/image", auth_dependency=auth_image)
+
+# Different rate limits per app
+@app.middleware("http")
+async def rate_limit_middleware(request: Request, call_next):
+    if request.url.path.startswith("/seo"):
+        # Apply SEO-specific rate limiting
+        pass
+    elif request.url.path.startswith("/image"):
+        # Apply image-specific rate limiting
+        pass
+    return await call_next(request)
+```
+
+### File Structure for Multi-App
+```
+consolidated_apps/
+├── main.py                 # FastAPI with multiple mounts
+├── apps/
+│   ├── seo_workflow/
+│   │   ├── app.py
+│   │   └── articles.txt
+│   ├── image_generator/
+│   │   ├── app.py
+│   │   └── models/
+│   └── chat_assistant/
+│       ├── app.py
+│       └── prompts/
+├── shared/
+│   ├── auth.py            # Shared authentication
+│   ├── rate_limiting.py   # Shared rate limiting
+│   └── utils.py
+├── requirements.txt       # All dependencies
+├── Dockerfile            # Single container
+└── docker-compose.yml    # Local development
+```
+
+### When to Switch to Microservices
+
+**Switch to independent containers when:**
+- Individual apps get >100 users each
+- Different apps need different scaling patterns
+- You want to deploy apps independently
+- Technology stacks diverge significantly
+- You're comfortable with $15/month cost
+
+**Current recommendation**: Start with single container, migrate to microservices when you hit scaling limits.

README.md

@@ -1,12 +1,6 @@
 ---
-title: Seo Workflow
-emoji: 📈
-colorFrom: gray
-colorTo: purple
-sdk: gradio
-sdk_version: 5.39.0
+title: seo_workflow
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 5.37.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api_test_results.json

@@ -0,0 +1,21 @@
+{
+  "gpt-4.1": {
+    "success": true,
+    "content": "Artificial intelligence (AI) is transforming marketing by enabling smarter, data-driven decisions. With AI, marketers can analyze vast amounts of customer data, predict behavior, and personalize content at scale. Chatbots powered by AI provide instant customer support, while algorithms optimize ad placements for higher ROI. AI tools also automate repetitive tasks, freeing up time for creative strategy. Predictive analytics help identify trends and customer preferences, allowing brands to tailor campaigns more effectively. As AI technology evolves, its role in marketing continues to grow, offering businesses a competitive edge through improved targeting, efficiency, and customer engagement. The future of marketing is undeniably AI-driven.",
+    "tokens_used": 144,
+    "model": "gpt-4.1",
+    "response_time": 3.49
+  },
+  "o3": {
+    "success": false,
+    "error": "HTTP 404: {\n    \"error\": {\n        \"message\": \"Your organization must be verified to use the model `o3`. Please go to: https://platform.openai.com/settings/organization/general and click on Verify Organization. If you just verified, it can take up to 15 minutes for access to propagate.\",\n        \"type\": \"invalid_request_error\",\n        \"param\": null,\n        \"code\": \"model_not_found\"\n    }\n}\n",
+    "model": "o3",
+    "response_time": 1.32
+  },
+  "gemini-2.5-pro": {
+    "success": true,
+    "content": "Artificial Intelligence (AI) is revolutionizing marketing, transforming how brands connect with consumers. By analyzing vast datasets, AI uncovers deep insights into customer behavior, enabling hyper-personalized campaigns that resonate on an individual level.\n\nFrom predictive analytics that forecast future trends to AI-powered chatbots offering 24/7 support, the technology automates and optimizes countless tasks. AI tools can draft ad copy, segment audiences with precision, and automate media buying for maximum ROI.\n\nThis shift allows marketers to move beyond guesswork, creating more efficient, data-driven strategies that enhance customer engagement and drive significant growth in a competitive digital landscape.",
+    "model": "gemini-2.5-pro",
+    "response_time": 16.51
+  }
+}

app.py

@@ -0,0 +1,472 @@
+import gradio as gr
+import os
+import requests
+import json
+from dotenv import load_dotenv
+import logging
+from typing import List, Dict, Tuple
+
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Config:
+    """Central configuration for the app"""
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+    ARTICLES_FILE_PATH = "articles.txt"
+    
+    # Model configurations
+    AI_MODELS = {
+        "gpt-4.1": "OpenAI GPT-4.1", 
+        "o3": "OpenAI o3",
+        "gemini-2.5-pro": "Google Gemini 2.5 Pro"
+    }
+    
+    DEFAULT_MODEL = "gpt-4.1"
+    
+class ArticleKnowledgeBase:
+    """Handles loading and managing reference articles"""
+    
+    def __init__(self):
+        self.articles = self._load_articles()
+    
+    def _load_articles(self) -> str:
+        """Load articles from file"""
+        try:
+            with open(Config.ARTICLES_FILE_PATH, 'r', encoding='utf-8') as f:
+                content = f.read().strip()
+                logger.info(f"Loaded {len(content.split())} words from articles.txt")
+                return content
+        except FileNotFoundError:
+            logger.warning(f"Articles file not found at {Config.ARTICLES_FILE_PATH}")
+            return "No reference articles found. Please add articles to articles.txt"
+        except Exception as e:
+            logger.error(f"Error loading articles: {str(e)}")
+            return "Error loading reference articles."
+    
+    def get_context(self) -> str:
+        """Get the articles context for the AI"""
+        return self.articles
+
+class SEOArticleGenerator:
+    """Handles article generation using OpenAI and Gemini models"""
+    
+    def __init__(self):
+        self.openai_api_key = Config.OPENAI_API_KEY
+        self.gemini_api_key = Config.GEMINI_API_KEY
+        self.knowledge_base = ArticleKnowledgeBase()
+    
+    def generate_article(
+        self, 
+        context: str, 
+        keywords: str, 
+        model: str = "gpt-4.1",
+        previous_article: str = None,
+        edit_instructions: str = None
+    ) -> Dict[str, any]:
+        """Generate SEO-optimized article using OpenAI or Gemini models"""
+        
+        # Check API keys based on model
+        if model.startswith("gemini-"):
+            if not self.gemini_api_key:
+                return {
+                    "success": False,
+                    "error": "Gemini API key not found. Please set GEMINI_API_KEY in .env file."
+                }
+        else:
+            if not self.openai_api_key:
+                return {
+                    "success": False,
+                    "error": "OpenAI API key not found. Please set OPENAI_API_KEY in .env file."
+                }
+        
+        # Get reference articles
+        reference_articles = self.knowledge_base.get_context()
+        
+        # Parse keywords
+        keyword_list = [k.strip() for k in keywords.split(',') if k.strip()]
+        
+        # Build the system prompt
+        system_prompt = f"""You are an expert SEO content writer. Create engaging, high-quality articles that naturally incorporate SEO keywords while providing genuine value to readers.
+
+            <reference_articles>
+            {reference_articles}
+            </reference_articles>
+
+            Use the reference articles above to guide your writing style and quality standards. 
+
+            Your goals:
+            - Write naturally and engagingly - let your expertise shine
+            - Incorporate the provided keywords organically (aim for 2-3 keywords minimum)
+            - Create valuable, actionable content that readers will actually want to read
+            - Use proper markdown formatting with clear headings and structure
+            - Target 800-1500 words unless context suggests otherwise
+
+            Trust your instincts as a writer - focus on creating content that both search engines and humans will love."""
+        
+        # Build user prompt based on whether this is an edit or new article
+        if previous_article and edit_instructions:
+            user_prompt = f"""Please edit the following article based on these instructions:
+
+                <editing_instructions>
+                {edit_instructions}
+                </editing_instructions>
+
+                <current_article>
+                {previous_article}
+                </current_article>
+
+                <context>
+                {context}
+                </context>
+
+                <seo_keywords>
+                {', '.join(keyword_list)}
+                </seo_keywords>
+
+                Please provide the edited version of the article, maintaining the SEO keywords and improving based on the editing instructions."""
+        else:
+            user_prompt = f"""Write a comprehensive SEO-optimized article based on the following:
+
+                <context>
+                {context}
+                </context>
+
+                <seo_keywords>
+                {', '.join(keyword_list)}
+                </seo_keywords>
+
+                Remember to:
+                - Incorporate at least 2-3 of the provided keywords naturally
+                - Create an engaging, well-structured article
+                - Use markdown formatting
+                - Aim for 800-1500 words
+                - Make it valuable and informative for readers"""
+        
+        try:
+            if model.startswith("gemini-"):
+                # Use Gemini API
+                response = requests.post(
+                    f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent",
+                    headers={
+                        "Content-Type": "application/json",
+                        "x-goog-api-key": self.gemini_api_key
+                    },
+                    json={
+                        "contents": [{
+                            "parts": [{
+                                "text": f"{system_prompt}\n\n{user_prompt}"
+                            }]
+                        }]
+                    }
+                )
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    article = result['candidates'][0]['content']['parts'][0]['text'].strip()
+                else:
+                    return {
+                        "success": False,
+                        "error": f"Gemini API error: {response.status_code} - {response.text}"
+                    }
+            else:
+                # Use OpenAI API
+                response = requests.post(
+                    "https://api.openai.com/v1/chat/completions",
+                    headers={
+                        "Authorization": f"Bearer {self.openai_api_key}",
+                        "Content-Type": "application/json"
+                    },
+                    json={
+                        "model": model,
+                        "messages": [
+                            {"role": "system", "content": system_prompt},
+                            {"role": "user", "content": user_prompt}
+                        ],
+                        "temperature": 0.7,
+                        "max_tokens": 3000
+                    }
+                )
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    article = result['choices'][0]['message']['content'].strip()
+                else:
+                    return {
+                        "success": False,
+                        "error": f"OpenAI API error: {response.status_code} - {response.text}"
+                    }
+            
+            # Count keyword occurrences
+            keyword_counts = {}
+            for keyword in keyword_list:
+                keyword_counts[keyword] = article.lower().count(keyword.lower())
+            
+            return {
+                "success": True,
+                "article": article,
+                "keyword_counts": keyword_counts,
+                "word_count": len(article.split())
+            }
+                
+        except Exception as e:
+            logger.error(f"Error generating article: {str(e)}")
+            return {
+                "success": False,
+                "error": f"Error generating article: {str(e)}"
+            }
+
+class SEOArticleBot:
+    """Main application class"""
+    
+    def __init__(self):
+        self.generator = SEOArticleGenerator()
+    
+    def generate_article(
+        self,
+        context: str,
+        keywords: str,
+        model: str
+    ) -> Tuple[str, str, str]:
+        """Generate new article"""
+        
+        if not context.strip():
+            return "", "Please provide context for the article", ""
+        
+        if not keywords.strip():
+            return "", "Please provide at least one SEO keyword", ""
+        
+        result = self.generator.generate_article(context, keywords, model)
+        
+        if result["success"]:
+            # Create status message with keyword counts
+            keyword_info = "\n".join([f"- {k}: {v} occurrences" for k, v in result["keyword_counts"].items()])
+            status = f"✅ Article generated successfully!\n\nWord count: {result['word_count']}\n\nKeyword usage:\n{keyword_info}"
+            
+            # Create a preview/info section
+            info = f"**Article Stats:**\n- Words: {result['word_count']}\n- Keywords incorporated: {len([k for k, v in result['keyword_counts'].items() if v > 0])}/{len(result['keyword_counts'])}"
+            
+            return result["article"], status, info
+        else:
+            return "", f"❌ Error: {result['error']}", ""
+    
+    def edit_article(
+        self,
+        current_article: str,
+        context: str,
+        keywords: str,
+        edit_instructions: str,
+        model: str
+    ) -> Tuple[str, str]:
+        """Edit existing article based on instructions"""
+        
+        if not current_article.strip():
+            return current_article, "No article to edit. Please generate an article first."
+        
+        if not edit_instructions.strip():
+            return current_article, "Please provide editing instructions"
+        
+        result = self.generator.generate_article(
+            context, 
+            keywords, 
+            model,
+            previous_article=current_article,
+            edit_instructions=edit_instructions
+        )
+        
+        if result["success"]:
+            keyword_info = "\n".join([f"- {k}: {v} occurrences" for k, v in result["keyword_counts"].items()])
+            status = f"✅ Article edited successfully!\n\nWord count: {result['word_count']}\n\nKeyword usage:\n{keyword_info}"
+            return result["article"], status
+        else:
+            return current_article, f"❌ Error: {result['error']}"
+
+def create_interface():
+    """Create the Gradio interface"""
+    app = SEOArticleBot()
+    
+    with gr.Blocks(title="SEO Article Generator", theme=gr.themes.Default()) as demo:
+        gr.Markdown("""
+        # 📝 SEO Article Generator Bot
+        Generate SEO-optimized articles based on your context and keywords. The bot uses reference articles to match writing style and quality.
+        """)
+        
+        with gr.Row():
+            # Left Column - Inputs
+            with gr.Column(scale=1):
+                gr.Markdown("### 📋 Article Configuration")
+                
+                context_input = gr.Textbox(
+                    label="Article Context",
+                    placeholder="Provide the main topic, key points, and any specific information you want the article to cover...",
+                    lines=10
+                )
+                
+                keywords_input = gr.Textbox(
+                    label="SEO Keywords (comma-separated)",
+                    placeholder="e.g., digital marketing, SEO tips, content strategy, online presence, search rankings",
+                    lines=2
+                )
+                
+                model_dropdown = gr.Dropdown(
+                    choices=list(Config.AI_MODELS.keys()),
+                    value=Config.DEFAULT_MODEL,
+                    label="AI Model"
+                )
+                
+                generate_btn = gr.Button(
+                    "🚀 Generate Article",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                # Status and info section
+                status_output = gr.Textbox(
+                    label="Status",
+                    interactive=False,
+                    lines=6
+                )
+                
+                article_info = gr.Markdown("", visible=True)
+            
+            # Right Column - Article Display and Editing
+            with gr.Column(scale=2):
+                gr.Markdown("### 📄 Generated Article")
+                
+                article_display = gr.Markdown(
+                    value="*Your generated article will appear here...*",
+                    elem_classes=["article-display"]
+                )
+                
+                # Hidden textbox to store the raw article for editing
+                article_storage = gr.Textbox(visible=False)
+                
+                # Editing section
+                with gr.Group():
+                    gr.Markdown("### ✏️ Edit Article")
+                    
+                    edit_instructions = gr.Textbox(
+                        label="Editing Instructions",
+                        placeholder="e.g., Make the introduction more engaging, add more statistics in the second section, expand on the benefits...",
+                        lines=3
+                    )
+                    
+                    edit_btn = gr.Button(
+                        "🔄 Apply Edits",
+                        variant="secondary"
+                    )
+        
+        # Footer with instructions
+        gr.Markdown("""
+        ---
+        **💡 Tips for best results:**
+        - Provide detailed context about your topic and target audience
+        - Include 3-5 relevant SEO keywords (the bot will use at least 2-3)
+        - Use the edit feature to refine specific sections
+        - Reference articles in `articles.txt` are used to match writing style
+        """)
+        
+        # Event handlers
+        def generate_handler(context, keywords, model):
+            article, status, info = app.generate_article(context, keywords, model)
+            if article:
+                return gr.update(value=article), article, status, gr.update(value=info)
+            else:
+                return gr.update(value="*Article generation failed. Check the status message.*"), "", status, gr.update(value="")
+        
+        def edit_handler(current_article, context, keywords, edit_instructions, model):
+            edited_article, status = app.edit_article(
+                current_article, context, keywords, edit_instructions, model
+            )
+            return gr.update(value=edited_article), edited_article, status
+        
+        # Wire up events
+        generate_btn.click(
+            fn=generate_handler,
+            inputs=[context_input, keywords_input, model_dropdown],
+            outputs=[article_display, article_storage, status_output, article_info]
+        )
+        
+        edit_btn.click(
+            fn=edit_handler,
+            inputs=[article_storage, context_input, keywords_input, edit_instructions, model_dropdown],
+            outputs=[article_display, article_storage, status_output]
+        )
+        
+        # Add custom CSS
+        demo.css = """
+        .article-display {
+            max-height: 600px;
+            overflow-y: auto;
+            padding: 20px;
+            border: 1px solid #e5e7eb;
+            border-radius: 8px;
+            background-color: #ffffff;
+            line-height: 1.6;
+        }
+        .article-display h2 {
+            color: #1f2937;
+            margin-top: 24px;
+            margin-bottom: 16px;
+        }
+        .article-display h3 {
+            color: #374151;
+            margin-top: 20px;
+            margin-bottom: 12px;
+        }
+        .article-display p {
+            margin-bottom: 16px;
+            color: #4b5563;
+        }
+        .article-display ul, .article-display ol {
+            margin-bottom: 16px;
+            padding-left: 24px;
+        }
+        .article-display li {
+            margin-bottom: 8px;
+        }
+        """
+    
+    return demo
+
+if __name__ == "__main__":
+    # Check for required files and keys
+    if not os.path.exists(".env"):
+        print("Warning: .env file not found. Please create one with:")
+        print("OPENAI_API_KEY=your_openai_key")
+    
+    if not os.path.exists(Config.ARTICLES_FILE_PATH):
+        print(f"Warning: {Config.ARTICLES_FILE_PATH} not found.")
+        print("Creating a sample articles.txt file...")
+        
+        # Create a sample articles.txt file
+        sample_content = """=== Article 1: The Ultimate Guide to Content Marketing ===
+
+            Content marketing has become the cornerstone of digital marketing strategies...
+
+            [Add your reference articles here]
+
+            === Article 2: SEO Best Practices for 2024 ===
+
+            Search engine optimization continues to evolve...
+
+            [Add more articles as needed]
+            """
+        
+        with open(Config.ARTICLES_FILE_PATH, 'w', encoding='utf-8') as f:
+            f.write(sample_content)
+        
+        print(f"Created {Config.ARTICLES_FILE_PATH}. Please add your reference articles to this file.")
+    
+    # Launch the app
+    demo = create_interface()
+    demo.launch(
+        share=True,
+        debug=True,
+        server_name="0.0.0.0",
+        server_port=7862
+    )

articles.txt

@@ -0,0 +1,304 @@
+## Articel 1
+
+How Video Marketing Increases Sales & Brand Awareness
+Innovating the right marketing tools is crucial for helping brands stand out and get a leg up on their competitors. Video marketing is one of the best tools for captivating an audience. By combining engaging visuals, compelling storytelling, and effective calls to action, video content captures attention and delivers messages in a way that resonates deeply with audiences. No matter the size of your business, video marketing will make a significant difference in reaching your desired target audience, and helping you achieve your business goals.
+The Power of Video Marketing
+“One video has the power to increase your consumer base to unimaginable heights.” - Matt Hamilton, Producer/Videographer at Hoegger Communications. Whether it’s a viral social media post or a carefully crafted commercial that resonates with a large audience, the power of video marketing is stronger now than ever before. Now, we understand that making a viral video or an award-winning commercial is easier said than done, believe us, we’ve earned every one of our 300+ awards through countless hours of brainstorming sessions, late-night drafts, and strategy meetings. Successful video marketing is more than just pressing record on a camera - it requires a well-thought-out strategy.
+But here’s the good news: we’ve got the experience (and the awards) to guide you. Let us share some proven tips to help you kickstart your next video project with confidence:
+
+Team Hoegger’s Video Marketing Strategies
+Implementing the following strategies will ensure that your video marketing efforts deliver measurable results. 
+1.	Understand Your Audience: Knowing your target demographic helps tailor content to their interests and needs. For example, an engaging tutorial might appeal to one group, while a testimonial video could resonate more with another.
+2.	Use Storytelling: Videos that tell a story are more memorable and impactful. Whether it’s showcasing your company’s journey or illustrating a customer success story, storytelling builds an emotional connection.
+3.	Optimize for SEO: Using relevant keywords in your titles and descriptions will allow your videos to be put in front of the right audiences, which will increase your video’s chances of success.
+4.	Leverage Social Media Platforms: Tailor your videos for platforms such as Instagram, YouTube, and TikTok. Short-form videos work well on Instagram Reels and TikTok, while YouTube is ideal for long-form content.
+5.	Add a Clear Call to Action (CTA): End your videos with a strong CTA encouraging viewers to visit your website, make a purchase, or share the video.
+How to Use Video in Digital Marketing
+Integrating video into your digital marketing plan can yield impressive results. Here’s how to make the most of this medium:
+1. Enhancing Social Media Campaigns
+For small local businesses in Wichita Falls and large metropolitan corporations like Dallas / Fort Worth, the rules of social media are the same. Short, engaging videos perform best on TikTok and Instagram, while longer-form videos do better on YouTube. Platforms like Facebook and LinkedIn are perfect for more in-depth content like company introductions or business updates. These strategies become even more effective when paired with professional video advertising services designed to create impactful video campaigns, tailored specifically for engaging local audiences like we do in Wichita Falls.
+2. Boosting Website Engagement
+Including videos on your homepage or landing pages increases dwell time, a key factor in SEO. Explainer videos, customer testimonials, and product demos provide value to visitors and guide them through the buyer’s journey. Research shows that landing pages with videos can boost conversion rates by up to 80%.
+3. Improving Email Marketing
+Embedding videos in email campaigns increases click-through rates by up to 300%. A personalized message or a quick product demonstration video can grab attention and encourage recipients to take action.
+4. Paid Advertising
+Platforms like Google Ads and YouTube offer powerful tools to reach your target audience through video ads. Pair this with precise geo-targeting - especially in areas like Wichita Falls - to ensure your content reaches the right viewers.
+Why Video Builds Brand Awareness
+Videos enable brands to showcase their personality, share authentic stories, and connect with audiences on a personal level, building trust and relatability through genuine communication. Here are some ways they help:
+●     Visual Storytelling: Videos combine visuals, sound, and emotion to create a lasting impression. A compelling brand story can elevate your business above competitors.
+●     Shareability: Videos are highly shareable, especially on social media. When viewers share your content, it extends your reach and exposes your brand to new audiences.
+●     Authority and Credibility: High-quality, informative videos position your brand as an expert in your field. For example, collaborating with a Wichita Falls video content specialist ensures your content meets professional standards and resonates with your audience.
+Local Success: Video Advertising Services in Wichita Falls
+Local businesses in Wichita Falls can significantly benefit from video marketing. Collaborating with local video professionals allows businesses in Wichita Falls to produce authentic, high-quality content that resonates with the community and reflects its unique culture. Whether it’s a promotional video for a new product or a testimonial featuring a satisfied customer, localized video content helps build trust and foster strong relationships within the community. People enjoy seeing updates from local businesses. There is a more personal connection with local consumers when they see a video from a business owner that they have interacted with.
+Measuring the Impact of Video Marketing
+The success of video marketing lies in its measurable impact. Key performance indicators (KPIs) like view counts, click-through rates, and conversions provide valuable insights into the effectiveness of your campaigns. Tools like Google Analytics and social media insights can help track performance and refine strategies for better results.
+Why Invest in Professional Video Production
+Although creating videos in-house is an option for some businesses, professional production elevates the quality and impact of content, ensuring it aligns with strategic goals and audience expectations. Companies specializing in video advertising services in Wichita Falls bring expertise in scripting, filming, and editing, ensuring your videos align with your brand’s vision and goals. Professional production also enhances credibility, leaving a positive impression on viewers.
+ Where to Start?
+If you implement some of these video marketing strategies into your digital campaigns, video marketing can help your business build trust and credibility,  increase brand awareness, and most importantly - generate more sales. You don’t have to spend an arm and a leg to start implementing effective video marketing strategies. Hoegger Communications built a reputation on helping small businesses grow in Wichita Falls - our video content specialists are ready to help your business see the success that can come from a professionally crafted video at a reasonable, and affordable price that makes sense for you! Stop by our office, talk to one of our team members, and let us show you why National and Local brands trust Hoegger Communications to start their video marketing journey. 
+ 
+ 
+
+## Article 2
+
+Do You Need Small Business Video in Wichita Falls?
+Yes. Video is one of the most powerful tools for engaging audiences, building brand recognition, and driving conversions. Video helps grab a potential customer’s attention, it helps build trust and helps develop credibility within the community. Whether it’s showcasing your products or services, telling your brand’s story, or connecting with customers on a personal level, video has the unique ability to convey emotion, authenticity, and value in ways that other mediums can’t. For a small business in Wichita Falls, where the market is limited, video marketing is not a luxury - it’s a necessity.
+H2: Why Video is Essential for Businesses
+Video is the cornerstone of modern marketing, offering businesses a dynamic way to connect with audiences. It combines visuals, sound, and storytelling to create memorable experiences that resonate with viewers. While there are hundreds of reasons why video is important, we’ll focus on three main elements: Brand Awareness, Conversions, and Future of Advertising.
+1. Video Increases Engagement and Brand Awareness
+Consumers are far more likely to engage with video content than with text or static images. Videos capture attention quickly, hold it longer, and leave a lasting impression, making them a powerful tool for building brand recognition. Whether it's a compelling story, a product demonstration, or a behind-the-scenes look at your business, video can connect with audiences on a personal level. Additionally, videos are highly shareable, meaning they can amplify your message as viewers share them across social media platforms, further increasing your reach and solidifying your brand in the minds of potential customers. 
+According to multiple industry studies:
+•	Video posts get 1200% more shares than text and images combined, making it one of the most powerful tools for organic reach. 
+•	Viewers retain 95% of a message when they watch it in a video, compared to just 10% when reading text, reinforcing why video is the preferred content format. 
+•	Video increases website dwell time, which signals quality to search engines, ultimately improving rankings and visibility. 
+2. Video Converts Viewers into Customers
+A well-crafted video does more than just grab attention - it motivates viewers to “take action”. By presenting information in a visually engaging and easily digestible format, video helps potential customers understand the value of your product or service quickly and effectively. Whether it’s a testimonial that builds trust, a product demo that showcases benefits, or a call-to-action that encourages immediate responses, video creates a direct path from interest to decision. With the ability to evoke emotions and address customer pain points, video is a highly effective tool for turning viewers into loyal customers. 
+Here are some stats to consider:
+•	Landing pages with video increase conversions by 80%, making them a must-have for any high-performing website.
+•	72% of customers prefer learning about a product via video instead of text, proving that video is an essential part of the buyer’s journey.
+•	90% of consumers say watching a product video helps them decide whether to buy, highlighting its role in driving purchasing decisions.
+3. Video is the Future of Advertising
+From Google Ads to social media commercials, video ads consistently outperform static content in capturing attention and driving results. As digital platforms increasingly prioritize video in their algorithms, businesses that invest in video advertising are more likely to reach their target audiences and stay ahead of the competition. Video offers a dynamic and engaging way to tell your story, showcase your products, and connect with consumers in real time. With the growing popularity of video-centric platforms like YouTube, TikTok, and Instagram Reels, it's clear that video is not just the present of advertising - it’s the future.
+•	YouTube is the second-largest search engine after Google, demonstrating video’s dominance in the digital landscape.
+•	TikTok and Instagram Reels lead social media engagement, showing that short-form videos are key to capturing audience attention.
+•	Google prioritizes video in search results, boosting SEO performance and driving organic traffic for brands leveraging video marketing.
+H2: Where Businesses Can Use Video Marketing
+Professional video content isn't just for websites - it powers every aspect of digital marketing. Here’s where businesses can leverage video to increase brand visibility, improve ad performance, and drive more sales.
+1. Social Media Platforms
+Video needs to be “native” to the social media platform in which it’s going to be shared. Here are the types of videos you need to make an impact on social media:
+•	Instagram & TikTok: Short-form videos, Reels, and Stories increase organic reach and engagement.
+•	Facebook & LinkedIn: Longer professional videos showcase expertise and company culture.
+•	YouTube: The go-to platform for long-form educational and promotional content.
+2. Google & Social Media Ads
+Paid advertising is dominated by video, delivering better ROI than static photo/text ads. 
+•	Google Video Ads: Google prioritizes video ads, boosting visibility across YouTube and search results.
+•	Facebook & Instagram Ads: Video ads get higher click-through rates (CTR) and lower cost per click (CPC).
+•	TikTok Ads: With 1 billion+ active users, TikTok video ads help businesses connect with younger audiences.
+3. Website & Landing Pages
+Videos increase engagement and help convert website visitors into customers. 
+•	Homepage videos: Instantly showcase your brand story, mission, and offerings. 
+•	Explainer videos: Break down complex products or services into digestible, engaging content. 
+•	Testimonial videos: Build trust and credibility by featuring real customers sharing positive experiences.
+4. Email Marketing & Sales Funnels
+Including a video in an email, boosts click-through rates by 200-300%. 
+•	Product demo videos encourage more conversions.
+•	Behind-the-scenes videos create a personal connection with subscribers.
+5. Traditional Advertising & Live Events
+For brick-and-mortar businesses, video enhances in-person marketing strategies.
+•	TV commercials and digital ads keep your business top-of-mind.
+•	Looped video displays in-store grab customer attention.
+•	Trade show presentations help businesses stand out in competitive environments.
+H2: What Value does a Professional Video Production Bring?
+Planning, Expertise, Quality, and Results.
+Professional video production delivers immense value by creating polished, high-quality videos that establish credibility, build trust, and enhance brand authority. Production companies, like Hoegger Communications here in Wichita Falls, strategically plan videos to achieve specific goals - whether it's answering customer questions, launching a campaign, or targeting a particular audience.
+Well-executed video content also boosts search engine rankings, as Google prioritizes video in search results, driving more organic traffic to your website. Moreover, professional video production ensures a greater return on investment, with businesses using video marketing experiencing 49% faster revenue growth, generating 66% more leads, and helping 90% of marketers attract new business. By partnering with a professional video production company, you can create impactful content that drives measurable growth and delivers long-term results because it’s planned.
+H2: Is DIY Enough?
+Yes, DIY video can be enough for certain projects, especially when resources are limited. However, creating a truly impactful marketing video requires more than just filming - it demands strategic planning, technical expertise, and a polished execution to ensure your message resonates.
+While smartphones and editing tools make video creation accessible, professional video production brings a level of quality that sets your brand apart. Superior lighting, sound, editing, and storytelling ensure your video not only captures attention but leaves a lasting impression.
+Ultimately, while DIY might work in some situations, if you’re going to invest your time and money into producing a video, gambling on the results isn’t ideal. A professional production company helps you stay ahead by crafting a video that maximizes your investment and delivers meaningful, measurable results.
+H2: Hoegger Communications: Your Video Production Partner
+We understand the power of video. Our team of experienced videographers and producers are passionate about crafting compelling video content that helps businesses in Wichita Falls, TX achieve their marketing goals. 
+Matt Hamilton, Producer/Videographer at Hoegger Communication, puts it best: “We approach every project as if it were our first. We maintain a mindset of wanting to exceed the client’s expectations and treat each project as our first. I believe this passion is what distinguishes us from other video production companies and is a significant factor contributing to the growth of our video team.”
+Whether you need:
+•	A corporate video to showcase your company culture
+•	A commercial to promote your latest product or service 
+•	Engaging social media content to connect with your audience
+We've got you covered. We specialize in award-winning professional videography services, offering commercial videography in Wichita Falls to businesses of all sizes. Our work has been recognized with multiple ADDY Awards, a testament to our commitment to creativity, quality, and impactful storytelling in video marketing.
+H2: Ready to Elevate Your Brand with Video? 
+Let’s start with a discovery call to see how our award-winning video production services in Wichita Falls can help you achieve your business goals. Together, we’ll bring your vision to life with high-quality, engaging video content that makes an impact. 
+
+
+## Article 3
+
+5 Ways Your Business Will Benefit From OTT
+There is no denying that streaming services are on the rise. Successful businesses are ceasing the opportunity to use this rise of streaming platforms to help their brand grow to new heights. How are they doing this? Three simple letters. OTT.
+Before we dive into the top 5 ways OTT can skyrocket your business to the top level of marketing, we should probably explain what OTT is.
+What is OTT Advertising?
+OTT stands for "over-the-top." It refers to an advertising method that delivers content over the Internet without the help of traditional cable, satellite, or broadcast TV services.
+Examples of OTT advertising can be seen on Disney+, Max, YouTube, Apple TV, Hulu, Crunchyroll, and any of the other countless streaming platforms we have access to in 2025. These ads include:
+●	Pre-roll ads – Short ads that play before a video and may or may not be skipped.
+
+●	Mid-roll ads – Ads that play in the middle of a video and may or may not be skipped. These are the ads that show up at the worst time in shows and movies. Right when the killer is about to be revealed, you get hit with an ad for the new Doritos Locos Taco from Taco Bell.
+
+●	Post-roll ads – These ads play after a video and may or may not be skipped. An example of these ads can be seen on YouTube. When your video is over, a post-roll ad will typically appear before your next video plays.
+
+●	Bumper ads – Short, unskippable ads that can appear anywhere in a video. These ads appear across multiple digital platforms. Depending on the placement… At Hoegger Communications, we are known for providing the best OTT marketing services in Wichita Falls. We produce one-of-a-kind video content for our clients’ digital advertising campaigns. If you want to climb the marketing ladder, give us a call today!...these ads can catch the attention of your audience and produce great results.
+
+●	Sponsored ads – Ads where businesses pay to have their video shown. These videos are typically not skippable.
+Now that we have gone over what OTT is and some examples of these types of ads, let’s talk about how implementing OTT can help your business succeed.
+What Can OTT Do for Your Business?
+Businesses can see drastic increases in their sales and brand popularity with OTT. There are countless benefits to using OTT properly. The top five benefits your business can experience include:
+1.	Increased brand awareness – OTT has been shown to increase ad recall from consumers by 11.5 percent and brand message association by 4.3 percent. Getting the right video in front of your target audience at the right time yields higher attention rates, ultimately leading to more sales for your business.
+
+2.	Targeted advertising – Your business can ensure the right demographic is viewing your ads. Age, gender, location, and many other key demographics can be targeted in your OTT messages.
+
+3.	Cost-effective – How much your business will spend on OTT depends on a few factors, such as the popularity of the platform you want to run your ads on and whether you want prime-time spots. However, the overall cost per thousand views (CPM) is significantly lower than a commercial spot and other forms of advertising.
+
+4.	Measurable results in real-time – We know you want the most accurate data possible when running ads and campaigns. With OTT, consumer interactions are updated in real time, allowing your business to have the most accurate information on the performance of your ads.
+
+5.	Increased engagement – Using targeted demographics, you can make your ads more personal to viewers, leading to a higher chance of conversion. OTT ads can go out on multiple devices, such as smartphones, computers, laptops, and smart TVs—essentially devices that almost everyone has access to. This will increase the reach of your ads, which will produce more leads.
+Affordable OTT Streaming Services for Small Business Advertising
+●	Tubi (Owned by Fox)
+○	Ad Formats: Pre-roll, mid-roll, and post-roll video ads.
+○	Targeting: Demographics, interests, and device targeting.
+○	Audience: 74+ million monthly active users.
+○	Why It’s Affordable: 100% free, ad-supported, and lower CPMs compared to premium platforms.
+○	Best For: Small businesses, local advertisers, and brands looking for broad reach.
+
+●	Pluto TV (Owned by Paramount)
+○	Ad Formats: Video ads (15-30 seconds), branded content integrations.
+○	Targeting: Demographics, behavioral, geographic, and contextual targeting.
+○	Audience: 80+ million active users per month.
+○	Why It’s Affordable: Free, ad-supported model with lower ad rates than subscription-based platforms.
+○	Best For: Brands looking for exposure on a variety of niche channels.
+
+●	Crackle (Owned by Chicken Soup for the Soul Entertainment)
+○	Ad Formats: Pre-roll, mid-roll video ads, and sponsorships.
+○	Targeting: Audience demographics, geographic location, and behavioral insights.
+○	Audience: 40+ million active users.
+○	Why It’s Affordable: Lower competition and cost-effective CPMs.
+○	Best For: Niche brands and businesses looking to target entertainment-based audiences.
+
+●	Xumo (Owned by Comcast)
+○	Ad Formats: 15-30 second video ads, channel sponsorships.
+○	Targeting: Programmatic and demographic targeting.
+○	Audience: 10+ million monthly users.
+○	Why It’s Affordable: No subscription fees, making it an attractive option for cost-conscious advertisers.
+○	Best For: Local businesses, startups, and brands focused on news, sports, and lifestyle audiences.
+
+●	Peacock (Free Tier) (Owned by NBCUniversal)
+○	Ad Formats: Traditional video ads, interactive ads, and sponsorships.
+○	Targeting: Interest-based, location-based, and behavioral targeting.
+○	Audience: 30+ million monthly active users on the free tier.
+○	Why It’s Affordable: The free version of Peacock allows businesses to advertise without the high costs of premium networks.
+○	Best For: Businesses looking for a mix of premium content exposure and affordability.
+○	
+Top Overall OTT Streaming Platforms for Business Advertising
+1.	Hulu (Owned by Disney)
+○	Ad Formats: Video ads (15-30 sec), interactive ads, binge ads, pause ads.
+○	Targeting: Advanced options including demographics, interests, viewing behavior, and even household income.
+○	Audience: 48+ million subscribers.
+○	Why It’s Great: Hulu has a premium, engaged audience, making it highly effective for brand recall and conversions.
+○	Best For: Mid-to-large businesses looking for premium ad inventory and targeted reach.
+
+2.	YouTube TV (Owned by Google)
+○	Ad Formats: Skippable and non-skippable video ads, bumper ads, and display ads.
+○	Targeting: Google’s advanced audience data, including search and YouTube behavior.
+○	Audience: 8+ million subscribers, but access to YouTube’s 2+ billion users.
+○	Why It’s Great: Cross-platform targeting and integration with Google Ads make YouTube TV highly efficient.
+○	Best For: Businesses with strong video ad creatives looking for measurable results.
+
+3.	Roku (Owned by Roku, Inc.)
+○	Ad Formats: Video ads, home screen takeovers, sponsored content.
+○	Targeting: Demographics, interests, location, and Roku’s proprietary data.
+○	Audience: 70+ million active users.
+○	Why It’s Great: Roku’s data-driven targeting and high engagement rates make it a top choice.
+○	Best For: Brands looking to target cord-cutters and digital-first audiences.
+
+4.	Amazon Freevee (Owned by Amazon)
+○	Ad Formats: Pre-roll, mid-roll video ads, interactive ads, custom sponsorships.
+○	Targeting: Amazon’s powerful customer data, shopping habits, and demographics.
+○	Audience: 50+ million monthly users.
+○	Why It’s Great: Access to Amazon’s ecosystem allows for precise targeting and retargeting.
+○	Best For: E-commerce brands, tech companies, and businesses looking to leverage Amazon’s insights.
+
+5.	Paramount+ (Owned by Paramount Global)
+○	Ad Formats: 15-30 sec video ads, interactive ads, sponsorships.
+○	Targeting: Demographics, interests, geo-targeting, and behavioral tracking.
+○	Audience: 60+ million subscribers (including the ad-supported tier).
+○	Why It’s Great: Premium content with extensive targeting capabilities.
+○	Best For: Businesses looking to advertise alongside popular shows and live sports events.
+
+Key Takeaways for OTT Advertising
+Streaming is an ever-growing advertising medium, and it would be wise for you to take steps toward getting your business’s ads displayed on these platforms as soon as possible. With countless streaming sites, there are a variety of options to choose from when deciding which platform will align with your marketing goals the best.
+If you are looking for cost-effective OTT advertising, Tubi, Pluto TV, Crackle, Xumo, and Peacock Free offer affordable ad placements with broad audience reach. If targeting a premium audience with advanced ad options is your priority, platforms like Hulu, YouTube TV, Roku, Amazon Freevee, and Paramount+ provide strong engagement and measurable results.
+OTT ads allow you to get your videos in front of the right audience for an affordable price. Take your business and advertising to the next level by taking advantage of all that OTT has to offer.
+Ready to get Started?
+If you don’t know where to start, don’t worry—Team Hoegger is here to help! Give us a call to set up a free consultation, and we will provide a detailed marketing plan that will lay out the best OTT strategies for your business!
+
+
+## Article 4
+
+The Top 5 Types of Videos Every Business Should Have
+
+Think of the most memorable advertisements you’ve seen. Chances are you’re thinking of a commercial you couldn’t get out of your head, and maybe a famous video from years or even decades ago. Video marketing captures attention and captivates your audience, fostering deeper engagement and building lasting connections.
+
+At Hoegger Communications, we understand that entering the business video production arena can have its own challenges. Luckily, you’ve found the right group to make this daunting process fun and stress-free. As a video production company located in Wichita Falls, Texas, we’ve won more than 300 awards for our video work. We’ve mastered the art of combining compelling storytelling and stunning visuals. Explore how video marketing can propel your business forward with confidence, and create a lasting impact on the future of your business.
+
+In this blog post, we’ll explore the five best types of video for marketing that your business needs to enhance brand recognition, engage your target audience, and drive traffic to the right places.
+
+1.	Explainer Videos
+
+An explainer video simplifies more complex concepts and presents them in a user-friendly format. This powerful tool can help your potential customers gain a better understanding of your products or services. The best part? It’s entertaining and educational at the same time.
+
+Examples and Use Cases:
+●	Whiteboard animation: This is the most well-known format of explainer video, and can be used to keep the viewer engaged and focused on the message itself.
+●	Product demonstration: Features real people explaining the concept. This format adds a personal touch and builds trust with new customers and potential customers. 
+●	Character animation: Uses animated characters to tell a story and explain the product or service. For complex or abstract ideas, this format can be more engaging and memorable for the viewer.
+
+Key Benefits:
+●	Increased Engagement and Attention: Videos are inherently more engaging than text. They capture attention and hold it longer, especially with compelling visuals.
+●	Improved Understanding and Retention: They break down complex topics into simple, understandable concepts, improving comprehension.
+●	Enhanced Brand Awareness: Engaging videos are more likely to be shared on social media, expanding your reach and brand visibility.
+
+2.	Customer Testimonial Videos
+
+Social proof is a powerful tool in business video production, and customer testimonials are one of the best ways to build trust and credibility. Featuring real customers while sharing their positive experiences with your product or service can make a massive impact on potential customers.
+
+Examples and Use Cases:
+●	Direct-to-Camera Testimonial: A customer speaks directly to the camera about their experience. This is the most common and straightforward format, creating a personal connection with the viewer.
+●	Short-Form Testimonial (Social Media): Bite-sized testimonials designed for social media platforms. These are typically under a minute long and focus on a key takeaway or positive experience.
+●	Before And After Testimonial: The customer shares their "before" situation (the problem they faced) and their "after" situation (how your product/service helped them). This format clearly demonstrates the value and impact of your offering.
+
+Key Benefits:
+●	Build Trust and Credibility: Potential customers are likely to believe other customers when discussing their positive experiences.
+●	Humanizing Your Brand: Testimonials put a human face on your brand, making it more relatable and approachable. They allow potential customers to connect with real people who have benefited from your products or services.
+●	Authenticity: Raw, unscripted testimonials feel incredibly authentic and genuine, which resonates with viewers.
+
+3.	Promotional Videos
+
+Looking to generate excitement for a new product, service, promotion, or event? Promotional videos drive immediate action and create the buzz you need for a successful launch.
+
+Examples and Use Cases:
+●	Product Launches: Generate hype and anticipation for a new product by showcasing its features and benefits. These can range from short, attention-grabbing teasers to more in-depth demonstrations.
+●	Seasonal Promotions: Promote special offers, discounts, and sales during holidays or specific times of the year.
+●	Event Promotions: Promote upcoming events, such as grand openings, anniversary celebrations, workshops, or webinars. These videos can highlight speakers, showcase the venue, and generate excitement for attending.
+
+Key Benefits:
+●	Generate Excitement and Hype: Promotional videos are designed to create buzz and anticipation for your offering.
+●	Drive Immediate Action: They often include clear calls to action, encouraging viewers to take advantage of a limited-time offer, register for an event, or make a purchase.
+●	Enhance Brand Image: High-quality promotional videos can enhance your brand image and position you as a leader in your industry.
+
+4.	Social Media Videos
+
+Social media videos are short, engaging videos designed specifically for social media platforms. They're crucial for capturing attention in fast-paced feeds, building community, and driving traffic where you need it most.
+
+Examples and Use Cases:
+●	Behind-the-Scenes: Offer followers a glimpse into your company culture, daily operations, or the making of your products. This humanizes your brand and fosters connection.
+●	Product Demos (Short & Sweet): Quick, snappy demonstrations of your product or service’s key features and benefits. Focus on solving a specific problem or showcasing a unique selling point.
+●	Live Streams: Engage with your audience in real-time through Q&As, product launches, or behind-the-scenes glimpses. Live streams foster a sense of community and immediacy.
+
+●	Key Benefits:
+●	Increased Engagement and Reach: Social media videos are highly shareable, leading to increased reach and engagement with your target audience.
+●	Improved Brand Awareness: Consistent video content helps build brand recognition and strengthens your brand's presence on social media.
+●	Stronger Community Building: Engage with your audience through comments, shares, and live streams, fostering a sense of community around your brand.
+
+5.	Corporate Videos
+
+Corporate videos are professional videos produced for a variety of internal and external communication purposes. They aim to communicate a company's message, values, and story in a compelling and engaging way.  Unlike promotional videos, which often focus on sales and marketing, corporate videos have a broader range of objectives.
+
+Examples and Use Cases:
+●	Company Overview/About Us: Introduce your company, its mission, history, values, and culture. These videos are often used on your website’s “About Us” page, and for onboarding new employees.
+●	Recruitment Videos: Attract top talent by showcasing your company culture, employee benefits, and career opportunities. These videos can be used on job boards and company websites.
+●	Brand Storytelling: Tell the story of your brand, its origins, and its vision for the future. These videos connect with audiences on an emotional level and build brand loyalty.
+
+
+Key Benefits:
+●	Enhanced Communication: Videos are a more engaging and effective way to communicate complex information compared to text or presentations.
+●	Stronger Brand Identity: Corporate videos help define and communicate your brand's identity, values, and culture.
+●	Improved Employee Engagement: Video training and internal communications can boost employee engagement and knowledge retention.
+
+
+Create Impactful Video Content With Hoegger Communications
+
+When you’re looking to transform your business with video production, we have the experience (and the awards) to help. Our team is dedicated to you and invested in your success. Let’s explore the best types of video for marketing together - it doesn’t cost anything to set up a meeting with our energetic team!

test_apis.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+API Testing Script for SEO Article Generator
+Tests OpenAI and Gemini API endpoints without deploying the full app
+"""
+
+import os
+import requests
+import json
+from dotenv import load_dotenv
+import time
+from typing import Dict, Any
+
+# Load environment variables
+load_dotenv()
+
+class APITester:
+    def __init__(self):
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        self.gemini_api_key = os.getenv("GEMINI_API_KEY")
+        
+        # Test prompt
+        self.test_prompt = "Write a short 100-word article about AI in marketing."
+        
+        # Models to test
+        self.models = {
+            "gpt-4.1": "openai",
+            "o3": "openai", 
+            "gemini-2.5-pro": "gemini"
+        }
+    
+    def test_openai_api(self, model: str) -> Dict[str, Any]:
+        """Test OpenAI API endpoint"""
+        print(f"\n🔄 Testing OpenAI model: {model}")
+        
+        if not self.openai_api_key:
+            return {"success": False, "error": "OpenAI API key not found"}
+        
+        try:
+            response = requests.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.openai_api_key}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "model": model,
+                    "messages": [
+                        {"role": "user", "content": self.test_prompt}
+                    ],
+                    "temperature": 0.7,
+                    "max_tokens": 200
+                },
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                content = result['choices'][0]['message']['content'].strip()
+                return {
+                    "success": True,
+                    "content": content,
+                    "tokens_used": result.get('usage', {}).get('total_tokens', 'N/A'),
+                    "model": model
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"HTTP {response.status_code}: {response.text}",
+                    "model": model
+                }
+                
+        except requests.exceptions.Timeout:
+            return {"success": False, "error": "Request timeout (30s)", "model": model}
+        except Exception as e:
+            return {"success": False, "error": str(e), "model": model}
+    
+    def test_gemini_api(self, model: str) -> Dict[str, Any]:
+        """Test Gemini API endpoint"""
+        print(f"\n🔄 Testing Gemini model: {model}")
+        
+        if not self.gemini_api_key:
+            return {"success": False, "error": "Gemini API key not found"}
+        
+        try:
+            response = requests.post(
+                f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent",
+                headers={
+                    "Content-Type": "application/json",
+                    "x-goog-api-key": self.gemini_api_key
+                },
+                json={
+                    "contents": [{
+                        "parts": [{
+                            "text": self.test_prompt
+                        }]
+                    }]
+                },
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                content = result['candidates'][0]['content']['parts'][0]['text'].strip()
+                return {
+                    "success": True,
+                    "content": content,
+                    "model": model
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"HTTP {response.status_code}: {response.text}",
+                    "model": model
+                }
+                
+        except requests.exceptions.Timeout:
+            return {"success": False, "error": "Request timeout (30s)", "model": model}
+        except Exception as e:
+            return {"success": False, "error": str(e), "model": model}
+    
+    def test_all_models(self):
+        """Test all models and provide comprehensive report"""
+        print("🚀 Starting API Testing for SEO Article Generator")
+        print("=" * 60)
+        
+        results = {}
+        
+        for model, provider in self.models.items():
+            start_time = time.time()
+            
+            if provider == "openai":
+                result = self.test_openai_api(model)
+            elif provider == "gemini":
+                result = self.test_gemini_api(model)
+            
+            end_time = time.time()
+            result["response_time"] = round(end_time - start_time, 2)
+            results[model] = result
+            
+            # Print immediate result
+            if result["success"]:
+                print(f"✅ {model}: SUCCESS ({result['response_time']}s)")
+                print(f"   Content preview: {result['content'][:100]}...")
+                if 'tokens_used' in result:
+                    print(f"   Tokens used: {result['tokens_used']}")
+            else:
+                print(f"❌ {model}: FAILED ({result['response_time']}s)")
+                print(f"   Error: {result['error']}")
+        
+        # Summary report
+        print("\n" + "=" * 60)
+        print("📊 TESTING SUMMARY")
+        print("=" * 60)
+        
+        successful = [m for m, r in results.items() if r["success"]]
+        failed = [m for m, r in results.items() if not r["success"]]
+        
+        print(f"✅ Successful: {len(successful)}/{len(self.models)} models")
+        print(f"❌ Failed: {len(failed)}/{len(self.models)} models")
+        
+        if successful:
+            print(f"\n🎉 Working models: {', '.join(successful)}")
+            avg_time = sum(results[m]["response_time"] for m in successful) / len(successful)
+            print(f"⚡ Average response time: {avg_time:.2f}s")
+        
+        if failed:
+            print(f"\n⚠️ Failed models: {', '.join(failed)}")
+            print("\nError details:")
+            for model in failed:
+                print(f"  • {model}: {results[model]['error']}")
+        
+        return results
+
+def main():
+    """Main testing function"""
+    tester = APITester()
+    results = tester.test_all_models()
+    
+    # Save results to file for later reference
+    with open("api_test_results.json", "w") as f:
+        json.dump(results, f, indent=2)
+    
+    print(f"\n💾 Detailed results saved to: api_test_results.json")
+
+if __name__ == "__main__":
+    main()