← Back to Home

Introduction: Why I Needed an AI Agent to Help Me Produce Content

AI AgentMiniMax APIMCP Server 协议 ProtocolWorkflow AutomationContent Generation

# AI Agent Workflow Automation in 2026: How I Achieved Full Content Production with MiniMax API

---

Introduction: Why I Needed an AI Agent to Help Me Produce Content

I'm an independent developer running 3 tech blogs and 2 YouTube channels simultaneously. Here's what manual content updates looked like:

I was spending over 15 hours per week on these repetitive content tasks. This was clearly unsustainable.

In October 2025, I started researching AI Agents and discovered the MCP (Model Context Protocol) that lets me chain multiple AI services into automated workflows. After 6 months of troubleshooting and optimization, I've now achieved near-complete automation from content production to publishing, reducing daily manual intervention from 3 hours to 15 minutes.

This article is my complete踩坑 record, suitable for tech bloggers, indie developers, and content operators.

---

Part 1: Understanding AI Agents and the MCP Protocol

What Is an AI Agent

An AI Agent is an AI system capable of autonomously planning and executing multi-step tasks. Unlike simple single-turn Q&A, an Agent can:

My use case: My AI Agent automatically checks tech news sources every hour, captures articles relevant to my blog topics, uses the MiniMax API to generate Chinese summaries, and automatically publishes to various platforms.

What Is the MCP Protocol

MCP (Model Context Protocol) is an open standard protocol released by Anthropic in November 2024, designed to solve interoperability problems between different AI tools.

Before MCP, each AI tool required independent development and adaptation:

AI Assistant → OpenWeather API (independent adaptation)
AI Assistant → Slack API (independent adaptation)
AI Assistant → GitHub API (independent adaptation)

With MCP, all tools connect through a unified protocol:

AI Assistant ← MCP Protocol → Weather Tool
                 → Messaging Tool
                 → Code Tool
                 → MiniMax API ← MCP → AI Assistant

The core advantage of MCP is configure once, run everywhere. After I configured the MiniMax MCP Server, any MCP-compatible AI client (Cursor, Claude Desktop, Cline) can directly call the MiniMax API.

---

Part 2: Environment Setup and Toolchain Selection

Hardware and System Environment

My test environment configuration:

ComponentConfigurationNotes
Operating SystemUbuntu 开发环境 24.04 LTSNoble Numbat, the latest LTS version confirmed
Memory16GB DDR5Agent doesn't use much RAM, but 16GB+ recommended for concurrent tasks
Disk500GB NVMe SSDContent data + Docker images require sufficient space
Python3.12.3Confirmed latest stable Python version
DockerPlease refer to official Docker release notes for latest versionEssential for containerized deployment
Nginx 性能调优1.30.0Reverse proxy + static resource serving

Why not use cloud functions directly? Cloud functions (like AWS Lambda) are suitable for stateless computing, but AI Agent workflows typically require persistent state (memory, context), and long-running costs are higher than VPS.

Software Dependency Installation (10 Detailed Steps)

Step 1: Update System and Install Base Dependencies

# Update system packages
sudo apt update && sudo apt upgrade -y

# Install base dependencies
sudo apt install -y curl wget git build-essential \
  libssl-dev libffi-dev python3-pip python3-venv \
  nginx certbot python3-certbot-nginx

Step 2: Install Docker (Ubuntu 24.04 Environment)

# Add Docker official GPG key
curl -fsSL https://download.Docker 容器化部署.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add Docker repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Verify installation
sudo docker run --rm hello-world

> ⚠️ **踩坑 Record**: When installing Docker on Ubuntu 24.04, using the old repository address causes signature errors. You must explicitly specify the key path using the signed-by parameter—this is Ubuntu 24.04's new APT security policy.

Step 3: Install Nginx and Configure Reverse Proxy Foundation

# Install Nginx
sudo apt install -y nginx

# Enable and start on boot
sudo systemctl enable nginx
sudo systemctl start nginx

# Check Nginx status
sudo systemctl status nginx
# Should see "active (running)"

Step 4: Install Python 3.12 and Project Virtual Environment

# Ubuntu 24.04 default Python is already 3.12, no extra installation needed
python3 --version
# Output: Python 3.12.3

# Create project directory
mkdir -p ~/ai-agent-project
cd ~/ai-agent-project

# Create virtual environment
python3 -m venv venv
source venv/bin/activate

# Install core dependencies
pip install --upgrade pip
pip install requests python-dotenv mcp httpx aiofiles

Step 5: Obtain MiniMax API Key

1. Visit MiniMax platform: https://platform.minimaxi.com

2. Register and complete real-name authentication

