LangChain GPT Researcher
1.0.0
Les outils LocalGPTResearcher et WebGPTResearcher sont conçus pour aider à mener des recherches approfondies sur des sujets ou des requêtes spécifiques. Ces outils exploitent la puissance des modèles GPT pour générer des rapports détaillés, ce qui les rend idéaux pour diverses tâches liées à la recherche. L'outil LocalGPTResearcher accède aux fichiers de données locaux, tandis que le WebGPTResearcher récupère les informations du Web.
LocalGPTResearcher peut travailler avec divers formats de fichiers locaux tels que PDF, documents de mots, CSVS, etc.WebGPTResearcher récupère les données directement à partir d'Internet, ce qui le rend adapté à la collecte d'informations à jour.Assurez-vous que Python 3 soit installé sur votre système.
Installez les packages nécessaires à l'aide de PIP:
pip install gpt-researcher Pour LocalGPTResearcher , vous devez définir les variables d'environnement suivantes:
export DOC_PATH=/path/to/your/documents
export OPENAI_API_KEY=your-openai-api-key
export TAVILY_API_KEY=your-tavily-api-key Pour WebGPTResearcher , seuls les OPENAI_API_KEY et TAVILY_API_KEY sont nécessaires:
export OPENAI_API_KEY=your-openai-api-key
export TAVILY_API_KEY=your-tavily-api-key Cet exemple montre comment utiliser LocalGPTResearcher pour générer un rapport basé sur des documents locaux.
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 ) Cet exemple montre comment utiliser WebGPTResearcher pour générer un rapport basé sur les données 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 avec WebGPTResearcherVoyons comment construire un emballage d'agentExecutor qui utilise un LLM et notre outil pour rédiger un essai et fournir une citation / signature à la fin du rapport.
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 )WebGPTResearcherConstruisons une chaîne de couleurs qui ont un chercheur qui écrit un rapport et une niveleuse qui note et marque le rapport.
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 Vous pouvez créer des outils personnalisés en étendant la classe BaseGPTResearcher . Voici un exemple:
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)Référence de l'API: (outil de chercheur GPT) [Lien]
Vous pouvez définir un outil GPTR personnalisé comme indiqué ci-dessous:
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 )Alternativement, vous pouvez utiliser directement les outils fournis sans modification standard.
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 et gpt-4o (contexte 128k) uniquement lorsque cela est nécessaire. La tâche de recherche moyenne dure environ 3 minutes et coûte environ 0,005 $.Nous accueillons des contributions pour améliorer et étendre les outils de recherche GPT. Visitez le référentiel GitHub pour commencer avec la contribution.
