跳转到主内容

走进 GPT Researcher 的故事

·阅读时长 5 分钟
Elisha Kramer
GPT Researcher 核心贡献者

GPTR reflecting ourselves

巴诺书店之梦

我记得十几岁时,走进巴诺书店(Barnes & Noble),空气中弥漫着新书的墨香,我的指尖划过那些塑造思想、俘获人心的书脊。我曾对自己低语:总有一天,我的名字也会出现在这里。

对我来说,书不仅仅是故事——它们是人类经验的反映,是人们更清晰地认识自己的方式。莎士比亚曾说:“艺术的目的是把镜子举向自然。”这个想法深深地吸引了我。艺术、写作和讲故事不仅仅是为了娱乐,它们是为了以新的方式理解我们自己。

但世界变了。书店逐渐消失,人们的注意力转移了,曾经是深度思考和反思顶峰的小说,让位给了新的互动形式。那种漫长、沉浸式的阅读体验被更动态、更具互动性的东西所取代。

踏上编程之旅:辛巴时刻

大约九年前,就像《狮子王》中的辛巴一样,我踏上了一段充满怀疑和不确定性的新旅程。我离开了我熟悉的写作世界,踏入了未知的编程领域。起初,这对我来说是一门外语——无尽的语法、毫无头绪的调试错误,以及无数次让我感觉自己是开发者世界里的冒牌货的沮丧时刻。

这段旅程很艰难——我努力寻找自己的位置,面临合同被取消,被挫败的次数多得数不清。每一次拒绝,每一次错失机会,都让我怀疑自己是否走错了路。也许我注定不该去创造——也许我应该留在故事的世界里。

即使我最终在 Fiverr 找到了一份使用 JavaScript、MySQL、HTML 和 CSS 的工作,我仍然觉得自己抛弃了作为一名作家的身份。

发现 GPT Researcher

大约一年前的一个晚上,在我深入研究人工智能的某个时刻,我偶然发现了 GPT Researcher。这个概念立刻打动了我——人工智能不仅仅是一个工具,它是一种扩展人类知识、提炼问题、重塑我们研究方法的手段。

我联系了 Assaf,并没抱太大期望。但他没有礼貌地回应一下就了事,而是欢迎我加入。那一刻——看到我的第一个提交被合并——感觉就像我旧日梦想的回响。只是这一次,我不再仅仅是写故事,我正在构建某种东西,帮助他人发现他们自己的故事。

研究员魔镜里的恶毒女巫

大约在那个时候,我发现自己反复向 GPT Researcher 问同一个问题:

“Elisha Kramer 是谁?”

起初,它就像《白雪公主》里的魔镜,会给出一个通用的回答,比如:“Elisha Kramer 是一位有网页开发经验的软件工程师。”它从我的领英、GitHub 和 Udemy 个人资料中提取信息,描绘出我的职业形象。但后来,事情变得奇怪起来。

我向 GPT Researcher 提交了更多的 commit,做出了更多的贡献。随着我不断编码,我问了一个不同的问题。

“GitHub 上的 ElishaKay 是谁?”

随着时间的推移,答案变了,因为 Researcher 会从网络搜索结果中抓取最新的信息源。

“ElishaKay 是一位活跃的开源贡献者,拥有多个代码仓库,在过去一年中有超过 500 次 commit。”

我的天哪!它在学习。又一个 commit。又一个新功能。又一行文档。是时候问得更具体些了。

“gpt-researcher 项目的 ElishaKay 是谁?”

“ElishaKay 是 GPT Researcher 的核心贡献者,通过重要的代码和文档贡献,改善了研究工作流并增强了 AI 检索能力。”

这下说到点子上了。但我还没结束。就像那个恶毒女巫一样,我一次又一次地回来。更多的 commit。更多的改进。更多的功能。

直到最后,我问道:

“跟我聊聊 gpt-researcher 以及改进它的建议”

然后 GPT Researcher 看着我,回答道:

“GPTR 是一个蓬勃发展的开源社区。最好的前进道路是继续投资于这个社区——通过代码贡献、改进文档以及帮助新贡献者入门。这个项目的优势在于其协作性。”

就在那时我明白了——我不仅仅是在使用 GPT Researcher,我正在成为它故事的一部分。

AI:我们自身的镜子

这种不断演变的反馈帮助我构建了自己的自我叙事。GPT Researcher 不仅仅是在反映已知的信息——它还在整合我的工作和更广泛的互联网背景。

它在反映我自己的旅程,每一步都在提炼它,模糊了固定身份的幻象,拥抱了一个不断演变的自我。

每一次查询,每一次 commit,每一次改进,都在塑造这个工具——反过来,它也在塑造我。

以社区之力共建

GPT Researcher 不仅仅是一个工具。它是开源精神的体现,一个活生生的、不断演进的生态系统,在这里知识不是静态的,而是不断被提炼。它不只是回答问题,它在参与对话,根据最新的贡献、研究和发现来塑造和重塑叙事。这不再仅仅关乎我个人,而是关乎我们。一个由 138 名贡献者组成的网络。一个拥有 20,000 颗星标关注的开源项目。一场推动人工智能驱动研究边界的集体运动。

每一个研究人员、每一个开发者、每一个好奇心旺盛的人,只要他们提炼问题、贡献功能或与工具互动,就都是这宏大事业的一部分。人工智能不是某个吐出答案的黑匣子——它是一个帮助我们提炼自己的思维、挑战假设、扩展理解的工具。这是一个迭代的过程,就像生活本身一样。我们提供的背景信息越多,我们得到的见解就越好。我们参与得越多,它反映的就不仅仅是过去的我们,更是我们正在成为的我们。

一个仍在书写的故事

所以,虽然我曾经梦想在巴诺书店的书脊上看到我的名字,但现在我看到了更伟大的东西。我的文字不再局限于一本书——它们存在于每一行代码、每一次贡献、每一位提炼问题的研究人员之中。我们不仅仅是用户,我们是建设者。这也不再只是我的故事,而是我们的故事。而这个故事,仍在书写之中。

推出 Deep Research:开源替代方案

·阅读时长 8 分钟

人工智能深度研究的黎明

随着“深度研究”能力的出现,人工智能研究领域正在经历一场革命性的转变。但深度研究究竟是什么,你又为何应该关心它?

