feat: Add multi-platform social media analysis with 7 platform-specific endpoints

- Add 7 new platform analyzers: YouTube, Instagram, LinkedIn, Facebook, X/Twitter, TikTok, Pinterest
- Create shared model loader with .env configurable MODEL_ID (0.5B/1.5B/7B)
- Refactor services with shared JSON repair and validation utilities
- Update schemas with 7 platform-specific Pydantic response models
- Add temperature tuning per platform (precise 0.3 to creative 0.45)
- Implement professional error handling with safe_analyze wrapper
- Add .env.example for model configuration documentation
- Keep backward-compatible original /analyze-seo route

.env.example

@@ -0,0 +1,6 @@
+# AI Model Configuration
+# Options:
+#   Qwen/Qwen2.5-0.5B-Instruct   (Nano - ~1GB, fastest, CPU-friendly)
+#   Qwen/Qwen2.5-1.5B-Instruct   (Goldilocks - ~3GB, recommended for GPU)
+#   Qwen/Qwen2.5-7B-Instruct     (Smartest - needs 4-bit quantization + GPU)
+MODEL_ID=Qwen/Qwen2.5-0.5B-Instruct

.gitignore

@@ -3,3 +3,5 @@ __pycache__/
 .env
 venv/
 .DS_Store
+*.safetensors
+*.bin

main.py

@@ -1,38 +1,115 @@
 from fastapi import FastAPI, HTTPException
-from models.schemas import SEORequest, SEOResponse
+from models.schemas import (
+    SEORequest, SEOResponse,
+    YouTubeResponse, InstagramResponse, LinkedInResponse,
+    FacebookResponse, TwitterResponse, TikTokResponse, PinterestResponse
+)
 from services.analyzer import analyze_seo_content
+from services.youtube_analyzer import analyze_youtube
+from services.instagram_analyzer import analyze_instagram
+from services.linkedin_analyzer import analyze_linkedin
+from services.facebook_analyzer import analyze_facebook
+from services.twitter_analyzer import analyze_twitter
+from services.tiktok_analyzer import analyze_tiktok
+from services.pinterest_analyzer import analyze_pinterest
 import uvicorn
-import os
+import traceback
 
 app = FastAPI(
-    title="SEO Keyword Analyzer API",
-    description="Professional SEO Analysis using Generative AI",
-    version="1.0.0"
+    title="Social Media SEO Analyzer API",
+    description="Professional social media content analysis using Generative AI. Covers YouTube, Instagram, LinkedIn, Facebook, X/Twitter, TikTok, and Pinterest.",
+    version="2.0.0"
 )
 
-@app.get("/")
-def read_root():
-    return {"status": "active", "service": "SEO Analyzer API"}
+ERROR_MASK = "An internal error occurred. Please try again later."
 
-@app.post("/analyze-seo", response_model=SEOResponse)
-def analyze_seo(request: SEORequest):
-    """
-    Analyzes the provided content and returns a detailed SEO strategy.
-    """
+def safe_analyze(analyze_fn, content: str):
     try:
-        print(f"📥 Received request: {request.content[:50]}...")
-        result = analyze_seo_content(request.content)
-        
-        if "error" in result and result["error"]:
-            print(f"❌ Logic Error: {result['error']}")
+        result = analyze_fn(content)
+        if isinstance(result, dict) and result.get("error"):
             raise HTTPException(status_code=500, detail=str(result["error"]))
-            
         return result
+    except HTTPException:
+        raise
     except Exception as e:
