GPT Researcher

Realiza pesquisas autônomas e aprofundadas, explorando e validando múltiplas fontes para fornecer informações relevantes e atualizadas.

GitHub

371

Experimente este MCPPatrocinado

Documentação

🔍 GPT Researcher MCP Server

Por que GPT Researcher MCP?

Embora aplicativos de LLM possam acessar ferramentas de busca na web com MCP, o GPT Researcher MCP entrega resultados de pesquisa aprofundada. Ferramentas de busca padrão retornam resultados brutos que exigem filtragem manual, frequentemente contendo fontes irrelevantes e desperdiçando espaço da janela de contexto.

O GPT Researcher explora e valida autonomamente inúmeras fontes, focando apenas em informações relevantes, confiáveis e atualizadas. Embora seja um pouco mais lento que a busca padrão (~30 segundos de espera), ele entrega:

✨ Informações de maior qualidade
📊 Uso otimizado de contexto
🔎 Resultados abrangentes
🧠 Melhor raciocínio para LLMs

💻 Claude Desktop Demo

https://github.com/user-attachments/assets/ef97eea5-a409-42b9-8f6d-b82ab16c52a8

🚀 Início Rápido com Claude Desktop

Quer usar isso com o Claude Desktop imediatamente? Aqui está o caminho mais rápido:

Instale as dependências:

git clone https://github.com/assafelovic/gptr-mcp.git
pip install -r requirements.txt

Configure seu Claude Desktop em ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "gptr-mcp": {
      "command": "python",
      "args": ["/absolute/path/to/gpt-researcher/gptr-mcp/server.py"],
      "env": {
        "OPENAI_API_KEY": "your-openai-key-here",
        "TAVILY_API_KEY": "your-tavily-key-here"
      }
    }
  }
}

Reinicie o Claude Desktop e comece a pesquisar! 🎉

Para instruções detalhadas de configuração, veja a seção completa de Integração com Claude Desktop abaixo.

Recursos

research_resource: Obtenha recursos web relacionados a uma determinada tarefa por meio de pesquisa.

Ferramentas Principais

deep_research: Realiza pesquisa web aprofundada sobre um tópico, encontrando as informações mais confiáveis e relevantes
quick_search: Realiza uma busca web rápida otimizada para velocidade em vez de qualidade, retornando resultados de busca com trechos. Suporta qualquer recuperador web suportado pelo GPTR, como Tavily, Bing, Google, etc... Saiba mais aqui
write_report: Gere um relatório com base nos resultados da pesquisa
get_research_sources: Obtenha as fontes usadas na pesquisa
get_research_context: Obtenha o contexto completo da pesquisa

Prompts

research_query: Crie um prompt de consulta de pesquisa

Pré-requisitos

Antes de executar o servidor MCP, certifique-se de ter:

Python 3.11 ou superior instalado
- Importante: GPT Researcher >=0.12.16 requer Python 3.11+
Chaves de API para os serviços que você planeja usar:
- OpenAI API key
- Tavily API key

Você também pode conectar outros mecanismos de busca web ou MCP usando recuperadores suportados pelo GPTR. Confira a documentação aqui

⚙️ Instalação

Clone o repositório do GPT Researcher:

git clone https://github.com/assafelovic/gpt-researcher.git
cd gpt-researcher

Instale as dependências do gptr-mcp:

cd gptr-mcp
pip install -r requirements.txt

Configure suas variáveis de ambiente:
- Copie o arquivo .env.example para criar um novo arquivo chamado .env:
```
cp .env.example .env
```
- Edite o arquivo .env e adicione suas chaves de API e configure outras configurações:
```
OPENAI_API_KEY=your_openai_api_key
TAVILY_API_KEY=your_tavily_api_key
```

Você também pode adicionar qualquer outra variável de ambiente para sua configuração do GPT Researcher.

🚀 Executando o Servidor MCP

Você pode executar o servidor MCP de várias maneiras:

Método 1: Diretamente usando Python

python server.py

Método 2: Usando a CLI do MCP (se instalada)

mcp run server.py

Método 3: Usando Docker (recomendado para produção)

Início Rápido