深度研究代表了人工智能驱动信息检索的下一次进化——它远远超出了简单的搜索,能够对复杂主题进行全面、多层次的分析。与返回链接列表的传统搜索引擎,甚至提供表层摘要的第一代人工智能助手不同,深度研究工具部署了复杂的算法,以前所未有的深度和广度探索主题,模仿人类研究员处理复杂课题的方式。

定义真正深度研究能力的关键特征包括:动态地优化查询和结果的迭代分析(InfoQ, 2025)、整合不同数据格式的多模态处理(Observer, 2025)、用于获取最新见解的实时数据检索(WinBuzzer, 2025),以及为学术和技术应用提供带有适当引用的结构化输出(Helicone, 2025)。

近几个月来,我们看到各大公司都推出了自己的深度研究解决方案,每家公司在市场上都有其独特的方法和定位。

  • Perplexity AI 专注于速度,通过实时数据检索,在三分钟内提供研究结果(Analytics Vidhya, 2025)。其高性价比的模式(从免费版开始)让更广泛的受众能够接触到高级研究,不过一些分析师指出,为了速度可能会在准确性上有所妥协(Medium, 2025)。

  • OpenAI 的深度研究(基于 O3 模型)优先考虑深度和精度,在技术和学术应用方面表现出色,具有先进的推理能力(Helicone, 2025)。其结构化输出包含详细的引用,确保了可靠性和可验证性。然而,每月 200 美元的价格(Opentools, 2025)是一笔巨大的投资,而且生成综合报告可能需要 5-30 分钟(ClickItTech, 2025)。

  • 谷歌的 Gemini 2.0 强调跨文本、图像、音频和视频的多模态整合,在企业应用方面尤其强大(Adyog, 2024)。每月 20 美元的价格,使其成为比 OpenAI 解决方案更实惠的选择,不过一些用户指出其在定制灵活性方面存在限制(Helicone, 2025)。

深度研究之所以真正令人兴奋,在于它有潜力使高级知识合成大众化(Medium, 2025),通过自动化耗时的研究任务来显著提高生产力(The Mobile Indian, 2025),并通过先进的推理能力为跨学科研究开辟新途径(Observer, 2025)。

然而,当前市场的一个关键限制是可及性——最强大的深度研究工具仍然被锁在昂贵的付费墙或封闭系统之后,使得许多最能从这些能力中受益的研究人员、学生和小型组织无法企及。

隆重推出 GPT Researcher 深度研究 ✨

我们很高兴地宣布我们针对这一趋势的解决方案:GPT Researcher 深度研究——一个先进的开源递归研究系统,能够深入且广泛地探索主题,同时保持成本效益和透明度。