-        import traceback
-        error_msg = f"CRITICAL SERVER ERROR: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        raise HTTPException(status_code=500, detail=error_msg)
+        print(f"CRITICAL SERVER ERROR: {e}\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=ERROR_MASK)
+
+# ---------------------------------------------------------------------------
+# Root
+# ---------------------------------------------------------------------------
+
+@app.get("/")
+def read_root():
+    return {"status": "active", "service": "Social Media SEO Analyzer API", "version": "2.0.0"}
+
+# ---------------------------------------------------------------------------
+# Generic SEO
+# ---------------------------------------------------------------------------
+
+@app.post("/analyze-seo", response_model=SEOResponse)
+def analyze_seo(request: SEORequest):
+    return safe_analyze(analyze_seo_content, request.content)
+
+# ---------------------------------------------------------------------------
+# YouTube
+# ---------------------------------------------------------------------------
+
+@app.post("/analyze/youtube", response_model=YouTubeResponse)
+def analyze_youtube_route(request: SEORequest):
+    return safe_analyze(analyze_youtube, request.content)
+
+# ---------------------------------------------------------------------------
+# Instagram
+# ---------------------------------------------------------------------------
+
+@app.post("/analyze/instagram", response_model=InstagramResponse)
+def analyze_instagram_route(request: SEORequest):
+    return safe_analyze(analyze_instagram, request.content)
+
+# ---------------------------------------------------------------------------
+# LinkedIn
+# ---------------------------------------------------------------------------
+
+@app.post("/analyze/linkedin", response_model=LinkedInResponse)
+def analyze_linkedin_route(request: SEORequest):
+    return safe_analyze(analyze_linkedin, request.content)
+
+# ---------------------------------------------------------------------------
+# Facebook
+# ---------------------------------------------------------------------------
+
+@app.post("/analyze/facebook", response_model=FacebookResponse)
+def analyze_facebook_route(request: SEORequest):
+    return safe_analyze(analyze_facebook, request.content)
+
+# ---------------------------------------------------------------------------
+# X / Twitter
+# ---------------------------------------------------------------------------
+
+@app.post("/analyze/twitter", response_model=TwitterResponse)
+def analyze_twitter_route(request: SEORequest):
+    return safe_analyze(analyze_twitter, request.content)
+
+# ---------------------------------------------------------------------------
+# TikTok
+# ---------------------------------------------------------------------------
+
+@app.post("/analyze/tiktok", response_model=TikTokResponse)
+def analyze_tiktok_route(request: SEORequest):
+    return safe_analyze(analyze_tiktok, request.content)
+
+# ---------------------------------------------------------------------------
+# Pinterest
+# ---------------------------------------------------------------------------
+
+@app.post("/analyze/pinterest", response_model=PinterestResponse)
+def analyze_pinterest_route(request: SEORequest):
+    return safe_analyze(analyze_pinterest, request.content)
+
+# ---------------------------------------------------------------------------
+# Entrypoint
+# ---------------------------------------------------------------------------
 
 if __name__ == "__main__":
     uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

models/schemas.py

@@ -1,6 +1,10 @@
 from pydantic import BaseModel
 from typing import List, Optional
 
+# ---------------------------------------------------------------------------
+# Existing generic SEO
+# ---------------------------------------------------------------------------
+
 class KeywordData(BaseModel):
     keyword: str
     search_volume: str
@@ -22,3 +26,132 @@ class SEOResponse(BaseModel):
     content_titles: List[str]
     target_audience: str
     error: Optional[str] = None
+
+# ---------------------------------------------------------------------------
+# YouTube
+# ---------------------------------------------------------------------------
+
+class VideoTitle(BaseModel):
+    title: str
+    expected_ctr: str
+
+class YouTubeResponse(BaseModel):
+    video_titles: List[VideoTitle]
+    tags: List[str]
+    description_template: str
+    thumbnail_ideas: List[str]
+    best_posting_time: str
+    engagement_strategies: List[str]
+    competition_gap_analysis: str
+    error: Optional[str] = None
+
+# ---------------------------------------------------------------------------
+# Instagram
+# ---------------------------------------------------------------------------
+
+class CaptionData(BaseModel):
+    caption: str
+    tone: str
+
+class HashtagSets(BaseModel):
+    small: List[str]
+    medium: List[str]
+    large: List[str]
+
+class ContentIdeas(BaseModel):
+    reels: List[str]
+    carousels: List[str]
+    stories: List[str]
+
+class InstagramResponse(BaseModel):
+    captions: List[CaptionData]
+    hashtag_sets: HashtagSets
+    content_ideas: ContentIdeas
+    best_posting_time: str
+    growth_strategies: List[str]
+    error: Optional[str] = None
+
+# ---------------------------------------------------------------------------
+# LinkedIn
+# ---------------------------------------------------------------------------
+
+class PostDraft(BaseModel):
+    headline: str
+    body: str
+    hook: str
+
+class LinkedInResponse(BaseModel):
+    post_drafts: List[PostDraft]
+    hashtags: List[str]
+    article_topics: List[str]
+    thought_leadership_angles: List[str]
+    best_posting_time: str
+    industry_insights: str
+    error: Optional[str] = None
+
+# ---------------------------------------------------------------------------
+# Facebook
+# ---------------------------------------------------------------------------
+
+class PostIdea(BaseModel):
+    type: str
+    content: str
+
+class FacebookResponse(BaseModel):
+    post_ideas: List[PostIdea]
+    engagement_hooks: List[str]
+    hashtags: List[str]
+    ad_copy_suggestions: List[str]
+    best_posting_time: str
+    page_growth_tips: List[str]
+    error: Optional[str] = None
+
+# ---------------------------------------------------------------------------
+# X / Twitter
+# ---------------------------------------------------------------------------
+
+class TweetThread(BaseModel):
+    tweets: List[str]
+    theme: str
+
+class TwitterResponse(BaseModel):
+    tweet_threads: List[TweetThread]
+    viral_hooks: List[str]
+    hashtags: List[str]
+    best_posting_time: str
+    engagement_tactics: List[str]
+    error: Optional[str] = None
+
+# ---------------------------------------------------------------------------
+# TikTok
+# ---------------------------------------------------------------------------
+
+class VideoConcept(BaseModel):
+    hook: str
+    script_snippet: str
+    sound_suggestion: str
+
+class TikTokResponse(BaseModel):
+    video_concepts: List[VideoConcept]
+    trending_angles: List[str]
+    hashtags: List[str]
+    best_posting_time: str
+    viral_strategies: List[str]
+    error: Optional[str] = None
+
+# ---------------------------------------------------------------------------
+# Pinterest
+# ---------------------------------------------------------------------------
+
+class PinIdea(BaseModel):
+    title: str
+    description: str
+    keyword_focus: str
+
+class PinterestResponse(BaseModel):
+    pin_ideas: List[PinIdea]
+    board_organization: List[str]
+    seo_keywords: List[str]
+    best_posting_time: str
+    traffic_strategies: List[str]
+    error: Optional[str] = None

services/analyzer.py

@@ -1,160 +1,49 @@
-import os
-import json
-import torch
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
-from dotenv import load_dotenv
-from pathlib import Path
-
-# Load environment variables
-env_path = Path(__file__).resolve().parent.parent.parent / ".env"
-load_dotenv(dotenv_path=env_path)
-
-# Configuration: Run Locally to bypass all API limits/errors
-# Qwen-0.5B is the "Nano" model - Ultra Fast, designed for Mobile/Limitless CPU use.
-MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
-
-print(f"⏳ Loading Local Model {MODEL_ID}... (This happens once)")
-try:
-    # Initialize Local Pipeline
-    # optimization: torch_dtype=torch.float16 reduces RAM usage significantly
-    # device_map="auto" uses CPU or GPU if available
-    pipe = pipeline(
-        "text-generation",
-        model=MODEL_ID,
-        torch_dtype=torch.bfloat16, # Efficient for CPU
-        device_map="auto",
-        trust_remote_code=True
-    )
-    print("✅ Model Loaded Successfully!")
-except Exception as e:
-    print(f"❌ Model Load Failed: {e}")
-    pipe = None
-
-def clean_json_string(text: str) -> str:
-    """Helper to extract JSON from markdown or raw text."""
-    if "```json" in text:
-        text = text.split("```json")[1].split("```")[0]
-    elif "```" in text:
-        text = text.split("```")[1].split("```")[0]
-    return text.strip()
-
-def repair_json(json_str: str) -> str:
-    """Attempt to repair truncated JSON by closing open brackets/braces."""
-    json_str = json_str.strip()
-    
-    # Remove potentially invalid trailing content that isn't a closer
-    # (e.g. if it ends with "keyword": "val", -> we need to remove comma)
-    json_str = json_str.rstrip(", ")
-
-    # Balance brackets
-    open_braces = json_str.count("{")
-    close_braces = json_str.count("}")
-    open_brackets = json_str.count("[")
-    close_brackets = json_str.count("]")
-
-    if open_braces > close_braces:
-        json_str += "}" * (open_braces - close_braces)
-    
-    if open_brackets > close_brackets:
-        json_str += "]" * (open_brackets - close_brackets)
-            
-    return json_str
-
-def validate_and_fill_data(data: dict) -> dict:
-    """Ensure all required fields exist in the response."""
-    defaults = {
-        "core_keywords": [],
-        "related_phrases": [],
-        "viral_hashtags": [],
-        "content_titles": ["Content Strategy Guide", "SEO Optimization Tips", "Viral Content Ideas"], # Fallbacks
-        "strategy_tips": ["Focus on user intent.", "Optimize for long-tail keywords.", "Improve meta tags."], # Fallbacks
-        "target_audience": "General Audience interested in this topic."
-    }
-    
-    for key, default_val in defaults.items():
-        if key not in data or data[key] is None:
-            data[key] = default_val
-            
-    return data
+from services.utils import run_analysis, validate_and_fill_data_defaults
+
+SYSTEM_PROMPT = """You are a World-Class SEO Strategist. Return ONLY valid JSON.
+RULES:
+1. Estimate 'search_volume' (High/Medium/Low).
+2. 'competition' (Hard/Medium/Easy).
+3. 'relevance' (0-100)."""
+
+DEFAULTS = {
+    "core_keywords": [],
+    "related_phrases": [],
+    "viral_hashtags": [],
+    "content_titles": ["Content Strategy Guide", "SEO Optimization Tips", "Viral Content Ideas"],
+    "strategy_tips": ["Focus on user intent.", "Optimize for long-tail keywords.", "Improve meta tags."],
+    "target_audience": "General Audience interested in this topic."
+}
 
 def analyze_seo_content(content: str) -> dict:
-    """
-    Analyzes content using LOCAL Qwen-0.5B.
-    """
-    if pipe is None:
-        return {"error": "Model failed to load on server startup. Check logs."}
-
-    print(f"🧠 Running Local Inference on: {content[:50]}...")
-    
-    # Qwen Chat Template
     messages = [
-        {
-            "role": "system", 
-            "content": """You are a World-Class SEO Strategist. Return ONLY valid JSON.
-            RULES:
-            1. Estimate 'search_volume' (High/Medium/Low).
-            2. 'competition' (Hard/Medium/Easy).
-            3. 'relevance' (0-100)."""
-        },
-        {
-            "role": "user", 
-            "content": f"""Analyze topic: "{content[:2000]}"
-            
-            REQUIREMENTS:
-            - **Core Keywords**: 30 high-value keywords.
-            - **Related Phrases**: 10 variations.
-            - **Viral Hashtags**: 8 tags.
-            - **Content Titles**: 3 titles.
-            - **Strategy Tips**: 3 tips.
-            - **Target Audience**: Profile.
-            
-            JSON OUTPUT STRUCTURE:
-            {{
-                "core_keywords": [
-                    {{"keyword": "...", "search_volume": "...", "competition": "...", "relevance": 90}}, ... (Total 30 items)
-                ],
-                "related_phrases": ["..."],
-                "viral_hashtags": [{{"tag": "#...", "post_count": "..."}}],
-                "content_titles": ["..."],
-                "strategy_tips": ["..."],
-                "target_audience": "..."
-            }}
-            """
-        }
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"""Analyze topic: "{content[:2000]}"
+
+REQUIREMENTS:
+- **Core Keywords**: 30 high-value keywords.
+- **Related Phrases**: 10 variations.
+- **Viral Hashtags**: 8 tags.
+- **Content Titles**: 3 titles.
+- **Strategy Tips**: 3 tips.
+- **Target Audience**: Profile.
+
+JSON OUTPUT STRUCTURE:
+{{
+    "core_keywords": [
+        {{"keyword": "...", "search_volume": "...", "competition": "...", "relevance": 90}}, ... (Total 30 items)
+    ],
+    "related_phrases": ["..."],
+    "viral_hashtags": [{{"tag": "#...", "post_count": "..."}}],
+    "content_titles": ["..."],
+    "strategy_tips": ["..."],
+    "target_audience": "..."
+}}"""}
     ]
 
