🤖 Multi-AI Agent Blog Generator using CrewAI

Automatically generate well-researched, technically accurate, and beautifully formatted blog posts on any topic — powered by a crew of 5 specialized AI agents working in a sequential pipeline.

---

📌 Table of Contents

• What is this project?
• Why does this project exist?
• How it works — The Agent Pipeline
• Flowchart
• Project Structure
• Tech Stack & Tools
• Agent Details
• Task Details
• Setup & Installation
• Running on Google Colab
• Configuration
• Sample Output
• Limitations
• How Limitations Can Be Resolved
• Key Concepts for Beginners
• Contributing

---

🧠 What is this project?

This project is a Multi-AI Agent Blog Generator built using the CrewAI framework. Instead of asking a single AI to do everything, it assigns 5 specialized AI agents — each with a specific role — to collaborate on generating a high-quality blog post from scratch.

Think of it like a newsroom:

• A researcher gathers information
• A writer drafts the article
• A technical expert fact-checks it
• An editor polishes the language
• A formatter prepares it for publishing

All of this happens automatically when you provide a topic.

---

💡 Why does this project exist?

Writing a high-quality blog post manually involves:

1. Hours of research across multiple sources
2. Structuring the content logically
3. Writing in an engaging, readable style
4. Fact-checking all technical claims
5. Editing grammar and flow
6. Formatting for publishing platforms

This project automates the entire pipeline using AI agents, reducing a multi-hour task to a few minutes. It is especially useful for:

• 📚 Developers who want to document concepts quickly
• ✍️ Content creators who need a strong first draft
• 🎓 Students learning about AI orchestration and multi-agent systems
• 🚀 Startups that need frequent technical content at scale

---

⚙️ How it works — The Agent Pipeline

The system uses 5 AI agents in a sequential pipeline. Each agent completes its task before passing the output to the next agent.

User provides a Topic
        │
        ▼
┌───────────────────┐
│  1. Researcher    │  ── Gathers and summarizes key information about the topic
└────────┬──────────┘
         │ Research Document
         ▼
┌───────────────────┐
│  2. Content       │  ── Writes an engaging 1,000-word blog post from the research
│     Generator     │
└────────┬──────────┘
         │ Draft Blog Post
         ▼
┌───────────────────┐
│  3. Technical     │  ── Reviews the draft for technical accuracy and correctness
│     Reviewer      │
└────────┬──────────┘
         │ Verified Blog Post
         ▼
┌───────────────────┐
│  4. Copy Editor   │  ── Polishes grammar, style, tone, and readability
└────────┬──────────┘
         │ Polished Blog Post
         ▼
┌───────────────────┐
│  5. Markdown      │  ── Converts content into clean, publish-ready Markdown
│     Formatter     │
└────────┬──────────┘
         │
         ▼
   Final Blog Post (.md)

---

🗺️ Flowchart

                   ╔══════════════════════════╗
                   ║    User Input: Topic      ║
                   ╚══════════════╦═══════════╝
                                  │
                   ╔══════════════▼═══════════╗
                   ║       CrewAI Crew         ║
                   ║   (Sequential Process)    ║
                   ╚══════════════╦═══════════╝
                                  │
         ┌────────────────────────┼──────────────────────┐
         │                        │                       │
╔════════▼═══════╗     ╔══════════▼══════════╗  ╔════════▼═══════╗
║  Task 1        ║     ║  Task 2             ║  ║  Task 3        ║
║  Research      ║────▶║  Draft Blog Post    ║─▶║  Tech Review   ║
║  [Researcher]  ║     ║  [Generator]        ║  ║  [Reviewer]    ║
╚════════════════╝     ╚═════════════════════╝  ╚════════╦═══════╝
                                                          │
                                          ╔═══════════════▼══════════╗
                                          ║  Task 4                  ║
                                          ║  Copy Editing            ║
                                          ║  [Copy Editor]           ║
                                          ╚═══════════════╦══════════╝
                                                          │
                                          ╔═══════════════▼══════════╗
                                          ║  Task 5                  ║
                                          ║  Markdown Formatting     ║
                                          ║  [MD Formatter]          ║
                                          ╚═══════════════╦══════════╝
                                                          │
                                          ╔═══════════════▼══════════╗
                                          ║  Final Blog Output       ║
                                          ║  (Markdown .md format)   ║
                                          ╚══════════════════════════╝

LLM Token Budget per Agent

  Agent              Model           Temp   Max Tokens   Role
  ────────────────────────────────────────────────────────────
  Researcher         gpt-4o-mini     0.1    1500         Factual, detailed output
  Content Generator  gpt-4o-mini     0.3    1200         Creative, engaging writing
  Technical Reviewer gpt-4o-mini     0.0    800          Precise, zero hallucination
  Copy Editor        gpt-4o-mini     0.0    600          Consistent, clean edits
  Markdown Formatter gpt-4o-mini     0.0    500          Structured, predictable output

