AI
Marketing

mkdir seo-agent && cd seo-agent
pip install anthropic python-dotenv

ANTHROPIC_API_KEY=your_key_here

import os, json, re
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def research_keywords(seed: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2048,
        system="""You are an expert SEO strategist. Return valid JSON only:
{
  "primary_keyword": "best version to target",
  "secondary_keywords": ["kw1", "kw2", "kw3", "kw4", "kw5"],
  "search_intent": "informational | commercial | transactional",
  "title_options": ["title 1", "title 2", "title 3", "title 4", "title 5"],
  "meta_description": "155-char meta with keyword and clear value prop"
}""",
        messages=[{"role": "user", "content": f"Research this keyword: {seed}"}]
    )
    return response.content[0].text

if __name__ == "__main__":
    kw = input("Enter your target keyword: ").strip()
    print(research_keywords(kw))

python seo_agent.py

def generate_post(keyword_json: str, word_count: int = 1200) -> str:
    try:
        data = json.loads(re.sub(r'```(?:json)?', '', keyword_json).strip('`').strip())
        primary  = data.get('primary_keyword', 'the topic')
        secondry = ', '.join(data.get('secondary_keywords', [])[:5])
        intent   = data.get('search_intent', 'informational')
        title    = data.get('title_options', [''])[0]
    except Exception:
        primary, secondry, intent, title = keyword_json, '', 'informational', keyword_json

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=4096,
        system=f"""You are an expert SEO content writer. Write for {intent} intent.
Rules:
- Use primary keyword naturally 3-5 times, never stuffed
- Weave in secondary keywords where contextually natural
- Hook in the first 2 sentences
- H2 every 250-300 words
- End with a clear CTA
- ~{word_count} words, clean markdown""",
        messages=[{"role": "user", "content": f"Title: {title}\nPrimary: {primary}\nSecondary: {secondry}"}]
    )
    return response.content[0].text

def save(keyword: str, research: str, article: str):
    name = keyword.replace(' ', '_')[:40]
    with open(f"{name}_article.md", "w") as f:
        f.write(f"## SEO Research\n\n{research}\n\n---\n\n## Article\n\n{article}")
    print(f"✓ Saved to {name}_article.md")

if __name__ == "__main__":
    keyword = input("Target keyword: ").strip()
    print("\n[1/2] Researching keywords...")
    research = research_keywords(keyword)
    print("[2/2] Writing article...")
    article = generate_post(research)
    save(keyword, research, article)
    print("Done — paste the .md file into your CMS.")

pip install anthropic python-dotenv

import os, json, re
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

EMAIL_SEQUENCE = [
    ("welcome",       "Delivered immediately. Warm, personal, set expectations. NO hard sell."),
    ("value",         "Day 3. Pure value — teach something useful. Build trust. No CTA."),
    ("social_proof",  "Day 7. Real case study or testimonial with specific numbers. Soft CTA."),
    ("objection",     "Day 14. Address the #1 objection honestly. Reframe it."),
    ("offer",         "Day 21. Clear, specific, urgent offer. Strong CTA."),
]

def generate_email(product: str, audience: str, email_type: str, instructions: str, prev_subjects: list) -> dict:
    prev = f"\nAvoid repeating these subjects: {prev_subjects}" if prev_subjects else ""
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system=f"""You write emails for: {product}. Audience: {audience}.
Voice: conversational, human — never corporate or spammy.
Output valid JSON only: {{subject, preview_text, body}}
subject: under 50 chars. preview_text: under 90 chars.{prev}""",
        messages=[{"role": "user", "content": f"Write the {email_type} email. Instructions: {instructions}"}]
    )
    text = re.sub(r'```(?:json)?', '', response.content[0].text).strip('`').strip()
    return json.loads(text)

def run_sequence(product: str, audience: str):
    print(f"\nGenerating 5-email sequence for: {product}\n")
    prev_subjects = []

    for i, (email_type, instructions) in enumerate(EMAIL_SEQUENCE, 1):
        print(f"[{i}/5] Writing {email_type} email...")
        email = generate_email(product, audience, email_type, instructions, prev_subjects)
        prev_subjects.append(email['subject'])

        with open(f"email_{i:02d}_{email_type}.txt", "w") as f:
            f.write(f"SUBJECT: {email['subject']}\n")
            f.write(f"PREVIEW: {email['preview_text']}\n")
            f.write("─" * 40 + "\n\n")
            f.write(email['body'])
        print(f"    Subject: {email['subject']}")

    print(f"\n✓ 5 emails saved.")