-    try:
-        # Qwen/HuggingFace pipeline handles chat templates automatically
-        outputs = pipe(
-            messages,
-            max_new_tokens=1500,
-            do_sample=True,
-            temperature=0.3, # Low temp for strict JSON
-            top_p=0.9
-        )
-        
-        content_text = outputs[0]["generated_text"][-1]["content"]
-        cleaned_json = clean_json_string(content_text)
-        
-        try:
-            data = json.loads(cleaned_json)
-        except json.JSONDecodeError:
-            print("⚠️ JSON Parse Error. Attempting repair...")
-            cleaned_json = repair_json(cleaned_json)
-            try:
-                data = json.loads(cleaned_json)
-            except json.JSONDecodeError as final_err:
-                 print(f"❌ Repair Failed: {final_err}")
-                 return {
-                     "error": "Optimization Failed. The model generated invalid JSON.",
-                     "raw_output": content_text[:500] + "..." # Debug info
-                 }
-        
-        # Ensure Schema Compliance
-        data = validate_and_fill_data(data)
-            
+    data = run_analysis(messages, temperature=0.3)
+    if isinstance(data, dict) and "error" in data:
         return data
 
-    except Exception as e:
-        print(f"❌ Inference Error: {e}")
-        return {"error": f"Local AI Failed: {str(e)}"}
+    # Apply defaults for missing fields
+    return validate_and_fill_data_defaults(data, DEFAULTS)

