TL;DR

GPT Researcher is an autonomous agent that runs a full research workflow - plan questions, crawl the web, summarize sources, and write a cited report - on any topic you give it. Key highlights:

  • 29K+ GitHub stars, Apache-2.0, Python, created May 2023 and still actively maintained (last push July 2026)
  • Planner + executor architecture: one agent decomposes your query into sub-questions, parallel agents gather sources, a publisher aggregates the report
  • Provider-agnostic: works with OpenAI, Anthropic, Google, Groq, Ollama, and any OpenAI-compatible endpoint
  • Real citations: aggregates 20+ sources per report and tracks each claim back to its origin
  • Deep Research mode: recursive tree-of-thought exploration that trades cost and time for depth
  • Multiple surfaces: Python pip package, REST API, a lightweight web UI, an MCP server, and a Claude Skill

Install with pip install gpt-researcher, set an LLM key plus a TAVILY_API_KEY, and you have a self-hosted deep research pipeline in minutes.

What is GPT Researcher?

Deep research has become the flagship feature of every major AI lab - OpenAI, Google, Anthropic, and Perplexity all ship a “research mode” that spends minutes instead of seconds to produce a long, cited answer. GPT Researcher is the open-source project that got there first, and it remains the most popular self-hosted option.

Built by Assaf Elovic, GPT Researcher is described in its own words as “the first open deep research agent designed for both web and local research on any given task.” Instead of a single LLM call, it orchestrates a small team of agents: a planner that reasons about what to investigate, execution agents that go find the information, and a publisher that assembles everything into a coherent, referenced report.

The design is explicitly inspired by two research papers - Plan-and-Solve prompting and Retrieval-Augmented Generation (RAG) - and it targets the failure modes that plague naive LLM research: hallucination from outdated training data, token limits that cap report length, and bias from a narrow set of sources.

If you have ever wanted OpenAI’s Deep Research or Perplexity’s research mode but running on your own infrastructure, with your own model and your own search backend, this is the closest open-source equivalent.

Architecture: how it actually works

The core idea is a split between planner and execution agents. Here is the pipeline it runs for every query:

  1. Create a task-specific agent tuned to your research query.
  2. Generate research questions - a set of sub-questions that together form an objective view of the topic.
  3. Dispatch crawler agents to gather information for each question in parallel.
  4. Summarize and source-track every resource it reads, keeping a reference for each fact.
  5. Filter and aggregate the summaries into a final report that exceeds 2,000 words.

The parallelism is the important part. Because each sub-question is researched concurrently, GPT Researcher is meaningfully faster than agents that crawl sequentially, and the source-tracking step is what gives you citations you can actually verify rather than confident-sounding fabrications.

There are two research depths worth understanding:

  • Standard research aggregates roughly 20 sources for a broad, well-rounded report. Good default, predictable cost.
  • Deep Research (a recursive workflow added in a later release) explores the topic with agentic depth and breadth - it spins up sub-research trees, following threads that look promising. It produces richer reports but costs more tokens and takes longer.

Code examples

The pip package

The fastest way to embed research into your own app is the Python package:

pip install gpt-researcher
from gpt_researcher import GPTResearcher
import asyncio

async def run():
    query = "why is Nvidia stock going up?"
    researcher = GPTResearcher(query=query)
    # Conduct research on the given query
    await researcher.conduct_research()
    # Write the report
    report = await researcher.write_report()
    print(report)

asyncio.run(run())

Two environment variables get you running:

export OPENAI_API_KEY="sk-..."
export TAVILY_API_KEY="tvly-..."   # default web retriever

Tavily is the default search retriever, but you are not locked in - GPT Researcher supports a long list of retrievers including DuckDuckGo (no key), Google, Bing, SearchAPI, SerpAPI, Exa, and local document search.

Running the full stack

If you want the web UI and REST API rather than a library, clone and boot the server:

git clone https://github.com/assafelovic/gpt-researcher.git
cd gpt-researcher
pip install -r requirements.txt
python -m uvicorn main:app --reload

Then visit http://localhost:8000 and type a query into the frontend, which streams progress as the agents work and lets you export the finished report to PDF, Word, or Markdown.

Hybrid web + MCP research

One of the more powerful 2026-era additions is MCP (Model Context Protocol) support, which lets the researcher pull from private data sources alongside the open web:

from gpt_researcher import GPTResearcher
import asyncio, os

async def mcp_research_example():
    os.environ["RETRIEVER"] = "tavily,mcp"  # hybrid web + MCP
    researcher = GPTResearcher(
        query="What are the top open source web research agents?",
        mcp_configs=[
            {
                "name": "github",
                "command": "npx",
                "args": ["-y", "@modelcontextprotocol/server-github"],
                "env": {"GITHUB_TOKEN": os.getenv("GITHUB_TOKEN")},
            }
        ],
    )
    await researcher.conduct_research()
    return await researcher.write_report()

asyncio.run(mcp_research_example())

This is the pattern that makes GPT Researcher interesting for real teams: point it at your GitHub, a database, or an internal API through MCP, and it will blend proprietary context with live web sources in one report.

As a Claude Skill

If you live inside Claude, you can bolt GPT Researcher on directly:

npx skills add assafelovic/gpt-researcher

Once installed, Claude can invoke GPT Researcher’s deep-research loop from inside a normal conversation - a neat example of the tool meeting users where they already are.

Configuration and model flexibility

