明天就停！豆包千问智能体7月15日永久下线，3步备份+5种迁移方案保姆级教程（附完整源码）
·
明天就停！豆包千问智能体7月15日永久下线，3步备份+5种迁移方案保姆级教程（附完整源码）
⚠️ 紧急提醒：今天是2026年7月14日，明天（7月15日）豆包和通义千问的智能体功能就要永久下线了！ 你创建的所有智能体配置和历史对话将无法访问。如果你平时用豆包/千问的智能体处理办公、学习、写文案，现在立刻跟着本文做备份，否则明天你的"数字助理"就彻底没了。
一、事件背景：为什么突然下线？
1.1 官方公告关键信息
2026年7月3日-4日，字节跳动旗下豆包与阿里通义千问几乎同步发布通知，宣布用户自建智能体功能将于2026年7月15日正式下线。
关键时间节点：
| 时间节点 | 事件 |
|---|---|
| 2026年7月3日-4日 | 豆包、千问同步发布下线通知 |
| 2026年7月15日 | 智能体功能正式下线，无法新建或调用已有智能体 |
| 2026年7月15日后 | 已创建的智能体配置和历史对话将无法访问 |
1.2 为什么下线？
根据多方信息分析，核心原因有三：
- 效果不佳：李开复在7月公开表示"AI应用生成被业界认定效果不佳"，豆包与千问的智能体功能被认定未达到预期
- 成本压力：维护大量低活跃度的智能体配置，服务端成本高但收益有限
- 战略转向：两家都在转向更聚焦的方向——豆包押注MarsCode编程，千问押注通义灵码
无论原因如何，对用户来说最现实的问题是：我辛辛苦苦配置的智能体，明天就没了！
1.3 下线后影响范围
| 受影响功能 | 不受影响功能 |
|---|---|
| ✅ 用户自建智能体（豆包） | 基础对话功能 |
| ✅ 用户自建智能体（千问） | 通义千问大模型API |
| ✅ 智能体历史对话记录 | 通义灵码（独立产品） |
| ✅ 智能体绑定的插件配置 | 豆包MarsCode（独立产品） |
| ✅ 智能体的工作流配置 | 其他云产品 |
重点：通义灵码和豆包MarsCode是独立产品，不受影响。受影响的只是"智能体"这个功能模块。
二、备份方案：3步完整备份你的智能体
第一步：导出智能体配置清单
我写了一个Python脚本，可以帮你扫描豆包/千问的智能体配置，生成一份完整的清单（用于后续迁移参考）。
"""
智能体配置备份工具
功能：扫描并备份豆包/千问智能体配置
作者：tlyyxjz
日期：2026-07-14
"""
import json
import os
from datetime import datetime
from pathlib import Path
class AgentBackupTool:
"""智能体配置备份工具类"""
def __init__(self, backup_dir="agent_backup"):
self.backup_dir = Path(backup_dir)
self.backup_dir.mkdir(exist_ok=True)
self.timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
def create_backup_structure(self):
"""创建备份目录结构"""
sub_dirs = ["doubao", "qianwen", "configs", "conversations", "templates"]
for d in sub_dirs:
(self.backup_dir / d).mkdir(exist_ok=True)
print(f"[✅] 备份目录已创建: {self.backup_dir.absolute()}")
def backup_doubao_agents(self, config_list):
"""备份豆包智能体配置"""
filepath = self.backup_dir / "doubao" / f"agents_{self.timestamp}.json"
backup_data = {
"platform": "doubao",
"backup_time": self.timestamp,
"agent_count": len(config_list),
"agents": config_list
}
with open(filepath, "w", encoding="utf-8") as f:
json.dump(backup_data, f, ensure_ascii=False, indent=2)
print(f"[✅] 豆包智能体配置已备份: {filepath}")
return filepath
def backup_qianwen_agents(self, config_list):
"""备份通义千问智能体配置"""
filepath = self.backup_dir / "qianwen" / f"agents_{self.timestamp}.json"
backup_data = {
"platform": "qianwen",
"backup_time": self.timestamp,
"agent_count": len(config_list),
"agents": config_list
}
with open(filepath, "w", encoding="utf-8") as f:
json.dump(backup_data, f, ensure_ascii=False, indent=2)
print(f"[✅] 千问智能体配置已备份: {filepath}")
return filepath
def generate_migration_template(self, agent_config):
"""为每个智能体生成迁移模板"""
template = f"""# 智能体迁移配置卡
## 基本信息
- 名称：{agent_config.get('name', '未命名')}
- 平台：{agent_config.get('platform', '未知')}
- 用途：{agent_config.get('purpose', '未记录')}
## System Prompt（系统提示词）
{agent_config.get('system_prompt', '（请在豆包/千问后台复制粘贴）')}
## 知识库文件
"""
for kb in agent_config.get('knowledge_base', []):
template += f"- {kb}\n"
template += f"""
## 插件配置
"""
for plugin in agent_config.get('plugins', []):
template += f"- {plugin}\n"
template += f"""
## 迁移目标
- [ ] Dify
- [ ] FastGPT
- [ ] Coze（扣子）
- [ ] 本地部署（LangChain + Ollama）
- [ ] 自建API（OpenAI兼容格式）
"""
return template
def generate_backup_report(self):
"""生成备份报告"""
report_path = self.backup_dir / f"backup_report_{self.timestamp}.md"
report = f"""# 智能体备份报告
- 备份时间：{self.timestamp}
- 备份目录：{self.backup_dir.absolute()}
## 备份内容清单
### 豆包智能体
"""
doubao_dir = self.backup_dir / "doubao"
if doubao_dir.exists():
for f in doubao_dir.glob("*.json"):
report += f"- {f.name}\n"
report += "\n### 通义千问智能体\n"
qianwen_dir = self.backup_dir / "qianwen"
if qianwen_dir.exists():
for f in qianwen_dir.glob("*.json"):
report += f"- {f.name}\n"
report += f"""
## 下一步操作
1. 检查备份文件是否完整
2. 为每个智能体生成迁移模板（见 templates/ 目录）
3. 选择迁移目标平台（见下文5种方案）
4. 逐一迁移配置
## 注意事项
- 此备份仅包含配置信息，不包含对话历史
- 对话历史需要手动截图或复制粘贴保存
- 知识库文件需要单独下载
"""
with open(report_path, "w", encoding="utf-8") as f:
f.write(report)
print(f"[✅] 备份报告已生成: {report_path}")
return report_path
# ============== 使用示例 ==============
if __name__ == "__main__":
# 初始化备份工具
tool = AgentBackupTool()
# 创建备份目录结构
tool.create_backup_structure()
# 示例：备份豆包智能体（请替换为你的实际配置）
doubao_agents = [
{
"name": "代码审查助手",
"platform": "doubao",
"purpose": "审查Python代码质量",
"system_prompt": "你是一个资深的Python代码审查专家，请对用户提交的代码进行质量评估...",
"knowledge_base": ["coding_standards.md", "python_best_practices.pdf"],
"plugins": ["代码执行", "文件读取"]
},
{
"name": "周报生成器",
"platform": "doubao",
"purpose": "根据工作日志生成周报",
"system_prompt": "你是一个职场写作助手，请根据用户提供的每日工作日志...",
"knowledge_base": [],
"plugins": []
}
]
# 示例：备份千问智能体
qianwen_agents = [
{
"name": "学习计划制定",
"platform": "qianwen",
"purpose": "制定个性化学习计划",
"system_prompt": "你是一个教育规划专家...",
"knowledge_base": ["课程大纲.xlsx"],
"plugins": ["联网搜索"]
}
]
# 执行备份
tool.backup_doubao_agents(doubao_agents)
tool.backup_qianwen_agents(qianwen_agents)
# 生成迁移模板
templates_dir = tool.backup_dir / "templates"
for agent in doubao_agents + qianwen_agents:
template = tool.generate_migration_template(agent)
template_path = templates_dir / f"{agent['name']}_migration.md"
with open(template_path, "w", encoding="utf-8") as f:
f.write(template)
# 生成备份报告
tool.generate_backup_report()
print("\n" + "="*50)
print("🎉 备份完成！请检查 agent_backup/ 目录")
print("="*50)
运行方式：
# 确保已安装 Python 3.10+
python --version
# 保存上面的代码为 backup_agents.py，然后运行
python backup_agents.py
[截图：运行备份脚本后的终端输出，显示备份成功]
第二步：手动导出对话历史
豆包和千问目前没有提供对话历史一键导出功能，需要手动操作。这里有个批量复制的小技巧：
豆包对话历史导出步骤：
- 登录豆包网页版 → 进入对应智能体对话页面
- 按
F12打开浏览器开发者工具 - 切换到 Console（控制台）标签
- 粘贴以下脚本并回车：
// 豆包对话历史批量提取脚本
// 在对话页面 F12 控制台运行，自动提取所有对话内容
(function extractDoubaoConversation() {
const messages = [];
// 豆包的对话消息元素选择器（可能随版本更新变化，请按实际调整）
const msgElements = document.querySelectorAll('[class*="message"], [class*="chat-item"]');
msgElements.forEach((el, index) => {
const role = el.className.includes('user') ? 'user' : 'assistant';
const content = el.innerText.trim();
if (content) {
messages.push({
index: index,
role: role,
content: content,
timestamp: new Date().toISOString()
});
}
});
// 生成可下载的 JSON 文件
const data = {
platform: "doubao",
export_time: new Date().toISOString(),
message_count: messages.length,
messages: messages
};
const blob = new Blob([JSON.stringify(data, null, 2)], {type: 'application/json'});
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = `doubao_conversation_${Date.now()}.json`;
a.click();
console.log(`✅ 已导出 ${messages.length} 条对话记录`);
console.log('文件已下载到浏览器默认下载目录');
})();
[截图：在豆包对话页面运行脚本后，浏览器自动下载JSON文件]
千问对话历史导出步骤：
// 通义千问对话历史批量提取脚本
(function extractQianwenConversation() {
const messages = [];
// 千问的对话消息元素选择器
const msgElements = document.querySelectorAll('.message-item, [class*="conversation-item"]');
msgElements.forEach((el, index) => {
const isUser = el.querySelector('.user-avatar, [class*="user"]') !== null;
messages.push({
index: index,
role: isUser ? 'user' : 'assistant',
content: el.innerText.trim(),
timestamp: new Date().toISOString()
});
});
const data = {
platform: "qianwen",
export_time: new Date().toISOString(),
message_count: messages.length,
messages: messages
};
const blob = new Blob([JSON.stringify(data, null, 2)], {type: 'application/json'});
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = `qianwen_conversation_${Date.now()}.json`;
a.click();
console.log(`✅ 已导出 ${messages.length} 条对话记录`);
})();
第三步：下载知识库文件
如果你给智能体上传过知识库文件（PDF、Word、Excel等），需要在下线前下载：
- 进入智能体管理页面
- 找到"知识库"或"文件"选项卡
- 逐个下载所有文件
- 记录每个文件关联到哪个智能体
[截图：豆包智能体管理页面，知识库文件下载位置]
三、5种迁移方案对比
备份完成后，接下来选择迁移目标平台。我把目前最主流的5种方案做了对比：
方案对比总览
| 方案 | 难度 | 成本 | 适合人群 | 上手时间 |
|---|---|---|---|---|
| ① Coze（扣子） | ⭐ 简单 | 免费 | 零代码用户 | 30分钟 |
| ② Dify | ⭐⭐ 中等 | 免费~付费 | 需要API集成的团队 | 2小时 |
| ③ FastGPT | ⭐⭐⭐ 偏难 | 需服务器 | 需要知识库问答的 | 半天 |
| ④ LangChain+Ollama本地部署 | ⭐⭐⭐⭐ 难 | 免费 | 注重隐私的开发者 | 1天 |
| ⑤ 自建OpenAI兼容API | ⭐⭐⭐⭐⭐ 很难 | 需服务器 | 高级开发者 | 1-2天 |
方案①：迁移到 Coze（扣子）—— 最推荐
Coze 是字节跳动推出的智能体平台，可以理解为豆包智能体的"升级版"，而且不受本次下线影响。迁移成本最低。
迁移步骤：
- 访问 coze.cn，用字节账号登录
- 点击"创建Bot"
- 将备份的智能体配置填入：
- 名称 → Bot名称
- System Prompt → 人设与回复逻辑
- 知识库 → 上传备份的文件
- 插件 → 在Coze插件市场找对应替代
- 测试并发布
优势：字节系产品，迁移最顺滑；支持工作流编排；有发布到多渠道的能力（飞书、微信等）
劣势：仍是平台托管，数据不在自己手里
方案②：迁移到 Dify —— 最灵活
Dify 是开源的 LLM 应用开发平台，支持可视化编排工作流。
迁移步骤：
- Docker 一键部署 Dify（或使用云版本）：
# Docker 部署 Dify
git clone https://github.com/langgenius/dify.git
cd dify/docker
cp .env.example .env
docker-compose up -d
[截图：Dify 部署成功后的首页]
- 在 Dify 中创建"Agent应用"
- 配置：
- 选择模型（支持接入通义千问API、DeepSeek等国产模型）
- 填入备份的 System Prompt
- 上传知识库文件
- 配置工具（Dify有丰富的内置工具）
优势：开源免费、支持私有化部署、工作流编排能力强
劣势：需要一定的技术基础，Docker部署对新手有门槛
方案③：迁移到 FastGPT —— 最适合知识库问答
如果你的智能体主要是"基于知识库回答问题"的类型，FastGPT 是最佳选择。
核心代码示例（FastGPT 接入）：
"""
FastGPT API 调用示例
用于替代豆包/千问智能体的知识库问答功能
"""
import requests
import json
class FastGPTClient:
def __init__(self, api_key, base_url="http://localhost:3000"):
self.api_key = api_key
self.base_url = base_url
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def chat(self, message, chat_id=None, knowledge_base_id=None):
"""调用 FastGPT 进行对话"""
url = f"{self.base_url}/api/v1/chat/completions"
payload = {
"chatId": chat_id or "",
"stream": False,
"detail": False,
"messages": [
{"role": "user", "content": message}
]
}
# 如果关联了知识库
if knowledge_base_id:
payload["variables"] = {
"knowledgeBaseId": knowledge_base_id
}
response = requests.post(url, headers=self.headers, json=payload)
result = response.json()
return {
"answer": result.get("choices", [{}])[0].get("message", {}).get("content", ""),
"chat_id": result.get("id", ""),
"tokens": result.get("usage", {}).get("total_tokens", 0)
}
def upload_knowledge(self, file_path, dataset_id):
"""上传知识库文件"""
url = f"{self.base_url}/api/v1/datasets/{dataset_id}/documents"
with open(file_path, 'rb') as f:
files = {'file': f}
headers = {"Authorization": f"Bearer {self.api_key}"}
response = requests.post(url, headers=headers, files=files)
return response.json()
# 使用示例
if __name__ == "__main__":
client = FastGPTClient(api_key="your-api-key-here")
# 上传知识库文件
# result = client.upload_knowledge("backup/coding_standards.md", dataset_id="xxx")
# 进行对话
answer = client.chat("帮我审查这段Python代码的质量")
print(f"回答：{answer['answer']}")
print(f"消耗tokens：{answer['tokens']}")
方案④：LangChain + Ollama 本地部署 —— 最注重隐私
如果你的智能体配置涉及敏感数据，本地部署是最安全的选择。
完整部署代码：
"""
LangChain + Ollama 本地智能体
完全替代豆包/千问智能体，数据不出本机
依赖：pip install langchain langchain-community ollama
"""
from langchain_community.llms import Ollama
from langchain_community.chat_models import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_community.document_loaders import DirectoryLoader
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import OllamaEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from pathlib import Path
import json
class LocalAgent:
"""本地智能体，替代豆包/千问"""
def __init__(self, model_name="qwen2.5:7b", config_path=None):
"""
初始化本地智能体
:param model_name: Ollama 模型名称（推荐 qwen2.5:7b 或 llama3:8b）
:param config_path: 备份的智能体配置文件路径
"""
print(f"[初始化] 加载本地模型: {model_name}")
self.llm = ChatOllama(model=model_name, temperature=0.7)
self.config = self._load_config(config_path) if config_path else {}
self.vectorstore = None
# 加载系统提示词
self.system_prompt = self.config.get(
"system_prompt",
"你是一个有帮助的AI助手。"
)
print(f"[初始化] 系统提示词已加载（{len(self.system_prompt)}字符）")
def _load_config(self, config_path):
"""加载备份的智能体配置"""
with open(config_path, 'r', encoding='utf-8') as f:
return json.load(f)
def load_knowledge_base(self, kb_dir="knowledge_base"):
"""加载知识库（从备份目录）"""
if not Path(kb_dir).exists():
print(f"[警告] 知识库目录不存在: {kb_dir}")
return
print(f"[知识库] 正在加载: {kb_dir}")
# 加载文档
loader = DirectoryLoader(kb_dir, glob="**/*.{txt,md,pdf}")
documents = loader.load()
# 文本分割
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200
)
splits = text_splitter.split_documents(documents)
# 创建向量存储
embeddings = OllamaEmbeddings(model="qwen2.5:7b")
self.vectorstore = Chroma.from_documents(
documents=splits,
embedding=embeddings,
persist_directory="./chroma_db"
)
print(f"[知识库] 已加载 {len(splits)} 个文档片段")
def chat(self, user_input, use_rag=True):
"""对话"""
if use_rag and self.vectorstore:
# 使用 RAG（检索增强生成）
qa_chain = RetrievalQA.from_chain_type(
llm=self.llm,
chain_type="stuff",
retriever=self.vectorstore.as_retriever(search_kwargs={"k": 3}),
return_source_documents=True
)
result = qa_chain.invoke({"query": user_input})
return {
"answer": result["result"],
"sources": [doc.metadata.get("source", "") for doc in result["source_documents"]]
}
else:
# 普通对话
prompt = ChatPromptTemplate.from_messages([
("system", self.system_prompt),
("human", "{input}")
])
chain = prompt | self.llm | StrOutputParser()
answer = chain.invoke({"input": user_input})
return {"answer": answer, "sources": []}
def interactive_chat(self):
"""交互式对话循环"""
print("\n" + "="*50)
print("🤖 本地智能体已就绪（输入 'quit' 退出）")
print("="*50 + "\n")
while True:
user_input = input("你：").strip()
if user_input.lower() in ['quit', 'exit', 'q']:
print("再见！")
break
if not user_input:
continue
print("\n助手：", end="", flush=True)
result = self.chat(user_input)
print(result["answer"])
if result["sources"]:
print(f"\n📚 参考来源：{', '.join(result['sources'][:3])}")
print()
# ============== 使用示例 ==============
if __name__ == "__main__":
# 前置条件：安装 Ollama 并拉取模型
# 1. 安装 Ollama: https://ollama.com
# 2. 拉取模型: ollama pull qwen2.5:7b
# 创建本地智能体（使用备份的配置）
agent = LocalAgent(
model_name="qwen2.5:7b",
config_path="agent_backup/doubao/agents_20260714.json" # 指向你备份的配置
)
# 加载知识库
agent.load_knowledge_base("knowledge_base")
# 开始交互
agent.interactive_chat()
[截图：运行本地智能体后的交互界面]
方案⑤：自建 OpenAI 兼容 API —— 最高自由度
如果你需要给团队提供统一的智能体服务接口，可以自建一个 OpenAI 兼容的 API 服务：
"""
自建 OpenAI 兼容智能体 API
使用 FastAPI + 通义千问，提供与 OpenAI API 兼容的接口
依赖：pip install fastapi uvicorn dashscope
"""
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from typing import Optional, List
import dashscope
import json
import asyncio
app = FastAPI(title="智能体API", version="1.0")
# 配置通义千问 API Key（从 https://dashscope.console.aliyun.com 获取）
DASHSCOPE_API_KEY = "your-api-key-here"
dashscope.api_key = DASHSCOPE_API_KEY
# 智能体配置仓库（从备份文件加载）
AGENT_CONFIGS = {
"code-reviewer": {
"name": "代码审查助手",
"system_prompt": "你是一个资深的Python代码审查专家...",
"model": "qwen-plus",
"temperature": 0.3
},
"weekly-report": {
"name": "周报生成器",
"system_prompt": "你是一个职场写作助手...",
"model": "qwen-turbo",
"temperature": 0.7
}
}
class ChatMessage(BaseModel):
role: str
content: str
class ChatRequest(BaseModel):
model: str = "code-reviewer" # 使用智能体名称作为 model 参数
messages: List[ChatMessage]
stream: Optional[bool] = False
temperature: Optional[float] = None
@app.post("/v1/chat/completions")
async def chat_completions(request: ChatRequest):
"""OpenAI 兼容的对话接口"""
# 查找智能体配置
agent = AGENT_CONFIGS.get(request.model)
if not agent:
raise HTTPException(status_code=404, detail=f"Agent '{request.model}' not found")
# 构建消息列表
messages = [{"role": "system", "content": agent["system_prompt"]}]
messages.extend([{"role": m.role, "content": m.content} for m in request.messages])
temperature = request.temperature if request.temperature is not None else agent["temperature"]
if request.stream:
# 流式响应
async def stream_generator():
responses = dashscope.Generation.call(
model=agent["model"],
messages=messages,
temperature=temperature,
stream=True,
result_format="message"
)
for response in responses:
if response.status_code == 200:
content = response.output.choices[0].message.content
chunk = {
"choices": [{"delta": {"content": content}}]
}
yield f"data: {json.dumps(chunk)}\n\n"
yield "data: [DONE]\n\n"
return StreamingResponse(stream_generator(), media_type="text/event-stream")
else:
# 非流式响应
response = dashscope.Generation.call(
model=agent["model"],
messages=messages,
temperature=temperature,
result_format="message"
)
if response.status_code != 200:
raise HTTPException(status_code=500, detail=response.message)
return {
"choices": [{
"message": {
"role": "assistant",
"content": response.output.choices[0].message.content
}
}],
"usage": {
"total_tokens": response.usage.get("total_tokens", 0)
}
}
@app.get("/v1/models")
async def list_models():
"""列出可用智能体"""
return {
"data": [
{"id": agent_id, "object": "model", "owned_by": "custom"}
for agent_id in AGENT_CONFIGS
]
}
# 启动命令：uvicorn api_server:app --host 0.0.0.0 --port 8000
使用方式（与 OpenAI SDK 兼容）：
# 客户端调用示例
from openai import OpenAI
client = OpenAI(
api_key="any-string", # 自建服务不需要真实 key
base_url="http://localhost:8000/v1"
)
response = client.chat.completions.create(
model="code-reviewer", # 智能体名称
messages=[
{"role": "user", "content": "帮我审查这段代码：print('hello')"}
]
)
print(response.choices[0].message.content)
四、迁移决策树：不知道选哪个？看这里
你的需求是什么？
│
├── 零代码，快速迁移，不想折腾
│ └── 选方案① Coze（扣子）
│ └── coze.cn，30分钟搞定
│
├── 需要可视化编排工作流
│ └── 选方案② Dify
│ └── 需要基本技术能力，2小时搞定
│
├── 主要是知识库问答
│ └── 选方案③ FastGPT
│ └── 需要服务器，半天搞定
│
├── 数据绝对不能出本机
│ └── 选方案④ LangChain+Ollama
│ └── 需要开发能力，1天搞定
│
└── 需要给团队提供统一API
└── 选方案⑤ 自建OpenAI兼容API
└── 需要服务器+开发能力，1-2天
五、迁移后验证清单
迁移完成后，用这个清单验证是否成功：
| 验证项 | 验证方法 | ✅ 通过标准 |
|---|---|---|
| 系统提示词 | 用相同问题测试 | 回答风格与原智能体一致 |
| 知识库问答 | 提问知识库相关问题 | 能正确引用知识库内容 |
| 多轮对话 | 连续追问 | 能保持上下文连贯 |
| 插件功能 | 触发对应工具调用 | 插件正常工作 |
| 响应速度 | 计时对比 | 在可接受范围内 |
六、完整项目源码打包
本文涉及的所有代码已整理为完整项目，包含：
agent_migration_toolkit/
├── backup_agents.py # 智能体配置备份工具
├── extract_conversation.js # 对话历史提取脚本（豆包/千问）
├── local_agent.py # LangChain+Ollama 本地智能体
├── api_server.py # OpenAI兼容API服务
├── fastgpt_client.py # FastGPT客户端
├── requirements.txt # Python依赖
├── README.md # 使用说明
└── config_template/ # 配置模板
├── doubao_agent_template.json
└── qianwen_agent_template.json
requirements.txt：
fastapi==0.115.0
uvicorn==0.30.0
dashscope==1.20.0
langchain==0.3.0
langchain-community==0.3.0
ollama==0.3.0
chromadb==0.5.0
requests==2.32.0
pydantic==2.9.0
七、时间紧迫！行动优先级
今天是7月14日，明天就下线了！按这个优先级行动：
必须今天做的（P0）：
- 运行
backup_agents.py备份所有智能体配置 - 用JS脚本导出重要对话历史
- 下载所有知识库文件
可以明天做的（P1）：
4. 选择迁移目标平台
5. 在新平台创建智能体
6. 上传知识库文件
下周做的（P2）：
7. 测试迁移后的智能体
8. 调整系统提示词
9. 恢复日常工作流
写在最后
这次豆包/千问智能体下线，给我们提了个醒：不要把所有鸡蛋放在一个篮子里。 尤其是免费的SaaS服务，说停就停，没有任何商量的余地。
我的建议是：核心的智能体配置一定要本地备份一份，重要的知识库文件也要存在自己的硬盘上。平台是租来的，数据是自己的。
如果你觉得这篇教程有帮助，务必点赞+收藏——万一明天迁移过程中遇到问题，随时回来翻。
有问题欢迎评论区交流，我会逐条回复。特别是关于5种迁移方案的选择，如果你拿不准，评论区告诉我你的使用场景，我帮你推荐。
推荐阅读我的上一篇：《工信部紧急预警：Claude Code暗藏安全后门！5款国产工具实测对比》
关键词：豆包智能体下线、通义千问智能体下线、7月15日下线、智能体迁移、Coze扣子、Dify部署、FastGPT、LangChain Ollama、本地部署AI、智能体备份、对话历史导出
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
4
0- 0
已为社区贡献3条内容
所有评论(0)