3. Go to the "tokens" page to purchase a Token package (I have an exclusive discount code: E5yur9NOub—use it during registration for savings)

4. Create a new key on the "API Keys" page and save to the .env file:

# Create .env file in project directory
cat > .env << 'EOF'
MINIMAX_API_KEY=your_api_key_here
MINIMAX_BASE_URL=https://api.minimaxi.com/v1
EOF
chmod 600 .env  # Set key file permissions to 600

Step 6: Configure MCP Server (MiniMax Adapter)

Currently there's no official MiniMax Server in the MCP ecosystem, but I wrote a lightweight adapter in about 80 lines of Python:

# File: mcp_minimax_server.py
import os
import requests
from mcp.server import Server
from mcp.types import Tool, TextContent
from mcp.server.stdio import stdio_server

MINIMAX_API_KEY = os.getenv("MINIMAX_API_KEY")
MINIMAX_BASE_URL = os.getenv("MINIMAX_BASE_URL", "https://api.minimaxi.com/v1")

server = Server("minimax-mcp")

@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="minimax_chat",
            description="Use MiniMax API for chat generation",
            inputSchema={
                "type": "object",
                "properties": {
                    "prompt": {"type": "string", "description": "User prompt"},
                    "model": {"type": "string", "description": "Model name, default abab6.5s"},
                    "max_tokens": {"type": "integer", "description": "Max tokens to generate"}
                }
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "minimax_chat":
        response = requests.post(
            f"{MINIMAX_BASE_URL}/text/chatcompletion_v2",
            headers={"Authorization": f"Bearer {MINIMAX_API_KEY}"},
            json={
                "model": arguments.get("model", "abab6.5s"),
                "messages": [{"role": "user", "content": arguments["prompt"]}],
                "max_tokens": arguments.get("max_tokens", 1024)
            }
        )
        result = response.json()
        return TextContent(type="text", text=result["choices"][0]["message"]["content"])
    return TextContent(type="text", text="Unknown tool")

async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

Save and set executable, then test:

chmod +x mcp_minimax_server.py
python3 mcp_minimax_server.py
# If you see MCP server started successfully, configuration is correct

Step 7: Write AI Agent Main Program

# File: content_agent.py
import os
import asyncio
from datetime import datetime
from mcp_minimax_server import server, MINIMAX_API_KEY, MINIMAX_BASE_URL
import requests

class ContentWorkflowAgent:
    def __init__(self):
        self.api_key = MINIMAX_API_KEY
        self.base_url = MINIMAX_BASE_URL

    def research_topic(self, keyword: str) -> list:
        """Crawl and analyze trending content on related topics"""
        prompt = f"""You are a technical content researcher. Please analyze the topic "{keyword}":
        1. List 3 currently best-worth-writing niche angles (avoid highly competitive topics)
        2. Give a one-sentence title suggestion for each angle
        3. Give search keyword suggestions for each angle (3 keywords)
        Please answer in Chinese."""

        response = requests.post(
            f"{self.base_url}/text/chatcompletion_v2",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={
                "model": "abab6.5s",
                "messages": [{"role": "user", "content": prompt}],
                "max_tokens": 800
            }
        )
        return response.json()["choices"][0]["message"]["content"]

    def generate_article(self, topic: str, outline: list, style: str = "技术教程") -> str:
        """Generate complete article based on outline"""
        outline_str = "\n".join([f"- {o}" for o in outline])
        prompt = f"""You are a senior tech blogger, skilled at writing {style} style articles.

Topic: {topic}

Article outline:
{outline_str}

Requirements:
1. Write in first person, incorporate personal experience and troubleshooting records
2. Include specific commands, code, or configuration examples
3. Each section should have a summary
4. Word count requirement: 1500+ words
5. No AI tone—write like a real human engineer

Please start writing:"""

        response = requests.post(
            f"{self.base_url}/text/chatcompletion_v2",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={
                "model": "abab6.5s",
                "messages": [{"role": "user", "content": prompt}],
                "max_tokens": 4000
            }
        )
        return response.json()["choices"][0]["message"]["content"]

    def adapt_for_platform(self, content: str, platform: str) -> str:
        """Adapt content for different platforms"""
        platform_hints = {
            "twitter": "Convert to tweet style within 280 characters, highlight core points, include relevant hashtags",
            "zhihu": "Adjust to Zhihu style, increase professional depth, can appropriately expand technical details",
            "wechat": "Adjust to WeChat public account style, add opening hook and ending CTA",
            "devto": "Adjust to Dev.to tech community style, use English but retain technical depth"
        }

        prompt = f"""Rewrite the following content adapted for the {platform} platform:

{content[:2000]}...

Requirements: {platform_hints.get(platform, 'Keep original style')}"""

        response = requests.post(
            f"{self.base_url}/text/chatcompletion_v2",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={
                "model": "abab6.5s",
                "messages": [{"role": "user", "content": prompt}],
                "max_tokens": 1500
            }
        )
        return response.json()["choices"][0]["message"]["content"]

    async def run_full_workflow(self, keyword: str, platforms: list):
        """Run complete content production workflow"""
        print(f"[{datetime.now().strftime('%H:%M:%S')}] Starting content production workflow...")

        # Step 1: Research topic
        print(f"[1/4] Researching topic: {keyword}")
        research = self.research_topic(keyword)

        # Step 2: Generate article (simplified here, actual workflow extracts outline from research)
        print(f"[2/4] Generating article...")
        article = self.generate_article(keyword, ["Background Introduction", "Core Principles", "Practical Steps", "Common Issues"])

        # Step 3: Multi-platform adaptation
        print(f"[3/4] Adapting for publishing platforms: {', '.join(platforms)}")
        adaptations = {}
        for platform in platforms:
            adaptations[platform] = self.adapt_for_platform(article, platform)

        # Step 4: Generate publishing report
        print(f"[4/4] Generating publishing report")
        report = f"""
=== Content Production Report ===
Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
Topic: {keyword}
Produced: 1 main article + {len(platforms)} platform-adapted versions
Estimated reach: {len(platforms) * 500}+
Token consumption: ~{4000 + len(platforms) * 1500} (estimated by max_tokens)
"""
        print(report)
        return {"article": article, "adaptations": adaptations, "report": report}

if __name__ == "__main__":
    agent = ContentWorkflowAgent()
    result = asyncio.run(agent.run_full_workflow(
        keyword="VPS Development Environment Configuration",
        platforms=["zhihu", "twitter", "wechat"]
    ))

Step 8: Docker Containerized Deployment

# Dockerfile
FROM python:3.12-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Copy dependency file
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Set environment variables
ENV PYTHONUNBUFFERED=1
ENV MINIMAX_API_KEY=${MINIMAX_API_KEY}

# Run Agent
CMD ["python3", "-u", "content_agent.py"]
# docker-compose.yml
version: '3.8'
services:
  content-agent:
    build: .
    env_file:
      - .env
    volumes:
      - ./output:/app/output
      - ./logs:/app/logs
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 512M

  # Nginx reverse proxy (if exposing service externally)
  nginx-proxy:
    image: nginx:1.30.0
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - content-agent
    restart: unless-stopped

Step 9: Configure Nginx Reverse Proxy (if exposing service externally)

# File: nginx.conf (key sections)
events {
    worker_connections 1024;
}

http {
    upstream content_agent {
        server content-agent:8000;
        keepalive 32;
    }

    server {
        listen 80;
        server_name your-domain.com;

        location / {
            proxy_pass http://content_agent;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_read_timeout 300s;
            proxy_connect_timeout 75s;
        }

        # Health check endpoint
        location /health {
            access_log off;
            return 200 "healthy\n";
            add_header Content-Type text/plain;
        }
    }
}

Step 10: Start and Verify

# Execute in project directory
cd ~/ai-agent-project

# Build and start
docker compose up -d --build

# View logs
docker compose logs -f content-agent

# Verify service status
curl http://localhost/health
# Output: healthy

# View running containers
docker compose ps

---

Part 3: My 6-Month Usage Data and Cost Analysis

Actual Runtime Data

My AI Agent workflow has been running from October 2025 to now (April 2026), spanning 6 months. Here are real data:

MonthContent GeneratedAPI Cost (CNY)Manual Time SavedNotes
Oct 202512 articles8918 hoursDebugging period, many failed tasks
Nov 202528 articles15642 hoursWorkflow stabilized
Dec 202535 articles19852 hoursStarted multi-platform distribution
Jan 202642 articles23463 hoursAdded video script generation
Feb 202648 articles26772 hoursPeak month
Mar 202645 articles25167 hoursPrompt optimization

6-month total: 210 articles generated, 1,195 CNY spent, 314 hours saved (averaging 13 hours/week).

Cost Comparison Analysis

SolutionMonthly CostMonthly OutputHourly Rate Equivalent
Pure manual writing0 (time cost)8-12 articles4 hours per article × actual hourly rate
AI-assisted writing (MiniMax)~250 CNY45 articlesExtremely low cost, 4x efficiency improvement
Outsourced writing~3,000 CNY20 articlesHigh cost, inconsistent quality
My AI Agent solution~250 CNY45 articlesHighest efficiency, scalable

Conclusion: The MiniMax API solution costs 8% of outsourcing but produces 2.25x more content.

---

Part 4: Pros and Cons of This Solution, and Who It's For

Pros

1. Extremely low cost: MiniMax's token pricing is approximately 70% lower than OpenAI's, with significant advantages for long-text generation tasks. I spend about 250 CNY per month on APIs, generating 45 medium-length articles.

2. High degree of automation: From topic selection to multi-platform adaptation, one workflow handles it all. I only need to spend 15 minutes daily reviewing and publishing.

3. Strong scalability: The MCP protocol makes adding new tools extremely convenient. Later I integrated knowledge base search, image generation, and social media APIs—all plug-and-play configuration.

4. Data control: All data stays on my own VPS, not dependent on third-party SaaS stability.

Cons and Unsuitable Users

1. Requires technical foundation: This is not a "zero-configuration, ready to use" product. You need to understand Python code, APIs, and basic server operations. My estimate: You need at least 3 months of programming experience to smoothly deploy this system.

2. Requires manual review: AI-generated content may have factual errors or inappropriate expressions. I spend 15 minutes reviewing daily. Every article must be reviewed—you cannot completely hands-off.

3. Poor results for creative content: Template-based content like technical tutorials and news aggregation generates well; but in-depth commentary, personal narratives, and content requiring unique perspectives, AI generation quality still falls short of human writing.

4. Initial configuration is time-consuming: Going from zero to the first automated workflow took me about 2 weeks, mainly spent debugging MCP protocol compatibility and prompt optimization.

Suitable Audiences

✅ Suitable for:

❌ Not suitable for:

---

Part 5: Common Issues and Troubleshooting Records

Q1: How to Handle API Rate Limits?

MiniMax API has request-per-minute limits. My solution:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_calls: int, period: int):
        self.max_calls = max_calls
        self.period = period
        self.calls = deque()

    def wait_if_needed(self):
        now = time.time()
        # Clean up records outside the time window
        while self.calls and self.calls[0] < now - self.period:
            self.calls.popleft()

        if len(self.calls) >= self.max_calls:
            sleep_time = self.calls[0] + self.period - now
            if sleep_time > 0:
                print(f"Rate limit triggered, waiting {sleep_time:.1f}s...")
                time.sleep(sleep_time)

        self.calls.append(time.time())