GPT Researcher 深度研究不仅与行业巨头的能力相媲美,还在几个关键指标上超越了它们:

  • 高性价比:每次深度研究操作成本约为 0.40 美元(使用 o3-mini 并设置推理强度为 "high"
  • 高效率:约 5 分钟内完成研究
  • 完全可定制:调整参数以匹配您的特定研究需求
  • 透明:对研究过程和方法有完全的可见性
  • 开源:可免费使用、修改并集成到您的工作流程中

工作原理:递归研究树

GPT Researcher 深度研究之所以如此强大,是因为它采用了树状探索模式,以智能、递归的方式结合了广度和深度:

Research Flow Diagram

  1. 广度探索:在每一层,它都会生成多个搜索查询,以探索您主题的不同方面
  2. 深度挖掘:对于每个分支,它会递归地深入,追踪有价值的线索并揭示隐藏的联系
  3. 并发处理:利用异步/等待模式同时运行多个研究路径
  4. 上下文管理:自动聚合和综合所有分支的研究结果
  5. 实时追踪:提供跨广度和深度维度的研究进展更新

想象一下,部署一个由多个人工智能研究员组成的团队,每个研究员都遵循自己的研究路径,同时协作构建对您主题的全面理解。这就是 GPT Researcher 深度研究方法的威力。

几分钟内即可上手

将深度研究集成到您的项目中非常简单:

from gpt_researcher import GPTResearcher
import asyncio

async def main():
# Initialize researcher with deep research type
researcher = GPTResearcher(
query="What are the latest developments in quantum computing?",
report_type="deep", # This triggers deep research mode
)

# Run research
research_data = await researcher.conduct_research()

# Generate report
report = await researcher.write_report()
print(report)

if __name__ == "__main__":
asyncio.run(main())

底层原理:深度研究如何运作

查看代码库可以揭示支持 GPT Researcher 深度研究能力的复杂系统:

1. 查询生成与规划

系统首先会根据您的初始问题生成一组多样化的搜索查询。

async def generate_search_queries(self, query: str, num_queries: int = 3) -> List[Dict[str, str]]:
"""Generate SERP queries for research"""
messages = [
{"role": "system", "content": "You are an expert researcher generating search queries."},
{"role": "user",
"content": f"Given the following prompt, generate {num_queries} unique search queries to research the topic thoroughly. For each query, provide a research goal. Format as 'Query: <query>' followed by 'Goal: <goal>' for each pair: {query}"}
]

这个过程会创建有针对性的查询,每个查询都有一个具体的研究目标。例如,一个关于量子计算的查询可能会生成:

  • “2024-2025年最新量子计算突破”
  • “量子计算在金融领域的实际应用”
  • “量子纠错技术进展”

2. 并发研究执行

然后,系统会通过智能的资源管理并发执行这些查询。

# Process queries with concurrency limit
semaphore = asyncio.Semaphore(self.concurrency_limit)

async def process_query(serp_query: Dict[str, str]) -> Optional[Dict[str, Any]]:
async with semaphore:
# Research execution logic

这种方法在确保系统稳定性的同时最大化了效率——就像有多个研究人员并行工作一样。

3. 递归探索

神奇之处在于递归探索。

# Continue deeper if needed
if depth > 1:
new_breadth = max(2, breadth // 2)
new_depth = depth - 1
progress.current_depth += 1

# Create next query from research goal and follow-up questions
next_query = f"""
Previous research goal: {result['researchGoal']}
Follow-up questions: {' '.join(result['followUpQuestions'])}
"""

# Recursive research
deeper_results = await self.deep_research(
query=next_query,
breadth=new_breadth,
depth=new_depth,
# Additional parameters
)

这创建了一种树状的探索模式,能够深入追踪有前景的线索,同时保持覆盖的广度。

4. 上下文管理与综合

管理海量收集到的信息需要复杂的追踪机制。

# Trim context to stay within word limits
trimmed_context = trim_context_to_word_limit(all_context)
logger.info(f"Trimmed context from {len(all_context)} items to {len(trimmed_context)} items to stay within word limit")

这确保了在尊重模型上下文限制的同时,保留最相关的信息。

定制您的研究体验

GPT Researcher 开源方法的一个关键优势是完全的可定制性。您可以通过几个配置选项来根据您的具体需求定制研究过程:

deep_research_breadth: 4    # Number of parallel research paths
deep_research_depth: 2 # How many levels deep to explore
deep_research_concurrency: 4 # Maximum concurrent operations
total_words: 2500 # Word count for final report
reasoning_effort: medium

通过环境变量、配置文件或直接在代码中应用这些配置。

researcher = GPTResearcher(
query="your query",
report_type="deep",
config_path="path/to/config.yaml"
)

实时进度追踪

对于需要了解研究过程可见性的应用,GPT Researcher 提供了详细的进度追踪。

class ResearchProgress:
current_depth: int # Current depth level
total_depth: int # Maximum depth to explore
current_breadth: int # Current number of parallel paths
total_breadth: int # Maximum breadth at each level
current_query: str # Currently processing query
completed_queries: int # Number of completed queries
total_queries: int # Total queries to process

这使您可以构建能够实时显示研究进度的界面——非常适合那些希望用户能看到过程的应用。

为何这很重要:深度研究的影响

通过像 GPT Researcher 这样的开源工具实现深度研究能力的大众化,代表了我们处理和分析信息方式的范式转变。其好处包括:

  1. 更深刻的见解:揭示表层研究所会错过的联系和模式
  2. 节省时间:将数小时或数天的手动研究自动化到几分钟之内
  3. 降低成本:以极低的成本获得企业级的研究能力
  4. 可及性:将先进的研究工具带给个人和小型组织
  5. 透明度:对研究方法和来源有完全的可见性

立即开始

准备好在您的项目中体验深度研究的力量了吗?以下是如何开始:

  1. 安装pip install gpt-researcher
  2. API 密钥:为您选择的 LLM 提供商和搜索引擎设置 API 密钥
  3. 配置:根据您的研究需求自定义参数
  4. 实现:使用示例代码将其集成到您的应用程序中

更详细的说明和示例可以在 GPT Researcher 文档中找到。

无论您是构建下一代研究工具的开发者,寻求更深刻见解的学者,还是需要全面分析的商业专业人士,GPT Researcher 的深度研究能力都提供了一个易于访问、功能强大的解决方案,它能够与主要人工智能公司的产品相媲美,甚至在许多方面超越了它们。

人工智能驱动研究的未来已经到来,而且它是开源的。🎉

研究愉快!

研究的未来是混合模式

·阅读时长 8 分钟
Assaf Elovic
GPT Researcher 和 Tavily 的创建者

Hyrbrid Research with GPT Researcher

在过去几年中,我们见证了旨在颠覆研究的新型人工智能工具的爆炸式增长。其中一些,如 ChatPDFConsensus,专注于从文档中提取见解。另一些,如 Perplexity,则擅长在网络上搜寻信息。但问题在于:这些工具没有一个能将网络搜索和本地文档搜索结合在单一的上下文研究流程中。

这就是为什么我很高兴能向大家介绍 GPT Researcher 的最新进展——现在它能够针对任何给定的任务和文档进行混合研究。

基于网络的研究往往缺乏特定背景,有信息过载的风险,并且可能包含过时或不可靠的数据。另一方面,基于本地的研究仅限于历史数据和现有知识,可能造成组织内部的回音室效应,并错失关键的市场趋势或竞争对手的动向。这两种方法如果孤立使用,都可能导致不完整或有偏见的见解,从而妨碍您做出充分知情的决策。

今天,我们将改变这一局面。在本指南的最后,您将学会如何进行混合研究,它结合了网络和本地两种方式的优点,使您能够进行更彻底、更相关、更有见地的研究。

为什么混合研究效果更好

通过结合网络和本地来源,混合研究解决了这些局限性,并提供了几个关键优势:

  1. 有依据的上下文:本地文档提供了经过验证的、特定于组织的信息基础。这将研究建立在既有知识之上,减少了偏离核心概念或误解行业特定术语的风险。

    示例:一家制药公司在研究新药开发机会时,可以将其内部研究论文和临床试验数据作为基础,然后用网上最新发表的研究和监管更新来补充。

  2. 提高准确性:网络来源提供最新信息,而本地文档提供历史背景。这种结合可以进行更准确的趋势分析和决策。

    示例:一家金融服务公司在分析市场趋势时,可以将其历史交易数据与实时市场新闻和社交媒体情绪分析相结合,从而做出更明智的投资决策。

  3. 减少偏见:通过同时从网络和本地来源获取信息,我们降低了任何单一来源中可能存在的偏见风险。

    示例:一家科技公司在评估其产品路线图时,可以将内部功能请求和使用数据与外部客户评论和竞争对手分析相平衡,确保获得全面的视角。

  4. 改进规划和推理:大语言模型(LLM)可以利用本地文档的背景信息,更好地规划其网络研究策略,并对在网上找到的信息进行推理。

    示例:一个由人工智能驱动的市场研究工具,可以利用公司过去的市场活动数据来指导其在网上搜索当前的市场趋势,从而获得更相关、更具可操作性的见解。

  5. 定制化见解:混合研究允许将专有信息与公共数据相结合,从而产生独特的、特定于组织的见解。

    示例:一家零售连锁店可以将其销售数据与网络抓取的竞争对手定价和经济指标相结合,以优化其在不同地区的定价策略。

这些只是可以利用混合研究的商业用例中的几个例子,但闲话少说——让我们开始构建吧!

构建混合研究助手

在我们深入细节之前,值得一提的是,GPT Researcher 本身就具备进行混合研究的能力!然而,为了真正理解其工作原理并让您更深入地了解这个过程,我们将带您一探究竟。

GPT Researcher hybrid research

如上图所示,GPT Researcher 根据本地文档自动生成的计划进行网络研究。然后,它从本地和网络数据中检索相关信息,用于最终的研究报告。

我们将探讨如何使用 LangChain 处理本地文档,这是 GPT Researcher 文档处理的关键组件。然后,我们将向您展示如何利用 GPT Researcher 进行混合研究,结合网络搜索和您的本地文档知识库的优势。

使用 Langchain 处理本地文档

LangChain 提供了多种文档加载器,使我们能够处理不同的文件类型。在处理多样化的本地文档时,这种灵活性至关重要。以下是如何进行设置:

from langchain_community.document_loaders import (
PyMuPDFLoader,
TextLoader,
UnstructuredCSVLoader,
UnstructuredExcelLoader,
UnstructuredMarkdownLoader,
UnstructuredPowerPointLoader,
UnstructuredWordDocumentLoader
)
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

def load_local_documents(file_paths):
documents = []
for file_path in file_paths:
if file_path.endswith('.pdf'):
loader = PyMuPDFLoader(file_path)
elif file_path.endswith('.txt'):
loader = TextLoader(file_path)
elif file_path.endswith('.csv'):
loader = UnstructuredCSVLoader(file_path)
elif file_path.endswith('.xlsx'):
loader = UnstructuredExcelLoader(file_path)
elif file_path.endswith('.md'):
loader = UnstructuredMarkdownLoader(file_path)
elif file_path.endswith('.pptx'):
loader = UnstructuredPowerPointLoader(file_path)
elif file_path.endswith('.docx'):
loader = UnstructuredWordDocumentLoader(file_path)
else:
raise ValueError(f"Unsupported file type: {file_path}")

documents.extend(loader.load())

return documents

# Use the function to load your local documents
local_docs = load_local_documents(['company_report.pdf', 'meeting_notes.docx', 'data.csv'])

# Split the documents into smaller chunks for more efficient processing
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = text_splitter.split_documents(local_docs)

# Create embeddings and store them in a vector database for quick retrieval
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documents=splits, embedding=embeddings)

# Example of how to perform a similarity search
query = "What were the key points from our last strategy meeting?"
relevant_docs = vectorstore.similarity_search(query, k=3)

for doc in relevant_docs:
print(doc.page_content)

使用 GPT Researcher 进行网络研究

现在我们已经学会了如何处理本地文档,让我们快速了解一下 GPT Researcher 的工作原理:

GPT Researcher Architecture

如上所述,GPT Researcher 会根据给定的任务创建一个研究计划,生成一系列潜在的研究查询,这些查询可以共同提供对该主题的客观而广泛的概述。一旦这些查询生成,GPT Researcher 会使用像 Tavily 这样的搜索引擎来查找相关结果。每个抓取的结果随后会保存在一个向量数据库中。最后,检索与研究任务最相关的前 k 个数据块,以生成最终的研究报告。

GPT Researcher 支持混合研究,这涉及一个额外的步骤,即在检索最相关信息之前对本地文档进行分块(使用 Langchain 实现)。经过社区的大量评估,我们发现混合研究将最终结果的正确性提高了 40% 以上!

使用 GPT Researcher 运行混合研究

现在您对混合研究的工作原理有了更好的理解,让我们来演示一下使用 GPT Researcher 实现这一点是多么容易。

第一步:使用 PIP 安装 GPT Researcher

pip install gpt-researcher

第二步:设置环境

我们将使用 OpenAI 作为大语言模型(LLM)供应商,Tavily 作为搜索引擎来运行 GPT Researcher。在继续之前,您需要获取这两者的 API 密钥。然后,在您的命令行界面(CLI)中按如下方式导出环境变量:

export OPENAI_API_KEY={your-openai-key}
export TAVILY_API_KEY={your-tavily-key}

步骤 3:使用混合研究配置初始化 GPT Researcher

GPT Researcher 可以通过参数轻松初始化,以指示其运行混合研究。您可以进行多种形式的研究,请前往文档页面了解更多信息。

要让 GPT Researcher 运行混合研究,您需要将所有相关文件放入 my-docs 目录(如果不存在则创建),并将实例的 report_source 设置为“hybrid”,如下所示。一旦报告来源设置为混合模式,GPT Researcher 将会在 my-docs 目录中查找现有文档并将其纳入研究。如果不存在任何文档,它将忽略此步骤。

from gpt_researcher import GPTResearcher
import asyncio

async def get_research_report(query: str, report_type: str, report_source: str) -> str:
researcher = GPTResearcher(query=query, report_type=report_type, report_source=report_source)
research = await researcher.conduct_research()
report = await researcher.write_report()
return report

if __name__ == "__main__":
query = "How does our product roadmap compare to emerging market trends in our industry?"
report_source = "hybrid"

report = asyncio.run(get_research_report(query=query, report_type="research_report", report_source=report_source))
print(report)

如上所示,我们可以对以下示例进行研究:

  • 研究任务:“我们的产品路线图与我们行业的新兴市场趋势相比如何?”
  • 网络:当前市场趋势、竞争对手公告和行业预测
  • 本地:内部产品路线图文件和功能优先级列表

经过社区的各种评估,我们发现这种研究的结果将研究的质量和正确性提高了 40% 以上,并将幻觉减少了 50%。此外,如上所述,本地信息有助于大语言模型改进规划推理,使其能够做出更好的决策并研究更相关的网络资源。

但等等,还有更多!GPT Researcher 还包括一个使用 NextJS 和 Tailwind 构建的精美前端应用程序。要了解如何运行它,请查看文档页面。您可以轻松地使用拖放功能来处理文档,以进行混合研究。

结论

混合研究代表了数据收集和决策制定的重大进步。通过利用像 GPT Researcher 这样的工具,团队现在可以进行更全面、更具情境感知和更具可操作性的研究。这种方法解决了单独使用网络或本地资源的局限性,提供了诸如扎实的上下文、更高的准确性、减少的偏见、改进的规划和推理以及定制化的见解等好处。

混合研究的自动化可以使团队能够更快、更数据驱动地做出决策,最终提高生产力,并在分析不断扩大的非结构化和动态信息池方面提供竞争优势。

如何构建终极多智能体研究助理

·10分钟阅读
Assaf Elovic
GPT Researcher 和 Tavily 的创建者

Header

学习如何使用 LangGraph 和一组专业化 AI 智能体来构建一个自主研究助手

GPT Researcher 初版发布至今仅一年,但构建、测试和部署 AI 智能体的方法已经发生了显著的演变。这就是当前 AI 发展的本质和速度。从简单的零样本或少样本提示开始,迅速发展到智能体函数调用、RAG,现在终于到了智能体工作流(即“流程工程”)。

吴恩达(Andrew Ng)最近表示:“我认为 AI 智能体工作流今年将推动巨大的 AI 进步——甚至可能超过下一代基础模型。这是一个重要的趋势,我敦促所有从事 AI 工作的人关注它。”

在本文中,您将学习为什么多智能体工作流是当前最佳标准,以及如何使用 LangGraph 构建最优的自主研究多智能体助理。

要跳过本教程,请随时查看 GPT Researcher x LangGraph 的 Github 仓库。

LangGraph 简介

LangGraph 是 LangChain 的一个扩展,旨在创建智能体和多智能体工作流。它增加了创建循环流程的能力,并内置了内存——这两者都是创建智能体的重要属性。

LangGraph 为开发者提供了高度的可控性,对于创建自定义智能体和流程至关重要。几乎所有生产环境中的智能体都是根据其试图解决的特定用例进行定制的。LangGraph 赋予您创建任意定制化智能体的灵活性,同时为此提供了直观的开发者体验。

闲话少说,让我们开始构建吧!

构建终极自主研究智能体

通过利用 LangGraph,可以利用具有专业技能的多个智能体来显著提升研究的深度和质量。让每个智能体只专注于特定技能,可以实现更好的关注点分离、可定制性,并随着项目的发展支持更大规模的开发。

受近期 STORM 论文的启发,这个例子展示了一个 AI 智能体团队如何协同工作,对给定主题进行研究,从规划到发布。这个例子还将利用领先的自主研究智能体 GPT Researcher。

研究智能体团队

研究团队由七个 LLM 智能体组成

  • 总编辑 — 监督研究过程并管理团队。这是使用 LangGraph 协调其他智能体的“主”智能体。该智能体充当主要的 LangGraph 接口。
  • GPT Researcher — 一个专业的自主智能体,对给定主题进行深入研究。
  • 编辑 — 负责规划研究大纲和结构。
  • 审阅者 — 根据一组标准验证研究结果的正确性。
  • 修订者 — 根据审阅者的反馈修订研究结果。
  • 作者 — 负责整理和撰写最终报告。
  • 发布者 — 负责以各种格式发布最终报告。

架构

如下图所示,自动化过程基于以下几个阶段:规划研究、数据收集与分析、审阅与修订、撰写报告以及最终发布

Architecture

更具体地说,过程如下

  • 浏览器 (gpt-researcher) — 根据给定的研究任务在互联网上进行初步研究。这一步至关重要,能让大语言模型根据最新和相关的信息来规划研究过程,而不是仅仅依赖于预训练数据来处理给定的任务或主题。

  • 编辑 — 根据初步研究规划报告大纲和结构。编辑还负责根据规划的大纲触发并行的研究任务。

  • 针对每个大纲主题(并行进行)

    • 研究员(gpt-researcher) — 对子主题进行深入研究并撰写草稿。该智能体在底层利用 GPT Researcher Python 包,以获得优化、深入且基于事实的研究报告。
    • 审阅者 — 根据一套准则验证草稿的正确性,并向修订者提供反馈(如果有)。
    • 修订者 — 根据审阅者的反馈修订草稿,直到满意为止。
  • 作者 — 根据给定的研究发现,整理并撰写最终报告,包括引言、结论和参考文献部分。

  • 发布者 — 将最终报告发布为多种格式,如 PDF、Docx、Markdown 等。

  • 我们不会深入探讨所有代码,因为代码量很大,但会主要关注我发现有价值分享的有趣部分。

定义图状态

我最喜欢 LangGraph 的功能之一是状态管理。LangGraph 中的状态是通过一种结构化的方法实现的,开发者定义一个 `GraphState` 来封装应用程序的整个状态。图中的每个节点都可以修改这个状态,从而可以根据交互的演变上下文做出动态响应。

就像任何技术设计的开端一样,考虑整个应用程序的数据模式是关键。在这种情况下,我们将定义一个 `ResearchState`,如下所示

class ResearchState(TypedDict):
task: dict
initial_research: str
sections: List[str]
research_data: List[dict]
# Report layout
title: str
headers: dict
date: str
table_of_contents: str
introduction: str
conclusion: str
sources: List[str]
report: str

如上所示,状态分为两个主要区域:研究任务和报告布局内容。当数据在图智能体之间流转时,每个智能体将依次根据现有状态生成新数据,并为图下游的其他智能体进行后续处理而更新它。

然后我们可以用以下方式初始化图

from langgraph.graph import StateGraph
workflow = StateGraph(ResearchState)

用 LangGraph 初始化图。如上所述,多智能体开发的一大优点是构建每个智能体,使其具有专业化和范围明确的技能。让我们以使用 GPT Researcher python 包的 Researcher 智能体为例

from gpt_researcher import GPTResearcher

class ResearchAgent:
def __init__(self):
pass

async def research(self, query: str):
# Initialize the researcher
researcher = GPTResearcher(parent_query=parent_query, query=query, report_type=research_report, config_path=None)
# Conduct research on the given query
await researcher.conduct_research()
# Write the report
report = await researcher.write_report()

return report

如上所示,我们已经创建了一个 Research 智能体的实例。现在让我们假设我们已经为团队中的每个智能体都做了同样的操作。在创建所有智能体之后,我们将用 LangGraph 初始化图

def init_research_team(self):
# Initialize skills
editor_agent = EditorAgent(self.task)
research_agent = ResearchAgent()
writer_agent = WriterAgent()
publisher_agent = PublisherAgent(self.output_dir)

# Define a Langchain StateGraph with the ResearchState
workflow = StateGraph(ResearchState)

# Add nodes for each agent
workflow.add_node("browser", research_agent.run_initial_research)
workflow.add_node("planner", editor_agent.plan_research)
workflow.add_node("researcher", editor_agent.run_parallel_research)
workflow.add_node("writer", writer_agent.run)
workflow.add_node("publisher", publisher_agent.run)

workflow.add_edge('browser', 'planner')
workflow.add_edge('planner', 'researcher')
workflow.add_edge('researcher', 'writer')
workflow.add_edge('writer', 'publisher')

# set up start and end nodes
workflow.set_entry_point("browser")
workflow.add_edge('publisher', END)

return workflow

如上所示,创建 LangGraph 图非常直接,主要由三个函数组成:`add_node`、`add_edge` 和 `set_entry_point`。通过这些主要函数,您可以首先向图中添加节点,连接边,最后设置起点。

注意检查:如果你一直正确地跟随代码和架构,你会注意到审阅者(Reviewer)和修订者(Reviser)智能体在上面的初始化中缺失了。让我们深入探讨一下!

图中图,支持有状态的并行化

这是我使用 LangGraph 过程中最激动人心的部分!这个自主助理的一个令人兴奋的特性是为每个研究任务进行并行运行,这些任务会根据一组预定义的准则进行审阅和修订。

了解如何在一个流程中利用并行工作是优化速度的关键。但是,如果所有智能体都向同一个状态报告,你将如何触发并行智能体工作呢?这可能会导致竞争条件和最终数据报告中的不一致。为了解决这个问题,你可以创建一个子图,由主 LangGraph 实例触发。这个子图将为每次并行运行保持自己的状态,从而解决所提出的问题。

和之前一样,让我们定义 LangGraph 的状态和它的智能体。由于这个子图基本上是审阅和修订一份研究草稿,我们将用草稿信息来定义状态

class DraftState(TypedDict):
task: dict
topic: str
draft: dict
review: str
revision_notes: str

如 DraftState 中所示,我们主要关心讨论的主题,以及审阅者和修订说明,因为它们在彼此沟通以最终确定子主题研究报告时进行交互。为了创建循环条件,我们将利用 LangGraph 的最后一个重要部分,即条件边。

async def run_parallel_research(self, research_state: dict):
workflow = StateGraph(DraftState)

workflow.add_node("researcher", research_agent.run_depth_research)
workflow.add_node("reviewer", reviewer_agent.run)
workflow.add_node("reviser", reviser_agent.run)

# set up edges researcher->reviewer->reviser->reviewer...
workflow.set_entry_point("researcher")
workflow.add_edge('researcher', 'reviewer')
workflow.add_edge('reviser', 'reviewer')
workflow.add_conditional_edges('reviewer',
(lambda draft: "accept" if draft['review'] is None else "revise"),
{"accept": END, "revise": "reviser"})

通过定义条件边,如果审阅者有审阅意见,图就会导向修订者,否则循环将以最终草稿结束。如果你回头看我们构建的主图,你会看到这个并行工作是在一个名为“researcher”的节点下,由 ChiefEditor 智能体调用。

运行研究助理 在最终确定智能体、状态和图之后,是时候运行我们的研究助理了!为了使其更易于定制,该助理通过一个给定的 `task.json` 文件运行

{
"query": "Is AI in a hype cycle?",
"max_sections": 3,
"publish_formats": {
"markdown": true,
"pdf": true,
"docx": true
},
"follow_guidelines": false,
"model": "gpt-4-turbo",
"guidelines": [
"The report MUST be written in APA format",
"Each sub section MUST include supporting sources using hyperlinks. If none exist, erase the sub section or rewrite it to be a part of the previous section",
"The report MUST be written in spanish"
]
}

任务对象相当不言自明,但请注意,如果 `follow_guidelines` 为 `false`,将导致图忽略修订步骤和定义的指导方针。此外,`max_sections` 字段定义了要研究多少个子标题。设置较少的值将生成较短的报告。

运行该助手将生成一份最终的研究报告,格式包括 Markdown、PDF 和 Docx。

要下载并运行该示例,请查看 GPT Researcher x LangGraph 的开源页面

下一步是什么?

展望未来,有一些非常令人兴奋的事情值得思考。人在回路对于优化的 AI 体验至关重要。让真人帮助助手修订并专注于正确的研究计划、主题和提纲,将提升整体质量和体验。总的来说,在整个 AI 流程中依赖人类干预可以确保正确性、控制感和确定性的结果。很高兴看到 LangGraph 已经原生支持这一点,如此处所示。

此外,支持对网络和本地数据的研究对于许多商业和个人用例来说将是关键。

最后,可以做出更多努力来提高检索到来源的质量,并确保最终报告以最佳的故事情节构建。

LangGraph 和多智能体协作的一个进步方向是,助手可以根据给定的任务动态地规划和生成图。这一愿景将允许助手为给定任务仅选择一部分智能体,并根据本文中介绍的图的基本原理规划其策略,从而开启一个全新的可能性世界。鉴于 AI 领域的创新速度,不久就会推出一个颠覆性的新版 GPT Researcher。期待未来带来的一切!

要持续关注该项目的进展和更新,请加入我们的 Discord 社区。和往常一样,如果您有任何反馈或进一步的问题,请在下方评论!

如何构建可访问互联网的 OpenAI 助理

·6分钟阅读
Assaf Elovic
GPT Researcher 和 Tavily 的创建者

OpenAI 再次通过一场开创性的开发者日活动,展示了 OpenAI 工具、产品和服务套件的一些最新改进。其中一个重大发布是新的助手 API,它使开发者更容易构建自己的辅助性 AI 应用,这些应用有目标并且可以调用模型和工具。

新的助手 API 目前支持三种类型的工具:代码解释器、检索和函数调用。尽管您可能期望检索工具支持在线信息检索(例如搜索 API 或作为 ChatGPT 插件),但它目前仅支持原始数据,如文本或 CSV 文件。

本博客将演示如何利用最新的 Assistants API 和函数调用工具来获取在线信息。

如果想跳过下面的教程,可以直接查看完整的 Github Gist

从高层次来看,一次典型的 Assistants API 集成包含以下步骤:

  • 通过定义其自定义指令并选择一个模型,在 API 中创建一个助手。如果需要,可以启用代码解释器、检索和函数调用等工具。
  • 当用户开始对话时,创建一个对话线程(Thread)
  • 随着用户提问,向对话线程中添加消息(Message)
  • 在对话线程上运行(Run)助手以触发响应。这将自动调用相关工具。

如下所示,一个助手对象包含用于存储和处理助手与用户之间对话会话的对话线程(Threads),以及用于在对话线程上调用助手的运行(Run)。

OpenAI Assistant Object

让我们一步步实现这些步骤吧!作为示例,我们将构建一个能够提供金融问题见解的金融 GPT。我们将使用 OpenAI Python SDK v1.2Tavily 搜索 API

首先,我们来定义助手的指令:

assistant_prompt_instruction = """You are a finance expert. 
Your goal is to provide answers based on information from the internet.
You must use the provided Tavily search API function to find relevant online information.
You should never use your own knowledge to answer questions.
Please include relevant url sources in the end of your answers.
"""

接下来,让我们完成步骤1,使用最新的 GPT-4 Turbo 模型(128K 上下文)创建一个助手,并使用 Tavily 网页搜索 API 调用函数。

# Create an assistant
assistant = client.beta.assistants.create(
instructions=assistant_prompt_instruction,
model="gpt-4-1106-preview",
tools=[{
"type": "function",
"function": {
"name": "tavily_search",
"description": "Get information on recent events from the web.",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "The search query to use. For example: 'Latest news on Nvidia stock performance'"},
},
"required": ["query"]
}
}
}]
)