services/facebook_analyzer.py

@@ -0,0 +1,50 @@
+from services.utils import run_analysis, validate_and_fill_data_defaults
+
+SYSTEM_PROMPT = """You are a Facebook Marketing Expert specializing in organic reach, Facebook Groups, Page growth, and advertising psychology. You understand the Facebook algorithm, meaningful interactions, and ad copy optimization. Return ONLY valid JSON.
+
+RULES:
+1. Post ideas must specify content type: text, image, video, link, poll, live
+2. Engagement hooks must target emotional triggers (curiosity, outrage, inspiration, humor, nostalgia)
+3. Ad copy must follow AIDA framework (Attention, Interest, Desire, Action)
+4. Hashtags: 3-5 relevant tags maximum
+5. Facebook algorithm prioritizes meaningful interactions (comments > shares > reactions)
+6. Native video gets 10x more reach than external links"""
+
+DEFAULTS = {
+    "post_ideas": [],
+    "engagement_hooks": [],
+    "hashtags": [],
+    "ad_copy_suggestions": [],
+    "best_posting_time": "1-3 PM EST on weekdays",
+    "page_growth_tips": ["Post consistently", "Engage in relevant Groups", "Go live weekly"]
+}
+
+def analyze_facebook(content: str) -> dict:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"""Analyze topic for Facebook strategy: "{content[:2000]}"
+
+REQUIREMENTS:
+- **Post Ideas**: 8 post ideas with type (text/image/video/link/poll/live) and full content
+- **Engagement Hooks**: 10 hooks targeting different emotional triggers
+- **Hashtags**: 5 optimized hashtags
+- **Ad Copy Suggestions**: 3 ad copies following AIDA framework
+- **Best Posting Time**: Optimal day and time
+- **Page Growth Tips**: 5 actionable tips
+
+JSON OUTPUT STRUCTURE:
+{{
+    "post_ideas": [
+        {{"type": "video", "content": "..."}}, ... (Total 8 items)
+    ],
+    "engagement_hooks": ["..."],
+    "hashtags": ["..."],
+    "ad_copy_suggestions": ["..."],
+    "best_posting_time": "...",
+    "page_growth_tips": ["..."]
+}}"""}
+    ]
+    data = run_analysis(messages, temperature=0.35, max_new_tokens=2000)
+    if isinstance(data, dict) and "error" in data:
+        return data
+    return validate_and_fill_data_defaults(data, DEFAULTS)

