1、gpt-researcher 核心的接口是api_researcher,agent,run

2、利用trei进行编程，仿照豆包写前后端，真的好用

2月13日研究进展

1、基本搞清楚了gpt researcher的程序流程

1、从agent的conduct_research()到research的conduct_research，获得上下文

1、websocket_manager的report = await researcher.run()

 2、detail_report的   async def run(self) -> str:
        await self._initial_research()
        subtopics = await self._get_all_subtopics()
        report_introduction = await self.gpt_researcher.write_introduction()
        _, report_body = await self._generate_subtopic_reports(subtopics)
        self.gpt_researcher.visited_urls.update(self.global_urls)
        report = await self._construct_detailed_report(report_introduction, report_body)
        return report
3、write_introcuction的逻辑，
write_introduction在writer中。
write_report_introduction在report_generation中
    def generate_report_introduction(question: str, research_summary: str = "", language: str = "english", report_format: str = "apa") -> str:
        return f"""{research_summary}\n
Using the above latest information, Prepare a detailed report introduction on the topic -- {question}.
- The introduction should be succinct, well-structured, informative with markdown syntax.
- As this introduction will be part of a larger report, do NOT include any other sections, which are generally present in a report.
- The introduction should be preceded by an H1 heading with a suitable topic for the entire report.
- You must use in-text citation references in {report_format.upper()} format and make it with markdown hyperlink placed at the end of the sentence or paragraph that references them like this: ([in-text citation](url)).
Assume that the current date is {datetime.now(timezone.utc).strftime('%B %d, %Y')} if required.
- The output must be in {language} language.

生成计划的逻辑：

在 gpt-researcher 项目中，写作规划（research planning）的核心逻辑主要集中在以下几个部分：

1. 生成研究计划的函数：generate_research_plan 和 plan_research。
2. 生成带有检索 Web 指令的流程：通过调用搜索引擎（如 Tavily、Google 等）获取初始知识，并基于此生成后续的研究方向。
3. 主要函数和流程展示。

---

🧩 写作规划的主要函数

1. generate_research_plan 函数

位于文件：c:\code\gpt-researcher\backend\server\app.py

功能说明：

该函数用于根据用户的原始查询生成一系列后续研究问题，帮助明确研究方向。它会结合当前时间以及初步的网络搜索结果来生成有针对性的问题。

核心代码片段：

python

async def generate_research_plan(self, query: str, num_questions: int = 3) -> List[str]: """Generate follow-up questions to clarify research direction""" # Get initial search results to inform query generation search_results = await get_search_results( query, self.researcher.retrievers[0], researcher=self.researcher ) logger.info(f"Initial web knowledge obtained: {len(search_results)} results") # Get current time for context current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") messages = [ {"role": "system", "content": "You are an expert researcher. Your task is to analyze the original query and search results, then generate targeted questions that explore different aspects and time periods of the topic."}, {"role": "user", "content": f"""Original query: {query} Current time: {current_time} Search results: {search_results} Based on these results, the original query, and the current time, generate {num_questions} unique questions. Each question should explore a different aspect or time period of the topic, considering recent developments up to {current_time}. Format each question on a new line starting with 'Question: '"""} ] response = await create_chat_completion( messages=messages, llm_provider=self.researcher.cfg.strategic_llm_provider, model=self.researcher.cfg.strategic_llm_model, reasoning_effort=ReasoningEfforts.High.value, temperature=0.4 ) questions = [q.replace('Question:', '').strip() for q in response.split('\n') if q.strip().startswith('Question:')] return questions[:num_questions]

流程解析：

1. 获取初始搜索结果：

   • 调用 get_search_results 函数，使用默认检索器（如 Tavily）对原始查询进行初步搜索。
   • 获取的结果作为上下文输入给 LLM。

2. 构建提示词（Prompt）：

   • 提供原始查询、当前时间和初步搜索结果。
   • 要求 LLM 生成多个后续研究问题，覆盖不同方面或时间段。

3. 调用 LLM 生成问题：

   • 使用 create_chat_completion 调用大模型（如 GPT-4）生成问题。
   • 解析返回结果，提取以 Question: 开头的问题。

---

2. plan_research 函数

位于文件：c:\code\gpt-researcher\gpt_researcher\skills\researcher.py

功能说明：

这是更底层的研究规划函数，负责将原始查询拆解为子查询（sub-queries），以便后续并行处理。

核心代码片段：

python

async def plan_research(self, query, query_domains=None): """Gets the sub-queries from the query""" await stream_output( "logs", "planning_research", f"🌐 Browsing the web to learn more about the task: {query}...", self.researcher.websocket, ) search_results = await get_search_results(query, self.researcher.retrievers[0], query_domains, researcher=self.researcher) self.logger.info(f"Initial search results obtained: {len(search_results)} results") await stream_output( "logs", "planning_research", f"🤔 Planning the research strategy and subtasks...", self.researcher.websocket, ) retriever_names = [r.__name__ for r in self.researcher.retrievers] outline = await plan_research_outline( query=query, search_results=search_results, agent_role_prompt=self.researcher.role, cfg=self.researcher.cfg, parent_query=self.researcher.parent_query, report_type=self.researcher.report_type, cost_callback=self.researcher.add_costs, retriever_names=retriever_names, **self.researcher.kwargs ) self.logger.info(f"Research outline planned: {outline}") return outline

流程解析：

1. 初步搜索：

   • 调用 get_search_results 获取与原始查询相关的网页内容。
   • 这些内容用于指导后续的子查询生成。

2. 生成研究大纲：

   • 调用 plan_research_outline 函数，基于搜索结果和角色提示（agent role prompt）生成研究大纲。
   • 大纲中包含多个子查询（sub-queries），每个子查询代表一个研究分支。

3. 返回子查询列表：

   • 子查询将被用于后续的并行研究任务。

---

3. plan_research_outline 函数

位于文件：c:\code\gpt-researcher\gpt_researcher\actions\query_processing.py

功能说明：

这是一个关键函数，负责将原始查询转换为结构化的研究大纲（包含多个子查询）。

核心代码片段：

python

async def plan_research_outline( query: str, search_results: List[Dict], agent_role_prompt: str, cfg, parent_query: str, report_type: str, cost_callback, retriever_names: List[str], **kwargs ): """Plan the research outline with sub-queries""" messages = [ {"role": "system", "content": "You are an expert researcher tasked with breaking down a complex query into manageable sub-queries."}, {"role": "user", "content": f""" Original query: {query} Parent query: {parent_query} Search results: {search_results} Retrievers used: {retriever_names} Break down the query into 3-5 sub-queries that can be researched independently. Each sub-query should focus on a distinct aspect of the topic. Format each sub-query on a new line starting with 'Sub-query: '. """}, ] response = await create_chat_completion( messages=messages, llm_provider=cfg.strategic_llm_provider, model=cfg.strategic_llm_model, reasoning_effort=ReasoningEfforts.High.value, temperature=0.4 ) sub_queries = [line.replace("Sub-query:", "").strip() for line in response.split("\n") if line.strip().startswith("Sub-query:")] return sub_queries

流程解析：

1. 构建提示词：

   • 提供原始查询、父查询、搜索结果和使用的检索器信息。
   • 要求 LLM 将查询分解为 3-5 个子查询。

2. 调用 LLM 生成子查询：

   • 使用 create_chat_completion 调用大模型生成子查询。
   • 解析返回结果，提取以 Sub-query: 开头的内容。

3. 返回子查询列表：

   • 每个子查询将作为一个独立的研究任务。

---

🔍 带有检索 Web 的指令生成流程

整体流程图：

用户输入查询 → 初步搜索（get_search_results）→ 生成研究计划（generate_research_plan）→ 拆解为子查询（plan_research_outline）→ 并行研究（process_sub_query）

关键步骤详解：

1. 初步搜索：

   • 使用默认检索器（如 Tavily）对原始查询进行搜索。
   • 获取的结果作为上下文输入给后续步骤。

2. 生成研究计划：

   • 基于初步搜索结果和当前时间，生成后续研究问题。
   • 这些问题帮助细化研究方向。

3. 拆解为子查询：

   • 将原始查询进一步拆解为多个子查询。
   • 每个子查询对应一个独立的研究任务。

4. 并行研究：

   • 对每个子查询分别进行深入研究。
   • 支持 Web 搜索、本地文档检索等多种方式。

---

📌 主要函数总结

函数名	文件位置	功能
generate_research_plan	backend/server/app.py	生成后续研究问题
plan_research	gpt_researcher/skills/researcher.py	规划研究大纲
plan_research_outline	gpt_researcher/actions/query_processing.py	拆解为子查询
get_search_results	gpt_researcher/actions/query_processing.py	执行初步搜索
process_sub_query	gpt_researcher/skills/researcher.py	处理单个子查询

这些函数协同工作，实现了从用户输入到结构化研究计划再到并行研究的完整流程。

app.py接收所有的内容

2、将测试数据集合导入到了es库中

3、

我的逻辑流程：

1、问题分类，对来的问题要进行分类，然后去数据库中匹配相关的研究报告，

2、对研究成果提炼其中的特点规律

3、然后检索相关研究材料

4、构建基础知识库，

5、选择研究方法

6、还要结合任务不同，包括单份，多份综合，专题研究

7、对于单份编写任务，找到基础文本，然后

### 2月14日 ###

1、在选择报文界面加入了浏览已有报文

2、在rag里面的记忆，长期记忆是个人的情况，短期记忆就是现在对话的内容

3、大模型思维链# 2. 向长期记忆库写入基础数据（可批量导入）

base_memories = [ # 类型1：事实类记忆（历史数据/政策文件） {"type": "fact", "content": "2023年中美贸易额6669亿美元，中国对美出口占比15.6%"}, {"type": "fact", "content": "东盟2024年自贸协定覆盖率达90%，供应链本土化率提升至65%"},

# 类型2：规则类记忆（分析框架/方法论） {"type": "rule", "content": "国际关系经济维度分析需优先验证贸易依存度和关税政策"}, {"type": "rule", "content": "亚太供应链分析需重点关注中国、日本、韩国的半导体产业链"},

# 类型3：结论类记忆（历史分析结论） {"type": "conclusion", "content": "2022年中美关税战导致亚太供应链成本上升12%"}, ]

2月15

1、增加texttosql的选择报文的能力

主要流程：

（1）制作了1000条的sqllite原始数据

（2）实现了基于大模型问答的数据库选择

2、学习langgraph的方法

你想要理解 LangGraph 的核心基本概念，这是掌握它开发工作流（比如之前的文本审核程序）的关键。我会用通俗易懂的语言 + 实际场景举例，从核心定义到核心组件，帮你建立完整的认知，避免抽象难懂的术语堆砌。

一、LangGraph 是什么（先定调）

LangGraph 是基于 LangChain 构建的有状态、可循环、支持多智能体协作的工作流框架，核心目标是：把复杂的 AI 任务（如文本审核、智能客服、数据分析）拆成 “一步步的节点”，并定义节点之间的执行顺序 / 分支逻辑，让 AI 流程 “可控制、可回溯、可扩展”。

简单类比：

• 普通 LangChain 是 “线性的管道”（A→B→C 一条路走到底）；
• LangGraph 是 “带分支、可循环的流程图”（A 通过则走 B，不通过则走 C；B 执行完可回到 A 重跑）。

二、LangGraph 核心概念（按重要性排序）

1. State（状态）—— 流程的 “数据载体”

• 定义：整个工作流中流转的 “数据包”，包含所有需要在节点之间传递的信息（输入数据、中间结果、最终结果）。
• 作用：让不同节点能共享数据（比如标题审核节点的结果，能被内容审核节点读取）。
• 举例（对应之前的文本审核程序）：

  python

  运行

  class ReviewState(BaseModel):
      title: str  # 原始输入
      title_review_result: Optional[str]  # 标题审核中间结果
      final_result: Optional[str]  # 最终结果
  

• 关键特性：
  • 通常用 Pydantic 定义（保证数据类型规范）；
  • 状态是 “不可变” 的（节点修改状态时，会生成新的状态副本，避免数据混乱）。

2. Node（节点）—— 流程的 “最小执行单元”

• 定义：工作流中一个独立的 “步骤 / 任务”，本质是一个函数，接收「状态」作为输入，返回「需要更新的状态数据」。
• 作用：完成单一职责的操作（比如 “审核标题”“审核内容”“生成最终结果”）。
• 举例：

  python

  运行

  def check_title_elements(state: ReviewState) -> Dict[str, Any]:
      # 接收状态中的title，执行审核逻辑
      # 返回需要更新的状态字段（title_review_result、title_review_reason）
      return {
          "title_review_result": "通过",
          "title_review_reason": "要素齐全"
      }
  

• 常见节点类型：
  • 功能节点：执行具体任务（如调用大模型、读写数据库、计算）；
  • 决策节点：仅判断下一步走向（无业务逻辑，只返回分支名称）。

3. Edge（边）—— 节点之间的 “连接关系”

• 定义：定义节点的执行顺序，分为 “普通边” 和 “条件边” 两种。
• 作用：告诉框架 “这个节点执行完后，该走哪条路”。
• 两种核心边：

  表格

  类型	定义	举例（文本审核）
  普通边（Add Edge）	固定顺序的连接（A→B）	内容审核节点执行完 → 生成最终结果节点
  条件边（Conditional Edge）	根据状态动态选择下一个节点	标题审核通过 → 内容审核节点；不通过 → 最终结果节点

• 代码示例：

  python

  运行

  # 普通边：content审核 → 最终结果
  graph.add_edge("check_content_event", "generate_final_result")
  
  # 条件边：标题审核后根据结果选下一步
  graph.add_conditional_edges(
      "check_title_elements",  # 源节点
      decide_after_title_review,  # 决策函数（根据状态返回分支名）
      {
          "check_content_event": "check_content_event",
          "generate_final_result": "generate_final_result"
      }
  )
  

4. Entry Point（入口点）—— 流程的 “起点”

• 定义：指定工作流从哪个节点开始执行。
• 作用：明确流程的启动位置，避免节点执行顺序混乱。
• 举例：

  python

  运行

  graph.set_entry_point("check_title_elements")  # 文本审核从“标题审核”开始
  

5. END（终止点）—— 流程的 “终点”

• 定义：LangGraph 内置的特殊节点，表示工作流结束。
• 作用：标记流程的最终出口（所有分支最终都要指向 END）。
• 举例：

  python

  运行

  graph.add_edge("generate_final_result", END)  # 最终结果节点执行完，流程结束
  

6. Graph（图）—— 整个工作流的 “容器”

• 定义：将所有节点、边、入口 / 终止点整合在一起的 “流程图对象”，分为两种核心类型：
  • StateGraph：最常用，基于状态流转的图（适合大部分业务场景，如文本审核）；
  • MessageGraph：专为多轮对话设计的图（状态以 “消息列表” 形式流转，适合智能客服）。
• 核心操作：
  1. 创建图 → 2. 添加节点 → 3. 定义边 → 4. 设置入口点 → 5. 编译图 → 6. 调用执行。
• 举例：

  python

  运行

  # 1. 创建图
  graph = StateGraph(ReviewState)
  # 2. 添加节点
  graph.add_node("check_title_elements", check_title_elements)
  # 3. 定义边 + 4. 设置入口点（略）
  # 5. 编译图（生成可执行的工作流）
  compiled_graph = graph.compile()
  # 6. 执行图（传入初始状态）
  result = compiled_graph.invoke(ReviewState(title="xxx", content="xxx"))
  

7. Compilation（编译）—— 图的 “生效步骤”

• 定义：将定义好的节点、边等 “逻辑”，转换为 LangGraph 可执行的 “运行时对象”。
• 作用：验证流程逻辑是否合法（比如是否有未连接的节点、是否有循环依赖），并生成执行引擎。
• 关键：只有编译后的图才能调用 invoke()/stream() 执行。

三、LangGraph 核心特性（基于上述概念）

1. 有状态：状态在节点间流转，能记住每一步的结果（比如审核程序能记住标题审核结果）；
2. 可循环：支持节点之间的 “回环”（比如内容审核不通过，可回到 “修改内容” 节点，再重新审核）；
3. 分支逻辑：通过条件边实现 “不同结果走不同流程”；
4. 可观察：能追踪每一步的状态变化（调试时可查看每个节点的输入 / 输出）；
5. 多智能体协作：可定义多个 “智能体节点”（如 “审核智能体”“修改智能体”），协同完成任务。

四、核心概念关系（一张图理解）

预览

查看代码

通过

不通过

Entry Point
（入口：标题审核）

Node：审核标题

Conditional Edge
（标题是否通过？）

Node：审核内容

Node：生成最终结果

END
（流程结束）

State：title、title_review_result、content_review_result、final_result

graph TD
    A[Entry Point<br>（入口：标题审核）] --> B[Node：审核标题]
    B --> C{Conditional Edge<br>（标题是否通过？）}
    C -->|通过| D[Node：审核内容]
    C -->|不通过| E[Node：生成最终结果]
    D --> E
    E --> F[END<br>（流程结束）]
    style A fill:#f9f,stroke:#333
    style B fill:#9ff,stroke:#333
    style C fill:#ff9,stroke:#333
    style D fill:#9ff,stroke:#333
    style E fill:#9ff,stroke:#333
    style F fill:#f99,stroke:#333
    note[State：title、title_review_result、content_review_result、final_result]
    note -.-> A
    note -.-> B
    note -.-> D
    note -.-> E

通过

不通过

Entry Point
（入口：标题审核）

Node：审核标题

Conditional Edge
（标题是否通过？）

Node：审核内容

Node：生成最终结果

END
（流程结束）

State：title、title_review_result、content_review_result、final_result

豆包

你的 AI 助手，助力每日工作学习

总结

1. 核心载体：State（状态）是数据流转的核心，所有节点都围绕状态操作；
2. 核心单元：Node（节点）是最小执行步骤，完成单一任务；
3. 核心逻辑：Edge（边）定义节点执行顺序，支持分支 / 线性逻辑；
4. 核心容器：Graph（图）整合所有组件，编译后可执行；
5. 核心边界：Entry Point 是起点，END 是终点，框定流程范围。

理解这些概念后，你就能轻松扩展之前的文本审核程序（比如添加 “修改内容” 节点、增加 “人工复核” 分支），也能基于 LangGraph 开发其他复杂工作流（如智能问答、数据分析、多步骤任务规划）。