Agentic Blog Forge v2

Multi-Agent Blog Content Forge with FastAPI Service & Multi-Platform Deployment

Features | Installation | Quick Start | API | Deployment | Development

---

Overview

Agentic Blog Forge is a production-ready, multi-agent system for transforming raw dialogue and brainstorming content into polished, platform-optimized blog posts. Built with FastAPI and modern Python async patterns, it supports deployment across multiple AI platforms including OpenClaw, Hermes, WorkBuddy, Claude Code, and Kimi Code.

Features

Core Capabilities

• Multi-Agent Pipeline - 8 specialized agents working in concert:
  • InputAgent - Ingests and preprocesses raw dialogue/text
  • AnalyzerAgent - Extracts key information and generates analysis reports
  • TopicAgent - Identifies core topics and creates topic reports
  • WriterAgent-CN - Generates polished Chinese blog posts
  • WriterAgent-EN - Generates polished English blog posts
  • NarrativeAgent - Transforms content into engaging narratives
  • PlatformAgent - Adapts content for Medium, WeChat, X/Twitter, Xiaohongshu
  • LongTextScheduler - Handles arbitrarily long inputs via chunking

Technical Highlights

• FastAPI Service - High-performance async API with auto-generated docs
• Pydantic v2 Models - Type-safe data validation throughout
• Async/Await - Full asynchronous support for concurrent processing
• Multi-Platform Deployment - Adapters for OpenClaw, WorkBuddy, Claude Code, Kimi Code
• Docker Support - Multi-stage builds and compose orchestration
• CLI Tool - Rich command-line interface for local usage
• Comprehensive Logging - Structured logging with structlog
• Error Handling - Custom exceptions and middleware
• Metrics - Prometheus-compatible instrumentation

Installation

From PyPI (Recommended)

pip install agentic-blog-forge

Development Install

git clone https://github.com/agentic-team/agentic-blog-forge.git
cd agentic-blog-forge
make dev-install

Verify Installation

forge --version

Quick Start

CLI Usage

# Analyze a dialogue file
forge analyze --input dialogue.txt --output analysis.json

# Generate a full blog post
forge full --input brainstorming.md --output blog.md --language cn

# Start the API server
forge serve --host 0.0.0.0 --port 8000

API Usage

# Start the server
make run

# Analyze content
curl -X POST http://localhost:8000/api/v1/analyze \
  -H "Content-Type: application/json" \
  -d '{"content": "Your raw dialogue text here..."}'

# Full pipeline
curl -X POST http://localhost:8000/api/v1/full \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Your brainstorming notes...",
    "language": "cn",
    "platforms": ["wechat", "medium"]
  }'

Python API

import asyncio
from agentic_blog_forge.core.pipeline import Pipeline
from agentic_blog_forge.core.config import Settings

async def main():
    settings = Settings()
    pipeline = Pipeline(settings)

    result = await pipeline.run(
        content="Your raw content here...",
        language="cn",
        platforms=["wechat", "medium"]
    )

    print(result.blog_cn.content)
    print(result.platforms["wechat"].content)

asyncio.run(main())

API Documentation

When the server is running, interactive API documentation is available at:

• Swagger UI: http://localhost:8000/docs
• ReDoc: http://localhost:8000/redoc

Endpoints

Method	Endpoint	Description
POST	/api/v1/analyze	Analyze raw content
POST	/api/v1/topics	Extract topics
POST	/api/v1/write/cn	Write Chinese blog post
POST	/api/v1/write/en	Write English blog post
POST	/api/v1/transform	Narrative transformation
POST	/api/v1/adapt	Platform adaptation
POST	/api/v1/full	Full pipeline
GET	/api/v1/health	Health check

See docs/API.md for detailed API documentation.

Deployment

Docker

make docker-build
make docker-run

OpenClaw / Hermes

make deploy-openclaw

WorkBuddy (IDE Plugin)

make deploy-workbuddy

Claude Code

make deploy-claude

Kimi Code

make deploy-kimi

See docs/DEPLOY.md for platform-specific deployment details.

Development

# Install dev dependencies
make dev-install

# Run tests
make test

# Run linters
make lint

# Format code
make format

# Start dev server
make run

Project Structure

agentic-blog-forge/
├── src/agentic_blog_forge/    # Core package
│   ├── core/                  # Pipeline & config
│   ├── agents/                # Agent implementations
│   ├── api/                   # FastAPI service
│   ├── cli/                   # Command-line tool
│   └── utils/                 # Utilities
├── deploy/                    # Deployment adapters
│   ├── docker/                # Docker support
│   ├── openclaw/              # OpenClaw/Hermes
│   ├── workbuddy/             # WorkBuddy IDE
│   ├── claude_code/           # Claude Code
│   └── kimi_code/             # Kimi Code
├── tests/                     # Test suite
├── docs/                      # Documentation
├── pyproject.toml             # Project config
├── Makefile                   # Common commands
└── README.md                  # This file

Changelog

See CHANGELOG.md for version history.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Make your changes
4. Run tests and linting (make test && make lint)
5. Commit your changes (git commit -m 'Add amazing feature')
6. Push to the branch (git push origin feature/amazing-feature)
7. Open a Pull Request