services/instagram_analyzer.py

@@ -0,0 +1,54 @@
+from services.utils import run_analysis, validate_and_fill_data_defaults
+
+SYSTEM_PROMPT = """You are a top Instagram Growth Strategist and Content Creator. You specialize in the Instagram algorithm, visual aesthetics, Reels, Carousels, Stories, and viral marketing. Return ONLY valid JSON.
+
+RULES:
+1. Captions must have a strong hook in first line, value in middle, CTA at end
+2. Hash tag sets must be tiered: small (10k-50k posts), medium (50k-500k), large (500k+)
+3. Content ideas must specify format: Reel (<90s), Carousel (5-10 slides), Story (interactive)
+4. Growth strategies focused on: collaboration, trending audio, consistent posting, engagement pods
+5. Instagram algorithm prioritizes: saves > shares > comments > likes > reach"""
+
+DEFAULTS = {
+    "captions": [],
+    "hashtag_sets": {"small": [], "medium": [], "large": []},
+    "content_ideas": {"reels": [], "carousels": [], "stories": []},
+    "best_posting_time": "9-11 AM EST on weekdays",
+    "growth_strategies": ["Post consistently", "Use trending audio", "Engage with niche community"]
+}
+
+def analyze_instagram(content: str) -> dict:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"""Analyze topic for Instagram strategy: "{content[:2000]}"
+
+REQUIREMENTS:
+- **Captions**: 5 full captions with different tones (educational, entertaining, inspirational, behind-the-scenes, promotional)
+- **Hashtag Sets**: 10 small-tier, 10 medium-tier, 10 large-tier hashtags
+- **Content Ideas**: 4 Reel concepts, 4 Carousel ideas, 4 Story concepts
+- **Best Posting Time**: Optimal day and time
+- **Growth Strategies**: 5 actionable strategies
+
+JSON OUTPUT STRUCTURE:
+{{
+    "captions": [
+        {{"caption": "...", "tone": "..."}}, ... (Total 5 items)
+    ],
+    "hashtag_sets": {{
+        "small": ["#...", "#..."],
+        "medium": ["#...", "#..."],
+        "large": ["#...", "#..."]
+    }},
+    "content_ideas": {{
+        "reels": ["..."],
+        "carousels": ["..."],
+        "stories": ["..."]
+    }},
+    "best_posting_time": "...",
+    "growth_strategies": ["..."]
+}}"""}
+    ]
+    data = run_analysis(messages, temperature=0.4, max_new_tokens=2000)
+    if isinstance(data, dict) and "error" in data:
+        return data
+    return validate_and_fill_data_defaults(data, DEFAULTS)

services/linkedin_analyzer.py

