Abstract

In an age where content creation is both abundant and algorithm-driven, the demand for authentic, high-quality, and privacy-conscious editorial workflows has never been greater. Traditional AI tools often rely on cloud APIs that compromise privacy, incur usage costs, or introduce latency. In contrast, our Content Creation Multi-Agent System introduces a novel, zero-API, local-first architecture that enables autonomous article generation from start to finish—entirely offline.

The Content Creation Multi-Agent System is a fully local, privacy-first AI orchestration pipeline designed to automate high-quality content generation. By leveraging LangGraph and local Ollama LLMs, the system coordinates a team of specialized AI agents—from research to quality assurance—to produce SEO-optimized articles without requiring internet or API access.

This system leverages a collaborative pipeline of specialized agents, each responsible for a distinct phase in the content lifecycle. Whether it's performing web research, drafting a coherent article, optimizing for SEO, or conducting quality checks, these agents function harmoniously under the orchestration of LangGraph's state management, and run on your machine using local Ollama models.

Highlights:

• 🛡️ 100% offline and private
• 💸 Zero API costs
• 🤖 Multi-agent orchestration (Research → SEO → QA)
• 🧩 Modular and educational architecture

This project is updated version of the following project: https://app.readytensor.ai/publications/content-creation-multi-agent-system-KIOS1uHdGJUw

The new version is an updated, production‑ready release of this project with a Streamlit web UI and several enhancements:

• Streamlit UI: Form‑based inputs, live progress per agent, preview panel, and one‑click downloads of results.
• Offline by Default: Runs fully on Ollama with local models (no 3rd‑party APIs). Optional search tools can be enabled.
• Better Orchestration: Clear, typed state flowing across Research → Planning → Writer → Editor → SEO → QA with guardrails and retries.
• Reproducibility: Pinned dependencies, deterministic settings (temperature/seed), and saved run metadata.
• Quality Gates: Readability, structure, keyword coverage, and SEO scoring with failure handling.
• Usability Paths: CLI, Python API, and Streamlit—pick what suits your workflow.
• Artifacts & Logs: Organized outputs with audit‑friendly logging.

🔁 Feature Matrix: Previous vs Streamlit Edition

Methodology

🏗 System Architecture Overview

The Content Creation Multi-Agent System is built on a foundational belief: AI content generation should be trustworthy, reproducible, and under the user’s full control. This philosophy drives every component of its architecture—from model execution to task orchestration.

The core of the system is built on a LangGraph StateGraph, which manages the transitions between agents in a modular, traceable fashion. The high-level flow begins when a user submits a topic or request. This request then activates a set of six AI-powered agents, each executing a role akin to human editorial staff in a newsroom.

🧩 Agents and Roles

Agent Workflow is as follows:

Detailed Responsibilities

Research Agent

• Conducts web searches for topic information
• Gathers facts, statistics, and supporting data
• Builds a comprehensive research foundation

Planning Agent

• Creates detailed content outlines
• Defines structure and key points
• Sets target keywords and optimization strategy

Writer Agent

• Generates an initial content draft using a local Ollama model
• Follows the planned structure and incorporates research
• Maintains consistent tone and style

Editor Agent

• Reviews and improves content quality
• Enhances readability and flow using NLTK analysis
• Ensures target requirements are met

SEO Agent

• Optimizes content for search engines
• Analyzes keyword density and placement
• Provides actionable SEO recommendations

Quality Assurance Agent

• Performs final content validation
• Generates quality reports and metrics
• Saves final content with comprehensive metadata

All components are tied into a centralized State Management module, ensuring traceable transitions and robust recovery. Each step produces a tangible, inspectable output.

The Architecture at a Glance

To help visualize how the system works internally, consider the following architecture diagram:

graph TD
    D[Agent Pipeline]

    D --> E[ResearchAgent]
    D --> F[PlanningAgent] 
    D --> G[WriterAgent]
    D --> H[EditorAgent]
    D --> I[SEOAgent]
    D --> J[QualityAssuranceAgent]

    E --> K[DuckDuckGo API]
    G --> L[Ollama LLM]
    H --> M[NLTK Analysis]
    I --> N[SEO Tools]
    J --> O[File System]

This agent pipeline model not only enhances readability but also improves modular debugging and replacement of components.

🛠️ Tool Integration

🔧 Project Structure Snapshot

content-creation-multi-agent-system/
├── main.py                # Core LangGraph-driven workflow
├── demo.py                # Interactive use-case demo
├── test_agents.py         # Unit tests for each agent
├── resolve_conflicts.py   # Fix common local dependency issues
├── outputs/               # Generated articles and logs
├── OLLAMA_SETUP_GUIDE.md  # Step-by-step Ollama LLM install
├── .env                   # Local config for model parameters

