Content Generation Pipeline — Technical Specification

┌─────────────────────────────────────────────────────────────────────┐
│                         CONTENT PIPELINE                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  STAGE 1: STRATEGY       STAGE 2: STRUCTURE      STAGE 3: DRAFT       │
│  ┌─────────────┐         ┌─────────────┐        ┌─────────────┐       │
│  │  GLM 5.1    │         │  GLM 5.1    │        │  Local 32B  │       │
│  │  (Cloud)    │         │  (Cloud)    │        │  (Gaming PC)│       │
│  │  ~2K tokens │         │  ~3K tokens │        │  ~80K tokens│       │
│  └──────┬──────┘         └──────┬──────┘        └──────┬──────┘       │
│         │                       │                    │               │
│         ▼                       ▼                    ▼               │
│  ┌─────────────┐         ┌─────────────┐        ┌─────────────┐       │
│  │  Brief +    │         │  Validated  │        │  Draft      │       │
│  │  Outline    │────────▶│  Structure  │───────▶│  (local)    │       │
│  └─────────────┘         └─────────────┘        └──────┬──────┘       │
│                                                        │               │
│         STAGE 5: POLISH       STAGE 4: REVISION        │               │
│         ┌─────────────┐       ┌─────────────┐          │               │
│         │  GLM 5.1    │       │  Local 32B  │          │               │
│         │  (Cloud)    │       │  (Gaming PC)│◀─────────┘               │
│         │  ~2K tokens │       │  ~40K tokens│                          │
│         └──────┬──────┘       └─────────────┘                          │
│                │                                                     │
│                ▼                                                     │
│         ┌─────────────┐                                              │
│         │  Final      │                                              │
│         │  Post       │                                              │
│         └─────────────┘                                              │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

# local-ai-config.yaml
localai:
  api:
    bind: "0.0.0.0:8080"
    cors: true

  models:
    # Primary draft model - Qwen2.5 32B 4-bit
    - name: "draft-generator"
      backend: "llama-cpp"
      model: "/models/qwen2.5-32b-instruct-q4_k_m.gguf"
      context_size: 8192
      threads: 8
      f16: true
      gpu_layers: 35  # Max for 10GB VRAM

    # Fallback for shorter tasks
    - name: "fast-revision"
      backend: "llama-cpp"
      model: "/models/llama-3.1-8b-instruct-q4_k_m.gguf"
      context_size: 4096
      threads: 8
      gpu_layers: 35

# vllm serve command
python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen2.5-32B-Instruct-AWQ \
  --quantization awq \
  --tensor-parallel-size 1 \
  --max-model-len 8192 \
  --port 8000

# ollama setup
ollama pull qwen2.5:32b
ollama serve

titanium-butler (Beelink)          Gaming PC (3080 Ti)
    │                                    │
    │    Tailscale network (100.x.x.x)   │
    └────────────────────────────────────┘
              │
              ▼
    ┌─────────────────┐
    │  LocalAI API    │  ← http://gaming-pc:8080/v1
    │  (or vLLM)      │
    └─────────────────┘

# pipeline/config.py
LOCAL_LLM_HOST = "gaming-pc.tailXXXX.ts.net"  # Tailscale hostname
LOCAL_LLM_PORT = 8080
LOCAL_LLM_API_KEY = "sk-local-no-key-required"  # LocalAI default

CLOUD_LLM_API_KEY = os.getenv("GLM_API_KEY")
CLOUD_LLM_BASE_URL = "https://api.glm.ai/v1"

# Stage Orchestrator
def stage_strategy(...): ...
def stage_structure(strategy_output): ...      # NEW: Validate before Draft
def stage_draft(validated_brief, content_type): ...
def stage_revision(draft_output, edit_notes): ...
def stage_polish(revision_output, content_type): ...

# content/pipeline.py
def run_pipeline(
    topic: str,
    content_type: Literal["roundup", "how_i_solved", "build_log", "essay"],
    memory_query: Optional[str] = None
) -> dict:
    """
    Execute 5-stage pipeline for content generation.
    REVISED ORDER: Structure validated before expensive Draft stage.

    Typical runtime: 2-3 hours (designed for overnight/batch processing).
    Returns final post with metadata and cost breakdown.
    """

    # Stage 1: Strategy (Cloud - GLM 5.1) - ~1 min
    strategy = stage_strategy(topic, content_type, memory_query)

    # Stage 2: Structure (Cloud - GLM 5.1) - ~1 min
    # Validate angle BEFORE burning GPU time
    structure = stage_structure(strategy.output_text)

    # Stage 3: Draft (Local - Gaming PC) - ~90 min
    draft = stage_draft(structure.validated_brief, content_type)

    # Stage 4: Revision (Local - Gaming PC) - ~45 min
    revision = stage_revision(draft.output_text, structure.edit_notes)

    # Stage 5: Polish (Cloud - GLM 5.1) - ~1 min
    final = stage_polish(revision.output_text, content_type)

    return {
        "final_post": final.output_text,
        # ... rest unchanged
    }

# content/local_client.py
import httpx
import subprocess
from typing import Iterator, Optional