第2步和第3步非常直接,我们将启动一个新的对话线程,并用一条用户消息来更新它。

thread = client.beta.threads.create()
user_input = input("You: ")
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=user_input,
)

最后,我们将在对话线程上运行助手,以触发函数调用并获取响应。

run = client.beta.threads.runs.create(
thread_id=thread.id,
assistant_id=assistant_id,
)

到目前为止一切顺利!但这里开始变得有点麻烦了。与常规的 GPT API 不同,助手 API 不会返回同步响应,而是返回一个状态。这允许在助手之间进行异步操作,但需要更多的开销来获取状态并手动处理每一个。

Status Diagram

为了管理这个状态生命周期,让我们构建一个可复用的函数来处理等待各种状态(例如‘requires_action’)的情况。

# Function to wait for a run to complete
def wait_for_run_completion(thread_id, run_id):
while True:
time.sleep(1)
run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)
print(f"Current run status: {run.status}")
if run.status in ['completed', 'failed', 'requires_action']:
return run

只要运行尚未最终完成(例如,状态为已完成或需要函数调用操作),此函数就会休眠。

我们快要完成了!最后,让我们来处理助手想要调用网页搜索 API 的情况。

# Function to handle tool output submission
def submit_tool_outputs(thread_id, run_id, tools_to_call):
tool_output_array = []
for tool in tools_to_call:
output = None
tool_call_id = tool.id
function_name = tool.function.name
function_args = tool.function.arguments