if __name__ == "__main__":
    product  = input("Describe your product (1-2 sentences): ").strip()
    audience = input("Describe your target audience: ").strip()
    run_sequence(product, audience)

python email_agent.py

pip install anthropic python-dotenv

import os, json, re
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

PILLARS = [
    "Educational / How-to",
    "Behind the scenes",
    "Social proof / testimonial",
    "Product spotlight",
    "Community / engagement question",
]

PLATFORM_RULES = {
    "instagram": "Short punchy caption (150 chars max), hook on first line, 15-20 hashtags, DALL-E image prompt. JSON: {caption, hashtags, image_prompt}",
    "facebook":  "Conversational 2-3 short paragraphs, max 3 hashtags, end with a question. JSON: {caption}",
}

def generate_post(brand_brief: str, pillar: str, platform: str, day: int) -> dict:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=800,
        system=f"""{brand_brief}
Creating {platform} content. Rules: {PLATFORM_RULES[platform]}
Output valid JSON only.""",
        messages=[{"role": "user", "content": f"Day {day} post. Pillar: {pillar}. Be creative and on-brand."}]
    )
    text = re.sub(r'```(?:json)?', '', response.content[0].text).strip('`').strip()
    return json.loads(text)

def generate_calendar(brand: str, desc: str, audience: str, tone: str, days: int = 30):
    brief = f"Brand: {brand}\nWhat we do: {desc}\nAudience: {audience}\nTone: {tone}"
    print(f"\nGenerating {days}-day calendar for {brand}...\n")

    with open(f"{brand.replace(' ','_')}_social.txt", "w") as f:
        f.write(f"SOCIAL MEDIA CALENDAR — {brand}\n{'='*60}\n\n")
        for day in range(1, days + 1):
            pillar = PILLARS[(day - 1) % len(PILLARS)]
            print(f"Day {day:02d}/30 — {pillar}...")
            f.write(f"DAY {day:02d} | {pillar}\n{'─'*40}\n")

            ig = generate_post(brief, pillar, "instagram", day)
            f.write(f"INSTAGRAM:\n{ig.get('caption','')}\n")
            f.write(f"Hashtags: {' '.join(ig.get('hashtags',[]))}\n")
            f.write(f"Image prompt: {ig.get('image_prompt','')}\n\n")

            fb = generate_post(brief, pillar, "facebook", day)
            f.write(f"FACEBOOK:\n{fb.get('caption','')}\n\n{'='*60}\n\n")

    print(f"✓ Calendar saved.")

if __name__ == "__main__":
    brand    = input("Brand name: ").strip()
    desc     = input("What does your brand do? ").strip()
    audience = input("Target audience: ").strip()
    tone     = input("Tone (e.g. 'friendly and witty'): ").strip()
    generate_calendar(brand, desc, audience, tone)

python social_agent.py

pip install anthropic praw python-dotenv

ANTHROPIC_API_KEY=your_key
REDDIT_CLIENT_ID=your_client_id
REDDIT_CLIENT_SECRET=your_client_secret
REDDIT_USER_AGENT=opportunityscanner/1.0

import os, json, re
import praw
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client  = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
reddit  = praw.Reddit(
    client_id=os.getenv("REDDIT_CLIENT_ID"),
    client_secret=os.getenv("REDDIT_CLIENT_SECRET"),
    user_agent=os.getenv("REDDIT_USER_AGENT"),
)

def find_opportunities(subreddits: list, keywords: list, limit: int = 25) -> list:
    hits = []
    for sub in subreddits:
        for post in reddit.subreddit(sub).new(limit=limit):
            text = (post.title + " " + post.selftext).lower()
            if any(kw.lower() in text for kw in keywords):
                hits.append({
                    "id": post.id, "subreddit": sub,
                    "title": post.title, "body": post.selftext[:500],
                    "score": post.score,
                })
    return hits

def draft_comment(post: dict, brand_brief: str) -> dict:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=512,
        system=f"""{brand_brief}
Write a Reddit comment. Reddit hates marketing. Rules:
1. Lead with genuine help — answer the question WITHOUT mentioning your product
2. Only mention your brand at the very end IF it directly solves their problem
3. Sound like a real human, not a marketer
4. No exclamation marks, no emojis, no buzzwords
5. Max 3 short paragraphs
Score the opportunity 1-10. Return JSON: {{relevance_score, comment, mention_brand}}""",
        messages=[{"role": "user", "content": f"Title: {post['title']}\nBody: {post['body']}"}]
    )
    text = re.sub(r'```(?:json)?', '', response.content[0].text).strip('`').strip()
    return json.loads(text)

