别再盲目折腾AI变现了！这款开源工具让我副业收入翻倍，手把手教你从入门到精通

Python: 3.8 或更高版本
内存: 最低 4GB（推荐 8GB 以上）
硬盘: 至少 10GB 可用空间
操作系统: Windows / macOS / Linux 均可

pip install aitoearn

pip install git+https://github.com/yikart/AiToEarn.git

python -c "import aitoearn; print(aitoearn.__version__)"

# 克隆仓库
git clone https://github.com/yikart/AiToEarn.git

# 进入项目目录
cd AiToEarn

# 创建虚拟环境（强烈推荐）
python -m venv venv

# 激活虚拟环境
# Windows 系统：
venv\Scripts\activate
# macOS / Linux 系统：
source venv/bin/activate

# 安装依赖
pip install -e .

# AI 服务配置
ai_providers:
  openai:
    api_key: "your-openai-api-key"
    base_url: "https://api.openai.com/v1"  # 可选，自定义代理地址

  anthropic:
    api_key: "your-anthropic-api-key"

  # 国内用户常用配置
  zhipu:
    api_key: "your-zhipu-api-key"

  dashscope:
    api_key: "your-dashscope-api-key"

# 缓存配置
cache:
  enabled: true
  type: "local"  # local 或 redis
  local_path: "./cache"

# 日志配置
logging:
  level: "INFO"
  file: "./logs/aitoearn.log"

"""环境验证脚本"""
import aitoearn as ae

def test_environment():
    """测试运行环境是否正确"""
    print("=" * 50)
    print("AiToEarn 环境验证")
    print("=" * 50)

    # 检查版本
    print(f"✓ AiToEarn 版本: {ae.__version__}")

    # 检查AI服务连接
    try:
        provider = ae.get_provider("openai")
        print(f"✓ OpenAI 提供商已就绪")
    except Exception as e:
        print(f"✗ OpenAI 提供商配置错误: {e}")

    # 检查缓存
    cache = ae.get_cache()
    print(f"✓ 缓存系统已就绪: {cache.__class__.__name__}")

    print("=" * 50)
    print("环境验证完成！")
    print("=" * 50)

if __name__ == "__main__":
    test_environment()

python test_setup.py

from aitoearn import AIChat

# 初始化对话引擎
chat = AIChat(provider="openai", model="gpt-3.5-turbo")

# 单轮对话
response = chat.send("给我讲一个关于程序员的笑话")
print(response.content)

from aitoearn import AIChat

chat = AIChat(provider="openai", model="gpt-3.5-turbo")

print("AI正在回复：")
for chunk in chat.stream_send("解释一下什么是装饰器模式"):
    print(chunk, end="", flush=True)
print()  # 换行

from aitoearn import AIChat

chat = AIChat(provider="openai", model="gpt-3.5-turbo")

# 第一轮对话
chat.send("我想学习Python，请给我推荐学习路线")

# 第二轮对话（自动携带上下文）
chat.send("太难了，能不能再简单一些？")

# 第三轮对话
chat.send("那先从哪个方向开始比较好？")

# 获取完整对话历史
history = chat.get_history()
for msg in history:
    print(f"[{msg.role}]: {msg.content[:50]}...")

from aitoearn import AIChat

# 创建带自定义角色的AI助手
chat = AIChat(
    provider="openai",
    model="gpt-3.5-turbo",
    system_prompt="""你是一位资深的Python后端工程师，有10年的开发经验。
    你擅长Django、Flask、FastAPI等框架，对代码性能优化有独到见解。
    回答问题时，你会先分析问题，然后给出解决方案，最后提供代码示例。
    """
)

response = chat.send("Django和FastAPI应该选哪个？")
print(response.content)

from aitoearn import AIImage

# 初始化绘图引擎
image_gen = AIImage(provider="openai", model="dall-e-3")

# 生成图片
result = image_gen.generate(
    prompt="A cute robot sitting in a coffee shop, watercolor style",
    size="1024x1024",
    quality="standard"
)

# 保存图片
result.save("my_robot_coffee.png")
print(f"图片已保存: {result.filename}")
print(f"图片URL: {result.url}")

from aitoearn import AIImage

# 使用本地Stable Diffusion（需要先安装并启动）
image_gen = AIImage(
    provider="stable_diffusion",
    model="stable-diffusion-v1-5",
    device="cuda",  # 或 "cpu" 如果你没有GPU
    model_path="./models/sd-v1-5"
)

# 生成二次元风格图片
result = image_gen.generate(
    prompt="1girl, anime style, long hair, cherry blossoms, detailed",
    negative_prompt="low quality, bad anatomy, blurry",
    steps=30,
    cfg_scale=7.5
)

result.save("anime_girl.png")

from aitoearn import AIImage

image_gen = AIImage(provider="openai", model="dall-e-3")

# 使用预设画风
presets = image_gen.get_presets()
print("可用预设：")
for name in presets:
    print(f"  - {name}")

# 使用"油画"预设
result = image_gen.generate_with_preset(
    preset="oil_painting",
    prompt="A serene mountain lake at sunrise"
)

result.save("mountain_lake_oil.png")

from aitoearn import DocumentProcessor

doc = DocumentProcessor(provider="openai")

# 长文章内容
article = """
[这里放入你的长文章内容...]
"""

# 生成摘要
summary = doc.summarize(
    text=article,
    max_length=200,  # 摘要最大字数
    style="bullet_points"  # 或 "paragraph"
)

print("文章摘要：")
print(summary)

from aitoearn import DocumentProcessor

doc = DocumentProcessor(provider="dashscope")  # 使用阿里翻译

# 翻译单个文档
result = doc.translate(
    text="你好，世界！欢迎来到AI的世界。",
    source_lang="zh",
    target_lang="en"
)
print(result)

# 翻译整个文件夹（批量操作）
doc.translate_folder(
    source_dir="./articles_cn",
    target_dir="./articles_en",
    source_lang="zh",
    target_lang="en"
)

from aitoearn import DocumentProcessor

doc = DocumentProcessor(provider="openai")

# 改写为更吸引人的版本
rewritten = doc.rewrite(
    text="我们公司提供优质的产品和服务。",
    style="marketing",  # 营销风格
    tone="enthusiastic"  # 热情基调
)
print(rewritten)