@@ -0,0 +1,50 @@
+from services.utils import run_analysis, validate_and_fill_data_defaults
+
+SYSTEM_PROMPT = """You are a distinguished LinkedIn Content Strategist and Personal Branding Expert. You specialize in B2B networking, professional storytelling, thought leadership, and the LinkedIn algorithm. Return ONLY valid JSON.
+
+RULES:
+1. Post drafts must follow proven LinkedIn frameworks (hook → story → insight → CTA)
+2. Headlines must be curiosity-driven or contrarian within professional bounds
+3. Hashtags: max 5, mix of broad industry + niche specific
+4. Article topics should position the author as a thought leader
+5. Best post length: 900-1200 characters
+6. LinkedIn algorithm favors: dwell time > comments > reactions > shares"""
+
+DEFAULTS = {
+    "post_drafts": [],
+    "hashtags": [],
+    "article_topics": [],
+    "thought_leadership_angles": [],
+    "best_posting_time": "7-9 AM EST on weekdays (Tue-Thu best)",
+    "industry_insights": "Focus on providing unique data-driven perspectives in your niche."
+}
+
+def analyze_linkedin(content: str) -> dict:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"""Analyze topic for LinkedIn strategy: "{content[:2000]}"
+
+REQUIREMENTS:
+- **Post Drafts**: 5 full LinkedIn posts with headline, body, and hook
+- **Hashtags**: 5 optimized hashtags
+- **Article Topics**: 5 long-form article topic ideas
+- **Thought Leadership Angles**: 5 unique perspectives/angles
+- **Best Posting Time**: Optimal day and time
+- **Industry Insights**: 1 paragraph of key industry observations
+
+JSON OUTPUT STRUCTURE:
+{{
+    "post_drafts": [
+        {{"headline": "...", "body": "...", "hook": "..."}}, ... (Total 5 items)
+    ],
+    "hashtags": ["..."],
+    "article_topics": ["..."],
+    "thought_leadership_angles": ["..."],
+    "best_posting_time": "...",
+    "industry_insights": "..."
+}}"""}
+    ]
+    data = run_analysis(messages, temperature=0.3, max_new_tokens=2000)
+    if isinstance(data, dict) and "error" in data:
+        return data
+    return validate_and_fill_data_defaults(data, DEFAULTS)

services/model_loader.py

@@ -0,0 +1,43 @@
+import os
+import torch
+from transformers import pipeline
+from dotenv import load_dotenv
+from pathlib import Path
+
+env_path = Path(__file__).resolve().parent.parent / ".env"
+load_dotenv(dotenv_path=env_path)
+
+MODEL_ID = os.getenv("MODEL_ID", "Qwen/Qwen2.5-0.5B-Instruct")
+
+_pipe = None
+
+def get_pipe():
+    global _pipe
+    if _pipe is None:
+        print(f"⏳ Loading Local Model {MODEL_ID}...")
+        try:
+            _pipe = pipeline(
+                "text-generation",
+                model=MODEL_ID,
+                torch_dtype=torch.bfloat16,
+                device_map="auto",
+                trust_remote_code=True
+            )
+            print("✅ Model Loaded Successfully!")
+        except Exception as e:
+            print(f"❌ Model Load Failed: {e}")
+            _pipe = None
+    return _pipe
+
+def generate_text(messages, temperature=0.3, max_new_tokens=2000):
+    pipe = get_pipe()
+    if pipe is None:
+        return None
+    outputs = pipe(
+        messages,
+        max_new_tokens=max_new_tokens,
+        do_sample=True,
+        temperature=temperature,
+        top_p=0.9
+    )
+    return outputs[0]["generated_text"][-1]["content"]

services/pinterest_analyzer.py

@@ -0,0 +1,48 @@
+from services.utils import run_analysis, validate_and_fill_data_defaults
+
+SYSTEM_PROMPT = """You are a Pinterest SEO Specialist and Visual Marketing Expert who understands how to optimize Pins for search discovery, board strategy, and traffic generation. Return ONLY valid JSON.
+
+RULES:
+1. Pin ideas must have keyword-optimized titles and descriptions
+2. Board organization: categorize by theme, audience, and funnel stage
+3. SEO keywords: focus on long-tail, search-intent matching keywords
+4. Pinterest is a VISUAL SEARCH ENGINE, not social media
+5. Vertical 2:3 aspect ratio (1000 x 1500px) performs best
+6. Keyword-rich descriptions in every Pin
+7. Fresh content prioritized by algorithm"""
+
+DEFAULTS = {
+    "pin_ideas": [],
+    "board_organization": [],
+    "seo_keywords": [],
+    "best_posting_time": "8-11 PM EST on weekends",
+    "traffic_strategies": ["Create Rich Pins", "Join group boards", "Use Idea Pins", "Seasonal planning"]
+}
+
+def analyze_pinterest(content: str) -> dict:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"""Analyze topic for Pinterest strategy: "{content[:2000]}"
+
+REQUIREMENTS:
+- **Pin Ideas**: 10 pins with keyword-optimized title, description, and keyword focus
+- **Board Organization**: 5 board name suggestions with descriptions
+- **SEO Keywords**: 20 long-tail keywords
+- **Best Posting Time**: Optimal day and time
+- **Traffic Strategies**: 5 strategies for driving traffic from Pinterest
+
+JSON OUTPUT STRUCTURE:
+{{
+    "pin_ideas": [
+        {{"title": "...", "description": "...", "keyword_focus": "..."}}, ... (Total 10 items)
+    ],
+    "board_organization": ["..."],
+    "seo_keywords": ["..."],
+    "best_posting_time": "...",
+    "traffic_strategies": ["..."]
+}}"""}
+    ]
+    data = run_analysis(messages, temperature=0.3, max_new_tokens=2000)
+    if isinstance(data, dict) and "error" in data:
+        return data
+    return validate_and_fill_data_defaults(data, DEFAULTS)