class LocalLLMClient:
    """
    Client for local inference on Gaming PC via Tailscale.
    Handles connection retries, timeout, error fallback, and wake-on-LAN.
    """

    def __init__(
        self,
        base_url: str = "http://gaming-pc.tailXXXX.ts.net:8080",
        model: str = "draft-generator",
        timeout: int = 300,  # 5 min for long generation
        tailscale_hostname: str = "gaming-pc"
    ):
        self.client = httpx.Client(base_url=base_url, timeout=timeout)
        self.model = model
        self.tailscale_hostname = tailscale_hostname

    async def check_availability(self) -> dict:
        """
        Check if Gaming PC is online and model is loaded.
        Returns: {"available": bool, "status": str, "wake_lan_possible": bool}
        """
        try:
            response = await self.client.get("/ready", timeout=5.0)
            if response.status_code == 200:
                return {
                    "available": True,
                    "status": "ready",
                    "wake_lan_possible": False
                }
        except (httpx.ConnectError, httpx.TimeoutException):
            # Check if host is reachable via ping
            ping_result = subprocess.run(
                ["ping", "-c", "1", "-W", "2", self.tailscale_hostname],
                capture_output=True
            )
            if ping_result.returncode != 0:
                return {
                    "available": False,
                    "status": "offline",
                    "wake_lan_possible": True  # Could try WoL
                }
            return {
                "available": False,
                "status": "online_but_service_down",
                "wake_lan_possible": False
            }

    async def wake_if_needed(self, mac_address: Optional[str] = None) -> bool:
        """
        Attempt wake-on-LAN if Gaming PC is offline.
        Returns True if wake packet sent (doesn't guarantee boot).
        """
        if not mac_address:
            return False

        # Send WoL magic packet
        subprocess.run([
            "wakeonlan", mac_address
        ], check=False)

        logger.info(f"Wake-on-LAN sent to {mac_address}")
        return True

    async def generate_with_availability_check(
        self,
        prompt: str,
        max_tokens: int = 2048,
        temperature: float = 0.7,
        auto_wake: bool = False,
        mac_address: Optional[str] = None
    ) -> str:
        """
        Generate with pre-check. Optionally wake PC if offline.
        """
        status = await self.check_availability()

        if not status["available"]:
            if auto_wake and status["wake_lan_possible"] and mac_address:
                await self.wake_if_needed(mac_address)
                raise LocalLLMUnavailable(
                    "Gaming PC offline. Wake-on-LAN sent. Retry in 2 minutes."
                )
            else:
                logger.warning("Local LLM unavailable, falling back to cloud")
                return await cloud_client.generate(prompt, max_tokens, temperature)

        return await self.generate(prompt, max_tokens, temperature, stream=False)

class LocalLLMUnavailable(Exception):
    """Raised when local LLM is unreachable and fallback is disabled."""
    pass

# Qwen2.5-32B (primary)
huggingface-cli download bartowski/Qwen2.5-32B-Instruct-GGUF \
  --include "*Q4_K_M.gguf" --local-dir ./models

# Llama-3.1-8B (fast fallback)
huggingface-cli download bartowski/Meta-Llama-3.1-8B-Instruct-GGUF \
  --include "*Q4_K_M.gguf" --local-dir ./models

{# templates/prompts/stage_strategy.txt #}
You are a content strategist for a technical blog about home infrastructure,
AI agents, and the messy reality of building things.

TOPIC: {{ topic }}
CONTENT TYPE: {{ content_type }}

RECENT CONTEXT:
{{ memory_context }}

Your task: Create a brief and outline for a blog post.

OUTPUT FORMAT:
- Headline options (3)
- Angle: One sentence on why this matters now
- Key moment: The human trigger (e.g., "7 PM, Aundrea asks if internet is down")
- Structure: 5-7 bullet outline
- Technical details needed: What specific errors/configs/logs to include
- Key takeaway: What the reader learns

Be specific. Generic angles get rejected.

{# templates/prompts/stage_draft.txt #}
Write a blog post following this exact structure. Match the voice:
- Start with the human moment, not the solution
- Admit wrong turns before revealing the fix
- Use specific versions, error messages, timestamps
- End with actionable takeaways

BRIEF:
{{ strategy_output }}

TEMPLATE STRUCTURE:
{{ content_template }}

VOICE EXAMPLES:
{{ voice_samples }}

Write 800-1200 words. Do not use AI-speak. Do not say "leverage" or "unlock".

{# templates/prompts/stage_structure.txt #}
You are a developmental editor. Review this brief against good blog structure.

BRIEF:
{{ strategy_output }}

Provide:
1. Structural validation: Does this angle work? (yes/no + why)
2. Outline critique: Specific improvements to the 5-7 bullet structure
3. Red flags: Is the human moment clear? Is the takeaway actionable?

If the angle is weak, say so. Better to fail fast here than after 90 min of GPU time.

# content/scheduler.py
class OvernightPipelineScheduler:
    """
    Queue posts to generate during low-activity hours.
    Designed to run overnight while Gaming PC is idle.
    """

    def __init__(self, start_hour=22, end_hour=6):
        self.start_hour = start_hour  # 10 PM
        self.end_hour = end_hour       # 6 AM
        self.queue = []

    def add_to_queue(self, topic, content_type):
        self.queue.append({
            "topic": topic,
            "content_type": content_type,
            "added_at": datetime.now(),
            "status": "pending"
        })

    async def run_nightly_batch(self):
        """
        Check PC availability, wake if needed, process queue.
        """
        status = await local_client.check_availability()

        if not status["available"] and status["wake_lan_possible"]:
            await local_client.wake_if_needed(mac_address=GAMING_PC_MAC)
            logger.info("Gaming PC woken for overnight batch. Waiting 2 min...")
            await asyncio.sleep(120)  # Wait for boot

        for job in self.queue:
            if job["status"] == "pending":
                try:
                    result = await run_pipeline(
                        topic=job["topic"],
                        content_type=job["content_type"]
                    )
                    job["status"] = "completed"
                    job["result"] = result
                    job["completed_at"] = datetime.now()
                except Exception as e:
                    job["status"] = "failed"
                    job["error"] = str(e)

# Queue posts throughout the day
python -m content.queue --add "DNS incident April 2026" --type how_i_solved
python -m content.queue --add "OpenClaw tutorial: custom skills" --type tutorial

# Run overnight (cron job at 10 PM)
python -m content.queue --run-overnight