# 提取关键信息
info = doc.extract_info(
    text="张三先生，1985年出生于北京，2010年毕业于清华大学计算机系...",
    fields=["姓名", "出生年份", "出生地", "学历"]
)
print(info)
# 输出: {'姓名': '张三', '出生年份': 1985, '出生地': '北京', '学历': '清华大学计算机系'}

from aitoearn import Workflow, Task

# 创建工作流
workflow = Workflow(name="小红书文章生成")

# 定义工作流步骤
@workflow.step()
def generate_topic(topic_pool: list) -> str:
    """步骤1：从话题池中选择一个话题"""
    import random
    return random.choice(topic_pool)

@workflow.step()
def write_content(topic: str) -> str:
    """步骤2：根据话题写文章"""
    from aitoearn import AIChat
    chat = AIChat()
    response = chat.send(f"请为小红书写一篇关于'{topic}'的笔记，要求生动有趣，有emoji表情")
    return response.content

@workflow.step()
def generate_cover(content: str) -> str:
    """步骤3：生成封面图"""
    from aitoearn import AIImage
    image_gen = AIImage()
    result = image_gen.generate(
        prompt=f"小红书封面图，主题：{content[:50]}，清新可爱风格"
    )
    result.save("cover.png")
    return result.filename

@workflow.step()
def post_to_xiaohongshu(content: str, cover: str) -> dict:
    """步骤4：发布到小红书"""
    # 这里需要接入小红书API
    return {"status": "success", "post_id": "123456"}

# 执行工作流
result = workflow.execute(
    topic_pool=["AI副业", "编程学习", "效率工具", "职场成长"]
)

print(f"文章内容：{result['write_content']}")
print(f"封面图片：{result['generate_cover']}")
print(f"发布状态：{result['post_to_xiaohongshu']}")

from aitoearn import Workflow

workflow = Workflow(name="智能客服分流")

@workflow.step()
def classify_question(question: str) -> str:
    """分类用户问题"""
    # 简化的分类逻辑
    if any(word in question for word in ["价格", "多少钱", "收费"]):
        return "pricing"
    elif any(word in question for word in ["怎么用", "教程", "帮助"]):
        return "tutorial"
    elif any(word in question for word in ["投诉", "问题", "bug"]):
        return "support"
    else:
        return "general"

@workflow.branch(condition=lambda ctx: ctx["classify_question"] == "pricing")
def handle_pricing(ctx):
    """处理价格咨询"""
    from aitoearn import AIChat
    chat = AIChat()
    return chat.send(f"回答关于定价的问题：{ctx['classify_question']}")

@workflow.branch(condition=lambda ctx: ctx["classify_question"] == "tutorial")
def handle_tutorial(ctx):
    """处理教程请求"""
    from aitoearn import AIChat
    chat = AIChat()
    return chat.send(f"提供教程帮助：{ctx['classify_question']}")

# 执行
result = workflow.execute(question="你们这个软件怎么收费的？")
print(result)

"""
AI写作助手 - 内容创作利器
功能：
1. 关键词分析和大纲生成
2. 文章自动撰写
3. 标题优化
4. 封面图生成
"""

from aitoearn import AIChat, AIImage, DocumentProcessor
from typing import List, Dict
import json
from datetime import datetime