if function_name == "tavily_search":
output = tavily_search(query=json.loads(function_args)["query"])

if output:
tool_output_array.append({"tool_call_id": tool_call_id, "output": output})

return client.beta.threads.runs.submit_tool_outputs(
thread_id=thread_id,
run_id=run_id,
tool_outputs=tool_output_array
)

如上所示,如果助手判断应该触发函数调用,我们会提取所需的函数参数,并将其传回可运行的线程。我们捕捉到这个状态,并如下所示调用我们的函数:

if run.status == 'requires_action':
run = submit_tool_outputs(thread.id, run.id, run.required_action.submit_tool_outputs.tool_calls)
run = wait_for_run_completion(thread.id, run.id)

就这样!我们现在拥有一个可以工作的 OpenAI 助手,它能利用实时的在线信息来回答金融问题。以下是完整的可运行代码:

import os
import json
import time
from openai import OpenAI
from tavily import TavilyClient

# Initialize clients with API keys
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])

assistant_prompt_instruction = """You are a finance expert.
Your goal is to provide answers based on information from the internet.
You must use the provided Tavily search API function to find relevant online information.
You should never use your own knowledge to answer questions.
Please include relevant url sources in the end of your answers.
"""

# Function to perform a Tavily search
def tavily_search(query):
search_result = tavily_client.get_search_context(query, search_depth="advanced", max_tokens=8000)
return search_result