---

📁 Project Structure

multi-ai-agent-blog-generator/
│
├── Multi_AI_Agent_Blog_Generator_CrewAI.ipynb   # Main Colab notebook
├── requirements.txt                              # All Python dependencies
├── README.md                                     # This file
└── .env (optional)                               # API keys for local setup
                                                  # ⚠️ Never commit .env to GitHub

---

🛠️ Tech Stack & Tools

| Tool / Library | Version | Purpose | |---|---|---| | CrewAI | ≥ 0.80.0 | Multi-agent orchestration framework | | crewai-tools | latest | WebsiteSearchTool and other agent tools | | OpenAI API | gpt-4o-mini | LLM powering all 5 agents | | langchain-openai | latest | LLM integration layer (installed as dependency) | | Python | 3.10+ | Runtime environment | | Google Colab | — | Cloud notebook environment for execution |

Why CrewAI?

CrewAI is a framework built specifically for orchestrating role-playing AI agents that collaborate to complete complex tasks. Instead of writing all agent logic from scratch, CrewAI lets you:

• Define agents with roles, goals, and backstories
• Assign tasks to each agent with clear expected outputs
• Choose a process (sequential or hierarchical)
• Let the agents pass outputs to each other automatically

Why gpt-4o-mini?

• Significantly cheaper than GPT-4o while remaining capable for blog generation
• Supports a 128K token context window
• Fast response times, ideal for multi-step agent workflows
• Sufficient intelligence for structured writing and review tasks

Why Sequential Process?

In a Process.sequential workflow, each agent completes its task in order before the next one begins. This is ideal here because each stage depends on the output of the previous:

• Writer needs the research before writing
• Reviewer needs the draft before reviewing
• Editor needs the reviewed content before editing

---

🧑‍💼 Agent Details

1. 🔍 Researcher

