deep_researchLABSCO SUMMARY
Research that arrives already filtered.
A plain search tool hands back raw results and spends your context window on the irrelevant ones. This does the filtering first and returns what survived, with the sources attached.
What it is
The GPT Researcher agent exposed over MCP. It explores and validates many sources on its own, keeps only what holds up, and returns the findings with the sources behind them. A deep run takes around 30 seconds.
What you get
- Deep research on a topic: many sources explored and validated, only the relevant and trusted ones kept
- A fast web search for the questions where speed matters more than depth
- The gathered research context on its own, so the material can feed your own reasoning
- The list of sources behind a piece of research, for checking or citing
- A written report built from research already done, rather than from a fresh search
Requirements
Python with the repository's requirements installed, plus two keys in your client config: one for OpenAI and one for Tavily. Both services bill you directly for what the research consumes.
Setup effort
Build from source — git clone https://github.com/assafelovic/gptr-mcp.git
USE CASES
01
Getting to the bottom of an unfamiliar topic
One question, one autonomous pass over many sources, and an answer built only from what held up. Slower than a search call, and the difference shows in the result.
02
Checking a claim before you repeat it
Run the research, then ask for the sources behind it and read them yourself.
03
Writing the report after the research is done
Turn a completed run into a written report without paying for the search a second time.
04
Looking something up quickly
A fast search for the times a 30-second deep run is more than the question deserves.
05
Feeding findings into your own analysis
Take the gathered context out on its own and reason over it, rather than accepting someone else's summary.
5 tools
Listed in project docs. Your client may show a different list.
quick_searchwrite_reportget_research_sourcesget_research_contextBEFORE YOU INSTALL
What to know first
Tools you get
5 tools named in the project's documentation.
Requires
- Python 3.11 or higher
- An OpenAI API key (OPENAI_API_KEY)
- A Tavily API key (TAVILY_API_KEY)
INSTALLATION
Connect your client
You clone this one yourself.
Server setup
TERMINAL
git clone https://github.com/assafelovic/gptr-mcp.git
cd gptr-mcp
pip install -r requirements.txtNeeds Python 3.11 or higher, an OpenAI API key and a Tavily API key. Then add the entry for your client below
MCP Clients
Claude Desktop
CLAUDE DESKTOP · JSON
{
"mcpServers": {
"gptr-mcp": {
"command": "python",
"args": [
"<YOUR_PATH_TO_GPTR_MCP>/server.py"
],
"env": {
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>",
"TAVILY_API_KEY": "<YOUR_TAVILY_API_KEY>"
}
}
}
}Claude Desktop — wrapper script
Put your keys in .env first (cp .env.example .env, then edit OPENAI_API_KEY and TAVILY_API_KEY), and make the script executable with chmod +x.
Create run_gptr_mcp.sh in the clone
CLAUDE DESKTOP — WRAPPER SCRIPT · TERMINAL
#!/bin/bash
source <YOUR_PATH_TO_GPTR_MCP>/.env
python <YOUR_PATH_TO_GPTR_MCP>/server.pyThen use it in Claude Desktop
CLAUDE DESKTOP — WRAPPER SCRIPT · JSON
{
"mcpServers": {
"gptr-mcp": {
"command": "<YOUR_PATH_TO_GPTR_MCP>/run_gptr_mcp.sh"
}
}
}n8n — SSE via Docker network
Build and start the container on a shared Docker network
Run in the clone, after creating .env from .env.example with your keys.
N8N — SSE VIA DOCKER NETWORK · TERMINAL
docker build -t gptr-mcp .
docker run -d --name gptr-mcp -p 8000:8000 --env-file .env gptr-mcp
docker network create n8n-mcp-net
docker network connect n8n-mcp-net gptr-mcpIn n8n, connect to the SSE endpoint
n8n must be attached to the same n8n-mcp-net network; the container name is the hostname. The container uses SSE transport automatically.
N8N — SSE VIA DOCKER NETWORK · URL
http://gptr-mcp:8000/sse