class ContentCreator:
    """AI内容创作助手"""

    def __init__(self, writer_style: str = "专业但易懂"):
        """
        初始化创作助手

        参数:
            writer_style: 写作风格，如"专业但易懂"、"轻松幽默"、"深度分析"等
        """
        self.chat = AIChat(
            provider="openai",
            model="gpt-4",
            system_prompt=f"""你是一位资深的内容创作者，擅长写{writer_style}风格的文章。
            你熟悉各大内容平台的调性，知道如何写出吸引人的开头和有力的结尾。
            你会在文章中适当使用小标题、列表、引用等格式，让文章更易读。
            """
        )
        self.image_gen = AIImage(provider="openai", model="dall-e-3")
        self.doc = DocumentProcessor()

        # 存储生成的内容
        self.current_content = None

    def analyze_keywords(self, keywords: List[str]) -> Dict:
        """
        分析关键词，生成内容策略

        参数:
            keywords: 关键词列表

        返回:
            包含分析结果的字典
        """
        keywords_str = "、".join(keywords)

        prompt = f"""
请分析以下关键词组合，为我制定内容策略：

关键词：{keywords_str}

请从以下角度进行分析：
1. 用户痛点：围绕这些关键词，用户最关心什么问题？
2. 内容角度：可以从哪些独特的角度切入？
3. 关键词热度：这些关键词的热度和竞争程度如何？
4. 推荐标题：给出3个吸引人的标题备选

请用JSON格式输出分析结果。
"""

        response = self.chat.send(prompt)

        # 尝试解析JSON
        try:
            result = json.loads(response.content)
        except json.JSONDecodeError:
            # 如果解析失败，返回原始内容
            result = {"analysis": response.content}

        return result

    def generate_outline(self, topic: str, target_length: int = 1500) -> Dict:
        """
        生成文章大纲

        参数:
            topic: 文章主题
            target_length: 目标字数

        返回:
            文章大纲结构
        """
        prompt = f"""
请为以下主题生成一篇文章大纲：

主题：{topic}
目标字数：约{target_length}字

要求：
1. 大纲应该包含：开头、3-5个主要章节、结尾
2. 每个章节需要有具体的小点
3. 开头要能吸引读者继续阅读
4. 结尾要有号召性用语或总结

请用以下JSON格式输出：
{{
    "title": "文章标题",
    "outline": [
        {{"section": "章节标题", "points": ["要点1", "要点2", ...]}},
        ...
    ],
    "estimated_read_time": "预计阅读时间"
}}
"""

        response = self.chat.send(prompt)

        try:
            outline = json.loads(response.content)
            self.current_content = {"topic": topic, "outline": outline}
            return outline
        except json.JSONDecodeError:
            return {"error": "大纲生成失败", "raw_response": response.content}

    def write_article(self, outline: Dict) -> str:
        """
        根据大纲撰写完整文章

        参数:
            outline: generate_outline生成的大纲

        返回:
            完整的文章内容
        """
        # 构建写作指令
        sections = []
        for idx, section in enumerate(outline.get("outline", [])):
            section_title = section.get("section", "")
            points = section.get("points", [])
            points_text = "\n".join([f"- {p}" for p in points])

            sections.append(f"## {section_title}\n{points_text}")

        outline_text = "\n\n".join(sections)

        prompt = f"""
请根据以下大纲撰写一篇完整的文章：

标题：{outline.get('title', '')}

大纲：
{outline_text}

写作要求：
1. 语言生动有趣，避免过于生硬的技术表述
2. 每个章节要有具体的案例或故事
3. 适当使用emoji增加趣味性
4. 文章结构清晰，适当使用小标题
5. 总字数控制在1500字左右
"""

        response = self.chat.send(prompt)
        return response.content

    def generate_titles(self, article_content: str, count: int = 5) -> List[str]:
        """
        生成多个备选标题

        参数:
            article_content: 文章内容
            count: 生成标题数量

        返回:
            标题列表
        """
        prompt = f"""
请为以下文章生成{count}个吸引人的标题：

{article_content[:500]}...

要求：
1. 每个标题不超过30字
2. 标题要能引起好奇心或共鸣
3. 可以使用数字、疑问句、感叹句等技巧
4. 不同标题要有不同的风格角度

请直接输出标题，每行一个，不要编号。
"""

        response = self.chat.send(prompt)
        titles = [t.strip() for t in response.content.split("\n") if t.strip()]
        return titles[:count]

    def generate_cover_image(self, title: str, style: str = "modern minimalist") -> str:
        """
        生成文章封面图

        参数:
            title: 文章标题
            style: 图片风格

        返回:
            保存的图片路径
        """
        prompt = f"""
Create a blog cover image for: {title}

Style requirements: {style}, clean design, suitable for social media sharing,
high contrast text area, vibrant colors, professional look
"""

        result = self.image_gen.generate(
            prompt=prompt,
            size="1792x1024"  # 横版封面
        )

        # 保存图片
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"cover_{timestamp}.png"
        result.save(filename)

        return filename

    def create_complete_article(self, keywords: List[str]) -> Dict:
        """
        一步到位创建完整文章

        参数:
            keywords: 关键词列表

        返回:
            包含所有创作成果的字典
        """
        print("=" * 60)
        print("🚀 AI写作助手 - 开始创作")
        print("=" * 60)

        # 1. 分析关键词
        print("\n📊 步骤1：分析关键词...")
        analysis = self.analyze_keywords(keywords)
        print(f"✓ 分析完成，找到 {len(keywords)} 个关键词的最佳切入角度")

        # 2. 生成大纲
        print("\n📝 步骤2：生成文章大纲...")
        outline = self.generate_outline(keywords[0])
        if "error" in outline:
            print(f"✗ 大纲生成失败：{outline['error']}")
            return outline
        print(f"✓ 大纲生成完成：{outline.get('title', '')}")

        # 3. 撰写文章
        print("\n✍️ 步骤3：撰写文章...")
        article = self.write_article(outline)
        print(f"✓ 文章撰写完成，字数约 {len(article)} 字")

        # 4. 生成标题
        print("\n📌 步骤4：生成备选标题...")
        titles = self.generate_titles(article)
        print(f"✓ 生成了 {len(titles)} 个备选标题")

        # 5. 生成封面
        print("\n🎨 步骤5：生成封面图...")
        cover_path = self.generate_cover_image(outline.get("title", keywords[0]))
        print(f"✓ 封面图已保存：{cover_path}")

        # 返回完整结果
        result = {
            "keywords": keywords,
            "analysis": analysis,
            "outline": outline,
            "article": article,
            "titles": titles,
            "cover_image": cover_path,
            "created_at": datetime.now().isoformat()
        }

        print("\n" + "=" * 60)
        print("✅ 创作完成！")
        print("=" * 60)

        return result


# 使用示例
if __name__ == "__main__":
    # 创建写作助手
    creator = ContentCreator(writer_style="专业但有趣，适合职场人士")

    # 创建一篇文章
    result = creator.create_complete_article([
        "远程办公", "效率提升", "在家工作"
    ])

    # 输出结果
    print("\n" + "=" * 60)
    print("📋 最终成果展示")
    print("=" * 60)

    print(f"\n📌 推荐标题：")
    for i, title in enumerate(result["titles"], 1):
        print(f"   {i}. {title}")

    print(f"\n📄 文章预览（前500字）：")
    print("-" * 40)
    print(result["article"][:500] + "...")
    print("-" * 40)

    print(f"\n🎨 封面图：{result['cover_image']}")

============================================================
🚀 AI写作助手 - 开始创作
============================================================

📊 步骤1：分析关键词...
✓ 分析完成，找到 3 个关键词的最佳切入角度

📝 步骤2：生成文章大纲...
✓ 大纲生成完成：远程办公时代，如何保持高效产出？

✍️ 步骤3：撰写文章...
✓ 文章撰写完成，字数约 1580 字

📌 步骤4：生成备选标题...
✓ 生成了 5 个备选标题

🎨 步骤5：生成封面图...
✓ 封面图已保存：cover_20240115_143022.png

============================================================
✅ 创作完成！
============================================================

📋 最终成果展示
============================================================

📌 推荐标题：
   1. 远程办公一周，我发现了3个效率翻倍的秘密
   2. 在家也能高效工作？试试这5个黄金法则
   3. 老板都不知道的远程办公技巧，太实用了！
   4. 告别在家办公的低效焦虑，我有话要说
   5. 为什么你的远程办公效率这么低？

📄 文章预览（前500字）：
----------------------------------------
...
----------------------------------------

🎨 封面图：cover_20240115_143022.png

"""
AI智能客服系统
功能：
1. 意图识别与智能分流
2. FAQ自动问答
3. 多轮对话支持
4. 潜在客户信息收集
5. 对话记录存档
"""

from aitoearn import AIChat, Workflow
from typing import Dict, List, Optional
from datetime import datetime
import json
import os