| Attribute | Value | |---|---| | Role | Internet Research | | LLM Temperature | 0.1 (factual, low creativity) | | Max Tokens | 1500 | | Tools | None (uses LLM's internal knowledge) | | Goal | Research the topic and produce a structured summary | | Backstory | Highly skilled researcher specializing in extracting and consolidating information |

2. ✍️ Content Generator

| Attribute | Value | |---|---| | Role | Content Generator | | LLM Temperature | 0.3 (slightly creative) | | Max Tokens | 1200 | | Tools | None | | Goal | Write a 1,000-word engaging blog post with emojis and markdown | | Backstory | Expert blogger known for detailed, captivating, tutorial-style posts |

3. 🔬 Technical Reviewer

| Attribute | Value | |---|---| | Role | Technical Reviewer | | LLM Temperature | 0.0 (fully deterministic) | | Max Tokens | 800 | | Tools | None | | Goal | Verify all technical facts, examples, and code snippets | | Backstory | Technical expert who validates and improves blog accuracy |

4. 📝 Copy Editor

| Attribute | Value | |---|---| | Role | Copy Editor | | LLM Temperature | 0.0 (fully deterministic) | | Max Tokens | 600 | | Tools | None | | Goal | Polish grammar, tone, and readability | | Backstory | Skilled copy editor specializing in quality, tone, and readability |

5. 📄 Markdown Formatter

| Attribute | Value | |---|---| | Role | Markdown Formatter | | LLM Temperature | 0.0 (fully deterministic) | | Max Tokens | 500 | | Tools | None | | Goal | Format the final blog into clean, publish-ready Markdown | | Backstory | Expert in markdown structure, ensuring content is organized and clean |

---

📋 Task Details

| Task | Agent | Input | Output | |---|---|---|---| | task_search | Researcher | Topic string | 1,000-word research document | | task_draft_blog | Content Generator | Research document | Blog draft in Markdown | | task_review | Technical Reviewer | Blog draft | Revised, fact-checked blog | | task_edit | Copy Editor | Reviewed blog | Polished, grammar-corrected blog | | task_format_markdown | Markdown Formatter | Polished blog | Final .md-ready blog |

---

🚀 Setup & Installation

Prerequisites

• Python 3.10 or higher
• An OpenAI API key
• pip

Step 1: Clone the repository

git clone https://github.com/your-username/multi-ai-agent-blog-generator.git
cd multi-ai-agent-blog-generator

Step 2: Install dependencies

pip install -r requirements.txt

Step 3: Set up your API key

Option A — .env file (recommended for local development):

# Create a .env file in the project root
echo "OPENAI_API_KEY=sk-your-key-here" > .env

Then update the API key cell in the notebook:

from dotenv import load_dotenv
load_dotenv()
# OPENAI_API_KEY is now loaded from .env automatically

Option B — Environment variable directly in terminal:

export OPENAI_API_KEY=sk-your-key-here

Step 4: Run the notebook

Open Multi_AI_Agent_Blog_Generator_CrewAI.ipynb in Jupyter or VS Code and run all cells.

---

☁️ Running on Google Colab

This project is designed primarily for Google Colab. Follow these steps:

Step 1: Upload the notebook to Colab

Go to colab.research.google.com → File → Upload Notebook

Step 2: Store your API key in Colab Secrets

1. Click the 🔑 Secrets icon in the left sidebar
2. Click + Add new secret
3. Set Name = OPENAI_API_KEY
4. Set Value = your OpenAI API key (starts with sk-)
5. Toggle Notebook access to ON

Step 3: The notebook fetches the key automatically

from google.colab import userdata
os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

Step 4: Install dependencies (first cell)

!pip install crewai crewai_tools openai langchain-openai

Step 5: Run all cells

Runtime → Run all (Ctrl+F9)

⚠️ Note: The first run may take 3–8 minutes depending on your OpenAI rate limits (max_rpm=5).

---

⚙️ Configuration

You can customize the blog by changing these variables:

# Change the topic
topic = "Bagging vs Boosting in Machine Learning"

# Use a more powerful model for higher quality (costs more)
research_llm = LLM(temperature=0.1, model="gpt-4o", max_tokens=2000)

# Increase rate limit if you have a higher OpenAI tier
crew = Crew(..., max_rpm=20)

Token Budget Guide

| Goal | What to Change | |---|---| | Longer, richer research | Increase research_llm max_tokens (up to 4096) | | More creative blog writing | Increase generator_llm temperature (0.5–0.7) | | More detailed technical review | Increase review_llm max_tokens | | Faster execution | Increase max_rpm (requires higher OpenAI tier) | | Lower cost | Decrease all max_tokens or use gpt-3.5-turbo |

---

📄 Sample Output

Given the topic "Bagging vs Boosting in Machine Learning", the final output is a Markdown blog post structured like:

# Bagging vs Boosting in Machine Learning 🤖

## Introduction
Both Bagging and Boosting are ensemble learning techniques that combine
multiple models to improve prediction accuracy...

## What is Bagging? 🎒
Bagging (Bootstrap Aggregating) trains multiple models in **parallel**
on different random subsets of data...

## What is Boosting? 🚀
Boosting trains models **sequentially**, where each model focuses on
correcting the errors of the previous one...

## Key Differences
| Feature      | Bagging       | Boosting        |
|--------------|---------------|-----------------|
| Training     | Parallel      | Sequential      |
| Focus        | Variance ↓    | Bias ↓          |
| Example      | Random Forest | XGBoost         |

## Code Example
\`\`\`python
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier

rf = RandomForestClassifier(n_estimators=100)  # Bagging
gb = GradientBoostingClassifier(n_estimators=100)  # Boosting
\`\`\`

## Conclusion
...

---

⚠️ Limitations

1. Context Window Overflow (128K Token Limit)

What happens: With 5 sequential agents, the accumulated context (all previous agent outputs) can exceed gpt-4o-mini's 128K token limit, causing a context_length_exceeded error.

Why it happens: In a sequential crew, every agent receives the full conversation history of all previous agents. By agent 4 or 5, this history is enormous.

---

2. Rate Limiting (429 TPM Errors)

What happens: OpenAI enforces a Tokens Per Minute (TPM) limit. Free and Tier-1 accounts have a 200K TPM ceiling. Five agents burning tokens simultaneously can exhaust this quickly.

Why it happens: Each agent makes multiple internal LLM calls — for reasoning, tool use, and producing output. Failed calls trigger retries, which consume even more tokens.

---

3. No Real-Time Web Search

What happens: WebsiteSearchTool was removed (tools=[]) to prevent context overflow. The researcher now relies entirely on the LLM's pre-trained knowledge.

Why it matters: For fast-moving topics (e.g., "latest AI news in 2025"), the content may be outdated or incomplete.

---

4. No Automatic Output Saving

What happens: The generated blog is only printed to the console. If your Colab session disconnects or times out, the output is lost.

---

5. Single Model Dependency

What happens: All agents depend on OpenAI's API. An outage, billing limit, or key expiry causes the entire pipeline to fail.

---

6. Cost Per Run

Each run makes approximately 10–25 LLM API calls across 5 agents. At gpt-4o-mini pricing (~$0.15/1M input tokens, ~$0.60/1M output tokens), this costs roughly $0.01–$0.05 per blog.

---

🔧 How Limitations Can Be Resolved

Fix 1: Context Overflow → Switch to SerperDevTool

# SerperDevTool returns compact search snippets (~200 tokens)
# instead of full web pages (~10,000+ tokens)
from crewai_tools import SerperDevTool

os.environ["SERPER_API_KEY"] = userdata.get('SERPER_API_KEY')
# Free API key at: https://serper.dev

web_tool = SerperDevTool()

task_search = Task(
    ...,
    tools=[web_tool],   # re-enable web search safely
    agent=researcher
)

---

Fix 2: Rate Limiting → Throttle requests or upgrade tier

# Lower max_rpm for free-tier accounts
crew = Crew(..., max_rpm=3)

# OR upgrade to OpenAI Tier 2 (2M TPM limit)
# OR switch to a higher-TPM model
llm = LLM(model="gpt-3.5-turbo", max_tokens=800)

---

Fix 3: No Real-Time Data → Re-enable web search with SerperDevTool

See Fix 1 above. SerperDevTool is the correct replacement — it searches the web but returns only short summaries, not full page content.

---

Fix 4: Output Not Saved → Add file-saving logic

result = crew.kickoff()

# Auto-save to a markdown file
filename = f"blog_{topic.replace(' ', '_').lower()}.md"
with open(filename, "w", encoding="utf-8") as f:
    f.write(str(result))

print(f"✅ Blog saved to {filename}")

---

Fix 5: Single Model Dependency → Add fallback LLM providers

# Option A: Use Anthropic Claude (requires ANTHROPIC_API_KEY)
from crewai import LLM
llm = LLM(model="claude-3-haiku-20240307")

# Option B: Use open-source models via Ollama (free, runs locally)
llm = LLM(model="ollama/llama3", base_url="http://localhost:11434")

# Option C: Use Groq (very fast, generous free tier)
llm = LLM(model="groq/llama3-8b-8192")

---

Fix 6: Cost Optimization → Reduce agents for simple topics

# Use only 3 agents for simple or short blog posts
crew = Crew(
    agents=[researcher, generator, markdown_formatter],
    tasks=[task_search, task_draft_blog, task_format_markdown],
    verbose=True,
    max_rpm=5,
    process=Process.sequential
)

---

📚 Key Concepts for Beginners

What is an AI Agent?

An AI agent is a Large Language Model (LLM) given a role, a goal, and optionally tools. Instead of just answering one question, it reasons through a multi-step task, uses tools if needed, and produces a structured output — much like a human specialist.

What is CrewAI?

CrewAI is a Python framework that lets you define multiple agents and have them collaborate on a complex task. It handles:

• Passing outputs between agents automatically
• Managing conversation history and context
• Controlling the order of execution (sequential or hierarchical)
• Integrating external tools (web search, file readers, etc.)

What is a Sequential Process?

In Process.sequential, agents execute one after another in a fixed order. Agent 2 only starts after Agent 1 finishes, and receives Agent 1's output as context. This is appropriate when every step depends on the result of the previous step.

What is a Token?

A token is roughly ¾ of an English word. "Machine Learning" ≈ 2 tokens. LLMs have a context window — the maximum number of tokens they can process at once. gpt-4o-mini's limit is 128,000 tokens (~96,000 words). Exceeding this causes an error.

What is Temperature?

Temperature controls how creative vs. deterministic the LLM is:

• 0.0 = always picks the most statistically likely next word (consistent, factual, predictable)
• 1.0 = more random, diverse, and creative
• This project uses low temperatures (0.0–0.3) to keep outputs professional and accurate.

What is max_rpm?

max_rpm (Max Requests Per Minute) throttles how many API calls the crew makes per minute. Setting this low (e.g., 5) prevents hitting OpenAI's rate limits, at the cost of slower execution.

---

🤝 Contributing

Contributions are welcome! Here are some ideas to improve the project:

• 🌐 Add SerperDevTool for real-time web research
• 💾 Add automatic file saving of the generated blog
• 🖥️ Build a Streamlit UI for non-technical users
• 🤖 Add support for multiple LLM providers (Anthropic, Ollama, Groq)
• 🏗️ Experiment with Hierarchical Process mode (manager delegates tasks)
• 📊 Add a token usage tracker to monitor costs per run

To contribute:

# 1. Fork the repository on GitHub
# 2. Create a feature branch
git checkout -b feature/add-serper-tool

# 3. Make your changes and commit
git commit -m "Add SerperDevTool for real-time web search"

# 4. Push and open a Pull Request
git push origin feature/add-serper-tool

---

🙏 Acknowledgements

• CrewAI — for the multi-agent orchestration framework
• OpenAI — for the gpt-4o-mini model
• LangChain — for LLM integration utilities
• Serper.dev — for the web search API

---

Built with ❤️ using CrewAI and OpenAI