# Usage
limiter = RateLimiter(max_calls=60, period=60)  # Max 60 calls per minute

async def call_api():
    limiter.wait_if_needed()
    # Call API...

Q2: What If Docker Container Runs Out of Memory?

MCP Server + AI Agent memory usage can be high when generating large text. Limit memory in docker-compose.yml:

deploy:
  resources:
    limits:
      memory: 2G
    reservations:
      memory: 512M

Q3: How to Monitor Workflow Execution Status?

I use simple logging + web dashboard:

# Add status reporting in content_agent.py
def log_status(task: str, status: str, details: str = ""):
    log_line = f"[{datetime.now().isoformat()}] {status.upper()}: {task} {details}"
    print(log_line)
    with open("/app/logs/agent.log", "a") as f:
        f.write(log_line + "\n")

Pair with the watch command for real-time monitoring:

tail -f logs/agent.log

---

Conclusion: AI Agents Don't Replace You—They Amplify You

After 6 months of use, my feeling is: AI Agents are best understood as tireless assistants who never complain, not all-capable AI writers.

I set the direction and core viewpoints; the Agent handles the dirty work of gathering research, drafting, and multi-platform adaptation. Human brain time is spent where creativity and judgment truly matter.

If you're also considering how to use AI to improve content production efficiency, I suggest starting with the MiniMax API—low cost, fast onboarding:

👉 Get started now: https://platform.minimaxi.com/subscribe/token-plan?code=E5yur9NOub&source=link

Use my referral code E5yur9NOub during registration to enjoy Token purchase discounts. Register and buy a small package to test first; increase usage when it feels right. Much more flexible than committing to a large package from the start.

Feel free to leave comments if you have questions—I'll try my best to respond.

---

My 6-Month Troubleshooting Summary:

1. Start with simple workflows first—don't aim for full automation right away

2. Prompt optimization is ongoing—continuous iteration yields the best results

3. Monitor API costs—set budget alerts

4. The manual review step cannot be skipped—this is the quality baseline

I hope this article helps you!

🔗 Related Tech Articles

Deep dive into related technical topics:

2026-04-19-ai-agent-workflow-automation-in-2026-how-i-achieve-en.html
技术标签: minimax api, mcp protocol
n8n Self-Hosted Configuration Pitfalls
技术标签: n8n, self-hosted
AI and OpenClaw Automation for Profit
技术标签: openclaw, passive income
⚡ Automation Workflow Hardware
查看推荐 →