GPT Researcher is refreshingly un-opinionated about which model you use. Because it speaks the OpenAI-compatible API shape, you can route it through:

  • OpenAI / Azure OpenAI - the default, best-tested path
  • Anthropic Claude - strong for the writing/summarization stage
  • Google Gemini - including AI-generated inline images via the Nano Banana image model for report illustrations
  • Groq - fast, cheap inference for the many small summarization calls
  • Ollama and local models - fully offline research if you pair it with a keyless retriever like DuckDuckGo
# Point at any OpenAI-compatible endpoint (local models, alt providers)
export OPENAI_BASE_URL="http://localhost:11434/v1"

A common cost optimization: use a cheap, fast model for the dozens of “smart” summarization calls and a stronger model only for the final “strategic” report-writing step. GPT Researcher exposes both roles separately in its config, so you are not paying frontier prices for boilerplate summarization.

Community reactions

GPT Researcher has real staying power, which is rare in the AI-agent space where projects spike and die within a quarter.

In a widely upvoted r/LocalLLaMA roundup of local research tools (May 2026), the author concluded that “the most healthiest and local-friendly projects are ‘GPT Researcher’ by assafelovic and ‘Local Deep Research’ by LearningCircuit” - notable praise given how many deep-research clones exist now.

An independent comparison of open-source deep research agents (August 2026) singled out GPT Researcher’s maturity: 28,868 stars, 3,911 forks, Apache-2.0, created in 2023 and still shipping. In a field full of six-week-old repos, that track record matters when you are betting infrastructure on a tool.

The GitHub Discussions are active and honest. A recurring theme: output quality is excellent with the default OpenAI setup, but users who swap to smaller local models (one tester used a 120B GPT variant on Ollama) report a noticeable quality drop. That is not a knock on GPT Researcher so much as a reminder that a research agent is only as good as the model driving it.

The maintainers have also been responsive to cost complaints - a “Deep Research 2.0” update explicitly refined the recursive workflow to be “faster, smarter, and more cost-effective” in response to feedback, which is the kind of iteration you want to see.

Honest limitations

No tool is magic. GPT Researcher has real trade-offs you should know before adopting it:

  • Cost adds up fast. A single Deep Research run fans out into many LLM and search calls. Standard reports are cheap; recursive deep runs on a frontier model can cost real money per report. Budget accordingly and cap depth for routine queries.
  • Search retriever is a dependency. The default Tavily retriever needs an API key and has its own quota and pricing. You can switch to DuckDuckGo for free, but result quality and rate limits differ.
  • Local models underperform. As the community notes, the pipeline shines with strong hosted models. If you require fully offline operation, expect a quality gap versus GPT-5-class or Claude-class models.
  • It is a framework, not a polished product. The web UI is functional but lightweight; this is a self-hosted tool for developers, not a consumer app. Expect to read docs and set environment variables.
  • Web research inherits the web’s biases. Source-tracking helps, but the agent can only be as objective as the sources it can reach. Garbage sources in, confidently-cited garbage out.
  • Open issue count is non-trivial (~177 open at the time of writing), which is normal for a project this size but means you will occasionally hit rough edges on newer features.

Who should use it?

Good fit:

  • Developers who want OpenAI/Perplexity-style deep research but self-hosted, with their own model and search backend
  • Teams that need research blended with private data via MCP
  • Anyone building a product that needs an embeddable research step (the pip package makes this trivial)
  • Privacy-sensitive workflows that can run local models with a keyless retriever

Poor fit:

  • Non-technical users who want a one-click consumer app (use the hosted research modes instead)
  • Cost-sensitive users who cannot monitor per-report token spend on deep runs
  • Fully offline setups that also demand frontier-grade report quality

FAQ

Is GPT Researcher free? The software is free and open-source under Apache-2.0. You pay for the LLM API calls and, if you use the default Tavily retriever, for search API usage. Pair it with Ollama plus DuckDuckGo and you can run it at near-zero marginal cost, at some quality cost.

How is it different from OpenAI’s Deep Research or Perplexity? Those are closed, hosted products. GPT Researcher gives you the same category of workflow - plan, crawl, cite, report - but self-hosted, model-agnostic, and extensible via MCP. You trade polish for control and portability.

What LLMs does it support? Anything with an OpenAI-compatible API: OpenAI, Azure, Anthropic, Google Gemini, Groq, Ollama, and custom endpoints via OPENAI_BASE_URL. You can even use different models for summarization versus final report writing to control cost.

Does it work offline? Partially. Use a local model through Ollama and a keyless retriever like DuckDuckGo. It will run without external API keys, but expect lower report quality than hosted frontier models.

Can I use it inside my own app? Yes. pip install gpt-researcher, instantiate GPTResearcher(query=...), call conduct_research() then write_report(). There is also a REST API and an MCP server for integration with agents and IDEs.

What is “Deep Research” mode? A recursive research workflow that explores a topic with agentic depth and breadth, spinning up sub-research trees for promising threads. It produces richer reports than standard mode but costs more tokens and takes longer.

The bottom line

GPT Researcher is the deep-research agent to reach for when you want the capability without surrendering your model choice, your data, or your infrastructure to a closed vendor. Three years of maintenance, 29K stars, a clean planner/executor architecture, real citations, and first-class MCP support make it the mature, credible option in a crowded field.

It is not a consumer app, and deep runs will cost you tokens - but for developers and teams building research into their own workflows, GPT Researcher remains the open-source default for a reason.

Repo: github.com/assafelovic/gpt-researcher