Designed with simplicity: 1-click setup, modular customization, and extensive documentation make it ideal for both R&D and real-world use.

🔧 Installation & Quick‑Start Guide

Follow these steps to get the Content Creation Multi‑Agent System running on your local machine.

1. Clone the repository

   git clone https://github.com/your-org/content-creation-multi-agent-system.git
   cd content-creation-multi-agent-system

2. Create a virtual environment (optional but recommended)

   python -m venv .venv
   source .venv/bin/activate            # on macOS/Linux
   .venv\Scripts\activate             # on Windows

3. Install Python dependencies

   pip install -r requirements.txt

4. Install Ollama and download a local LLM

   The project is tested against llama3 (7‑B and 13‑B) models.
   See OLLAMA_SETUP_GUIDE.md for platform‑specific instructions.

   # Example
   brew install ollama           # macOS (Homebrew)
   ollama run llama3

5. Run the pipeline

   python main.py

All generated articles and logs will appear in the outputs/ directory.

Try python demo.py for an interactive walkthrough.

▶️ Streamlit Quickstart

# Launch the UI
streamlit run streamlit_app.py

UI highlights

• Guided form for topic, target audience, tone, word count, and keywords
• Live stage tracker (Research → Planning → Writer → Editor → SEO → QA)
• Inline preview and downloadable final artifact

🌐 Access to Technical Assets

✅ Testing

The Content Creation Multi-Agent System uses a comprehensive test suite with PyTest to ensure reliability, performance, and correctness across all components. The testing framework includes unit tests, integration tests, end-to-end tests, and tool validation tests.

Test Categories

1. Unit Tests

Purpose: Test individual agent functionality in isolation
Coverage: 15 tests across 6 agents + error handling
Focus: Agent initialization, core methods, exception handling

2. Integration Tests

Purpose: Test agent-to-agent interactions and state flow
Coverage: 14 tests covering pipeline stages and state management
Focus: Data flow, state consistency, feedback accumulation

3. End-to-End Tests

Purpose: Test complete content creation workflows
Coverage: 9 tests covering real-world scenarios
Focus: Full pipeline execution, different content types

4. Tool Tests

Purpose: Test external tool integrations
Coverage: 13 tests covering web search, analysis, SEO, file operations
Focus: API integration, error handling, data validation

Detailed test configuration and test runs are provided in **TEST_DOCUMENTATION.md** in code repository.

🎥 Results

Here is a video of a streamlit sample:

🧭 Significance & Implications

By orchestrating specialised agents entirely offline, this system proves that high‑quality, SEO‑ready content can be generated without surrendering data to cloud providers or incurring API fees.

Security, Privacy & Safety

Threat model & trust boundaries

• Offline‑by‑default: All LLM inference occurs via Ollama on localhost; network tools are opt‑in.
• Data stays local: Inputs, prompts, intermediate state, and artifacts are stored under ./outputs/ with access limited to the host user.
• Cost Efficiency: Eliminates recurring AI usage fees.
• Explicit trust zones: UI ↔ Orchestrator ↔ Tools/LLM ↔ Storage (see Figure 3). No third‑party services by default.

Controls

• Input hardening: schema‑validated requests; size/format limits; content sanitization.
• Prompt‑safety patterns: system prompts enforce "tool‑only" responses; sensitive content redaction before model calls.
• Tool allow‑listing: only vetted tools enabled; each tool runs with timeouts, retries, and rate limits.
• Output filtering: profanity/PHI/PII filters; markdown/HTML sanitization; link allow‑list.
• Secrets handling: .env file is optional; never logged. Secrets are read at process start and not written to disk.
• Logging & audit: structured logs (JSON) with run IDs; artifacts include a run manifest (model, hash, params, checksums).
• Dependency security: pip-audit and safety checks in CI; SBOM generation with pipdeptree.
• Sandboxing: OS‑level permissions; no shell tool execution by default; file IO constrained to project dirs.

Compliance alignment

• Privacy: data minimization; opt‑in telemetry (default off); simple data‑deletion procedure (./outputs/ purge).
• GDPR‑friendly: no cloud processing by default; clear purpose/retention; user‑requested deletion honored.

Security test cases (part of CI)

• Injection strings in inputs/prompts → verify neutralization
• Tool timeouts/retries → verify graceful failure and logging
• File path traversal attempts → verify denial

📜 Licensing & Usage Rights

This project is released under the MIT License:

• ✔️ Commercial & private use
• ✔️ Distribution & modification
• ✔️ Patent use

A full license text is available in the accompanying LICENSE file.
When redistributing, please retain copyright notices.

Model License: Local LLMs pulled via Ollama are subject to the model creator’s license.
Ensure compliance when integrating third‑party models.