# Function to wait for a run to complete
def wait_for_run_completion(thread_id, run_id):
while True:
time.sleep(1)
run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)
print(f"Current run status: {run.status}")
if run.status in ['completed', 'failed', 'requires_action']:
return run

# Function to handle tool output submission
def submit_tool_outputs(thread_id, run_id, tools_to_call):
tool_output_array = []
for tool in tools_to_call:
output = None
tool_call_id = tool.id
function_name = tool.function.name
function_args = tool.function.arguments

if function_name == "tavily_search":
output = tavily_search(query=json.loads(function_args)["query"])

if output:
tool_output_array.append({"tool_call_id": tool_call_id, "output": output})

return client.beta.threads.runs.submit_tool_outputs(
thread_id=thread_id,
run_id=run_id,
tool_outputs=tool_output_array
)

# Function to print messages from a thread
def print_messages_from_thread(thread_id):
messages = client.beta.threads.messages.list(thread_id=thread_id)
for msg in messages:
print(f"{msg.role}: {msg.content[0].text.value}")

# Create an assistant
assistant = client.beta.assistants.create(
instructions=assistant_prompt_instruction,
model="gpt-4-1106-preview",
tools=[{
"type": "function",
"function": {
"name": "tavily_search",
"description": "Get information on recent events from the web.",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "The search query to use. For example: 'Latest news on Nvidia stock performance'"},
},
"required": ["query"]
}
}
}]
)
assistant_id = assistant.id
print(f"Assistant ID: {assistant_id}")

