generate_SEO_blog.json

Overview

generate_SEO_blog.json defines a comprehensive multi-agent workflow for automatically generating SEO-optimized blog articles using AI. The workflow simulates a small editorial team composed of specialized AI "agents," each responsible for a distinct role in the blog creation pipeline. This architecture offers a human-like writing process with separate planning, outlining, drafting, and editing stages executed in parallel but coordinated by a Lead Agent.

The file is structured as a JSON configuration that specifies agents, their parameters, interactions, and the overall flow graph. It is designed for an AI orchestration platform that runs these agents to deliver a final, polished blog post in Markdown format based on simple user input specifying the topic, audience, and blog goals.

Detailed Components and Their Roles

1. Begin (Entry Point)

• Purpose: Starts the conversation with the user, collecting initial inputs necessary for blog generation.

• Parameters:

  • enablePrologue: true (enables an introductory prompt)

  • mode: "conversational" (interaction mode)

  • prologue: A prompt asking the user to provide:

    • Blog topic

    • Target audience

    • Blog goal (e.g., SEO traffic, education, marketing)

• Flow: Passes the user input downstream to the Lead Agent.

2. Agent:LuckyApplesGrab — Lead Agent

• Role: The central coordinator and controller of the entire SEO blog generation workflow.

• Responsibilities:

  • Parse and interpret the user’s initial input.

  • Generate a high-level writing plan including:

    • Topic summary

    • Audience description

    • Intent (blog type and style)

    • Long-tail keywords

  • Provide clear, scoped instructions to three specialized sub-agents:

    • Outline Agent: To create a structured blog outline.

    • Body Agent: To write blog content section-by-section.

    • Editor Agent: To polish and finalize the blog post.

  • Collect outputs from sub-agents and assemble them into a complete Markdown blog draft.

  • Manage retries and error handling for robustness.

• Key Parameters:

  • Uses deepseek-chat@DeepSeek LLM.

  • Max tokens per response: 4096.

  • Maximum retries: 3.

  • Temperature set low (0.1) for precise instructions.

  • Frequency and presence penalties applied to reduce repetition.

• Input Example Handling:

  • Parses user intents such as "I want to write about RAGFlow" or "Need a blog to promote our tool" to infer blog type and audience.

• Output Format: Markdown with sections like Parsed Writing Plan, Instructions for each sub-agent, and blog draft sections.

3. Agent:SlickSpidersTurn — Outline Agent

• Role: Creates a clear, SEO-friendly blog outline with H2 and H3 headings.

• Responsibilities:

  • Generate a logical, well-structured outline aligned with the user’s intent.

  • Assign 1-2 suggested long-tail keywords per section.

  • Produce section descriptions to guide the Body Agent.

  • Use the Tavily Search tool to research content structures when necessary (limited use).

  • Avoid writing paragraphs; focus on structure.

• Key Parameters:

  • Uses deepseek-chat@DeepSeek LLM.

  • Temperature set to 0.5 for balanced creativity.

  • Maximum retries: 3.

  • Has access to Tavily Search for external data retrieval.

• Output Format: Markdown outline including:

  • Suggested blog title

  • Introduction section with keywords

  • Several H2 and optional H3 sections with descriptions and keywords

  • Conclusion with key takeaways and optional call to action

4. Agent:IcyPawsRescue — Body Agent

• Role: Writes the full blog content based on the Outline Agent’s structure.

• Responsibilities:

  • Produce natural, engaging paragraphs (approx. 500-600 words per section).

  • Integrate keywords naturally.

  • Use Tavily Search only when additional factual support or examples are needed.

  • Follow the outline strictly, section-by-section.

  • Maintain tone appropriate to the audience and blog type.

  • Avoid filler content, prioritize clarity and SEO.

• Key Parameters:

  • LLM: deepseek-chat@DeepSeek.

  • Temperature: 0.2 for controlled creativity.

  • Uses Tavily Search tool with parameters for freshness and topical relevance.

• Output Format: Markdown content for each section, formatted under H2 headings.

5. Agent:TenderAdsAllow — Editor Agent

• Role: Finalizes the blog post, improving readability, SEO, and flow.

• Responsibilities:

  • Polish grammar, sentence flow, and transitions.

  • Ensure keyword integration is effective but not excessive.

  • Conduct lightweight SEO audit (checking headings, keyword density, structure).

  • Generate meta title and description.

  • Maintain Markdown formatting.

  • Align final content with original intent and audience.