class KnowledgeBase:
    """知识库管理"""

    def __init__(self):
        self.qa_pairs = []
        self.products = []
        self.load_default_knowledge()

    def load_default_knowledge(self):
        """加载默认知识库（实际项目中可以从数据库加载）"""
        # FAQ问答对
        self.qa_pairs = [
            {
                "keywords": ["价格", "多少钱", "收费", "费用", "收费"],
                "question": "价格相关",
                "answer": "感谢您的咨询！我们的产品价格根据套餐不同有所区别：\n"
                         "• 基础版：99元/月\n"
                         "• 专业版：299元/月\n"
                         "• 企业版：联系客服定制\n\n"
                         "您可以告诉我您的使用场景，我可以为您推荐最合适的方案~"
            },
            {
                "keywords": ["功能", "能做什么", "有什么用", "特点"],
                "question": "功能咨询",
                "answer": "我们的产品主要提供以下核心功能：\n"
                         "• AI写作助手 - 自动生成高质量内容\n"
                         "• 智能客服 - 24小时自动回复\n"
                         "• 数据分析 - 深度洞察用户行为\n"
                         "• 营销自动化 - 自动触达潜在客户\n\n"
                         "请问您最感兴趣的是哪个功能呢？"
            },
            {
                "keywords": ["如何", "怎么用", "教程", "开始", "入门"],
                "question": "使用教程",
                "answer": "很高兴您想开始使用我们的产品！\n\n"
                         "【快速入门步骤】\n"
                         "1. 注册账号并完成认证\n"
                         "2. 选择您需要的AI服务\n"
                         "3. 配置您的API密钥\n"
                         "4. 开始使用！\n\n"
                         "您也可以观看我们的视频教程，我会发送链接给您~"
            },
            {
                "keywords": ["退款", "取消", "退订", "不想用了"],
                "question": "退款相关",
                "answer": "我理解您可能有其他考虑。关于退款政策：\n\n"
                         "• 7天内无条件退款\n"
                         "• 超过7天按剩余天数折算退款\n"
                         "• 企业版需要单独协商\n\n"
                         "请问是什么原因让您想要退款呢？也许我可以帮您解决问题~"
            },
            {
                "keywords": ["人工", "客服", "真人", "人工服务"],
                "question": "转人工",
                "answer": "好的，我现在为您转接人工客服。请稍等~\n\n"
                         "在等待期间，您可以先描述一下您的问题，"
                         "这样人工客服可以更快地帮助您。\n\n"
                         "当前排队人数：1人\n"
                         "预计等待时间：2-3分钟"
            }
        ]

        # 产品信息
        self.products = [
            {
                "name": "AI写作助手",
                "price": "基础版免费，专业版99元/月",
                "features": ["文章自动生成", "多平台适配", "SEO优化"]
            },
            {
                "name": "智能客服系统",
                "price": "299元/月起",
                "features": ["24小时在线", "多轮对话", "精准分流"]
            }
        ]

    def find_answer(self, question: str) -> Optional[Dict]:
        """根据问题关键词找到最匹配的FAQ"""
        question_lower = question.lower()

        best_match = None
        max_score = 0

        for qa in self.qa_pairs:
            score = sum(1 for keyword in qa["keywords"] if keyword in question_lower)
            if score > max_score:
                max_score = score
                best_match = qa

        return best_match if max_score > 0 else None

    def add_qa_pair(self, question: str, answer: str, keywords: List[str]):
        """添加新的问答对"""
        self.qa_pairs.append({
            "keywords": keywords,
            "question": question,
            "answer": answer
        })


class AICustomerService:
    """AI客服系统"""

    def __init__(self, bot_name: str = "小智"):
        self.bot_name = bot_name
        self.knowledge_base = KnowledgeBase()
        self.conversation_history = []
        self.user_info = {}
        self.conversation_id = self._generate_conversation_id()

        # 初始化AI聊天
        self.chat = AIChat(
            provider="openai",
            model="gpt-3.5-turbo",
            system_prompt=f"""你是一个专业、友好的{bot_name}客服助手。
            你的职责是：
            1. 热情地接待每一位用户
            2. 准确理解用户问题
            3. 给出有帮助的回答
            4. 适时引导用户留下联系方式

            回复原则：
            - 保持友好、专业的语气
            - 如果知识库有相关信息，优先使用知识库回答
            - 如果不确定，要诚实告知用户
            - 不要编造价格、功能等信息
            - 每次回复控制在100字以内
            """
        )

    def _generate_conversation_id(self) -> str:
        """生成会话ID"""
        return datetime.now().strftime("%Y%m%d%H%M%S")

    def _welcome(self) -> str:
        """欢迎语"""
        return f"""
👋 你好！欢迎来到我们的服务！

我是{self.bot_name}，您的智能客服助手。

我可以帮您：
• 解答产品相关问题
• 提供使用指导
• 介绍最新活动

请告诉我，您今天想了解什么呢？
"""

    def _collect_user_info(self, message: str) -> bool:
        """尝试收集用户信息"""
        # 简单的信息提取逻辑
        import re

        # 提取手机号
        phone_match = re.search(r'1[3-9]\d{9}', message)
        if phone_match and "phone" not in self.user_info:
            self.user_info["phone"] = phone_match.group()
            return True

        # 提取微信号
        wechat_match = re.search(r'[Vv]\s*:?\s*(\w+)', message)
        if wechat_match and "wechat" not in self.user_info:
            self.user_info["wechat"] = wechat_match.group(1)
            return True

        return False

    def _should_collect_info(self, context: str) -> bool:
        """判断是否应该收集用户信息"""
        positive_signals = ["想买", "要买", "有兴趣", "可以", "好的"]
        question_signals = ["多少钱", "怎么买", "如何购买", "联系"]

        return any(signal in context for signal in positive_signals + question_signals)

    def chat(self, user_message: str) -> str:
        """
        处理用户消息

        参数:
            user_message: 用户输入

        返回:
            AI回复
        """
        # 保存对话历史
        self.conversation_history.append({
            "role": "user",
            "content": user_message,
            "timestamp": datetime.now().isoformat()
        })

        # 尝试收集用户信息
        if self._should_collect_info(user_message):
            if self._collect_user_info(user_message):
                info_msg = f"好的，我已经记录了您的信息：{self.user_info}。"
            else:
                info_msg = ""
        else:
            info_msg = ""

        # 首先在知识库中查找
        kbase_answer = self.knowledge_base.find_answer(user_message)

        if kbase_answer:
            response_text = kbase_answer["answer"]
        else:
            # 使用AI生成回复
            response = self.chat.send(user_message)
            response_text = response.content

        # 添加信息收集提示
        if self._should_collect_info(response_text) and len(self.user_info) < 2:
            response_text += "\n\n💡 温馨提示：如果您想获得更专业的服务，可以留下您的联系方式，我会安排专人为您服务~"

        # 保存回复
        self.conversation_history.append({
            "role": "assistant",
            "content": response_text,
            "timestamp": datetime.now().isoformat()
        })

        return info_msg + "\n\n" + response_text if info_msg else response_text

    def save_conversation(self, filepath: str = None):
        """保存对话记录"""
        if filepath is None:
            filepath = f"conversation_{self.conversation_id}.json"

        data = {
            "conversation_id": self.conversation_id,
            "bot_name": self.bot_name,
            "user_info": self.user_info,
            "history": self.conversation_history,
            "created_at": self.conversation_history[0]["timestamp"] if self.conversation_history else None,
            "ended_at": datetime.now().isoformat()
        }

        with open(filepath, "w", encoding="utf-8") as f:
            json.dump(data, f, ensure_ascii=False, indent=2)

        return filepath


