MiroThinker一个全球领先的开源搜索Agent
文件名角色比喻职责描述基因/DNA决定了 Agent 是个暴躁的黑客，还是严谨的会计。main.py脑干维持生命体征，加载配置，唤醒意识。agent.py前额叶/意识核心控制器。负责“想 -> 做 -> 看”的死循环。眼睛/望远镜让 Agent 看到外面的世界（互联网）。手/左脑负责逻辑运算、画图、操作文件。E2B 沙箱就是它的无菌手术室。context.py海马体/代谢系统关键模块。负责遗忘不重
·
一 、MiroThinker文件结构解析与树形图
MiroThinker/
├── 📜 justfile # [神经反射] 快捷指令集 (just run, just deploy)
├── 📜 pyproject.toml # [细胞核] 依赖管理 (uv lock)
│
├── 🧠 apps/miroflow-agent/ # [大脑中枢] The Agent Core
│ ├── 📜 .env # [体液] 关键激素 (API Keys)
│ ├── 📜 main.py # [脑干] 意识唤醒入口
│ │
│ ├── 📂 conf/ # [DNA] 基因配置库
│ │ ├── config.yaml # 基础生理参数
│ │ └── agent/ # 人格特质
│ │ ├── 🧬 mirothinker_v1.5_keep5.yaml # [平衡型] 推荐配置
│ │ └── 🧬 mirothinker_v1.5_deep.yaml # [深思型] 400轮思考
│ │
│ └── 📂 src/ # [皮层] 高级思维区域
│ ├── 🧠 agent.py # [意识] ReAct 状态机循环
│ ├── 🗂️ context.py # [记忆] Context 动态压缩算法
│ ├── 📝 prompt_manager.py # [语言] System Prompt 模板库
│ └── 🔌 mcp_client.py # [神经突触] 连接 Tools 的适配器
│
├── 🛠️ libs/miroflow-tools/ # [四肢与感官] The Toolset (MCP Servers)
│ ├── 📜 pyproject.toml # 工具独立依赖
│ └── 📂 src/tools/
│ ├── 🐍 tool_python.py # [左手] E2B 代码解释器
│ ├── 🔍 search_tool.py # [眼睛] Serper 搜索引擎
│ ├── 📖 browser_tool.py # [眼镜] Jina 网页阅读器
│ └── 💾 file_system.py # [右手] 本地文件读写
│
└── 📊 assets/ # [外貌]
└── gradio_demo.py # [面孔] 可视化交互界面
核心文件深度剖析 (Deep Dive)
我们对 MiroThinker 最独特的两个核心组件进行隐喻式解读。
A. 意识维持系统 (The Consciousness Loop)
核心文件: apps/miroflow-agent/src/agent.py 标签: [意志 / 执念]
深度解析:
- 交互式扩展 (Interactive Scaling): 其他 Agent 追求“一次做对”，MiroThinker 追求“反复验证”。这个文件定义了一个永不放弃的循环。
- 错误恢复机制: 如果
tool-python报错（例如代码语法错误），agent.py不会崩溃，而是将报错信息（Traceback）作为“观察”喂回给 LLM。LLM 会像程序员一样说：“啊，我少写了一个括号”，然后重新生成代码。这种自我纠错能力是其核心。 - 终止条件: 不是简单的“回答完毕”，而是需要 LLM 输出特定的终止 Token，或者达到
max_turns上限。
B. 记忆代谢系统 (The Memory Metabolism)
核心文件: apps/miroflow-agent/src/context.py (及相关配置 keep_tool_result) 标签: [新陈代谢 / 遗忘曲线]
深度解析:
- 信息过载问题: 在 200 轮的 Deep Research 中，Agent 可能会读取几十万字的网页。如果全部塞进 Prompt，任何模型都会崩溃。
- 代谢算法: 该模块实现了一个类似人类短期记忆的机制。
- T-0 (当前): 保留完整的网页内容、完整的代码输出。
- T-5 (5轮前): 仅保留“我搜索了X，得到结论Y”，原始网页内容被丢弃。
- 原理: 这种机制保证了 Agent 即使运行了 100 小时，其 Context Window 占用依然保持在一个健康的、模型处理得过来的水平（如 32k tokens 以内），从而实现无限长程推理。
C. 神经传导接口 (The Interface)
核心文件: libs/miroflow-tools/src/tools/python_tool.py 标签: [念力 / 远程操控]
深度解析:
- E2B 集成: 这个文件不是简单的
exec()。它建立了一个通往 E2B 云端沙箱 的加密隧道。 - 状态保持: 当 Agent 在第 1 轮定义了变量
df = load_csv()，在第 10 轮画图时，df依然存在。这是因为python_tool.py维护了一个有状态的 Jupyter Kernel 会话，而不是无状态的函数调用。这让 Agent 感觉自己是在操作一台真正的电脑，而不是在发 API 请求。
二、这些文件是如何协作的？
为了让你透彻理解 MiroThinker 的运行机制，我们将展示从用户输入一个复杂问题（如“预测2026年半导体市场”）开始，代码内部如同精密齿轮般的咬合过程。
2.1 工作流程与数据流 (Workflow & Data Stream)
┌─────────────────────────────────────────────────────────────────┐
│ Stage 1: 创世纪与觉醒 (Genesis & Initialization) │
├─────────────────────────────────────────────────────────────────┤
│ 输入: 用户指令 (Task Prompt) + 配置文件 (.yaml) │
│ 处理: │
│ 1. main.py → 读取 justfile 启动指令，加载环境变量 (.env) │
│ 2. hydra_config → 读取 conf/agent/*.yaml (注入人设与参数) │
│ 3. tool_loader → 实例化 libs/miroflow-tools (装上义肢) │
│ 输出: 初始化的 Agent 实例 (具备了性格、记忆槽和工具箱) │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Stage 2: 感知与规划 (Perception & Planning) │
├─────────────────────────────────────────────────────────────────┤
│ 处理: │
│ 1. agent.py → 接收任务，结合 System Prompt 构建初始上下文 │
│ 2. context.py → 检查历史记忆 (若是多轮对话)，进行相关性提取 │
│ 3. llm_client → 发送 Request 到大模型 (Thinking Process) │
│ 输出: 思考轨迹 (Thought Trace) + 行动意图 (Next Step) │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Stage 3: 行动与执行 (Action & Execution) │
├─────────────────────────────────────────────────────────────────┤
│ 处理: │
│ 1. action_parser → 解析 LLM 输出的 <tool_code> 代码块 │
│ 2. search_tool.py → 若需联网，调用 Serper API 抓取搜索结果 │
│ 3. browser.py → 若需阅读，调用 Jina Reader 抓取并清洗网页 │
│ 4. tool_python.py → 若需计算，发送代码至 E2B 沙箱运行 │
│ 输出: 原始观测结果 (Raw Observation: HTML/JSON/Error Log) │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Stage 4: 记忆代谢 (Memory Metabolism) [核心创新] │
├─────────────────────────────────────────────────────────────────┤
│ 处理: │
│ 1. jina_scrape_llm_summary → 对长网页进行“即时摘要” │
│ 2. context.py (Keep-K Strategy) → │
│ - 保留最近 5 轮的详细代码和搜索结果 │
│ - 将 5 轮之前的交互压缩为“我做过X，得到了结论Y” │
│ 输出: 压缩后的健康上下文 (Sanitized Context) │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Stage 5: 递归与收敛 (Recursion & Convergence) │
├─────────────────────────────────────────────────────────────────┤
│ 功能: │
│ 1. agent.py → 判断是否满足退出条件 (Goal Achieved / Max Turn)│
│ 2. 若未完成 → 携带新观测值，返回 Stage 2 (进入下一轮 Tick) │
│ 3. 若完成 → 综合所有线索，生成最终深度研究报告 │
│ 输出: 最终答案 + 完整的思维链 (Trace) │
└─────────────────────────────────────────────────────────────────┘
2.2 文件依赖关系图 (Dependency Graph)
这展示了文件之间是谁在调用谁，谁依赖谁。
┌──────────────────────────────────────────────────────────────────────┐
│ MiroThinker 模块依赖拓扑 │
└──────────────────────────────────────────────────────────────────────┘
[配置与启动层]
│
├──→ .env (API Keys) ────────┐
│ │
├──→ conf/agent/*.yaml ──────┼──→ main.py (启动入口)
│ (定义能力边界) │
│ │
└──→ justfile (命令封装) ────┘
│
▼
[核心思维层 (Brain)]
│
├──→ src/agent.py (主控循环) ◄──┐
│ │ │
│ ├──→ src/prompt.py (话术) │
│ │ │
│ ├──→ src/llm.py (智商) ────┘
│ │
│ └──→ src/context.py (记忆管理/海马体)
│
▼
[感知与执行层 (Limbs)]
│
├──→ libs/miroflow-tools/src/tools/
│
├──→ search_tool.py ──→ Serper API (外部)
│
├──→ browser.py ──────→ Jina API (外部)
│ │
│ └──→ jina_summary (调用小模型做摘要)
│
└──→ python_tool.py ──→ E2B Cloud Sandbox (外部)
(数据回传: PNG/CSV)
2.3 核心协作流程 (Core Collaboration)
用户输入复杂问题 ("分析 A 股与美股的关联性")
│
▼
┌──────────────┐
│ main.py │ ──→ 加载 mirothinker_v1.5 配置，唤醒 Agent
└──────┬───────┘
│
▼
┌──────────────┐
│ agent.py │ ──→ 开启 ReAct 循环 (Tick 1)
└──────┬───────┘
│ <Need Info?>
▼
┌──────────────┐ ┌──────────────────┐
│ llm_client │ ────►│ search_tool │ (眼睛)
│ (Brain) │ │ (Serper Google) │
└──────┬───────┘ └────────┬─────────┘
│ │
│ <Got URL> ▼
│ ┌──────────────────┐
│ ◄─────────── │ browser.py │ (阅读)
│ │ (Jina Summary) │
│ └────────┬─────────┘
▼ │
┌──────────────┐ │
│ tool_python │ ◄─────────────┘
│ (E2B Sandbox)│ (读取网页数据，画图)
└──────┬───────┘
│
▼
┌──────────────┐
│ context.py │ ──→ 压缩历史，防止溢出 (Keep-5 策略)
└──────┬───────┘
│
▼ (Loop back to agent.py)
生成最终报告
2.4 MiroThinker Simulation Pipeline (全链路运行机制树形图)
我们将智能体的运行过程比作一次**“认知探险”**。
MiroThinker Thinking Pipeline
│
├── 【阶段 I: 神经突触连接 (Synapse Connection)】
│ ├── 用户动作: 启动命令 `just run agent=finance_researcher`
│ │ └── 接口: CLI / API Server
│ │
│ ▼
│ [1. 人格构建 (Persona Injection)] ───────────────────────────────────┐
│ │ (由此文件总控: 🧠 apps/miroflow-agent/main.py) │
│ │ │
│ ├── A. 基因读取 (Config Loading) │
│ │ ├── <调用>: 📜 conf/agent/finance_researcher.yaml │
│ │ │ (读取: max_turns=200, tools=[python, search, bloomberg?]) │
│ │ └── > 状态: 确定了它是一个“极具耐心的金融专家”。 │
│ │ │
│ ├── B. 装备挂载 (Tool Mounting) │
│ │ ├── <调用>: 🛠️ libs/miroflow-tools/src/registry.py │
│ │ │ (动作: 验证 SERPER_API_KEY, 初始化 E2B Session) │
│ │ └── > 状态: "眼睛"张开了，"手"伸进了沙箱。 │
│ └────────────────────────────────────────────────────────────────────┘
│
├── 【阶段 II: 深度思考循环 (The ReAct Loop)】 <★ 核心引擎机制>
│ │
│ ▼
│ [2. 认知迭代 (Cognitive Iteration)] ─────────────────────────────────┐
│ │ (由此文件总控: 🧠 src/agent.py - while 循环) │
│ │ (每一圈代表一次“思考-行动-观察”的完整闭环) │
│ │ │
│ ├── Step 1: 态势感知 (Observation & Thought) │
│ │ ├── <输入>: 当前的目标 + 过去5步做了什么(Memory) │
│ │ ├── <思考>: 调用 src/llm_client.py │
│ │ │ (Prompt: "我现在有Google和Python，要查股价，我该先做什么？") │
│ │ └── > 决策: "我需要先搜索 NVIDA 的最新财报发布日期。" │
│ │ │
│ ├── Step 2: 肢体行动 (Action Execution) │
│ │ ├── <动作>: 路由到 🔍 search_tool.py │
│ │ ├── <执行>: 发送 HTTP 请求给 Google Serper │
│ │ └── > 产物: 返回 10 条 URL 链接和 Snippets。 │
│ │ │
│ ├── Step 3: 信息消化 (Information Digestion) │
│ │ ├── <动作>: 发现 Snippets 信息量不够，决定深读。 │
│ │ ├── <工具>: 📖 browser.py + 🧠 jina_scrape_llm_summary │
│ │ │ (逻辑: 抓取 URL -> 提取正文 -> 用小模型总结成 500字) │
│ │ └── > 产物: 高密度的信息摘要 (Dense Knowledge)。 │
│ │ │
│ └── Step 4: 记忆新陈代谢 (Context Metabolism) │
│ ├── <动作>: 这一轮结束了，准备进入下一轮。 │
│ ├── <文件>: 🧠 src/context.py │
│ │ (逻辑: "第 1 轮的搜索结果已经没用了，只保留摘要，删除原文") │
│ └── > 状态: 释放了 2000 Tokens 空间，为下一轮思考腾地。 │
│ └────────────────────────────────────────────────────────────────────┘
│
├── 【阶段 III: 坍缩与产出 (Collapse & Output)】
│ │
│ ▼
│ [3. 成果生成 (Final Reporting)] ─────────────────────────────────────┐
│ │ │
│ ├── A. 逻辑收敛 (Convergence) │
│ │ ├── 触发: 收集到了足够的信息 (LLM 判断 info_sufficiency=True) │
│ │ └── 动作: agent.py 停止循环。 │
│ │ │
│ ├── B. 报告撰写 (Drafting) │
│ │ ├── <调用>: src/llm_client.py │
│ │ │ (Input: 所有有效的 Memory 摘要 + E2B 生成的图表路径) │
│ │ └── > 最终输出: Markdown 格式的深度报告，包含图表 URL。 │
│ └────────────────────────────────────────────────────────────────────┘
2.5 这些文件是如何“相辅相成”的？（协作细节深度解析）
我们将上述流程拆解为三个具体的协作场景，用拟人化的方式解释文件之间的交互。
场景一：初次接触——从迷茫到清晰
- 任务: 用户问：“特斯拉最新的 FSD 版本安全吗？”
- main.py (指挥官): 启动
agent.py，把问题丢给它。 - agent.py (大脑): 发现自己脑子里（Context）是空的，不知道答案。它向
llm_client求助。 - llm_client (智囊): 建议：“先用
search_tool搜一下 FSD accident statistics。” - search_tool (侦察兵): 跑出去搜了一圈，带回来一堆链接。
- 协作点: 此时，
agent.py并没有盲目回答，而是根据侦察兵的情报，发现了一个 PDF 报告的链接，它决定启动下一个工具。
场景二：精密手术——E2B 沙箱与数据的舞蹈
- 任务: 接上文，需要分析那个 PDF 里的事故率数据。
- agent.py (大脑): 指示：“
tool_python，给我把这个 PDF 里的表格画成折线图。” - tool_python.py (机械手):
- 它不会在本地运行（怕中毒）。它通过 API 唤醒了远端（E2B）的一个 Docker 容器。
- 它在容器里安装
pandas和matplotlib。 - 它执行代码，生成了
chart.png。
- 协作点:
tool_python把图片链接回传给agent.py，但不回传几百行的原始数据（节省 Token）。它只说：“图画好了，数据趋势是下降的。”context.py记录下这个结论，让大脑感到满意。
场景三：记忆清理——防止“老年痴呆”
- 任务: 任务进行到了第 150 轮，已经查阅了 200 个网页。
- 问题: 如果把这 200 个网页全文都塞进 Prompt，连 GPT-5 都会报错（Context Overflow）。
- context.py (清洁工):
- 每过一轮，它就会检查：“第 145 轮搜索的网页原文还有用吗？”
- jina_summary (速记员): 配合清洁工，把第 145 轮那篇 1万字的新闻，改写成 100 字的：“该新闻提到 FSD 在雪地表现不佳。”
- agent.py (大脑): 它只看到了这 100 字的摘要，依然能保持清醒的逻辑，继续做第 151 轮决策。
- 协作点: 正是
context.py和jina_summary的默契配合，才使得 MiroThinker 敢于宣称支持 无限长程推理。
总结：文件角色比喻表
| 文件名 | 角色比喻 | 职责描述 |
|---|---|---|
| conf/agent/*.yaml | 基因/DNA | 决定了 Agent 是个暴躁的黑客，还是严谨的会计。 |
| main.py | 脑干 | 维持生命体征，加载配置，唤醒意识。 |
| agent.py | 前额叶/意识 | 核心控制器。负责“想 -> 做 -> 看”的死循环。 |
| search_tool.py | 眼睛/望远镜 | 让 Agent 看到外面的世界（互联网）。 |
| tool_python.py | 手/左脑 | 负责逻辑运算、画图、操作文件。E2B 沙箱就是它的无菌手术室。 |
| context.py | 海马体/代谢系统 | 关键模块。负责遗忘不重要的信息，只把关键记忆交给大脑。 |
| jina_scrape | 阅读眼镜 | 把人类看的花哨网页，变成机器爱看的 Markdown 摘要。 |
三、MiroThinker 一个全球领先的开源搜索的创新点
以下是结合了认知增强理论 (Cognitive Augmentation) 与 Agentic AI 系统设计 的深度剖析及树形逻辑图。
MiroThinker 并非仅仅是一个“带联网功能的 Chatbot”，它是一个具备自我反思与长程执行力的数字研究员 (Autonomous Digital Researcher)。其核心创新在于打破了“模型越大越聪明”的参数定律，转而通过增加推理深度 (Deep Reasoning) 和 交互式信息采集 (Interactive Information Gathering) 来提升任务解决率。
创新点总览
| 创新点说明 | 优势 | 技术实现 |
|---|---|---|
| 交互式扩展 (Interactive Scaling) | 小模型胜大模型：允许 30B 模型通过数百次“试错”达到 1T 模型的表现。 | ReAct Loop + Max Turn 200+ |
| 动态上下文卫生 (Dynamic Context Hygiene) | 无限长程推理：解决长任务中的 Context 溢出问题，始终保持注意力聚焦。 | Keep-K Strategy + Summary Pruning |
| 异构工具链 (Heterogeneous Toolchain) | 全能型选手：左脑写代码 (E2B)，右脑看世界 (Search)，具备跨模态解决能力。 | MCP Protocol + E2B + Serper + Jina |
| 开源开放 (Fully Open Source) | 可控与隐私：相比 DeepResearch 等闭源竞品，企业可完全私有化部署，数据不出域。 | MIT License + Local Deploy |
| 自我纠错机制 (Self-Correction) | 高鲁棒性：代码报错不崩溃，而是将其作为 Feedback 进行自我修正。 | Error Trace Feedback Loop |
1. 架构创新：交互式扩展 (Interactive Scaling)
标签: [计算换智能 / 深度思考 / System 2 Thinking]
深度解析:
- 参数定律的终结?: 传统观念认为 AI 越强参数越大。MiroThinker 证明了 Compute-time Compute (推理时计算) 的重要性。它类似于人类的“慢思考” (System 2)，遇到难题时不急于回答，而是花更多时间（更多计算量）去查资料、验证、计算。
- 勤能补拙: 一个 30B 的模型，如果允许它思考 100 步，查阅 50 个网页，写 20 次代码验证，其最终产出的报告质量，远高于一个 1T 模型仅思考 1 步给出的直觉性回答。
- 非线性路径: 它的思考过程不是直线的，而是树状的。它会“走弯路”，发现路不通后“回溯”，重新尝试新路径。
[交互式扩展推演逻辑树形图]
[MiroThinker 思考深度模型：用时间换取质量]
│
├── 🔴 复杂输入: "预测 2026 年固态电池的市场渗透率"
│
▼
[1. 宏观规划层 (Macro-Planning)] <★ 战略制定>
│ ├── 思考: "不能直接回答。需拆解为：技术成熟度、产能规划、车企订单三个子维度。"
│ └── 决策: "先查技术成熟度，再查产能。"
│
▼
[2. 微观执行循环 (Micro-Execution Loop)] <★ 战术执行 - 可达 200+ 轮>
│ │
│ ├── [尝试 A: 搜索技术路线]
│ │ ├── Action: Search "Solid-state battery roadmap 2026"
│ │ ├── Result: 找到 10 篇软文，信息模糊。
│ │ └── Reflect: "信息源质量太差，不可信。需切换搜索策略，查阅学术论文或财报。"
│ │
│ ├── [尝试 B: 精准检索 (修正策略)]
│ │ ├── Action: Search "Toyota solid-state battery investor report pdf"
│ │ ├── Result: 找到丰田 2025 财报 PDF。
│ │ └── Insight: "发现关键数据：2027 年才量产，2026 年仅为试产。"
│ │
│ ├── [尝试 C: 数据交叉验证]
│ │ ├── Action: Search "CATL solid-state battery timeline"
│ │ ├── Result: 宁德时代宣布 2026 小批量装车。
│ │ └── Synthesis: "中日两大巨头进度不一致，需综合加权。"
│ │
│ └── [尝试 D: 编写代码建模]
│ ├── Action: Python (E2B) -> `scipy.optimize.curve_fit(...)`
│ ├── Result: 基于现有产能爬坡曲线，拟合出渗透率约为 0.5% - 1.2%。
│ └── Validation: "模型 R-squared 较高，结论可信。"
│
▼
[3. 结论坍缩层 (Conclusion Collapse)] <★ 最终产出>
│ ├── 现象: 综合 50 次搜索和 3 次代码计算。
│ └── 结论: "2026年并非爆发年，而是'前夜'。渗透率预计在 0.8% 左右，主要受限于硫化物电解质成本。"
│
▼
输出 (Output)
└── 包含置信度区间和完整证据链的深度研报
2. 记忆创新：动态上下文卫生 (Dynamic Context Hygiene)
标签: [信息熵减 / 记忆代谢 / 长程注意力]
深度解析:
- 上下文的诅咒: 随着 Agent 查阅资料增多，Prompt 长度会迅速逼近 128k/200k 上限。不仅烧钱，更会导致 LLM 的“迷失中间” (Lost in the Middle) 现象，即忽略掉中间的关键信息。
- Keep-K 策略: MiroThinker 引入了一种类似生物“短期记忆转长期记忆”的机制。它只保留最近 K 轮（例如 5 轮）的全量细节（如网页 HTML、报错堆栈）。对于更早的记忆，它会强制进行语义压缩，只保留“做过什么、得到什么结论”的摘要。
- 高信噪比: 这种机制保证了无论任务运行多久，输入给 LLM 的 Prompt 始终保持高信噪比，使其能专注于当下的逻辑推理。
[记忆代谢处理逻辑树形图]
[MiroThinker 记忆流：如何保持清醒]
│
├── 场景输入: 第 50 轮思考，正在分析第 20 个网页。
│
▼
[1. 记忆缓存池 (Context Buffer)]
│ ├── T-0 (当前): 正在抓取的网页全文 (20k tokens)
│ ├── T-1: 上一步的 Python 绘图代码 (2k tokens)
│ ├── ...
│ └── T-5: 五步前的 Google 搜索结果列表 (5k tokens)
│
▼
[2. 卫生管理策略 (Hygiene Policy: Keep-5)] <★ 创新点>
│ ├── 触发: 准备进入 T+1 轮。
│ │
│ ├── <处理 T-5 数据>:
│ │ ├── 动作: 丢弃原始搜索列表。
│ │ ├── 转化: 调用 Summary LLM -> "第五步搜索了宁德时代产能，确认其2025年产能为 500GWh。"
│ │ └── 存储: 存入 `Historical_Summary` (仅 20 tokens)。
│ │
│ └── <保留 T-0 数据>:
│ └── 动作: 保持原样，因为下一步分析可能需要回顾网页细节。
│
▼
[3. 提示词合成 (Prompt Synthesis)]
│ ├── System Prompt: "你是一个研究员..."
│ ├── Long-term Memory: 过去 45 轮的压缩摘要 (仅 1k tokens)
│ ├── Short-term Memory: 最近 5 轮的详细交互 (25k tokens)
│ └── Current Task: "基于上述信息，计算总产能。"
│
▼
最终效果
└── 尽管任务极其复杂，LLM 看到的 Prompt 依然清晰、精炼，未超窗口上限。
3. 工具创新：异构工具链与容错 (Heterogeneous Toolchain with Fault Tolerance)
标签: [跨模态执行 / 反脆弱性 / E2B沙箱]
深度解析:
- 跨越文理分科: 大多数 Agent 要么擅长陪聊（文科），要么擅长写 SQL（理科）。MiroThinker 集成了
Serper(文科/搜索) 和E2B Python(理科/计算)。它能自己上网找数据，然后自己写代码分析数据，实现了“文理兼修”。 - 反脆弱 (Antifragile): 在代码执行出错时，普通 Agent 会停止或乱编。MiroThinker 会将
Traceback报错信息看作是一种“有价值的反馈”。它会分析报错，修改代码，重新运行。这种在错误中学习的能力，使其鲁棒性极高。
[异构工具协同逻辑树形图]
[MiroThinker 工具协同：遇到报错怎么办？]
│
├── 任务: "绘制过去十年原油价格波动图"
│
▼
[1. 搜索阶段 (The Eyes)]
│ ├── Action: Google Search "Crude oil price history csv"
│ └── Result: 找到一个 CSV 下载链接。
│
▼
[2. 编码阶段 (The Hands - Attempt 1)]
│ ├── Action: Python (E2B)
│ │ ```python
│ │ import pandas as pd
│ │ df = pd.read_csv("url")
│ │ df.plot() # <--- 潜在错误点
│ │ ```
│ └── Execution Result: ❌ Error: "No columns to plot" (读取格式错误)
│
▼
[3. 自我修复阶段 (Self-Correction)] <★ 创新点>
│ ├── 感知: 收到 Error Log。
│ ├── 思考: "啊，原来 CSV 分隔符不是逗号，是分号。或者文件有表头。"
│ │
│ └── [编码阶段 (The Hands - Attempt 2)]
│ ├── Action: Python (E2B)
│ │ ```python
│ │ # 修正：指定分隔符和跳过行
│ │ df = pd.read_csv("url", sep=';', skiprows=1)
│ │ print(df.head()) # 先看一眼数据
│ │ ```
│ └── Execution Result: ✅ Success! 打印出了正确的前5行。
│
▼
[4. 最终成图 (Finalization)]
│ ├── Action: 再次运行绘图代码。
│ └── Output: 生成 `oil_price.png`，嵌入报告。
总结：MiroThinker 的“护城河”
这三个创新点共同构建了 MiroThinker 的核心竞争力：
- 交互式扩展 赋予了它深度（Deep），让小模型也能处理大问题。
- 动态上下文卫生 赋予了它耐力（Endurance），让它能进行马拉松式的长程推理。
- 异构工具链与容错 赋予了它韧性（Resilience），让它在复杂多变的互联网环境中也能稳定运行。
对于企业和开发者而言，MiroThinker 是目前替代 OpenAI DeepResearch 的最佳开源方案，它不仅是工具，更是一个可以自我进化的数字员工框架。
四、Agent 智能体如何调用与集成MiroThinker
这是将 MiroThinker 的深度思考能力赋能给你现有 AI 系统的“最后一公里”。将 MiroThinker 作为一个独立的**“深度思考单元 (Deep Thinking Unit)”**集成到你的 Master Agent（如企业助理、客服大脑）中，就像是给你的 AI 装上了一个 “System 2（慢思考）”外挂。当遇到简单问题时，Master Agent 快速回答；当遇到复杂研究课题时，它会调用 MiroThinker 去“闭关修炼”十分钟，再带着详尽的研报回来。
4.1 Agent 架构集成逻辑图 (The Integration Architecture)
在这个架构中，你的 Master Agent 是前台经理（负责分发），而 MiroThinker 是后台的研究团队（负责攻坚）。
[基于 MiroThinker 的深度研究型 Agent 集成架构]
│
├── 【1. 意图识别与任务路由 (Intent & Routing)】
│ ├── 用户指令: "分析一下 DeepSeek 和 OpenAI o1 的技术差异，并预测未来 6 个月的竞争格局。"
│ ├── Master Agent (决策主脑):
│ │ ├── 识别: 这是一个需要深度调研和推演的问题 (Deep Research Task)，而非简单的闲聊。
│ │ ├── 决策: 自身知识库可能过时，且问题过于复杂，需要调用 MiroThinker。
│ │ └── 动作: 将自然语言指令路由给 `DeepResearch_Tool`。
│
▼
├── 【2. 任务参数构造 (Task Configuration)】 <★ 关键转换>
│ ├── 动作: 将模糊指令转换为 MiroThinker 的标准输入 (Task Spec)。
│ ├── 参数设定:
│ │ ├── task_prompt: "Compare DeepSeek-V3 vs OpenAI o1 technical architecture..."
│ │ ├── max_turns: 100 (给予充足的思考时间)
│ │ ├── output_format: "markdown_report_with_citations"
│ │ └── tools: ["search_tool", "browser", "tool_python"] (全量开启)
│ └── 调用: `MiroThinker_Client.run_task({ ...params... })`
│
▼
├── 【3. MiroThinker 深度闭环 (The Deep Loop Execution)】
│ ├── [MiroThinker Engine] 启动 ReAct 循环
│ │ │
│ │ ├── Phase 1 (广度搜索): 搜索两大模型的技术白皮书、Github Issue、Twitter 讨论。
│ │ ├── Phase 2 (深度阅读): 用 Jina Reader 抓取 20 篇长文，进行摘要提炼。
│ │ ├── Phase 3 (逻辑验证): 发现关于 "DeepSeek 显存占用" 的说法不一，写 Python 脚本计算参数量与显存关系。
│ │ └── Phase 4 (报告撰写): 综合所有证据，撰写 5000 字报告。
│ │
│ └── 结果回传: 返回 `final_report.md` (包含引用源) + `trace_log.json` (思考过程)。
│
▼
├── 【4. 结果整合与交付 (Synthesis & Delivery)】
│ ├── Master Agent 处理结果:
│ │ ├── 摘要: "MiroThinker 已完成调研。核心差异在于 MoE 架构的稀疏度..."
│ │ ├── 附件: "完整报告已生成，点击下载 [Deep_Research_Report.md]"
│ │ └── 追问建议: "基于报告，你可能还想了解 DeepSeek 的本地部署成本吗？"
│ └── 最终回复: 以用户友好的方式呈现复杂的研究成果。
4.2 核心代码实现：将 MiroThinker 封装为 LangChain Tool
要让 Master Agent 调用 MiroThinker，我们需要将其封装为一个标准的 LangChain Tool。我们假设你已经通过 Docker 将 MiroThinker 部署为 API 服务。
第一步：确保 MiroThinker API 就绪 (Server Side)
假设你已经在 apps/miroflow-agent 下启动了一个 FastAPI 服务，暴露了 POST /v1/agent/run 接口。
第二步：编写 Client 集成代码
这里展示如何构建一个“具备深度研究能力的超级助理”。
import time
import requests
import json
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import tool
# --- 1. 定义 MiroThinker 客户端 ---
class MiroThinkerClient:
def __init__(self, base_url="http://localhost:8000"):
self.base_url = base_url
def submit_task(self, query, depth="deep"):
"""提交深度研究任务"""
# 根据深度选择不同的配置文件
config_name = "mirothinker_v1.5_keep5_max200" if depth == "deep" else "mirothinker_v1.5_fast"
payload = {
"task": query,
"agent_config": config_name,
"return_trace": False # Master Agent 不需要看详细日志，只要结果
}
try:
res = requests.post(f"{self.base_url}/v1/agent/run", json=payload, timeout=600)
return res.json()
except Exception as e:
return {"status": "error", "message": str(e)}
# 实例化客户端
miro_client = MiroThinkerClient()
# --- 2. 定义 Agent 的 "深度思考" 工具 (The Super Tool) ---
@tool
def deep_research_tool(research_topic: str, research_focus: str = "comprehensive"):
"""
当用户的问题非常复杂、需要查阅大量资料、或者需要进行多步推理和验证时，必须使用此工具。
不要用于简单的闲聊或常识性问题。
此工具会调用 MiroThinker 智能体进行长达几分钟的深度研究。
Args:
research_topic: 研究的具体主题 (例如: "2026年固态电池技术成熟度分析")
research_focus: 关注点 (例如: "technical_specs", "market_share", "financial_risk")
"""
print(f"🧠 正在激活 MiroThinker 深度思考单元: {research_topic}...")
# 构造更具体的 Prompt
refined_query = f"Please conduct a deep research on: {research_topic}. Focus specifically on: {research_focus}. Produce a detailed markdown report."
result = miro_client.submit_task(refined_query, depth="deep")
if result.get("status") == "success":
report = result.get("answer", "No answer generated.")
return f"深度研究报告摘要:\n{report[:2000]}...\n(由于篇幅限制，仅展示前2000字符，请引导用户查看完整报告)"
else:
return f"研究失败: {result.get('message')}"
# --- 3. 构建 Master Agent ---
llm = ChatOpenAI(model="gpt-4o", temperature=0) # Master Agent 用聪明的大模型做分发
tools = [deep_research_tool]
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个高级 AI 顾问。对于简单问题直接回答。对于复杂的研究课题，你必须调用 `deep_research_tool` 来获取准确信息，而不是依靠自己的幻觉。"),
("human", "{input}"),
("placeholder", "{agent_scratchpad}"),
])
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# --- 4. 运行演示 ---
# 场景 A：简单问题 (不调用工具)
# agent_executor.invoke({"input": "你好，你是谁？"})
# 场景 B：复杂问题 (触发 MiroThinker)
query = "帮我调研一下目前市面上开源的 Agent 框架（如 AutoGPT, BabyAGI, MiroThinker），对比它们的架构优缺点，并推荐一个适合金融分析的框架。"
agent_executor.invoke({"input": query})
4.3 Agent 内部的思考链 (Thought Process)
当上述代码运行时，你的 Master Agent 会经历以下决策过程：
[Master Agent 的内部独白]
│
├── 步骤 1: 任务定性 (Qualify)
│ ├── 用户输入: "对比开源 Agent 框架...推荐适合金融分析的..."
│ ├── 评估:
│ │ 1. 这是一个对比分析任务，涉及多个对象。
│ │ 2. 涉及 "金融分析" 场景，需要高准确度。
│ │ 3. 自身的训练数据可能截止于 2023 年，不知道最新的框架状态。
│ └── 结论: 必须使用工具。
│
├── 步骤 2: 工具调用 (Call)
│ ├── 决策: Call Tool 'deep_research_tool'
│ ├── 参数构造:
│ │ ├── research_topic: "Comparison of open-source Agent frameworks (AutoGPT, BabyAGI, MiroThinker) for financial analysis"
│ │ └── research_focus: "architecture, pros/cons, financial use-case suitability"
│ └── 执行: 挂起当前会话，等待 MiroThinker 返回。
│
├── 步骤 3: 等待与接收 (Await) <★ 此时 MiroThinker 正在后台运行 100 轮思考>
│ ├── (MiroThinker): 搜索 Github Stars -> 阅读各框架文档 -> 搜索 "MiroThinker finance benchmark" -> 发现 MiroThinker 在 BrowseComp 上表现优异。
│ └── 工具返回: "深度研究报告摘要: ...经过对比，MiroThinker 因支持 E2B 沙箱和长程推理，最适合金融场景..."
│
├── 步骤 4: 交付 (Deliver)
│ └── 最终回复: "根据深度调研，我为您生成了一份对比报告。对于金融分析场景，我强烈推荐使用 **MiroThinker**，原因如下..."
4.4 MiroThinker 适合接入的功能模块与作用
如果你将 MiroThinker 集成到你的 AI 产品中，它可以充当以下核心角色：
| 功能模块 | 角色定位 | 接入价值 | 使用场景 |
|---|---|---|---|
| Deep Research (深度研报) | 首席研究员 | 将 AI 的能力从“问答”提升到“产出”。它能生成包含数据图表、引用来源的专业报告。 | 投资尽调、竞品分析、学术文献综述。 |
| Fact Checking (事实核查) | 审计员 | 作为一个独立的验证层。主模型生成的文案，交给 MiroThinker 去网上逐句核实，消除幻觉。 | 新闻稿发布前审核、医疗/法律建议审核。 |
| Code Execution (复杂计算) | 数据科学家 | 利用其 E2B 集成能力，处理 Excel/CSV 文件，进行清洗、回归分析和可视化。 | 用户上传 Excel 要求分析销售趋势、财务报表自动审计。 |
| Long-horizon Plan (长程规划) | 项目经理 | 利用其 200+ 轮的规划能力，为用户生成极其详细的执行计划（如旅行攻略、学习计划）。 | “帮我制定一个从零开始学习量子计算的 3 个月详细计划，包含每周资源链接”。 |
总结
MiroThinker 不应被视为一个简单的 Chatbot，而应被视为一个异步的、高算力的后端推理服务。通过 API 集成，它能让你的轻量级前端 Agent 瞬间拥有顶级的深度思考能力。
五、MiroThinker 智能体助手搭建实战
本实战将基于 MiroThinker 开源架构，搭建一个名为 “DeepResearcher-Pro” 的本地智能体。它将是一个**“全能研究员”**，具备：1. 深度联网搜索（Web Deep Research）；2. E2B 安全沙箱计算（Secure Code Execution）；3. 长程自我反思（Long-horizon Self-reflection）。
5.1 核心组件设计
| 组件选型 | 作用与配置 |
|---|---|
| LLM (Brain) | Qwen2.5-32B-Instruct (vLLM 量化部署)。 理由: 32B 是性价比之选，足够聪明来理解复杂的搜索结果，又能在一张 24G 显卡（如 RTX 3090/4090）上流畅运行。MiroThinker 的 Interactive Scaling 策略允许用更多时间弥补参数劣势。 |
| Agent Core | MiroThinker-Agent (Python + Hydra)。 理由: 使用官方框架，支持 Keep-K 上下文管理和 ReAct 循环。 |
| Sandbox | E2B (SaaS) 或 Docker (Local)。 理由: 为了安全，我们将 Agent 的代码执行环境与主机物理隔离。如果是企业内网，可部署本地 Docker 容器作为沙箱。 |
| Search Engine | Serper (Google API)。 理由: 搜索质量最高的商业 API，也支持 Google Scholar。 |
| Web Reader | Jina Reader。 理由: 将杂乱的 HTML 网页转为干净的 Markdown，并自带摘要功能，大幅节省 Token。 |
5.2 代码实现步骤
5.2.1 项目文件树形结构
deep-researcher-pro/ # 项目根目录
│
├── .env # [密钥库] OPENAI_API_KEY, SERPER_API_KEY, E2B_API_KEY
├── docker-compose.yml # [容器编排] 启动 Redis (消息队列) 和 Agent 服务
├── pyproject.toml # [依赖管理] 使用 uv 管理依赖
│
├── app/ # [应用代码]
│ ├── main.py # [启动入口] FastAPI 服务
│ ├── config.py # [配置加载] 读取 .env 和 yaml
│ │
│ ├── agent/ # [MiroThinker 核心复用]
│ │ ├── core.py # [ReAct循环] 实现 Think-Act-Observe
│ │ ├── memory.py # [记忆管理] Keep-K 策略实现
│ │ └── prompts.py # [提示词] 包含深度研究的 System Prompt
│ │
│ ├── tools/ # [工具集]
│ │ ├── search.py # [搜索] 封装 Serper
│ │ ├── browser.py # [阅读] 封装 Jina
│ │ └── sandbox.py # [代码] 封装 E2B
│ │
│ └── api/ # [接口层]
│ └── routes.py # 定义 POST /research 接口
│
└── data/ # [持久化]
└── logs/ # 存放 Agent 的思考轨迹日志 (Trace)
5.2.1.1 核心文件深度剖析 (Deep Dive)
A. 基础设施 (Infrastructure)
- docker-compose.yml
- 标签: [生命维持系统]
- 深度解析: 如果你在本地没有显卡，这里可以配置接入 OpenAI 或 DeepSeek 的 API。如果你有显卡，可以在这里添加一个
vllm-service容器，把 Qwen2.5-32B 模型加载起来，作为 Agent 的大脑。 - 协作: 它确保 Agent 启动时，大脑（LLM）、记忆缓存（Redis）都已经就位。
B. 思维核心 (The Brain Core)
- app/agent/core.py
- 标签: [前额叶 / 决策机]
- 深度解析:
- Infinite Loop: 实现了一个
while turn < max_turns:循环。 - Error Tolerance: 当工具执行报错（如 Python 语法错误、网页 404）时，它不会抛出异常终止程序，而是把错误信息作为
Observation喂回给 LLM，让 LLM 尝试修复。 - Reasoning Trace: 它会记录每一步的
Thought(思考) 和Action(行动)，这对事后复盘非常重要。
- Infinite Loop: 实现了一个
- app/agent/memory.py
- 标签: [记忆代谢系统]
- 深度解析:
- 实现了 Keep-K Strategy。如果不加限制，Deep Research 跑 100 轮后 Token 会破 200k，不仅烧钱而且慢。这个文件负责在第 N 轮时，把第 N-5 轮的详细 HTML 内容替换为一句话摘要：“查阅了网页 A，未发现有效信息”。
C. 感知与手脚 (Senses & Limbs)
- app/tools/sandbox.py
- 标签: [隔离手术室]
- 深度解析:
- 这是 MiroThinker 区别于普通 RAG 的关键。它调用 E2B API 创建一个临时的云端 Linux 环境。
- Stateful: 支持有状态的会话。你在第一步定义的
df = pd.read_csv(...)，在第十步依然可以调用df.plot()。 - File I/O: 支持上传文件进去处理，处理完把生成的图表下载回来。
5.2.2 核心模块实现
(1) app/agent/core.py (ReAct 循环引擎)
import json
from openai import OpenAI
from app.agent.memory import MemoryManager
from app.tools.registry import ToolRegistry
class DeepResearchAgent:
def __init__(self, model="qwen2.5-32b", max_turns=50):
self.client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") # 指向 vLLM
self.memory = MemoryManager(keep_k=5)
self.tools = ToolRegistry()
self.max_turns = max_turns
def run(self, user_goal):
"""执行深度研究任务"""
print(f"🚀 开始研究: {user_goal}")
# 1. 初始化系统提示词
self.memory.add_message("system", "你是一个不知疲倦的研究员。遇到困难时，尝试换个搜索词或换个方法，不要轻易放弃。")
self.memory.add_message("user", user_goal)
turn = 0
while turn < self.max_turns:
turn += 1
print(f"--- Turn {turn} ---")
# 2. 记忆修剪 (Context Hygiene)
context = self.memory.get_pruned_context()
# 3. 思考 (Think)
response = self.client.chat.completions.create(
model="qwen2.5-32b",
messages=context,
temperature=0.7 # 稍微有点创造力，方便发散思维
)
thought = response.choices[0].message.content
print(f"🧠 思考: {thought[:100]}...") # 打印部分思考
# 4. 决策与行动 (Act)
if "<tool_code>" in thought:
tool_name, args = self._parse_tool(thought)
print(f"🛠️ 调用工具: {tool_name}")
try:
# 执行工具 (Serper / E2B / Jina)
observation = self.tools.execute(tool_name, args)
except Exception as e:
observation = f"Error: {str(e)}" # 容错机制
# 5. 观察写入记忆 (Observe)
self.memory.add_message("assistant", thought)
self.memory.add_message("tool", observation) # 作为工具输出
elif "FINAL ANSWER" in thought:
print("✅ 研究完成")
return thought
return "❌ 达到最大思考轮数，未能完成任务。"
def _parse_tool(self, text):
# 简单的解析逻辑，MiroThinker 原版使用更复杂的正则
# 假设格式: <tool_code>search(query="xxx")</tool_code>
# ...解析代码...
return "search", {"query": "test"}
(2) app/tools/sandbox.py (E2B 沙箱封装)
from e2b_code_interpreter import Sandbox
class CodeSandbox:
def __init__(self, api_key):
self.api_key = api_key
def run_python(self, code):
"""在云端沙箱运行 Python 代码"""
print("💻 正在沙箱中执行代码...")
# 创建沙箱实例 (这是一个远程 Docker 容器)
with Sandbox(api_key=self.api_key) as sandbox:
execution = sandbox.run_code(code)
# 处理输出
logs = execution.logs.stdout
errors = execution.logs.stderr
# 处理生成的图表 (如果有)
images = []
for result in execution.results:
if result.png:
images.append(result.png) # 返回 Base64 图片
if errors:
return f"Execution Failed:\n{errors}"
return f"Execution Success:\n{logs}\nGenerated {len(images)} images."
5.2.3 启动入口 (app/main.py)
from fastapi import FastAPI, BackgroundTasks
from app.agent.core import DeepResearchAgent
app = FastAPI()
@app.post("/research")
async def start_research(task: str, background_tasks: BackgroundTasks):
"""
异步启动一个深度研究任务。
因为研究可能持续 5-10 分钟，所以使用后台任务。
"""
agent = DeepResearchAgent(max_turns=100)
# 将任务放入后台运行，避免阻塞 HTTP 请求
background_tasks.add_task(agent.run, task)
return {"status": "started", "message": "Research agent is running in background. Check logs for progress."}
5.3 运行与调试指南
1. 环境准备 (Docker & Keys)
你需要以下基础设施：
- vLLM 服务: 如果你有 24G+ 显存，推荐部署
Qwen2.5-32B-Instruct-AWQ。如果没有，可以修改代码指向 DeepSeek API。 - API Keys:
E2B_API_KEY: 注册 E2B 获取（有免费额度）。SERPER_API_KEY: 注册 Serper.dev 获取。JINA_API_KEY: 注册 Jina.ai 获取。
2. 启动服务
# 1. 启动 vLLM (如果有本地显卡)
docker run --gpus all -v ~/.cache/huggingface:/root/.cache/huggingface \
-p 8000:8000 \
--ipc=host \
vllm/vllm-openai:latest \
--model Qwen/Qwen2.5-32B-Instruct-AWQ --quantization awq
# 2. 启动 Agent 服务
uv run fastapi dev app/main.py
3. 发送任务与观察
使用 curl 发送一个硬核任务：
curl -X POST "http://localhost:8000/research?task=调查OpenAI的o1模型和DeepSeek-V3在代码生成任务上的基准测试分数对比，并绘制柱状图"
观察 Logs (涌现现象):
你应该能在终端看到如下精彩的思考链：
- Turn 1: “我需要先找 o1 的分数。调用
search('OpenAI o1 coding benchmark')” - Turn 2: “搜索结果只有新闻。我需要找技术报告。调用
search('OpenAI o1 technical report pdf')” - Turn 5: “找到了 DeepSeek 的分数。现在数据齐了。我要写代码画图。调用
run_python(...)” - Turn 6: “代码报错
ModuleNotFoundError: matplotlib。哎呀，忘记安装库了。修正代码pip install matplotlib…” - Turn 7: “图画好了。生成最终回复。”
这就是 MiroThinker 的魅力——它像一个真实的人类实习生一样，会犯错、会纠正、会坚持，直到把任务搞定。
六、利用此开源项目可实现的 AI 应用
基于 MiroThinker 的核心架构特性（交互式扩展、长程推理、异构工具链），我们可以构建一系列区别于传统 RAG（检索增强生成）的高价值应用。传统 RAG 只能做“搬运工”（把搜到的东西总结一下），而 MiroThinker 能做“思考者”（去验证、去计算、去推演）。
以下是三个最具落地价值的 AI 应用场景深度解析、逻辑树形图及实现代码。
1. 自动化金融尽调分析师 (Automated Financial Due Diligence Agent)
深度解析：
金融分析师每天花费数小时在 SEC 官网查阅财报、在 Google 搜寻新闻、在 Excel 里拉数据。
- 传统 RAG 痛点：只能搜到新闻，无法读取 PDF 中的表格，更无法计算“同比增长率”。
- MiroThinker 优势：
- 深度阅读：利用
browser.py+jina_summary，能读懂长达 100 页的 10-K 财报。 - 沙箱计算：利用
tool_python，能提取表格数据，用 Pandas 计算 P/E Ratio、毛利率等指标，甚至绘制 K 线图。 - 自我核查：如果搜到的数据不一致（如新闻说涨了，财报说跌了），它会触发“自我反思”，去寻找第三方数据源（如 Bloomberg 截图或交易所公告）进行仲裁。
- 深度阅读：利用
应用逻辑树形图：
[应用一：自动化金融尽调]
│
├── 【输入层 (Input)】
│ ├── 标的公司: "分析 Tesla (TSLA) 2025年 Q4 财报"
│ └── 关注指标: "毛利率, FSD 收入占比, 交付量趋势"
│
▼
├── 【MiroThinker 深度推演 (Deep Research)】
│ │
│ ├── 1. 信息搜集 (Data Harvesting)
│ │ ├── 动作: Search "Tesla Q4 2025 investor deck pdf"
│ │ └── 动作: Search "Tesla 2025 Q4 earnings call transcript"
│ │
│ ├── 2. 数据清洗与计算 (Data Processing - Sandbox)
│ │ ├── 动作: 下载 PDF -> 提取 "Financial Summary" 表格。
│ │ ├── 思考: "需要计算 Auto Gross Margin (ex-credits)"
│ │ └── 代码: `df['margin'] = (df['rev'] - df['cost']) / df['rev']`
│ │
│ └── 3. 交叉验证 (Cross-Validation)
│ ├── 现象: 财报显示利润下滑，但股价盘后大涨。
│ ├── 追问: "Why TSLA stock up after missing earnings?"
│ └── 发现: "马斯克在电话会承诺 2026 推出 Model 2。"
│
▼
├── 【决策输出 (Report Generation)】
│ └── 产出: 一份包含 Matplotlib 趋势图、关键风险提示、电话会摘要的 10 页 PDF 报告。
│
▼
[商业价值]
└── 将分析师从“找数据”的苦力活中解放出来，专注于“做判断”。效率提升 10 倍。
实战代码片段：
from app.agent.core import DeepResearchAgent
class FinancialAnalyst:
def __init__(self):
self.agent = DeepResearchAgent(max_turns=100) # 金融分析需要长思考
def analyze_stock(self, ticker):
prompt = f"""
你是一名华尔街高级分析师。请对 {ticker} 进行深度研报。
要求：
1. 必须使用 Python 工具绘制过去 3 年的 Revenue 和 Net Income 趋势图。
2. 必须查阅最近一次 Earnings Call Transcript，总结管理层对未来的指引。
3. 搜索竞争对手（如 BYD）的同期数据进行对比。
4. 最终报告必须包含数据来源链接。
"""
report = self.agent.run(prompt)
return report
# 使用
analyst = FinancialAnalyst()
print(analyst.analyze_stock("TSLA"))
2. 复杂代码库维护与迁移助手 (Legacy Code Migration Specialist)
深度解析：
很多公司维护着十年前的“屎山代码”（如 Python 2.7, Java 8），没人敢动，也没人懂。
- MiroThinker 优势：
- 全库认知：它不只是看一个文件，而是通过
ls -R,grep,cat等命令在沙箱中遍历整个项目结构。 - 试错迁移：它可以在 E2B 沙箱中尝试升级依赖（如
pip install --upgrade），如果报错，它会分析报错日志，修改代码，再试一次。这种“改代码 -> 跑测试 -> 修正”的循环，正是人类程序员的工作方式。
- 全库认知：它不只是看一个文件，而是通过
应用逻辑树形图：
[应用二：代码迁移助手]
│
├── 【输入层 (Input)】
│ ├── 任务: "将这个 Python 2.7 的 Flask 项目迁移到 Python 3.10"
│ └── 资源: 项目 Zip 包 (上传至沙箱)
│
▼
├── 【MiroThinker 工程化执行 (Engineering Execution)】
│ │
│ ├── 1. 环境探索 (Exploration)
│ │ ├── 动作: `find . -name "*.py"` -> 建立文件树。
│ │ └── 动作: `cat requirements.txt` -> 分析过时依赖。
│ │
│ ├── 2. 迭代修复 (Iterative Refactoring)
│ │ ├── 动作: 尝试运行 `python3 app.py`。
│ │ ├── 报错: "SyntaxError: print 'hello' is missing parentheses"
│ │ ├── 修复: 调用 `sed` 或重写文件，将 `print` 改为函数调用。
│ │ └── 循环: 再次运行 -> 报新错 (ImportError) -> 再修复。
│ │
│ └── 3. 单元测试 (Verification)
│ ├── 动作: 编写一个新的 `test_basic.py`。
│ └── 验证: 确保 API 接口返回 200 OK。
│
▼
├── 【交付 (Delivery)】
│ └── 产出: 迁移后的代码包 + 迁移日志 (Migration Log)。
│
▼
[商业价值]
└── 自动化解决技术债务。对于外包公司或维护老旧系统的银行/电信企业价值巨大。
3. 学术综述与论文生成器 (Academic Reviewer & Writer)
深度解析：
写论文最痛苦的是做 Literature Review（文献综述）：需要找几十篇论文，读完，归纳，然后引用。
- MiroThinker 优势：
- 学术搜索：通过
Google Scholar(Serper) 搜索权威文献。 - 引用管理：它能记住每条信息的来源（Keep-K 策略保留了源链接），生成报告时自动标注
[1],[2]。 - 去伪存真：它会交叉验证。如果论文 A 说这个算法好，论文 B 说不好，MiroThinker 会在报告中写出“存在争议”，而不是片面采信。
- 学术搜索：通过
应用逻辑树形图：
[应用三：学术综述生成器]
│
├── 【输入层 (Input)】
│ ├── 课题: "大语言模型在医疗诊断中的幻觉问题综述"
│ └── 要求: "引用至少 20 篇 2024 年后的顶会论文 (NeurIPS, ICLR)"
│
▼
├── 【MiroThinker 学术研究 (Academic Research)】
│ │
│ ├── 1. 广度搜索 (Broad Search)
│ │ ├── 动作: Search "LLM hallucination medical diagnosis survey 2024"
│ │ └── 筛选: 过滤掉 CSDN/Medium，只保留 Arxiv/PubMed 链接。
│ │
│ ├── 2. 深度阅读 (Deep Reading)
│ │ ├── 动作: Jina Reader 抓取论文 PDF 内容。
│ │ ├── 提炼: 提取每篇论文的 "Methodology" 和 "Results"。
│ │
│ └── 3. 结构化写作 (Structured Writing)
│ ├── 规划: 拟定大纲 (Introduction -> Methods -> Challenges -> Future)。
│ └── 填充: 将提取的观点填入对应章节，并自动生成 BibTeX 引用。
│
▼
├── 【交付 (Delivery)】
│ └── 产出: 一篇 LaTeX 格式的文献综述草稿。
│
▼
[商业价值]
└── 辅助科研人员、博士生快速掌握领域前沿，将数周的文献阅读时间压缩到几小时。
总结与建议
- 企业用户（金融/咨询）：首选 应用一（金融尽调）。这是最能直接通过“节省人力”来计算 ROI 的场景。可以结合私有化部署的 MiroThinker，确保财报数据不出内网。
- 技术团队（运维/DevOps）：尝试 应用二（代码迁移）。将其集成到 CI/CD 流水线中，作为自动化的 Code Reviewer 或 Refactor 工具。
- 教育/科研机构：使用 应用三（学术综述）。可以搭建一个校内服务，帮助学生进行开题报告的预研。
MiroThinker 的核心不在于“聊”，而在于**“干”**。它是一个能干脏活累活的数字劳动力。
有“AI”的1024 = 2048，欢迎大家加入2048 AI社区
更多推荐
21
0- 0
已为社区贡献37条内容
所有评论(0)