Keyword Research → Content Planning → Template Rendering → SEO Validation → Publishing

import requests
from typing import List, Dict

def fetch_related_queries(seed_keyword: str, limit: int = 50) -> List[Dict]:
    """Fetch related search queries using Google's Suggest API."""
    url = "https://suggestqueries.google.com/complete/search"
    params = {
        "client": "firefox",
        "q": seed_keyword,
        "hl": "en",
    }
    resp = requests.get(url, params=params)
    suggestions = resp.json()[1]

    keywords = []
    for kw in suggestions[:limit]:
        keywords.append({
            "keyword": kw,
            "seed": seed_keyword,
            "intent": classify_intent(kw),  # informational, transactional, etc.
        })
    return keywords

def classify_intent(keyword: str) -> str:
    """Simple intent classifier based on keyword patterns."""
    transactional = ["buy", "price", "discount", "deal", "cheap", "review"]
    if any(t in keyword.lower() for t in transactional):
        return "transactional"
    return "informational"

import sqlite3

def init_keyword_db(db_path: str = "keywords.db"):
    conn = sqlite3.connect(db_path)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS keywords (
            id INTEGER PRIMARY KEY,
            keyword TEXT UNIQUE,
            seed TEXT,
            intent TEXT,
            search_volume INTEGER DEFAULT 0,
            difficulty INTEGER DEFAULT 0,
            content_status TEXT DEFAULT 'pending',
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    """)
    conn.commit()
    return conn

from jinja2 import Template
from datetime import datetime

tutorial_template = Template("""
# {{ title }}

**Last updated:** {{ date }}

{{ intro }}

## What You'll Learn
{% for item in learning_points %}
- {{ item }}
{% endfor %}

## Step-by-Step Guide
{% for step in steps %}
### {{ loop.index }}. {{ step.heading }}

{{ step.content }}

{% endfor %}

## Common Pitfalls
{% for pitfall in pitfalls %}
> **⚠️ {{ pitfall.title }}:** {{ pitfall.description }}
{% endfor %}

## Key Takeaways
{% for takeaway in takeaways %}
- {{ takeaway }}
{% endfor %}
""")

def render_article(keyword_data: dict, content_brief: dict) -> str:
    """Render a complete article from keyword data and a content brief."""
    return tutorial_template.render(
        title=content_brief["title"],
        date=datetime.now().strftime("%B %d, %Y"),
        intro=content_brief["intro"],
        learning_points=content_brief["learning_points"],
        steps=content_brief["steps"],
        pitfalls=content_brief.get("pitfalls", []),
        takeaways=content_brief["takeaways"],
    )

import re
from collections import Counter

def validate_seo(markdown_content: str, target_keyword: str) -> dict:
    """Run SEO checks on rendered content and return a report."""
    checks = {}

    # Extract H1
    h1_match = re.search(r'^# (.+)$', markdown_content, re.MULTILINE)
    title = h1_match.group(1) if h1_match else ""
    checks["title_length"] = {
        "value": len(title),
        "pass": 50 <= len(title) <= 60,
        "recommendation": "50-60 characters"
    }

    # Keyword density
    words = markdown_content.lower().split()
    keyword_count = sum(1 for w in words if target_keyword.lower() in w)
    density = (keyword_count / len(words)) * 100 if words else 0
    checks["keyword_density"] = {
        "value": round(density, 2),
        "pass": 0.5 <= density <= 2.0,
        "recommendation": "0.5% - 2.0%"
    }

    # Link count
    link_count = len(re.findall(r'\[.+?\]\(https?://.+?\)', markdown_content))
    checks["external_links"] = {
        "value": link_count,
        "pass": link_count >= 2,
        "recommendation": "at least 2 external links"
    }

    checks["all_pass"] = all(c["pass"] for c in checks.values() if isinstance(c, dict) and "pass" in c)
    return checks

import requests
from typing import Optional

class ContentPublisher:
    def __init__(self, devto_api_key: str):
        self.devto_key = devto_api_key
        self.session = requests.Session()

    def publish_to_devto(self, title: str, markdown: str, tags: list) -> Optional[str]:
        """Publish an article to dev.to via the Forem API."""
        payload = {
            "article": {
                "title": title,
                "body_markdown": markdown,
                "published": True,
                "tags": tags[:4],  # dev.to limit
            }
        }
        resp = self.session.post(
            "https://dev.to/api/articles",
            headers={
                "api-key": self.devto_key,
                "Content-Type": "application/json",
            },
            json=payload,
        )
        if resp.status_code == 201:
            data = resp.json()
            return data.get("url")
        raise RuntimeError(f"Publish failed: {resp.status_code} - {resp.text}")

    def run_pipeline(self, articles: list) -> dict:
        """Run the full pipeline for a batch of articles."""
        results = {"published": [], "failed": []}
        for article in articles:
            # Step 1: Render
            rendered = render_article(article["keyword"], article["brief"])

            # Step 2: Validate SEO
            seo_report = validate_seo(rendered, article["keyword"]["keyword"])
            if not seo_report["all_pass"]:
                print(f"⚠️  SEO issues for '{article['title']}': {seo_report}")

            # Step 3: Publish
            try:
                url = self.publish_to_devto(
                    article["title"], rendered, article.get("tags", [])
                )
                results["published"].append({"title": article["title"], "url": url})
            except Exception as e:
                results["failed"].append({"title": article["title"], "error": str(e)})

        return results

git clone https://github.com/ulnit/dev-content-toolkit
cd dev-content-toolkit
pip install -e .

dev-content generate \
  --keyword "python web scraping" \
  --template tutorial \
  --tags python,webdev,tutorial \
  --publish