基于Codex与Vibe Coding的世界杯热点内容批量生成技术实践
·
最近在做内容运营时，经常需要快速跟进世界杯这样的热点事件。传统的手工操作效率太低，一个热点出来，从数据采集到内容生成再到发布，往往需要好几个小时，等到内容上线时热度已经下降了不少。为了解决这个问题，我尝试用 Codex 开发了一套自动化流程，把整个热点跟进做成了 AI 程序，实现了真正的批量处理。
这套方案的核心是利用 Codex CLI 工具，结合 vibe coding 的编程理念，通过自然语言指令就能完成复杂的数据处理和内容生成任务。下面将完整分享从环境搭建到实际应用的整个流程，包含详细的代码示例和避坑指南，适合有一定 Python 基础的内容运营人员和开发者参考使用。
1. Codex 与 Vibe Coding 核心概念解析
1.1 什么是 Codex？
Codex 是 OpenAI 推出的代码生成模型，能够理解自然语言描述并生成对应的代码。最新版本支持多种编程语言，特别擅长 Python、JavaScript 等常用语言。与传统的代码补全工具不同，Codex 可以基于业务需求描述直接生成完整的功能代码，大大提升了开发效率。
在实际应用中，Codex 特别适合处理重复性高的编码任务，比如数据清洗、API 调用、文件处理等场景。对于热点内容批量生成这类需求，正好是 Codex 的强项。
1.2 Vibe Coding 编程理念
Vibe coding 是一种新兴的编程方式，强调的是通过自然语言与 AI 工具进行"对话式"编程。开发者不需要关注具体的语法细节，而是专注于描述业务逻辑和需求，由 AI 工具来完成具体的代码实现。
这种编程方式特别适合原型开发、快速验证和自动化脚本编写。在热点内容处理场景下，我们可以用自然语言描述"获取世界杯最新赛程"、"生成赛事分析文章"这样的需求，Codex 就能自动生成相应的代码。
1.3 技术架构设计
整个批量处理世界杯热点的程序架构分为三个主要层次：
- 数据采集层 ：负责从各大体育网站、社交媒体平台获取最新的世界杯相关信息
- 内容生成层 ：利用 Codex 对采集到的数据进行加工处理，生成不同形式的内容
- 发布调度层 ：将生成的内容自动发布到各个平台，并监控发布效果
这种分层设计使得每个模块都可以独立优化，也便于后续的功能扩展。
2. 环境准备与工具配置
2.1 基础环境要求
在开始之前，需要确保系统满足以下基础要求：
- 操作系统：Windows 10/11、macOS 10.15+ 或 Ubuntu 18.04+
- Python 版本：3.8 或更高版本
- 内存：至少 8GB RAM
- 网络：稳定的互联网连接
2.2 Codex CLI 安装与配置
Codex CLI 是命令行工具，提供了与 Codex 模型交互的接口。安装步骤如下：
# 使用 pip 安装 codex-cli
pip install codex-cli
# 验证安装是否成功
codex --version
# 配置 API 密钥
codex config set api_key YOUR_API_KEY_HERE
如果安装过程中遇到 "conda: 无法识别" 的错误，说明系统没有正确配置 Python 环境变量。可以尝试以下解决方案：
# 检查 Python 是否在 PATH 中
python --version
# 如果找不到 Python，需要手动添加到环境变量
# Windows 系统示例：
set PATH=%PATH%;C:\Python38
# Linux/macOS 系统示例：
export PATH=$PATH:/usr/bin/python3
2.3 必要依赖包安装
除了 Codex CLI，还需要安装一些辅助工具包：
# requirements.txt 文件内容
requests>=2.28.0
beautifulsoup4>=4.11.0
pandas>=1.5.0
openai>=0.27.0
schedule>=1.1.0
python-dotenv>=0.19.0
# 安装命令
pip install -r requirements.txt
2.4 项目结构规划
建议按照以下结构组织项目文件：
worldcup_hotspot/
├── config/
│ ├── __init__.py
│ └── settings.py
├── data/
│ ├── raw/ # 原始数据
│ ├── processed/ # 处理后的数据
│ └── output/ # 生成的内容
├── src/
│ ├── collectors/ # 数据采集模块
│ ├── generators/ # 内容生成模块
│ ├── publishers/ # 发布模块
│ └── utils/ # 工具函数
├── logs/ # 日志文件
├── tests/ # 测试用例
└── main.py # 主程序入口
3. 数据采集模块实现
3.1 体育数据 API 集成
世界杯相关数据可以从多个体育数据提供商获取，以下是一个通用的 API 采集示例：
# src/collectors/sports_api.py
import requests
import pandas as pd
from datetime import datetime
import time
class SportsDataCollector:
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "https://api.sportsdata.io/v4/soccer"
self.headers = {
"Ocp-Apim-Subscription-Key": api_key
}
def get_upcoming_matches(self, days=7):
"""获取未来几天内的比赛日程"""
url = f"{self.base_url}/matches"
params = {
"dateFrom": datetime.now().strftime("%Y-%m-%d"),
"dateTo": (datetime.now() + timedelta(days=days)).strftime("%Y-%m-%d")
}
try:
response = requests.get(url, headers=self.headers, params=params)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"API 请求失败: {e}")
return None
def get_match_stats(self, match_id):
"""获取具体比赛的统计数据"""
url = f"{self.base_url}/matches/{match_id}/stats"
response = requests.get(url, headers=self.headers)
if response.status_code == 200:
return response.json()
else:
print(f"获取比赛统计失败: {response.status_code}")
return None
# 使用示例
collector = SportsDataCollector("your_api_key_here")
matches = collector.get_upcoming_matches()
3.2 网络爬虫实现
对于没有 API 的数据源，可以使用爬虫技术获取信息：
# src/collectors/web_crawler.py
from bs4 import BeautifulSoup
import requests
import re
class WorldCupCrawler:
def __init__(self):
self.session = requests.Session()
self.session.headers.update({
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
})
def crawl_news(self, source_url):
"""从新闻网站爬取世界杯相关新闻"""
try:
response = self.session.get(source_url, timeout=10)
soup = BeautifulSoup(response.content, 'html.parser')
# 根据网站结构提取新闻内容
articles = []
news_items = soup.find_all('article', class_=re.compile(r'news|article'))
for item in news_items[:10]: # 限制数量避免过多请求
title_elem = item.find(['h1', 'h2', 'h3'])
content_elem = item.find('p')
if title_elem and content_elem:
article = {
'title': title_elem.get_text().strip(),
'content': content_elem.get_text().strip()[:200], # 限制长度
'source': source_url,
'timestamp': datetime.now()
}
articles.append(article)
return articles
except Exception as e:
print(f"爬取新闻失败: {e}")
return []
# 使用多个数据源提高覆盖率
crawler = WorldCupCrawler()
sources = [
"https://example-sports-news.com/worldcup",
"https://another-news-site.com/football"
]
all_articles = []
for source in sources:
articles = crawler.crawl_news(source)
all_articles.extend(articles)
3.3 数据清洗与标准化
采集到的原始数据需要经过清洗处理：
# src/utils/data_cleaner.py
import pandas as pd
import re
from datetime import datetime
class DataCleaner:
@staticmethod
def clean_match_data(raw_data):
"""清洗比赛数据"""
if not raw_data:
return None
df = pd.DataFrame(raw_data)
# 处理缺失值
df.fillna({
'home_team': '未知主队',
'away_team': '未知客队',
'venue': '未知场地'
}, inplace=True)
# 标准化时间格式
df['match_time'] = pd.to_datetime(df['match_time'], errors='coerce')
# 过滤无效数据
df = df[df['match_time'].notna()]
return df.to_dict('records')
@staticmethod
def extract_keywords(text, max_keywords=10):
"""从文本中提取关键词"""
# 简单的关键词提取逻辑，实际中可以接入更复杂的NLP处理
words = re.findall(r'\b\w{3,}\b', text.lower())
word_count = {}
for word in words:
if word not in ['the', 'and', 'for', 'with', 'this', 'that']:
word_count[word] = word_count.get(word, 0) + 1
# 按频率排序并返回前N个关键词
sorted_words = sorted(word_count.items(), key=lambda x: x[1], reverse=True)
return [word for word, count in sorted_words[:max_keywords]]
4. 内容生成模块核心实现
4.1 Codex 集成与提示词工程
内容生成的核心是利用 Codex 的自然语言理解能力，以下是与 Codex 交互的基础类：
# src/generators/codex_client.py
import openai
from openai import OpenAI
import json
import time
class CodexContentGenerator:
def __init__(self, api_key):
self.client = OpenAI(api_key=api_key)
self.model = "gpt-4" # 根据实际情况调整模型版本
def generate_article(self, prompt, max_tokens=1000, temperature=0.7):
"""使用 Codex 生成文章内容"""
try:
response = self.client.chat.completions.create(
model=self.model,
messages=[
{"role": "system", "content": "你是一个专业的体育内容编辑，擅长撰写世界杯相关的分析文章。"},
{"role": "user", "content": prompt}
],
max_tokens=max_tokens,
temperature=temperature
)
return response.choices[0].message.content.strip()
except Exception as e:
print(f"生成内容失败: {e}")
return None
def batch_generate(self, prompts, delay=1):
"""批量生成内容，避免API限制"""
results = []
for i, prompt in enumerate(prompts):
if i > 0:
time.sleep(delay) # 避免频繁请求
content = self.generate_article(prompt)
if content:
results.append({
'prompt': prompt,
'content': content,
'timestamp': datetime.now()
})
return results
# 实例化生成器
generator = CodexContentGenerator("your_openai_api_key")
4.2 赛事报道自动生成
针对不同类型的比赛生成相应的报道内容：
# src/generators/match_reporter.py
class MatchReporter:
def __init__(self, codex_generator):
self.generator = codex_generator
def generate_preview(self, match_data):
"""生成赛前前瞻文章"""
prompt = f"""
请根据以下比赛信息撰写一篇赛前前瞻报道：
比赛双方：{match_data['home_team']} vs {match_data['away_team']}
比赛时间：{match_data['match_time']}
比赛地点：{match_data['venue']}
写作要求：
1. 分析两队近期状态和历史交锋记录
2. 预测比赛可能的结果和关键球员
3. 语言生动有趣，适合体育新闻阅读
4. 字数在500字左右
请开始撰写：
"""
return self.generator.generate_article(prompt)
def generate_review(self, match_data, match_result):
"""生成赛后总结文章"""
prompt = f"""
请根据比赛结果撰写一篇赛后总结：
比赛：{match_data['home_team']} {match_result['home_score']} - {match_result['away_score']} {match_data['away_team']}
比赛亮点：{match_result['highlights']}
写作要求：
1. 分析比赛过程和关键节点
2. 评价双方球员表现
3. 探讨比赛对小组出线形势的影响
4. 字数在600字左右
请开始撰写：
"""
return self.generator.generate_article(prompt)
def generate_player_analysis(self, player_stats):
"""生成球员表现分析"""
prompt = f"""
分析以下球员在本届世界杯的表现：
球员：{player_stats['name']}
位置：{player_stats['position']}
数据：{player_stats['stats']}
请从技术特点、对球队贡献、发展潜力等方面进行分析，字数400字左右。
"""
return self.generator.generate_article(prompt)
# 使用示例
reporter = MatchReporter(generator)
preview_article = reporter.generate_preview(match_data)
4.3 多平台内容适配生成
不同平台需要不同风格的内容，以下是适配多个平台的生成策略：
# src/generators/platform_adapter.py
class ContentAdapter:
def __init__(self, codex_generator):
self.generator = codex_generator
def weibo_style(self, content):
"""生成微博风格的短内容"""
prompt = f"""
将以下足球比赛内容改写成适合微博发布的短文案：
原文：{content}
要求：
1. 长度在140字以内
2. 加入合适的话题标签
3. 语言活泼，有互动性
4. 包含表情符号
改写结果：
"""
return self.generator.generate_article(prompt, max_tokens=200)
def official_account_style(self, content):
"""生成公众号风格的长文"""
prompt = f"""
将以下内容扩展为微信公众号文章：
基础内容：{content}
要求：
1. 文章结构完整，有开头、正文、结尾
2. 加入小标题使内容层次清晰
3. 语言正式但不失趣味性
4. 字数在800-1000字
请开始撰写：
"""
return self.generator.generate_article(prompt, max_tokens=1200)
def video_script(self, match_data):
"""生成短视频脚本"""
prompt = f"""
为以下比赛制作一个短视频脚本：
比赛信息：{match_data}
脚本要求：
1. 时长1-2分钟
2. 包含开场、高潮、结尾
3. 有解说词和画面描述
4. 适合短视频平台传播
请输出完整脚本：
"""
return self.generator.generate_article(prompt)
# 内容适配示例
adapter = ContentAdapter(generator)
weibo_content = adapter.weibo_style(preview_article)
official_content = adapter.official_account_style(preview_article)
5. 自动化发布与调度系统
5.1 任务调度器实现
使用 schedule 库实现定时任务调度：
# src/scheduler/task_manager.py
import schedule
import time
import threading
from datetime import datetime, timedelta
class TaskScheduler:
def __init__(self):
self.running = False
self.thread = None
def daily_data_collection(self):
"""每日数据采集任务"""
print(f"{datetime.now()} - 开始执行每日数据采集")
# 执行数据采集逻辑
from src.collectors.sports_api import SportsDataCollector
collector = SportsDataCollector("your_api_key")
matches = collector.get_upcoming_matches()
# 保存数据
self.save_data(matches, 'daily_matches')
print("每日数据采集完成")
def hourly_content_generation(self):
"""每小时内容生成任务"""
print(f"{datetime.now()} - 开始内容生成")
# 读取最新数据
latest_data = self.load_latest_data()
if latest_data:
# 生成内容
from src.generators.match_reporter import MatchReporter
reporter = MatchReporter(generator)
content = reporter.generate_preview(latest_data[0])
# 保存生成的内容
self.save_content(content)
print("内容生成完成")
def setup_schedule(self):
"""设置任务调度"""
# 每天上午9点执行数据采集
schedule.every().day.at("09:00").do(self.daily_data_collection)
# 每小时执行内容生成
schedule.every().hour.do(self.hourly_content_generation)
# 每6小时执行一次发布
schedule.every(6).hours.do(self.publish_content)
def run_continuously(self, interval=1):
"""持续运行调度器"""
self.running = True
def run():
while self.running:
schedule.run_pending()
time.sleep(interval)
self.thread = threading.Thread(target=run)
self.thread.start()
def stop(self):
"""停止调度器"""
self.running = False
if self.thread:
self.thread.join()
# 启动调度器
scheduler = TaskScheduler()
scheduler.setup_schedule()
scheduler.run_continuously()
5.2 多平台发布集成
实现向不同平台自动发布内容的功能：
# src/publishers/multi_platform.py
import requests
import json
class MultiPlatformPublisher:
def __init__(self, platform_configs):
self.configs = platform_configs
def publish_to_weibo(self, content, image_path=None):
"""发布到微博"""
# 微博API发布逻辑
url = "https://api.weibo.com/2/statuses/share.json"
payload = {
"access_token": self.configs['weibo']['access_token'],
"status": content
}
if image_path:
files = {'pic': open(image_path, 'rb')}
response = requests.post(url, data=payload, files=files)
else:
response = requests.post(url, data=payload)
return response.status_code == 200
def publish_to_wechat(self, content, title, cover_image=None):
"""发布到微信公众号"""
# 微信公众号发布逻辑
url = f"https://api.weixin.qq.com/cgi-bin/material/add_news?access_token={self.configs['wechat']['access_token']}"
article = {
"articles": [{
"title": title,
"author": "AI体育编辑",
"digest": content[:100],
"content": content,
"content_source_url": "",
"thumb_media_id": cover_image or ""
}]
}
response = requests.post(url, json=article)
return response.json()
def publish_to_toutiao(self, content, title, category='sports'):
"""发布到今日头条"""
# 头条号发布逻辑
url = "https://mp.toutiao.com/content/publish"
headers = {
"Content-Type": "application/json",
"X-Token": self.configs['toutiao']['token']
}
data = {
"title": title,
"content": content,
"category": category,
"tag": "世界杯,足球"
}
response = requests.post(url, headers=headers, json=data)
return response.status_code == 200
def batch_publish(self, content_package):
"""批量发布到多个平台"""
results = {}
# 微博发布
if 'weibo' in self.configs:
weibo_content = content_package.get('weibo_content', content_package['default'])
results['weibo'] = self.publish_to_weibo(weibo_content)
# 微信公众号发布
if 'wechat' in self.configs:
wechat_content = content_package.get('wechat_content', content_package['default'])
results['wechat'] = self.publish_to_wechat(wechat_content, content_package['title'])
# 今日头条发布
if 'toutiao' in self.configs:
toutiao_content = content_package.get('toutiao_content', content_package['default'])
results['toutiao'] = self.publish_to_toutiao(toutiao_content, content_package['title'])
return results
# 发布器配置和使用
platform_configs = {
'weibo': {'access_token': 'your_weibo_token'},
'wechat': {'access_token': 'your_wechat_token'},
'toutiao': {'token': 'your_toutiao_token'}
}
publisher = MultiPlatformPublisher(platform_configs)
6. 常见问题与解决方案
6.1 Codex API 使用问题
在使用 Codex 过程中可能会遇到的一些常见问题：
问题1：API 调用频率限制
- 现象：频繁收到 429 错误码
- 解决方案：实现请求间隔控制，使用指数退避策略
# src/utils/api_utils.py
import time
import random
def api_call_with_retry(api_func, max_retries=3, base_delay=1):
"""带重试机制的API调用"""
for attempt in range(max_retries):
try:
return api_func()
except Exception as e:
if "rate limit" in str(e).lower() and attempt < max_retries - 1:
delay = base_delay * (2 ** attempt) + random.random()
print(f"达到频率限制，等待 {delay:.2f} 秒后重试")
time.sleep(delay)
else:
raise e
# 使用示例
def call_codex_api():
# API调用逻辑
pass
result = api_call_with_retry(call_codex_api)
问题2：生成内容质量不稳定
- 现象：有时生成的内容不符合要求
- 解决方案：优化提示词设计，增加约束条件
def improved_prompt_design(match_data):
"""改进的提示词设计"""
prompt = f"""
请以专业体育记者的身份，基于以下比赛数据撰写前瞻报道：
【比赛基本信息】
主队：{match_data['home_team']}
客队：{match_data['away_team']}
时间：{match_data['match_time']}
地点：{match_data['venue']}
【写作要求】
1. 首先分析两队近期5场比赛的战绩
2. 然后对比两队历史交锋记录
3. 重点分析两队核心球员的状态
4. 最后给出专业的比赛预测
5. 文章字数控制在600-800字
6. 使用客观专业的体育新闻语言
【禁止事项】
- 不要使用主观臆断的词语
- 不要夸大或贬低任何球队
- 不要涉及与比赛无关的内容
请开始撰写：
"""
return prompt
6.2 数据采集常见问题
问题3：网站结构变化导致爬虫失效
- 解决方案：实现多数据源备份和自动适配
# src/collectors/adaptive_crawler.py
class AdaptiveCrawler:
def __init__(self):
self.selectors = [
{'title': 'h1.article-title', 'content': 'div.article-content'},
{'title': 'h1.post-title', 'content': 'div.post-content'},
{'title': 'h1.news-title', 'content': 'div.news-body'}
]
def try_multiple_selectors(self, soup):
"""尝试多种选择器组合"""
for selector in self.selectors:
title_elem = soup.select_one(selector['title'])
content_elem = soup.select_one(selector['content'])
if title_elem and content_elem:
return {
'title': title_elem.get_text().strip(),
'content': content_elem.get_text().strip()
}
return None
6.3 内容质量监控
建立内容质量评估机制：
# src/quality/content_validator.py
import re
class ContentValidator:
@staticmethod
def validate_article(article):
"""验证文章质量"""
issues = []
# 检查长度
if len(article) < 300:
issues.append("文章过短")
elif len(article) > 2000:
issues.append("文章过长")
# 检查关键词密度
keywords = ['世界杯', '足球', '比赛', '球员']
keyword_count = sum(article.count(keyword) for keyword in keywords)
if keyword_count < 3:
issues.append("关键词密度不足")
# 检查段落结构
paragraphs = re.split(r'\n\n+', article)
if len(paragraphs) < 3:
issues.append("段落结构不完整")
return len(issues) == 0, issues
@staticmethod
def auto_correct(article, issues):
"""自动修正内容问题"""
corrected = article
if "文章过短" in issues:
# 使用Codex扩展内容
expansion_prompt = f"请将以下文章扩展到500字左右：\n\n{article}"
corrected = generator.generate_article(expansion_prompt)
return corrected
7. 性能优化与最佳实践
7.1 代码优化策略
缓存机制实现 ：
# src/utils/cache_manager.py
import pickle
import os
from datetime import datetime, timedelta
class CacheManager:
def __init__(self, cache_dir="cache", ttl_hours=24):
self.cache_dir = cache_dir
self.ttl = timedelta(hours=ttl_hours)
os.makedirs(cache_dir, exist_ok=True)
def get_cache_key(self, data):
"""生成缓存键"""
import hashlib
return hashlib.md5(str(data).encode()).hexdigest()
def get(self, key):
"""获取缓存数据"""
cache_file = os.path.join(self.cache_dir, f"{key}.pkl")
if os.path.exists(cache_file):
# 检查是否过期
file_time = datetime.fromtimestamp(os.path.getmtime(cache_file))
if datetime.now() - file_time < self.ttl:
with open(cache_file, 'rb') as f:
return pickle.load(f)
return None
def set(self, key, data):
"""设置缓存数据"""
cache_file = os.path.join(self.cache_dir, f"{key}.pkl")
with open(cache_file, 'wb') as f:
pickle.dump(data, f)
# 使用缓存优化API调用
cache = CacheManager()
def get_cached_data(data_source):
cache_key = cache.get_cache_key(data_source)
cached_data = cache.get(cache_key)
if cached_data is None:
# 实际获取数据
fresh_data = fetch_data_from_source(data_source)
cache.set(cache_key, fresh_data)
return fresh_data
else:
return cached_data
7.2 错误处理与日志记录
建立完善的错误处理机制：
# src/utils/logger.py
import logging
import sys
from datetime import datetime
def setup_logger():
"""配置日志系统"""
logger = logging.getLogger('worldcup_bot')
logger.setLevel(logging.INFO)
# 文件处理器
file_handler = logging.FileHandler(f'logs/worldcup_bot_{datetime.now().strftime("%Y%m%d")}.log')
file_handler.setLevel(logging.INFO)
# 控制台处理器
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setLevel(logging.INFO)
# 日志格式
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.addHandler(console_handler)
return logger
# 在项目中使用
logger = setup_logger()
try:
# 业务逻辑
result = some_risky_operation()
logger.info("操作成功完成")
except Exception as e:
logger.error(f"操作失败: {e}", exc_info=True)
7.3 配置管理最佳实践
使用环境变量管理敏感信息：
# config/settings.py
import os
from dotenv import load_dotenv
load_dotenv()
class Config:
# API配置
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
SPORTS_API_KEY = os.getenv('SPORTS_API_KEY')
# 平台配置
WEIBO_ACCESS_TOKEN = os.getenv('WEIBO_ACCESS_TOKEN')
WECHAT_ACCESS_TOKEN = os.getenv('WECHAT_ACCESS_TOKEN')
# 应用配置
CACHE_TTL_HOURS = int(os.getenv('CACHE_TTL_HOURS', '24'))
REQUEST_TIMEOUT = int(os.getenv('REQUEST_TIMEOUT', '30'))
# 内容生成配置
DEFAULT_ARTICLE_LENGTH = int(os.getenv('DEFAULT_ARTICLE_LENGTH', '800'))
MAX_RETRY_ATTEMPTS = int(os.getenv('MAX_RETRY_ATTEMPTS', '3'))
# 使用配置
config = Config()
通过这套完整的批量处理世界杯热点内容的AI程序，我成功将内容生产效率提升了5倍以上，实现了真正的自动化运营。关键是要理解vibe coding的理念，充分发挥Codex在自然语言处理方面的优势，同时建立可靠的数据流水线和错误处理机制。
在实际应用中，建议先从小的功能模块开始验证，逐步扩展到完整的流程。也要注意内容质量的监控和优化，确保生成的内容既有数量也有质量。这种技术方案不仅可以用于体育热点，稍作调整就能应用到其他领域的批量内容生产场景中。
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
10
0- 0
已为社区贡献57条内容
所有评论(0)