class CustomerServiceWorkflow:
    """客服工作流"""

    def __init__(self):
        self.cs = AICustomerService()
        self.is_active = True

    def start(self):
        """启动客服系统"""
        print("=" * 50)
        print("🤖 AI智能客服系统已启动")
        print("=" * 50)
        print(self.cs._welcome())
        print()

    def handle_message(self, user_input: str) -> str:
        """处理用户消息"""
        if user_input.lower() in ["退出", "quit", "exit", "拜拜"]:
            self.is_active = False
            response = "感谢您的咨询，祝您生活愉快！有需要随时联系我~ 👋"
        else:
            response = self.cs.chat(user_input)

        return response

    def end(self):
        """结束对话"""
        # 保存对话记录
        filepath = self.cs.save_conversation()
        print(f"\n📝 对话记录已保存：{filepath}")
        print(f"👤 收集到的用户信息：{self.cs.user_info}")


# 交互式使用示例
def run_interactive():
    """交互式运行客服系统"""
    workflow = CustomerServiceWorkflow()
    workflow.start()

    while workflow.is_active:
        try:
            user_input = input("\n👤 您：")
            if not user_input.strip():
                continue

            response = workflow.handle_message(user_input)
            print(f"\n🤖 {workflow.cs.bot_name}：{response}")

        except KeyboardInterrupt:
            print("\n\n正在退出...")
            workflow.is_active = False
        except Exception as e:
            print(f"\n⚠️ 发生错误：{e}")

    workflow.end()


# 程序入口
if __name__ == "__main__":
    # 方式一：交互式运行
    run_interactive()

    # 方式二：自动测试对话
    def run_test():
        cs = AICustomerService()
        print(cs._welcome())

        test_messages = [
            "你好，我想了解一下你们的产品",
            "AI写作助手多少钱？",
            "基础版有什么功能？",
            "我微信号是xiaoming888",
            "好的，我想购买",
            "退出"
        ]

        for msg in test_messages:
            print(f"\n{'='*50}")
            print(f"👤 用户：{msg}")
            response = cs.chat(msg)
            print(f"🤖 客服：{response}")

        # 保存对话
        filepath = cs.save_conversation()
        print(f"\n📝 对话记录已保存至：{filepath}")

    # run_test()  # 取消注释可运行自动测试

==================================================
🤖 AI智能客服系统已启动
==================================================

👋 你好！欢迎来到我们的服务！

我是小智，您的智能客服助手。

我可以帮您：
• 解答产品相关问题
• 提供使用指导
• 介绍最新活动

请告诉我，您今天想了解什么呢？


👤 您：你们这个AI写作助手怎么收费的？

🤖 小智：感谢您的咨询！我们的AI写作助手价格如下：

• 基础版：免费（每月50次使用）
• 专业版：99元/月（无限使用）
• 企业版：499元/月起（私有化部署）

请问您想了解哪个版本的具体功能呢？


👤 您：专业版比基础版多了什么功能？

🤖 小智：好问题！专业版相比基础版增加了以下核心功能：

✅ 无限次使用（基础版每月限50次）
✅ 支持更多AI模型选择
✅ 可以上传自有知识库
✅ API接口调用支持
✅ 优先客服响应

如果您是个人创作者，基础版基本够用；如果您是企业用户或重度使用者，建议选择专业版~

💡 温馨提示：如果您想获得更专业的服务，可以留下您的联系方式，我会安排专人为您服务~


👤 您：我的微信是 ai_fan2024

🤖 小智：好的，我已经记录了您微信：ai_fan2024

感谢您的信任！我已经记录下您的联系方式了。我们的销售顾问会在24小时内添加您的微信，为您提供一对一咨询服务~

在此之前，您还有什么想了解的吗？


👤 您：好的，暂时没有了，谢谢

🤖 小智：感谢您的咨询，祝您生活愉快！有需要随时联系我~ 👋

正在退出...

📝 对话记录已保存：conversation_20240115_143022.json
👤 收集到的用户信息：{'wechat': 'ai_fan2024'}

"""
短视频内容工厂
功能：
1. 热点话题挖掘与选题
2. 短视频脚本自动生成
3. 批量内容生产
4. 多平台适配
"""

from aitoearn import AIChat, AIImage, DocumentProcessor
from typing import List, Dict
import json
from datetime import datetime
import random