A maneira mais simples de executar com Docker:

# Build and run with docker-compose
docker-compose up -d

# Or manually:
docker build -t gptr-mcp .
docker run -d \
  --name gptr-mcp \
  -p 8000:8000 \
  --env-file .env \
  gptr-mcp

Para Integração com n8n

Se você precisar se conectar a uma rede n8n existente:

# First, start the container
docker-compose up -d

# Then connect to your n8n network
docker network connect n8n-mcp-net gptr-mcp

# Or create a shared network first
docker network create n8n-mcp-net
docker network connect n8n-mcp-net gptr-mcp

Nota: A imagem Docker usa Python 3.11 para atender aos requisitos do gpt-researcher >=0.12.16. Se você encontrar erros durante a construção, certifique-se de estar usando o Dockerfile mais recente deste repositório.

Quando o servidor estiver em execução, você verá uma saída indicando que o servidor está pronto para aceitar conexões. Você pode verificar se está funcionando:

Endpoint SSE: Acesse o endpoint Server-Sent Events em http://localhost:8000/sse para obter um ID de sessão
Comunicação MCP: Use o ID de sessão para enviar mensagens MCP para http://localhost:8000/messages/?session_id=YOUR_SESSION_ID
Teste: Execute o script de teste com python test_mcp_server.py

Importante para Integração Docker/n8n:

O servidor vincula-se a 0.0.0.0:8000 para funcionar com contêineres Docker
Usa transporte SSE para comunicação MCP baseada na web
O gerenciamento de sessão requer obter um ID de sessão do endpoint /sse primeiro
Cada conexão de cliente precisa de um ID de sessão único para comunicação adequada

🚦 Modos de Transporte e Melhores Práticas

O servidor MCP do GPT Researcher suporta múltiplos protocolos de transporte e escolhe automaticamente o melhor para o seu ambiente:

Tipos de Transporte

Transporte	Caso de Uso	Quando Usar
STDIO	Claude Desktop, clientes MCP locais	Padrão para desenvolvimento local
SSE	Docker, clientes web, integração n8n	Habilitado automaticamente no Docker
Streamable HTTP	Implantações web modernas	Implantações web avançadas

Detecção Automática

O servidor detecta automaticamente seu ambiente:

# Local development (default)
python server.py
# ➜ Uses STDIO transport (Claude Desktop compatible)

# Docker environment  
docker run gptr-mcp
# ➜ Auto-detects Docker, uses SSE transport

# Manual override
export MCP_TRANSPORT=sse
python server.py
# ➜ Forces SSE transport

Variáveis de Ambiente

Variável	Descrição	Padrão	Exemplo
`MCP_TRANSPORT`	Forçar transporte específico	`stdio`	`sse`, `streamable-http`
`DOCKER_CONTAINER`	Forçar modo Docker	Detectado automaticamente	`true`

Exemplos de Configuração

Para Claude Desktop (Local)

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "gpt-researcher": {
      "command": "python",
      "args": ["/absolute/path/to/server.py"],
      "env": {
         "..."
      }
    }
  }
}

Para Implantação Docker/Web

# Set transport explicitly for web deployment
export MCP_TRANSPORT=sse
python server.py

# Or use Docker (auto-detects)
docker-compose up -d

Para Integração MCP com n8n

# Use the container name as hostname
docker run --name gptr-mcp -p 8000:8000 gptr-mcp

# In n8n, connect to: http://gptr-mcp:8000/sse

Endpoints de Transporte

Ao usar transportes SSE ou HTTP:

Health Check: GET /health
Endpoint SSE: GET /sse (obter ID de sessão)
Mensagens MCP: POST /messages/?session_id=YOUR_SESSION_ID

Melhores Práticas

Desenvolvimento Local: Use STDIO padrão para Claude Desktop
Produção: Use Docker com detecção automática de SSE
Teste: Use endpoints de saúde para verificar a conectividade
Integração n8n: Sempre use rede de contêineres com Docker
Implantação Web: Considere Streamable HTTP para clientes modernos

Integrando com Claude

Você pode integrar seu servidor MCP com Claude usando:

Integração com Claude Desktop - Para uso com o aplicativo de desktop Claude no Mac

Para instruções detalhadas, siga o link acima.

💻 Integração com Claude Desktop

Para integrar seu servidor MCP em execução local com Claude para Mac, você precisará:

Certifique-se de que o servidor MCP está instalado e em execução
Configure o Claude Desktop:
- Localize ou crie o arquivo de configuração em ~/Library/Application Support/Claude/claude_desktop_config.json
- Adicione seu servidor MCP local do GPT Researcher à configuração com variáveis de ambiente
- Reinicie o Claude para aplicar a configuração

⚠️ Importante: Variáveis de Ambiente Necessárias

O Claude Desktop inicia seu servidor MCP como um subprocesso separado, então você deve passar explicitamente suas chaves de API na configuração. O servidor não pode acessar as variáveis de ambiente do seu shell ou o arquivo .env automaticamente.

Exemplo de Configuração

{
  "mcpServers": {
    "gptr-mcp": {
      "command": "python",
      "args": ["/absolute/path/to/your/server.py"],
      "env": {
        "OPENAI_API_KEY": "your-actual-openai-key-here",
        "TAVILY_API_KEY": "your-actual-tavily-key-here"
      }
    }
  }
}

Nota de Segurança

🔒 Sua configuração do Claude Desktop contém chaves de API sensíveis. Proteja-a:

chmod 600 ~/Library/Application\ Support/Claude/claude_desktop_config.json

Nunca envie este arquivo para controle de versão.

Alternativa: Script de Variáveis de Ambiente

Para melhor segurança, crie um script wrapper:

run_gptr_mcp.sh:

#!/bin/bash
source /path/to/your/.env
python /absolute/path/to/server.py

Depois use-o no Claude Desktop:

{
  "mcpServers": {
    "gptr-mcp": {
      "command": "/absolute/path/to/run_gptr_mcp.sh"
    }
  }
}

Para instruções completas passo a passo, veja o guia de Integração com Claude Desktop.

📝 Exemplo de Uso com Claude

User: I'm considering investing in NVIDIA. Can you research the current state of the company, recent stock performance, latest product announcements, and analyst opinions?

Claude: I'll help you research NVIDIA for investment purposes. This will take a moment as I conduct deep research to find the most up-to-date information about their stock performance, recent developments, and expert analysis.

[Claude uses deep_research tool - this takes 30-40 seconds]

Claude: Based on my research, here's a comprehensive analysis of NVIDIA's current state:

## NVIDIA (NVDA) Current Status

### Recent Stock Performance
- Current price: $942.89 (as of my research)
- YTD performance: +90.4% 
- 52-week range: $460.30 - $974.00
- Market cap: ~$2.32 trillion

### Recent Key Developments
1. **Blackwell AI Platform**: At GTC 2024, NVIDIA unveiled the Blackwell architecture, their next-generation AI chip platform promising 4x performance improvement over Hopper. Major cloud providers (AWS, Google, Microsoft) have already committed to integrating Blackwell.

2. **Q1 FY2025 Earnings (May 2024)**: 
   - Revenue: $26.0 billion (+262% YoY)
   - Data Center revenue: $22.6 billion (+427% YoY)
   - Gross margin: 78.4%
   - Announced 10-for-1 stock split effective June 7, 2024

3. **Supply Chain Expansion**: Increased investments in manufacturing capacity with TSMC to address ongoing chip shortages for their high-demand AI GPUs.

### Analyst Consensus
- Strong Buy consensus with 37 analysts rating it "Buy," 5 "Hold," and 0 "Sell"
- Average price target: $1,042 (post-split adjusted: $104.20)
- Key bull thesis: Continued AI infrastructure spending and NVIDIA's dominant position in AI chips
- Key bear concerns: Valuation, potential competition from AMD, Intel, and custom silicon from tech giants

### Industry Position
- Dominant in AI GPU market with estimated 80-90% market share
- Expanding ecosystem through CUDA software platform and industry partnerships
- Diversifying beyond chips with DGX Cloud, AI software platforms, and automotive solutions

🔧 Solução de Problemas

Se você encontrar problemas ao executar o servidor MCP:

Problemas Gerais

Chaves de API: Certifique-se de que suas chaves de API estão configuradas corretamente no arquivo .env
Versão do Python: Verifique se você está usando Python 3.11 ou superior (exigido pelo gpt-researcher >=0.14.0)
Dependências: Certifique-se de que todas as dependências estão instaladas corretamente: pip install -r requirements.txt
Logs do Servidor: Verifique os logs do servidor para mensagens de erro

Problemas com Docker

Contêiner não acessível:
- Verifique se o contêiner está em execução: docker ps | grep gptr-mcp
- Verifique os logs do contêiner: docker logs gptr-mcp
- Confirme que o servidor está vinculado a 0.0.0.0:8000 (os logs devem mostrar isso)
Problemas de Integração com n8n:
- Certifique-se de que ambos os contêineres estão na mesma rede Docker
- Use o nome do contêiner gptr-mcp como hostname no n8n
- Defina a URL do servidor MCP para: http://gptr-mcp:8000/sse
Problemas com ID de Sessão:
- O servidor usa transporte SSE que requer gerenciamento de sessão
- Primeiro, obtenha um ID de sessão conectando-se ao endpoint /sse
- Use o ID de sessão em solicitações MCP subsequentes: /messages/?session_id=YOUR_ID
- Cada cliente precisa do seu próprio ID de sessão

Etapas de Integração MCP com n8n

Obter ID de Sessão:

curl http://gptr-mcp:8000/sse
# Look for: data: /messages/?session_id=XXXXX

Inicializar MCP:

curl -X POST http://gptr-mcp:8000/messages/?session_id=YOUR_SESSION_ID \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {"roots": {"listChanged": true}}, "clientInfo": {"name": "n8n-client", "version": "1.0.0"}}}'

Chamar Ferramentas:

curl -X POST http://gptr-mcp:8000/messages/?session_id=YOUR_SESSION_ID \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "quick_search", "arguments": {"query": "test"}}}'

Testando o Servidor

Execute o script de teste incluído para verificar a funcionalidade:

python test_mcp_server.py

Isso testará:

Conexão SSE e recuperação de ID de sessão
Inicialização do MCP
Descoberta e execução de ferramentas

Problemas com Claude Desktop

Se seu servidor MCP não está funcionando com o Claude Desktop:

Servidor não aparecendo no Claude:
- Verifique se a sintaxe do seu claude_desktop_config.json é JSON válido
- Certifique-se de estar usando caminhos absolutos (não relativos)
- Verifique se o caminho para server.py está correto
- Reinicie o Claude Desktop completamente
Erro "OPENAI_API_KEY não encontrada":
- Certifique-se de que você adicionou chaves de API à seção env na sua configuração
- Não esqueça ambas OPENAI_API_KEY e TAVILY_API_KEY
- As chaves de API devem ser as chaves reais, não espaços reservados
Ferramentas não aparecendo:
- Procure o ícone de ferramentas 🔧 no Claude Desktop
- Verifique se o arquivo de configuração do Claude Desktop está no local correto:
  - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  - Windows: %APPDATA%\Claude\claude_desktop_config.json
Problemas de Python/Permissões:
- Certifique-se de que o Python está acessível pela linha de comando: python --version
- Tente usar o caminho completo do Python: "command": "/usr/bin/python3" ou "command": "python3"
- Verifique as permissões de arquivo no seu arquivo server.py
Ainda não funciona?
- Teste o servidor manualmente: python server.py (deve mostrar mensagem de transporte STDIO)
- Verifique os logs do Claude Desktop (se disponíveis)
- Tente o método de script alternativo da seção de integração acima

👣 Próximos Passos

Explore a documentação do protocolo MCP para entender melhor como integrar com Claude
Aprenda sobre os recursos principais do GPT Researcher para aprimorar suas capacidades de pesquisa
Confira o guia de Uso Avançado para mais opções de configuração

📄 Licença

Este projeto está licenciado sob a Licença MIT - consulte o arquivo LICENSE para detalhes.

📞 Suporte / Contato

Community Discord
Email: assaf.elovic@gmail.com

⬆️ Voltar ao Topo