AI Blog Content Assistant

A multi-agent AI application built with Streamlit and CrewAI to help users transform a blog topic into research-backed, SEO-oriented content.

This project demonstrates the practical use of autonomous AI agents working together through a structured workflow. It is designed as a portfolio project to showcase skills in AI agent orchestration, prompt design, workflow automation, Python development, and user-facing AI applications.

Application Screenshot

The following screenshot shows the Streamlit frontend of the AI Blog Content Assistant, including the topic input, generation workflow, and generated blog content interface.

Project Overview

Creating useful blog content often requires several separate activities: understanding what is currently relevant, converting research into readable content, and optimizing the result for search visibility.

This application brings these activities together into a single workflow using three specialized CrewAI agents:

1. Researcher Agent
2. Writer Agent
3. SEO Specialist Agent

The user enters a topic through a Streamlit interface. CrewAI then executes the agents sequentially and returns a structured content package containing an SEO-friendly title, a five-sentence article, relevant keywords, and a meta description.

Problem This Project Solves

Content creation can be time-consuming when research, writing, and SEO optimization are handled manually.

This solution demonstrates how a multi-agent AI workflow can divide the work according to specialized responsibilities:

• Research current and relevant information.
• Convert research into concise content.
• Optimize the content for search visibility.
• Present the final result through a simple web interface.

The objective is not simply to generate text, but to demonstrate how specialized AI agents can collaborate within a repeatable workflow.

Agent Workflow

                    User enters topic
                           |
                           v
                 +--------------------+
                 |  Researcher Agent  |
                 |--------------------|
                 | Current trends     |
                 | Recent information |
                 | Key insights       |
                 +--------------------+
                           |
                           v
                 +--------------------+
                 |    Writer Agent    |
                 |--------------------|
                 | Uses research      |
                 | Creates article    |
                 | Exactly 5 sentences|
                 +--------------------+
                           |
                           v
                 +--------------------+
                 | SEO Specialist     |
                 |--------------------|
                 | SEO title          |
                 | Keywords           |
                 | Meta description   |
                 | Final article      |
                 +--------------------+
                           |
                           v
                 +--------------------+
                 |  Streamlit Result  |
                 +--------------------+

The Crew is configured to run sequentially so that the output from one stage becomes useful context for the next stage.

Key Features

Multi-Agent Architecture

The application uses three specialized agents instead of asking a single AI agent to perform every task.

Research-Driven Content

The Researcher agent is instructed to focus on current and recent developments, with emphasis on the latest available information.

Structured Writing

The Writer agent converts the research into an article containing exactly five sentences.

SEO Optimization

The SEO Specialist produces:

• SEO-friendly title
• Final five-sentence article
• 5 to 10 relevant SEO keywords
• Meta description

Streamlit User Interface

The application provides a simple browser-based interface where the user can enter a topic and generate the content without interacting directly with the Python code.

Execution Feedback

The application displays a CrewAI execution status while the agents are working, helping the user understand that the multi-agent workflow is in progress.

Technology Stack

Technology Purpose

---

Python Application development CrewAI Multi-agent orchestration CrewAI Tools Agent tools and integrations Streamlit Web application interface OpenAI Large language model Serper Web search for research python-dotenv Environment variable management

Project Structure

blog-content-crew-agent/
|
├── app.py
├── agents.py
├── tasks.py
├── crew.py
├── requirements.txt
├── .env
└── README.md

app.py

Provides the Streamlit user interface, accepts the blog topic, starts the CrewAI workflow, and displays the generated content.

agents.py

Defines the three CrewAI agents:

• Trending Topic Researcher
• Blog Writer
• SEO Specialist

tasks.py

Defines the responsibilities and expected outputs for each agent.

crew.py

Creates and executes the CrewAI workflow using a sequential process.

requirements.txt

Contains the Python dependencies required to run the application.

.env

Stores API credentials and should not be committed to GitHub.

Prerequisites

Before running the project, make sure you have:

• Python 3.11 or a compatible supported Python environment
• Git
• A GitHub account if you want to clone or contribute to the project
• An OpenAI API key
• A Serper API key for web research
• Internet connectivity

It is recommended to use a Python virtual environment to keep project dependencies isolated.

Installation

1. Clone the repository

git clone <YOUR_GITHUB_REPOSITORY_URL>

Move into the project directory:

cd blog-content-crew-agent

2. Create a virtual environment

On Windows:

python -m venv venv

3. Activate the virtual environment

On Windows Command Prompt:

venv\Scripts\activate

On Windows PowerShell:

venv\Scripts\Activate.ps1

4. Install dependencies

python -m pip install -r requirements.txt

5. Configure environment variables

Create a file named .env in the project root.

Add:

OPENAI_API_KEY=your_openai_api_key
SERPER_API_KEY=your_serper_api_key

Replace the placeholder values with your own API keys.

Do not commit .env to GitHub.

A .gitignore file should include:

.env
venv/
__pycache__/
*.pyc

Running the Application

With the virtual environment activated, run:

python -m streamlit run app.py

Streamlit will provide a local URL, normally:

http://localhost:8501

Open the URL in your browser.

How to Use

1. Enter a topic in the blog topic field.
2. Select "Generate Blog Content".
3. The Researcher agent researches current information.
4. The Writer agent creates the five-sentence article.
5. The SEO Specialist optimizes the result.
6. Review the generated title, article, keywords, and meta description.

Example input:

Electric vehicle trends in 2026

Expected output sections:

SEO-Friendly Title

Article

SEO Keywords

Meta Description

Security and API Key Management

API keys are loaded through environment variables rather than being hard-coded into the Python source.

Never publish API keys in:

• GitHub repositories
• README files
• Screenshots
• Source code
• Public configuration files

For public repositories, provide a .env.example file instead of the real .env.

Example:

OPENAI_API_KEY=your_openai_api_key
SERPER_API_KEY=your_serper_api_key

Design Approach

This project follows a separation-of-responsibilities approach.

The Researcher is responsible for information gathering.

The Writer is responsible for transforming research into readable content.

The SEO Specialist is responsible for improving search-oriented elements.

This separation makes the workflow easier to understand, maintain, test, and extend.

It also demonstrates a practical use case for multi-agent systems where different agents have clearly defined responsibilities.

Future Enhancements

Potential improvements include:

• Display individual agent progress as each task completes
• Add source links from the research stage
• Allow users to select article tone and target audience
• Allow users to choose article length
• Add blog category selection
• Add downloadable Markdown and Word document output
• Add content quality scoring
• Add SEO score evaluation
• Add keyword difficulty analysis
• Add human approval between agent stages
• Add persistent content history
• Deploy the application using Streamlit Community Cloud or another hosting platform

Portfolio Value

This project demonstrates practical experience with:

• Generative AI application development
• Multi-agent AI architecture
• CrewAI agent orchestration
• Task and prompt design
• Sequential agent workflows
• Tool-enabled AI agents
• Web research integration
• Python application development
• Streamlit application development
• Environment and API key management
• AI-generated content workflows

The project focuses on a real-world business use case rather than a standalone model demonstration. It shows how multiple AI capabilities can be composed into a repeatable application workflow.

Author

Padmavathy Balasundararaj

AI and automation project demonstrating a CrewAI-based multi-agent workflow for research, content creation, and SEO optimization.

Disclaimer

AI-generated content should be reviewed before publication.

Research results may contain incomplete, outdated, or inaccurate information. The application is intended as a content creation assistant and does not replace human editorial review or professional fact-checking.

License

Add your preferred open-source license before publishing the repository. MIT License is a common choice for portfolio projects.