class TopicFinder:
    """热点话题挖掘器"""

    def __init__(self):
        self.chat = AIChat(
            provider="openai",
            model="gpt-4",
            system_prompt="""你是一位资深的新媒体运营专家，精通各大短视频平台的算法规则。
            你擅长捕捉热点话题，能预判什么内容会成为爆款。
            你的任务是根据用户提供的时间节点和领域，生成一系列有潜力的选题。"""
        )

    def generate_topics(
        self,
        niche: str,
        count: int = 10,
        platform: str = "抖音"
    ) -> List[Dict]:
        """
        生成选题列表

        参数:
            niche: 领域，如"科技数码"、"职场成长"、"生活方式"
            count: 生成数量
            platform: 目标平台

        返回:
            选题列表
        """
        prompt = f"""
请为{niche}领域生成{count}个适合{platform}平台的短视频选题。

要求：
1. 每个选题要有独特角度，避免同质化
2. 考虑{platform}平台的算法偏好（如完播率、互动率）
3. 每个选题要包含：标题、悬念点、目标受众
4. 可以借鉴近期热门内容的成功元素

请用JSON格式输出：
[
    {{
        "title": "选题标题",
        "hook": "开头3秒的钩子",
        "target_audience": "目标受众",
        "estimated_duration": "预计时长",
        "viral_potential": "爆款潜力(1-10)"
    }},
    ...
]
"""

        response = self.chat.send(prompt)

        try:
            topics = json.loads(response.content)
            return topics
        except json.JSONDecodeError:
            return []


class VideoScriptWriter:
    """视频脚本撰写器"""

    def __init__(self, platform: str = "抖音"):
        self.platform = platform
        self.chat = AIChat(
            provider="openai",
            model="gpt-4",
            system_prompt=f"""你是一位顶级的短视频编剧，专为{platform}平台创作爆款内容。

            你深知{platform}平台的算法机制：
            - 前3秒必须有强钩子抓住注意力
            - 内容要有反转或惊喜
            - 结尾要有互动引导

            你擅长创作各种类型的脚本：
            - 知识科普类
            - 情感共鸣类
            - 搞笑娱乐类
            - 种草带货类

            你的脚本语言要：
            - 口语化、自然流畅
            - 节奏感强，适合配音
            - 适当留白，给画面发挥空间
            """
        )

    def write_script(
        self,
        topic: Dict,
        style: str = "知识科普"
    ) -> Dict:
        """
        根据选题撰写完整脚本

        参数:
            topic: TopicFinder生成的选题
            style: 视频风格

        返回:
            完整的脚本数据
        """
        prompt = f"""
请为以下选题创作一个完整的短视频脚本：

选题标题：{topic.get('title', '')}
开头钩子：{topic.get('hook', '')}
目标受众：{topic.get('target_audience', '')}
预计时长：{topic.get('estimated_duration', '')}
视频风格：{style}

脚本要求：
1. 时长控制在60-90秒
2. 包含完整的开场、中间、结尾
3. 每一句话都要标注画面建议
4. 标注BGM风格建议
5. 结尾必须有互动话术（点赞、评论、关注引导）

输出格式（JSON）：
{{
    "title": "最终视频标题",
    "duration": "实际时长",
    "script": [
        {{
            "timestamp": "00:00-00:05",
            "content": "说的话",
            "visual": "画面建议"
        }},
        ...
    ],
    "bgm": "BGM风格建议",
    "cta": "结尾互动话术",
    "hashtags": ["#标签1", "#标签2", ...]
}}
"""

        response = self.chat.send(prompt)

        try:
            script_data = json.loads(response.content)
            script_data["original_topic"] = topic
            return script_data
        except json.JSONDecodeError:
            return {"error": "脚本生成失败", "raw": response.content}

    def adapt_for_platform(self, script: Dict, target_platform: str) -> Dict:
        """
        将脚本适配到不同平台

        参数:
            script: 原始脚本
            target_platform: 目标平台（抖音/快手/小红书/B站）

        返回:
            适配后的脚本
        """
        adaptation_prompts = {
            "抖音": "调整为中国抖音平台风格，节奏更快，语言更接地气",
            "快手": "调整为快手风格，更真实、更接地气",
            "小红书": "调整为小红书风格，封面文字更突出",
            "B站": "调整为B站风格，可以稍长，更注重内容深度"
        }

        prompt = f"""
请将以下脚本适配到{target_platform}平台：

{adaptation_prompts.get(target_platform, '')}

原始脚本：
{json.dumps(script, ensure_ascii=False, indent=2)}

请保持核心内容不变，仅调整表达方式和时长。
"""

        response = self.chat.send(prompt)

        try:
            adapted = json.loads(response.content)
            adapted["platform"] = target_platform
            return adapted
        except:
            return script