def run_agent(subreddits: list, keywords: list, brand_brief: str, min_score: int = 6):
    print(f"Scanning {len(subreddits)} subreddits...")
    posts = find_opportunities(subreddits, keywords)
    print(f"Found {len(posts)} relevant posts. Drafting responses...\n")

    good = []
    for post in posts:
        draft = draft_comment(post, brand_brief)
        if draft.get('relevance_score', 0) >= min_score:
            good.append({**post, **draft})
            print(f"[{draft['relevance_score']}/10] r/{post['subreddit']}: {post['title'][:60]}")

    with open("reddit_opportunities.txt", "w") as f:
        for opp in sorted(good, key=lambda x: -x['relevance_score']):
            f.write(f"SCORE: {opp['relevance_score']}/10\n")
            f.write(f"POST: {opp['title']}\n")
            f.write(f"URL: https://reddit.com/comments/{opp['id']}\n")
            f.write(f"DRAFT:\n{opp['comment']}\n{'='*60}\n\n")

    print(f"\n✓ {len(good)} opportunities saved for human review.")

if __name__ == "__main__":
    SUBREDDITS = ["entrepreneur", "startups", "SaaS", "marketing"]
    KEYWORDS   = ["looking for", "recommend", "how do I", "anyone tried"]
    BRAND      = "We build AI tools for small business owners."
    run_agent(SUBREDDITS, KEYWORDS, BRAND)

python reddit_agent.py

pip install anthropic python-dotenv

import os
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

POST_FORMATS = {
    "story":    "Personal story with a business lesson. Start with 'I' or a specific moment.",
    "insight":  "Contrarian industry insight. Start with a bold statement.",
    "list":     "Numbered list of 5-7 actionable items. One sentence each.",
    "question": "Thought-provoking question that sparks debate. Short setup, 1 question.",
    "mistake":  "A mistake you made and what you learned. Vulnerable but professional.",
}

def generate_post(your_role: str, industry: str, topic: str, fmt: str = "insight") -> str:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system=f"""You are {your_role} in {industry}. Write LinkedIn posts that perform.
Algorithm rules:
- Line 1 MUST stop the scroll (bold claim, surprising stat, or emotional hook)
- Line break every 1-2 sentences — LinkedIn rewards white space
- 3-5 hashtags at the very end only
- End with 1 question to drive comments
- Max 1,300 characters for best reach
- Sound human, never corporate
Format: {POST_FORMATS.get(fmt, POST_FORMATS['insight'])}""",
        messages=[{"role": "user", "content": f"Write a LinkedIn post about: {topic}"}]
    )
    return response.content[0].text

def connection_note(your_role: str, their_role: str, reason: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=150,
        system=f"You are {your_role}. Write a LinkedIn connection note. Max 300 chars. Specific reason — no generic 'I'd love to connect'. No pitch.",
        messages=[{"role": "user", "content": f"Connect with: {their_role}\nReason: {reason}"}]
    )
    return response.content[0].text.strip()

def followup_sequence(context: str, your_role: str) -> list:
    specs = [
        ("Day 3",  "Thank them for connecting. Ask one genuine question about their work. No pitch. Max 80 words."),
        ("Day 10", "Share something useful to them — an insight or resource. Still no pitch. Max 80 words."),
        ("Day 21", "Soft mention of what you do IF relevant. Ask if they'd be open to a 15-min chat. Max 100 words."),
    ]
    out = []
    for day, instructions in specs:
        r = client.messages.create(
            model="claude-sonnet-4-6", max_tokens=200,
            system=f"You are {your_role}. Context: {context}\n{instructions}\nSound human.",
            messages=[{"role": "user", "content": "Write the message."}]
        )
        out.append({"day": day, "message": r.content[0].text.strip()})
    return out

if __name__ == "__main__":
    role     = input("Your role/title: ").strip()
    industry = input("Your industry: ").strip()
    topic    = input("Post topic: ").strip()
    fmt      = input("Format (story/insight/list/question/mistake) [insight]: ").strip() or "insight"

    print("\n─── LINKEDIN POST ───")
    post = generate_post(role, industry, topic, fmt)
    print(post)

    with open("linkedin_post.txt", "w") as f:
        f.write(post)
    print("\n✓ Saved to linkedin_post.txt")

pip install anthropic python-dotenv