• Key Parameters:

  • LLM: deepseek-chat@DeepSeek.

  • Temperature: 0.2 for precision.

  • No external tool usage.

• Output Format: Fully polished Markdown blog post ready for publishing.

6. Message:ModernSwansThrow

• Purpose: Represents the final message output containing the Lead Agent’s content.

• Flow: Receives the final blog from Lead Agent and sends it as output.

7. Tavily Search Tool

• Used by the Outline and Body Agents to perform web searches for:

  • Blog structures

  • Relevant facts, statistics, and examples

• Parameters include:

  • Search depth: basic

  • Max results: 5

  • Content included: raw content (no images)

  • Timeframe: last 7 days for freshness

Workflow and Data Flow

1. User Interaction: User provides blog topic, target audience, and goal via the Begin node.

2. Lead Agent:

   • Receives input, interprets it.

   • Creates writing plan.

   • Sends instructions to Outline, Body, and Editor Agents in parallel.

3. Outline Agent:

   • Generates blog outline with SEO keywords.

   • Uses Tavily Search for research if needed.

4. Body Agent:

   • Writes complete content sections based on outline.

   • Enriches content with data from Tavily Search as needed.

5. Editor Agent:

   • Polishes content.

   • Ensures SEO compliance and readability.

   • Produces final meta title and description.

6. Lead Agent:

   • Collects all outputs.

   • Assembles final blog draft in Markdown.

7. Message Node:

   • Outputs final blog content to the user.

Important Implementation Details

• Multi-Agent Architecture: Decomposes blog writing into specialized tasks, improving quality and controllability.

• LLM Settings: Carefully tuned temperature and penalty parameters balance creativity with focus and precision.

• Error Handling: Agents use retry and delay parameters to handle failures gracefully.

• Tool Integration: Selective use of the Tavily Search tool adds factual grounding and SEO relevance.

• Markdown Output: Ensures compatibility with popular blogging platforms and maintains formatting standards.

• Parallel Processing: Sub-agents operate concurrently, reducing total generation time.

Interaction with Other System Parts

• This file is designed for an AI orchestration platform that understands the JSON DSL for defining agents and their flows.

• Agents utilize an LLM service (deepseek-chat@DeepSeek) for natural language generation.

• External search tool integration (Tavily Search) is embedded for knowledge augmentation.

• The conversational Begin node interfaces directly with the user input layer.

• The output message node sends the final blog content back to the user or downstream application.

Usage Example (High-Level)

User Input:

Topic: How to improve Google rankings with AI
Audience: SEO marketers
Goal: Generate SEO traffic and educate on AI tools

Workflow:

• Begin node collects input and triggers Lead Agent.

• Lead Agent generates writing plan and instructs Outline Agent to create an SEO-focused structure.

• Outline Agent creates outline with suggested keywords.

• Body Agent writes detailed content for each section, enriching with data via Tavily Search if needed.

• Editor Agent polishes the entire content and generates metadata.

• Lead Agent assembles and passes the final Markdown blog post to the Message node for output.

Visual Diagram: Workflow Flowchart

flowchart TD
    Begin(["Begin\n(User Input)"])
    LeadAgent["Lead Agent\n(Coordinator)"]
    OutlineAgent["Outline Agent\n(Generates Structure)"]
    BodyAgent["Body Agent\n(Writes Content)"]
    EditorAgent["Editor Agent\n(Finalizes & Polishes)"]
    MessageNode["Message Node\n(Output Blog)"]
    TavilySearch1["Tavily Search\n(Used by Outline Agent)"]
    TavilySearch2["Tavily Search\n(Used by Body Agent)"]

    Begin --> LeadAgent
    LeadAgent --> OutlineAgent
    LeadAgent --> BodyAgent
    LeadAgent --> EditorAgent

    OutlineAgent --> TavilySearch1
    BodyAgent --> TavilySearch2

    OutlineAgent --> LeadAgent
    BodyAgent --> LeadAgent
    EditorAgent --> LeadAgent

    LeadAgent --> MessageNode

Summary

generate_SEO_blog.json is a sophisticated configuration file defining a multi-agent AI workflow to automatically create SEO-optimized blogs. It embodies a modular architecture dividing the writing process into planning, outlining, drafting, and editing stages, each handled by dedicated agents. This structure allows for more controlled, scalable, and human-like content generation, leveraging advanced LLMs and integrated search tools to produce high-quality, SEO-friendly Markdown blog posts from simple user instructions.