LangChain GPT Researcher
1.0.0
Alat peneliti LocalGPTResearcher dan WebGPTResearcher dirancang untuk membantu melakukan penelitian menyeluruh tentang topik atau kueri tertentu. Alat-alat ini memanfaatkan kekuatan model GPT untuk menghasilkan laporan terperinci, membuatnya ideal untuk berbagai tugas terkait penelitian. Alat LocalGPTResearcher mengakses file data lokal, sedangkan WebGPTResearcher mengambil informasi dari web.
LocalGPTResearcher dapat bekerja dengan berbagai format file lokal seperti PDF, dokumen Word, CSV, dan banyak lagi.WebGPTResearcher mengambil data langsung dari internet, membuatnya cocok untuk pengumpulan informasi terkini.Pastikan Anda menginstal Python 3 di sistem Anda.
Pasang paket yang diperlukan menggunakan PIP:
pip install gpt-researcher Untuk LocalGPTResearcher , Anda perlu mengatur variabel lingkungan berikut:
export DOC_PATH=/path/to/your/documents
export OPENAI_API_KEY=your-openai-api-key
export TAVILY_API_KEY=your-tavily-api-key Untuk WebGPTResearcher , hanya dibutuhkan OPENAI_API_KEY dan TAVILY_API_KEY :
export OPENAI_API_KEY=your-openai-api-key
export TAVILY_API_KEY=your-tavily-api-key Contoh ini menunjukkan cara menggunakan LocalGPTResearcher untuk menghasilkan laporan berdasarkan dokumen lokal.
from libs . community . langchain_community . tools . gpt_researcher . tool import LocalGPTResearcher # This will be changed after successful PR
# Initialize the tool
researcher_local = LocalGPTResearcher ( report_type = "research_report" )
# You can also define it as `researcher_local = LocalGPTResearcher()` - default report_type is research_report.
# Run a query
query = "What is the demographics of Apple inc look like?"
report = researcher_local . invoke ({ "query" : query })
print ( "Generated Report:" , report ) Contoh ini menunjukkan cara menggunakan WebGPTResearcher untuk menghasilkan laporan berdasarkan data web.
from libs . community . langchain_community . tools . gpt_researcher . tool import WebGPTResearcher # This will be changed after successful PR
# Initialize the tool
researcher_web = WebGPTResearcher ( report_type = "research_report" ) # report_type="research_report" is optional as the default value is `research_report`
# Run a query
query = "What are the latest advancements in AI?"
report = researcher_web . invoke ({ "query" : query })
print ( "Generated Report:" , report )AgentExecutor dengan WebGPTResearcherMari kita lihat bagaimana membangun pembungkus agen yang menggunakan LLM dan alat kami untuk menulis esai dan memberikan kutipan/tanda tangan di akhir laporan.
from libs . community . langchain_community . tools . gpt_researcher . tool import WebGPTResearcher # This will be changed after successful PR
from langchain import hub
from langchain_core . tools import Tool
from langchain . agents import AgentExecutor , create_react_agent
from langchain . tools import tool
from langchain_openai import ChatOpenAI
# Let us see how to use the WebGPTResearcher tool along with AgentExecutor to perform a grand task with decision making.
# 1. Let us build a Reactive Agent who takes decisions based on reasoning.
# 2. Let us give our agent 2 tools - WebGPTResearcher and a dummy tool that provides a signature at the end of the text
# 3. We can then wrap our agent and tools inside an AgentExecutor object and ask our question!
# The expectation is the response must be signed at the end after a long report on a research topic.
# Create a new tool called citation_provider.
@ tool
def citation_provider ( text : str ) -> str :
"""Provides a citation or signature"""
return " n - Written by GPT-Makesh n Thanks for reading! n "
# Create the WebGPTResearcher tool
researcher_web = WebGPTResearcher ( "research_report" )
# Initialize tools and components
tools = [
researcher_web ,
Tool (
name = "citation_tool" ,
func = citation_provider ,
description = "Useful for when you need to add citation or signature at the end of text" ,
),
]
# Create an LLM
llm = ChatOpenAI ( model = "gpt-4o" )
prompt = hub . pull ( "hwchase17/react" )
# Create the ReAct agent using the create_react_agent function
agent = create_react_agent (
llm = llm ,
tools = tools ,
prompt = prompt ,
stop_sequence = True ,
)
# Wrap the components inside an AgentExecutor
agent_executor = AgentExecutor . from_agent_and_tools ( agent = agent , tools = tools , verbose = True )
# Run the agent
question = "What are the recent advancements in AI? Provide a citation for your report too."
response = agent_executor . invoke ({ "input" : question })
print ( "Agent Response:" , response )WebGPTResearcherMari kita membangun rantai runnables yang memiliki peneliti yang menulis laporan dan siswa kelas yang kemudian menilai dan mencetak laporan.
from libs . community . langchain_community . tools . gpt_researcher . tool import WebGPTResearcher
from langchain . prompts import ChatPromptTemplate
from langchain . schema . output_parser import StrOutputParser
from langchain . schema . runnable import RunnableLambda
from langchain_openai import ChatOpenAI
# Let us use WebGPTResearcher to grade the essay using LECL langchain Chaining tricks
# 1. Use the researcher to write an essay
# 2. Pass it as a chat_prompt_template (a runnable) to a grader to score the essay
# 3. Parse the output as a string
# Create a ChatOpenAI model
grader = ChatOpenAI ( model = "gpt-4o" )
researcher_tool = WebGPTResearcher ()
prompt_template = ChatPromptTemplate . from_messages (
[
( "system" , "You are a essay grader. Give score out of 10 in brief" ),
( "human" , "The essay: {essay}" ),
]
)
# Define our WebGPTResearcher tool as a RunnableLambda
researcher = RunnableLambda ( lambda x : researcher_tool . invoke ( x ))
# Create the combined chain using LangChain Expression Language (LCEL)
chain = researcher | prompt_template | grader | StrOutputParser ()
# Run the chain
result = chain . invoke ({ "query" : "What are the recent advancements in AI?" })
# Output
print ( result )BaseGPTResearcher Anda dapat membuat alat khusus dengan memperluas kelas BaseGPTResearcher . Inilah contohnya:
from libs . community . langchain_community . tools . gpt_researcher . tool import WebGPTResearcher
class CustomGPTResearcher ( BaseGPTResearcher ):
name = ""
description = ""
def __init__ ( self , report_type : ReportType = ReportType . RESEARCH ):
super (). __init__ ( report_type = report_type , report_source = "web" )
# Override or extend methods as needed (You need to implement `_run()` method, `_arun()` is optional)Referensi API: (alat peneliti GPT) [tautan]
Anda dapat mendefinisikan alat GPTR khusus seperti yang ditunjukkan di bawah ini:
import asyncio
from typing import Optional , Type
from langchain_core . callbacks import CallbackManagerForToolRun
from langchain_core . pydantic_v1 import BaseModel , Field
from langchain_core . tools import BaseTool
from gpt_researcher import GPTResearcher
class GPTRInput ( BaseModel ):
"""Input schema for the GPT-Researcher tool."""
query : str = Field ( description = "The search query for the research" )
class MyGPTResearcher ( BaseTool ):
name : str = "custom_gpt_researcher"
description : str = "Base tool for researching and producing detailed information about a topic or query using the internet."
args_schema : Type [ BaseModel ] = GPTRInput
async def get_report ( self , query : str ) -> str :
try :
researcher = GPTResearcher (
query = query ,
report_type = "research_report" ,
report_source = "web" ,
verbose = False
)
await researcher . conduct_research ()
report = await researcher . write_report ()
return report
except Exception as e :
raise ValueError ( f"Error generating report: { str ( e ) } " )
def _run (
self ,
query : str ,
run_manager : Optional [ CallbackManagerForToolRun ] = None
) -> str :
answer = asyncio . run ( self . get_report ( query = query ))
answer += " n n - By GPT-Makesh. n Thanks for reading!"
return answer
my_researcher = MyGPTResearcher ()
report = my_researcher . invoke ({ "query" : "What are the recent advancements in AI?" })
print ( report )Atau, Anda dapat secara langsung menggunakan alat yang disediakan tanpa modifikasi di luar rak.
from libs . community . langchain_community . tools . gpt_researcher . tool import WebGPTResearcher , LocalGPTResearcher
# Use LocalGPTResearcher
researcher_local = LocalGPTResearcher ( report_type = "research_report" )
report = researcher_local . invoke ({ 'query' : "What can you tell about the company?" })
# Use WebGPTResearcher
researcher_web = WebGPTResearcher ( report_type = "research_report" )
report = researcher_web . invoke ({ 'query' : "What are the latest advancements in AI?" })gpt-4o-mini dan gpt-4o (konteks 128K) hanya jika diperlukan. Tugas penelitian rata -rata memakan waktu sekitar 3 menit dan biaya sekitar $ 0,005.Kami menyambut kontribusi untuk meningkatkan dan memperluas alat peneliti GPT. Kunjungi repositori GitHub untuk memulai dengan berkontribusi.