import os, json, re
from pathlib import Path
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def create_brief(product: str, goal: str, audience: str, timeline: str) -> dict:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system="""You are a CMO creating a campaign brief. Output valid JSON only:
{
  "product_summary": "one sentence",
  "campaign_goal": "specific measurable goal",
  "target_audience": "detailed persona",
  "key_message": "the one thing everyone must remember",
  "tone": "2-3 adjectives",
  "hooks": ["hook1", "hook2", "hook3"],
  "primary_cta": "the main call to action"
}""",
        messages=[{"role": "user", "content": f"Product: {product}\nGoal: {goal}\nAudience: {audience}\nTimeline: {timeline}"}]
    )
    text = re.sub(r'```(?:json)?', '', response.content[0].text).strip('`').strip()
    return json.loads(text)

def setup_folder(product: str) -> Path:
    folder = Path(f"campaign_{product.replace(' ','_')[:30]}")
    folder.mkdir(exist_ok=True)
    return folder

def run_seo(brief: dict, folder: Path):
    r = client.messages.create(model="claude-sonnet-4-6", max_tokens=3000,
        system=f"Campaign brief: {json.dumps(brief)}\nWrite a 900-word SEO article targeting people searching for solutions to the problem described. Include meta description and H2 structure.",
        messages=[{"role": "user", "content": "Write the SEO article."}])
    (folder / "01_seo_article.md").write_text(r.content[0].text)
    print("  [SEO] ✓")

def run_email(brief: dict, folder: Path):
    types = ["welcome", "value", "social_proof", "objection", "offer"]
    out = ""
    for i, t in enumerate(types, 1):
        r = client.messages.create(model="claude-sonnet-4-6", max_tokens=600,
            system=f"Campaign brief: {json.dumps(brief)}\nWrite email {i}/5: {t}. Output JSON: {{subject, preview_text, body}}",
            messages=[{"role": "user", "content": f"Write the {t} email."}])
        out += f"\n\n--- EMAIL {i}: {t.upper()} ---\n{r.content[0].text}"
    (folder / "02_email_sequence.txt").write_text(out)
    print("  [EMAIL] ✓")

def run_social(brief: dict, folder: Path):
    r = client.messages.create(model="claude-sonnet-4-6", max_tokens=3000,
        system=f"Campaign brief: {json.dumps(brief)}\nGenerate 7 days of social content. Each day: Instagram caption + hashtags + image prompt, and Facebook caption.",
        messages=[{"role": "user", "content": "Generate the 7-day calendar."}])
    (folder / "03_social_calendar.txt").write_text(r.content[0].text)
    print("  [SOCIAL] ✓")

def run_reddit(brief: dict, folder: Path):
    r = client.messages.create(model="claude-sonnet-4-6", max_tokens=1000,
        system=f"Campaign brief: {json.dumps(brief)}\nCreate a Reddit strategy: top 5 subreddits, 10 keywords to monitor, 3 example authentic helpful comments (value-first), what NOT to do.",
        messages=[{"role": "user", "content": "Create the Reddit strategy."}])
    (folder / "04_reddit_strategy.txt").write_text(r.content[0].text)
    print("  [REDDIT] ✓")

def run_linkedin(brief: dict, folder: Path):
    r = client.messages.create(model="claude-sonnet-4-6", max_tokens=800,
        system=f"Campaign brief: {json.dumps(brief)}\nWrite 1 high-performing LinkedIn thought leadership post + a 3-message DM outreach sequence.",
        messages=[{"role": "user", "content": "Write the LinkedIn content."}])
    (folder / "05_linkedin.txt").write_text(r.content[0].text)
    print("  [LINKEDIN] ✓")

def run_campaign(product: str, goal: str, audience: str, timeline: str):
    print(f"\n{'='*60}\nCAMPAIGN: {product}\n{'='*60}\n")

    print("[1/6] Creating campaign brief...")
    brief  = create_brief(product, goal, audience, timeline)
    folder = setup_folder(product)
    (folder / "00_brief.json").write_text(json.dumps(brief, indent=2))
    print(f"      Key message: {brief['key_message']}\n")

    print("[2/6] Running channel agents...")
    run_seo(brief, folder)
    run_email(brief, folder)
    run_social(brief, folder)
    run_reddit(brief, folder)
    run_linkedin(brief, folder)

    print(f"\n{'='*60}")
    print(f"✓ Campaign complete — all files in: {folder}/")
    print(f"{'='*60}")

if __name__ == "__main__":
    product  = input("Product/service: ").strip()
    goal     = input("Campaign goal (e.g. '100 signups in 30 days'): ").strip()
    audience = input("Target audience: ").strip()
    timeline = input("Timeline (e.g. '30 days'): ").strip()
    run_campaign(product, goal, audience, timeline)

python campaign_orchestrator.py