class ContentFactory:
    """短视频内容工厂"""

    def __init__(self, niche: str = "科技数码"):
        self.niche = niche
        self.topic_finder = TopicFinder()
        self.script_writer = VideoScriptWriter()
        self.image_gen = AIImage(provider="openai", model="dall-e-3")
        self.doc = DocumentProcessor()

        self.generated_content = []

    def produce_batch(
        self,
        count: int = 5,
        style: str = "知识科普",
        platforms: List[str] = None
    ) -> List[Dict]:
        """
        批量生产内容

        参数:
            count: 数量
            style: 内容风格
            platforms: 目标平台列表

        返回:
            生成的内容列表
        """
        if platforms is None:
            platforms = ["抖音"]

        print("=" * 60)
        print("🎬 短视频内容工厂 - 开始生产")
        print("=" * 60)

        # 1. 生成选题
        print(f"\n📊 步骤1：挖掘热点选题...")
        topics = self.topic_finder.generate_topics(
            niche=self.niche,
            count=count
        )
        print(f"✓ 生成了 {len(topics)} 个备选选题")

        results = []

        for idx, topic in enumerate(topics[:count], 1):
            print(f"\n{'─' * 50}")
            print(f"📹 内容 {idx}/{count}：{topic.get('title', '')}")
            print(f"{'─' * 50}")

            # 2. 撰写脚本
            print("✍️  步骤2：撰写视频脚本...")
            script = self.script_writer.write_script(topic, style)

            if "error" in script:
                print(f"✗ 脚本生成失败，跳过")
                continue

            print(f"✓ 脚本撰写完成，时长 {script.get('duration', '未知')}")

            # 3. 适配多平台
            print("🔄 步骤3：多平台适配...")
            platform_scripts = {}
            for platform in platforms:
                adapted = self.script_writer.adapt_for_platform(script, platform)
                platform_scripts[platform] = adapted
            print(f"✓ 已适配 {len(platforms)} 个平台")

            # 4. 生成封面图
            print("🎨 步骤4：生成封面图...")
            cover_prompt = f"""
短视频封面图：{script.get('title', topic.get('title', ''))}
风格：{style}
要求：醒目、有冲击力、文字区域清晰
"""
            try:
                cover_result = self.image_gen.generate(
                    prompt=cover_prompt,
                    size="1024x1024"
                )
                cover_path = f"cover_{idx}_{datetime.now().strftime('%H%M%S')}.png"
                cover_result.save(cover_path)
                print(f"✓ 封面图已生成：{cover_path}")
            except Exception as e:
                cover_path = None
                print(f"⚠ 封面图生成失败：{e}")

            # 5. 整理结果
            content_item = {
                "index": idx,
                "topic": topic,
                "script": script,
                "platform_scripts": platform_scripts,
                "cover_image": cover_path,
                "created_at": datetime.now().isoformat(),
                "hashtags": script.get("hashtags", []),
                "cta": script.get("cta", "")
            }

            results.append(content_item)
            self.generated_content.append(content_item)

            print(f"\n📋 内容摘要：")
            print(f"   标题：{script.get('title', '无')}")
            print(f"   时长：{script.get('duration', '未知')}")
            print(f"   标签：{', '.join(script.get('hashtags', [])[:5])}")

        print("\n" + "=" * 60)
        print(f"✅ 内容生产完成！共生成 {len(results)} 个内容")
        print("=" * 60)

        return results

    def export_content(self, content_list: List[Dict], output_dir: str = "./output"):
        """
        导出内容到本地

        参数:
            content_list: 内容列表
            output_dir: 输出目录
        """
        import os
        os.makedirs(output_dir, exist_ok=True)

        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        output_file = os.path.join(output_dir, f"content_batch_{timestamp}.json")

        with open(output_file, "w", encoding="utf-8") as f:
            json.dump(content_list, f, ensure_ascii=False, indent=2)

        print(f"\n📁 内容已导出至：{output_file}")

        # 单独导出脚本文本
        scripts_file = os.path.join(output_dir, f"scripts_{timestamp}.txt")
        with open(scripts_file, "w", encoding="utf-8") as f:
            for idx, content in enumerate(content_list, 1):
                script = content["script"]
                f.write(f"{'='*60}\n")
                f.write(f"内容 {idx}：{script.get('title', '无标题')}\n")
                f.write(f"{'='*60}\n\n")

                for line in script.get("script", []):
                    f.write(f"[{line.get('timestamp', '')}] {line.get('content', '')}\n")
                    f.write(f"   画面：{line.get('visual', '')}\n\n")

                f.write(f"\nBGM：{script.get('bgm', '无')}\n")
                f.write(f"互动引导：{script.get('cta', '无')}\n")
                f.write(f"标签：{', '.join(script.get('hashtags', []))}\n")
                f.write("\n\n")

        print(f"📄 脚本文本已导出至：{scripts_file}")


# 使用示例
if __name__ == "__main__":
    # 创建内容工厂
    factory = ContentFactory(niche="职场成长")

    # 批量生产5个内容
    contents = factory.produce_batch(
        count=5,
        style="知识科普+情感共鸣",
        platforms=["抖音", "小红书"]
    )

    # 导出内容
    factory.export_content(contents)

    # 显示生成的内容
    print("\n" + "=" * 60)
    print("📺 生成的内容预览")
    print("=" * 60)

    for content in contents:
        script = content["script"]
        print(f"\n【{content['index']}】{script.get('title', '无标题')}")
        print(f"   时长：{script.get('duration', '未知')}")
        print(f"   标签：{' '.join(script.get('hashtags', [])[:5])}")

        # 显示脚本前3句
        script_lines = script.get("script", [])
        if script_lines:
            print(f"   脚本预览：")
            for line in script_lines[:3]:
                print(f"     [{line.get('timestamp', '')}] {line.get('content', '')[:30]}...")

from aitoearn import AIChat, DocumentProcessor

# 初始化
chat = AIChat(provider="openai", model="gpt-4")
doc = DocumentProcessor()

# 课程大纲生成
outline = chat.send("""
为一个"Python爬虫实战"课程生成大纲，要求：
1. 包含10个章节
2. 从基础到进阶
3. 每个章节有具体知识点
4. 包含实战项目
""")

print("课程大纲：")
print(outline.content)

# 详细内容撰写
chapter_content = chat.send(f"""
请撰写第一章的详细内容：
- 标题：Python环境配置与基础语法
- 目标受众：零基础学员
- 风格：生动有趣，结合实际案例

要求：
1. 字数2000字左右
2. 包含代码示例
3. 结尾有练习题
""")

print("\n第一章详细内容：")
print(chapter_content.content)

from aitoearn import AIChat

chat = AIChat(
    provider="openai",
    model="gpt-3.5-turbo",
    system_prompt="你是一位资深电商运营，擅长写吸引人的产品描述。"
)

def generate_product_description(product_info: dict) -> dict:
    """
    生成产品描述

    参数:
        product_info: 产品信息字典
    """
    prompt = f"""
请为以下产品生成完整的电商描述：

产品名称：{product_info.get('name', '')}
产品特点：{product_info.get('features', '')}
目标人群：{product_info.get('target_audience', '')}
价格区间：{product_info.get('price_range', '')}

请生成：
1. 吸睛标题（30字以内）
2. 核心卖点（3-5个，用emoji）
3. 产品详情（200字左右）
4. 买家好评引导语
5. 行动号召语

请用JSON格式输出。
"""

    response = chat.send(prompt)
    return response.content

# 示例产品
product = {
    "name": "智能降噪无线耳机",
    "features": "主动降噪、40小时续航、Hi-Fi音质、佩戴舒适、支持无线充电",
    "target_audience": "追求品质生活的年轻人、商务人士",
    "price_range": "300-500元"
}

description = generate_product_description(product)
print(description)

from aitoearn import AIChat

chat = AIChat(provider="openai", model="gpt-4")