# Create a thread
thread = client.beta.threads.create()
print(f"Thread: {thread}")

# Ongoing conversation loop
while True:
user_input = input("You: ")
if user_input.lower() == 'exit':
break

# Create a message
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=user_input,
)

# Create a run
run = client.beta.threads.runs.create(
thread_id=thread.id,
assistant_id=assistant_id,
)
print(f"Run ID: {run.id}")

# Wait for run to complete
run = wait_for_run_completion(thread.id, run.id)

if run.status == 'failed':
print(run.error)
continue
elif run.status == 'requires_action':
run = submit_tool_outputs(thread.id, run.id, run.required_action.submit_tool_outputs.tool_calls)
run = wait_for_run_completion(thread.id, run.id)

# Print messages from the thread
print_messages_from_thread(thread.id)

这个助手可以通过使用额外的检索信息、OpenAI 的代码解释器等功能进行进一步的定制和改进。此外,您还可以添加更多的函数工具,让助手变得更智能。

如果您有任何其他问题,请随时在下方留言!

我们如何构建 GPT Researcher

·7分钟阅读
Assaf Elovic
GPT Researcher 和 Tavily 的创建者

AutoGPT 发布后,我们立即对其进行了试用。首先想到的用例是自主在线研究。对于手动研究任务,要形成客观的结论可能需要花费大量时间,有时甚至需要数周才能找到合适的资源和信息。看到 AutoGPT 如何出色地创建和执行任务,让我开始思考利用人工智能进行全面研究的巨大潜力,以及这对未来在线研究的意义。