services/tiktok_analyzer.py

@@ -0,0 +1,48 @@
+from services.utils import run_analysis, validate_and_fill_data_defaults
+
+SYSTEM_PROMPT = """You are a Viral TikTok Strategist who deeply understands the For You Page (FYP) algorithm, trend culture, and short-form video psychology. Return ONLY valid JSON.
+
+RULES:
+1. Video concepts must specify: hook (first 3 seconds), script snippet, and trending sound suggestion
+2. Trending angles must reference current content patterns (day in life, tutorials, POV, commentary, transitions)
+3. Hashtags: 3-5 mix of trending, niche, and broad
+4. Hooks should create curiosity gaps with 80%+ estimated retention rates
+5. TikTok algorithm: completion rate > rewatches > shares > comments > likes
+6. Vertical 9:16 video, 21-60 seconds optimal length
+7. First 2-3 seconds are CRITICAL for retention"""
+
+DEFAULTS = {
+    "video_concepts": [],
+    "trending_angles": [],
+    "hashtags": [],
+    "best_posting_time": "7-9 AM or 7-10 PM local time",
+    "viral_strategies": ["Participate in trending challenges", "Use trending sounds", "Post 1-3x daily"]
+}
+
+def analyze_tiktok(content: str) -> dict:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"""Analyze topic for TikTok strategy: "{content[:2000]}"
+
+REQUIREMENTS:
+- **Video Concepts**: 8 concepts with hook, script snippet, and sound suggestion
+- **Trending Angles**: 5 trending content angles for this topic
+- **Hashtags**: 5 optimized hashtags (trending + niche + broad)
+- **Best Posting Time**: Optimal times
+- **Viral Strategies**: 5 strategies specific to this topic/niche
+
+JSON OUTPUT STRUCTURE:
+{{
+    "video_concepts": [
+        {{"hook": "...", "script_snippet": "...", "sound_suggestion": "..."}}, ... (Total 8 items)
+    ],
+    "trending_angles": ["..."],
+    "hashtags": ["..."],
+    "best_posting_time": "...",
+    "viral_strategies": ["..."]
+}}"""}
+    ]
+    data = run_analysis(messages, temperature=0.45, max_new_tokens=2000)
+    if isinstance(data, dict) and "error" in data:
+        return data
+    return validate_and_fill_data_defaults(data, DEFAULTS)

services/twitter_analyzer.py

@@ -0,0 +1,47 @@
+from services.utils import run_analysis, validate_and_fill_data_defaults
+
+SYSTEM_PROMPT = """You are a Viral Twitter/X Strategist who understands the platform's fast-paced, text-first nature. You specialize in thread writing, engagement hacking, and building followings through value-driven content. Return ONLY valid JSON.
+
+RULES:
+1. Tweet threads must have a compelling hook tweet followed by value tweets and a strong CTA
+2. Viral hooks must fit in 280 characters and create curiosity gaps
+3. Hashtags: 1-2 max, used sparingly
+4. Threads should have 5-10 tweets each
+5. X algorithm prioritizes: replies > retweets > likes > views
+6. Engaging with others' content = 40% of growth strategy"""
+
+DEFAULTS = {
+    "tweet_threads": [],
+    "viral_hooks": [],
+    "hashtags": [],
+    "best_posting_time": "7-9 AM EST on weekdays",
+    "engagement_tactics": ["Reply to industry leaders", "Quote tweet with your take", "Use polls"]
+}
+
+def analyze_twitter(content: str) -> dict:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"""Analyze topic for X/Twitter strategy: "{content[:2000]}"
+
+REQUIREMENTS:
+- **Tweet Threads**: 3 complete threads (each 5-10 tweets) with different themes/angles
+- **Viral Hooks**: 10 single-tweet hooks (under 280 chars each)
+- **Hashtags**: 2 optimized hashtags
+- **Best Posting Time**: Optimal day and time
+- **Engagement Tactics**: 5 specific tactics
+
+JSON OUTPUT STRUCTURE:
+{{
+    "tweet_threads": [
+        {{"tweets": ["..."], "theme": "..."}}, ... (Total 3 items)
+    ],
+    "viral_hooks": ["..."],
+    "hashtags": ["..."],
+    "best_posting_time": "...",
+    "engagement_tactics": ["..."]
+}}"""}
+    ]
+    data = run_analysis(messages, temperature=0.35, max_new_tokens=2000)
+    if isinstance(data, dict) and "error" in data:
+        return data
+    return validate_and_fill_data_defaults(data, DEFAULTS)