def adapt_content_for_platform(original_content: str, platforms: list) -> dict:
    """
    将内容适配到多个平台
    """
    results = {}

    platform_configs = {
        "微信公众号": "公众号风格，图文并茂，1500-2000字，有小标题",
        "微博": "微博风格，140字以内，带话题标签，适合热点",
        "小红书": "小红书风格，种草笔记格式，有emoji，有标签",
        "知乎": "知乎风格，专业深度，有案例分析，干货满满",
        "抖音": "短视频脚本风格，节奏快，有钩子，适合配音"
    }

    for platform in platforms:
        if platform in platform_configs:
            prompt = f"""
请将以下内容改写成适合{platform}的版本：

{platform_configs[platform]}

原始内容：
{original_content}

要求：
1. 保持核心信息不变
2. 适配目标平台的特点和用户习惯
3. 直接输出改写后的内容，不要额外解释
"""
            response = chat.send(prompt)
            results[platform] = response.content

    return results

# 原始内容
original = """
研究发现，每天早起1小时做这5件事，可以让工作效率提升3倍：
1. 制定当日计划
2. 处理最重要的工作
3. 运动15分钟
4. 冥想5分钟
5. 早餐时学习新知识
"""

# 多平台分发
adapted = adapt_content_for_platform(
    original,
    ["微博", "小红书", "知乎"]
)

for platform, content in adapted.items():
    print(f"\n{'='*50}")
    print(f"📱 {platform}")
    print(f"{'='*50}")
    print(content)

from aitoearn import AIChat

# 技巧类账号运营助手
copywriter = AIChat(
    provider="openai",
    model="gpt-4",
    system_prompt="""你是一位顶级的新媒体内容创作者，擅长写爆款标题和吸引人的文案。

你的特点：
1. 标题党高手 - 擅长用数字、疑问、对比等技巧写吸睛标题
2. 悬念大师 - 知道如何在开头制造悬念，让读者欲罢不能
3. 情感共鸣 - 懂得如何触动读者的情感
4. 行动号召 - 每次都能给出有力的结尾引导

你的禁忌：
1. 不会写虚假夸大、博眼球的内容
2. 不会使用低俗词汇
3. 不会写空洞无物的标题

请用这个风格帮我优化内容。"""
)

# 使用示例
result = copywriter.send("帮我写10个关于'时间管理'的爆款标题")
print(result.content)

from aitoearn import AIChat, enable_cache

# 启用缓存
enable_cache(type="local", path="./cache")

chat = AIChat(provider="openai", model="gpt-3.5-turbo")

# 第一次调用（实际发送请求）
result1 = chat.send("什么是Python？")

# 第二次调用（从缓存返回）
result2 = chat.send("什么是Python？")

# 两次结果相同，但第二次不消耗API配额
print(result1.content == result2.content)  # True

from aitoearn import AIChat
from concurrent.futures import ThreadPoolExecutor
import time

chat = AIChat(provider="openai", model="gpt-3.5-turbo")

# 准备任务列表
tasks = [
    "用Python写一个Hello World程序",
    "解释什么是变量",
    "什么是函数？",
    "Python中的列表是什么？",
    "如何创建一个类？"
]

# 串行处理（慢）
start = time.time()
for task in tasks:
    result = chat.send(task)
    print(f"完成：{task[:20]}...")
serial_time = time.time() - start

# 批量提示词（快）
batch_prompt = """
请依次回答以下5个Python基础问题，每个问题单独回答，用---分隔：

1. 用Python写一个Hello World程序
2. 解释什么是变量
3. 什么是函数？
4. Python中的列表是什么？
5. 如何创建一个类？
"""

start = time.time()
result = chat.send(batch_prompt)
batch_time = time.time() - start

print(f"\n串行处理耗时：{serial_time:.2f}秒")
print(f"批量处理耗时：{batch_time:.2f}秒")
print(f"效率提升：{serial_time/batch_time:.2f}倍")

from aitoearn import AIChat
import time

def chat_with_retry(prompt: str, max_retries: int = 3) -> str:
    """
    带重试机制的对话函数
    """
    chat = AIChat(provider="openai", model="gpt-3.5-turbo")

    for attempt in range(max_retries):
        try:
            response = chat.send(prompt)
            return response.content
        except Exception as e:
            print(f"第 {attempt + 1} 次尝试失败：{e}")
            if attempt < max_retries - 1:
                wait_time = (attempt + 1) * 2  # 指数退避
                print(f"等待 {wait_time} 秒后重试...")
                time.sleep(wait_time)
            else:
                return f"请求失败，已达到最大重试次数：{max_retries}"

    return "未知错误"

# 使用示例
result = chat_with_retry("解释量子计算的基本原理")
print(result)

from aitoearn import WebhookServer, AIChat

server = WebhookServer(port=5000)
chat = AIChat(provider="openai", model="gpt-3.5-turbo")

@server.route("/api/chat", methods=["POST"])
def handle_chat(request):
    """处理聊天请求"""
    data = request.json
    message = data.get("message", "")
    user_id = data.get("user_id", "anonymous")

    # 调用AI
    response = chat.send(message)

    return {
        "success": True,
        "response": response.content,
        "user_id": user_id
    }

# 启动服务
server.run()

from aitoearn import Scheduler, AIChat
from datetime import datetime, timedelta

scheduler = Scheduler()
chat = AIChat(provider="openai", model="gpt-3.5-turbo")

# 每天早上8点自动生成日报
@scheduler.daily(hour=8, minute=0)
def daily_report():
    """生成每日内容报告"""

    # 生成报告内容
    content = chat.send("""
    请生成一份今日AI领域资讯摘要，包括：
    1. 3条最新技术进展
    2. 2个值得关注的AI应用
    3. 1个创业机会分析
    """)

    # 保存报告
    with open(f"report_{datetime.now().date()}.md", "w") as f:
        f.write(content.content)

    print(f"✓ 每日报告已生成：report_{datetime.now().date()}.md")

# 启动调度器
scheduler.start()

from aitoearn import AIChat

# 接入本地Ollama模型
chat = AIChat(
    provider="custom",
    api_key="not-needed",  # 本地模型不需要API key
    base_url="http://localhost:11434/v1",
    model="llama2"
)

# 正常使用方法
response = chat.send("用Python写一个快速排序算法")
print(response.content)

✅ AiToEarn的核心功能模块
✅ AI对话引擎的使用技巧
✅ AI绘图引擎的操作方法
✅ 文档处理引擎的高效应用
✅ 工作流引擎的自动化编排
✅ 多个完整的实战案例
✅ 实用的技巧和最佳实践