但 AutoGPT 的问题在于它通常会陷入无限循环,几乎每一步都需要人为干预,不断失去对其进度的追踪,而且几乎从未真正完成任务。

尽管如此,在研究任务期间收集的信息和上下文都丢失了(例如,没有跟踪来源),有时还会产生幻觉。

利用人工智能进行在线研究的热情以及我发现的局限性,促使我踏上了一项使命,即尝试解决这个问题,同时与世界分享我的工作。就在那时,我创建了 GPT Researcher——一个用于在线全面研究的开源自主智能体。

在本文中,我们将分享引导我走向所提出解决方案的步骤。

从无限循环到确定性结果

解决这些问题的第一步是寻求一个更具确定性的解决方案,该方案最终能够保证在固定的时间范围内完成任何研究任务,而无需人为干预。

就在这时,我们偶然发现了最近的一篇论文《规划与解决》。该论文旨在为上述挑战提供更好的解决方案。这个想法非常简单,由两个部分组成:首先,制定一个计划,将整个任务分解为更小的子任务,然后根据计划执行这些子任务。

Planner-Excutor-Model

就研究而言,首先创建一个与任务相关的问题大纲,然后为每个大纲项目确定性地执行一个智能体。这种方法通过将智能体步骤分解为一组确定的有限任务,消除了任务完成中的不确定性。一旦所有任务完成,智能体就结束研究。

遵循这一策略,完成研究任务的可靠性提高到了100%。现在的挑战是,如何提高质量和速度?

追求客观和无偏见的结果

大语言模型(LLM)最大的挑战是缺乏事实性和无偏见的响应,这是由幻觉和过时的训练集(GPT 目前基于 2021 年的数据集进行训练)造成的。但讽刺的是,对于研究任务来说,优化的恰恰是这两个标准:事实性和偏见。

为了应对这些挑战,我们做了以下假设

  • 大数定律——更多的内容将导致更少偏见的结果。尤其是在收集得当的情况下。
  • 利用大语言模型对事实信息进行总结,可以显著提高结果的整体事实性。

在对大语言模型进行了相当长时间的实验后,我们可以说,基础模型擅长的领域是对给定内容进行总结和重写。因此,理论上,如果大语言模型只审查给定内容并对其进行总结和重写,可能会显著减少幻觉。

此外,假设给定的内容是无偏见的,或者至少包含了某主题各方的观点和信息,那么重写的结果也将是无偏见的。那么内容如何才能无偏见呢?大数定律。换句话说,如果抓取足够多的包含相关信息的网站,那么信息有偏见的可能性就会大大降低。所以想法是,抓取足够多的网站,以形成对任何主题的客观意见。

太好了!听起来,我们现在有了一个如何创建既确定、又真实、又无偏见的结果的想法。但是速度问题呢?

加快研究进程

AutoGPT 的另一个问题是它同步工作。其主要思想是创建一个任务列表,然后逐一执行。因此,如果一个研究任务需要访问 20 个网站,而每个网站的抓取和总结大约需要一分钟,那么整个研究任务至少需要 20 多分钟。这还是在它最终会停止的前提下。但如果我们能够并行化智能体的工作呢?

通过利用 Python 的 asyncio 等库,代理任务已得到优化,可以并行工作,从而显著减少了研究时间。

# Create a list to hold the coroutine agent tasks
tasks = [async_browse(url, query, self.websocket) for url in await new_search_urls]

# Gather the results as they become available
responses = await asyncio.gather(*tasks, return_exceptions=True)

在上面的例子中,我们并行触发所有 URL 的抓取,只有在全部完成后,才继续执行任务。根据多次测试,一个平均的研究任务大约需要三分钟(!!)。这比 AutoGPT 快了 85%。

完成研究报告

最后,在收集了尽可能多关于给定研究任务的信息之后,挑战在于撰写一份关于它的综合报告。

在尝试了几个 OpenAI 模型甚至开源模型后,我得出结论,目前使用 GPT-4 能获得最好的结果。任务很简单——向 GPT-4 提供所有聚合信息作为上下文,并要求它根据原始研究任务撰写一份详细报告。

提示如下

"{research_summary}" Using the above information, answer the following question or topic: "{question}" in a detailed report — The report should focus on the answer to the question, should be well structured, informative, in depth, with facts and numbers if available, a minimum of 1,200 words and with markdown syntax and apa format. Write all source urls at the end of the report in apa format. You should write your report only based on the given information and nothing else.

结果相当令人印象深刻,只有极少数样本中出现了轻微的幻觉,但可以合理地假设,随着 GPT 的不断改进,结果只会越来越好。

最终架构

既然我们已经回顾了 GPT Researcher 的必要步骤,现在让我们来分解一下最终的架构,如下所示

更具体地说

  • 生成一份研究问题大纲,以形成对任何给定任务的客观意见。
  • 对于每个研究问题,触发一个爬虫代理,从在线资源中抓取与给定任务相关的信息。
  • 对于每个抓取的资源,进行跟踪、过滤,并且只有在包含相关信息时才进行总结。
  • 最后,汇总所有总结的来源,并生成一份最终的研究报告。

展望未来

在线研究自动化的未来正朝着一个重大颠覆的方向发展。随着人工智能的不断进步,AI 智能体能够为我们日常的任何需求执行全面的研究任务只是时间问题。AI 研究可以颠覆金融、法律、学术、健康和零售等领域,将我们每次研究的时间减少 95%,同时在不断增长的海量在线信息中优化事实性和无偏见的报告。

想象一下,如果一个人工智能最终能够理解和分析任何形式的在线内容——视频、图像、图表、表格、评论、文本、音频。再想象一下,如果它能够在单个提示中支持和分析数十万字的聚合信息。甚至想象一下,人工智能最终能够在推理和分析方面有所提高,使其更适合得出新的、创新的研究结论。而且它能在几分钟甚至几秒钟内完成所有这些工作。

这一切都只是时间问题,也正是 GPT Researcher 的意义所在。