services/utils.py

@@ -0,0 +1,52 @@
+import json
+
+def clean_json_string(text: str) -> str:
+    if "```json" in text:
+        text = text.split("```json")[1].split("```")[0]
+    elif "```" in text:
+        text = text.split("```")[1].split("```")[0]
+    return text.strip()
+
+def repair_json(json_str: str) -> str:
+    json_str = json_str.strip()
+    json_str = json_str.rstrip(", ")
+    open_braces = json_str.count("{")
+    close_braces = json_str.count("}")
+    open_brackets = json_str.count("[")
+    close_brackets = json_str.count("]")
+    if open_braces > close_braces:
+        json_str += "}" * (open_braces - close_braces)
+    if open_brackets > close_brackets:
+        json_str += "]" * (open_brackets - close_brackets)
+    return json_str
+
+def parse_and_repair(raw_text: str, max_preview=500):
+    cleaned = clean_json_string(raw_text)
+    try:
+        return json.loads(cleaned), None
+    except json.JSONDecodeError:
+        print("⚠️ JSON Parse Error. Attempting repair...")
+        repaired = repair_json(cleaned)
+        try:
+            return json.loads(repaired), None
+        except json.JSONDecodeError as e:
+            return None, {
+                "error": "Optimization Failed. The model generated invalid JSON.",
+                "raw_output": raw_text[:max_preview]
+            }
+
+def run_analysis(messages, temperature=0.3, max_new_tokens=2000):
+    from services.model_loader import generate_text
+    raw = generate_text(messages, temperature, max_new_tokens)
+    if raw is None:
+        return {"error": "Model failed to load on server startup. Check logs."}
+    data, err = parse_and_repair(raw)
+    if err:
+        return err
+    return data
+
+def validate_and_fill_data_defaults(data: dict, defaults: dict) -> dict:
+    for key, default_val in defaults.items():
+        if key not in data or data[key] is None:
+            data[key] = default_val
+    return data

services/youtube_analyzer.py

@@ -0,0 +1,52 @@
+from services.utils import run_analysis, validate_and_fill_data_defaults
+
+SYSTEM_PROMPT = """You are a world-class YouTube SEO Strategist and Content Consultant. You know the YouTube algorithm inside out — CTR optimization, watch-time retention, keyword ranking, thumbnail psychology, and community engagement. Return ONLY valid JSON.
+
+RULES:
+1. Video titles must be click-worthy with high CTR potential (use numbers, power words, curiosity gaps, brackets)
+2. Tags must include a mix of broad, mid-tail, and long-tail keywords
+3. Description templates must include keyword placement, timestamps, and call-to-action
+4. Thumbnail ideas should reference proven design principles (contrast, faces with emotion, text overlay)
+5. Engagement strategies focus on: comments, polls, community tab, end screens, cards"""
+
+DEFAULTS = {
+    "video_titles": [],
+    "tags": [],
+    "description_template": "In this video we explore [TOPIC]. Make sure to like and subscribe!",
+    "thumbnail_ideas": ["Close-up expressive face with bold text overlay"],
+    "best_posting_time": "2-4 PM EST on weekdays",
+    "engagement_strategies": ["Pin a comment with a question", "Use end screens to suggest next video"],
+    "competition_gap_analysis": "Focus on underserved long-tail subtopics within this niche."
+}
+
+def analyze_youtube(content: str) -> dict:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"""Analyze topic for YouTube strategy: "{content[:2000]}"
+
+REQUIREMENTS:
+- **Video Titles**: 15 high-CTR titles with expected CTR percentage
+- **Tags**: 20 keywords (broad, mid-tail, long-tail)
+- **Description Template**: 1 full SEO-optimized description template
+- **Thumbnail Ideas**: 5 specific thumbnail concepts
+- **Best Posting Time**: Optimal day and time
+- **Engagement Strategies**: 5 tactics
+- **Competition Gap Analysis**: 1 paragraph
+
+JSON OUTPUT STRUCTURE:
+{{
+    "video_titles": [
+        {{"title": "...", "expected_ctr": "..."}}, ... (Total 15 items)
+    ],
+    "tags": ["..."],
+    "description_template": "...",
+    "thumbnail_ideas": ["..."],
+    "best_posting_time": "...",
+    "engagement_strategies": ["..."],
+    "competition_gap_analysis": "..."
+}}"""}
+    ]
+    data = run_analysis(messages, temperature=0.3, max_new_tokens=2000)
+    if isinstance(data, dict) and "error" in data:
+        return data
+    return validate_and_fill_data_defaults(data, DEFAULTS)