GPT Researcher

Realiza investigaciones autónomas y profundas explorando y validando múltiples fuentes para proporcionar información relevante y actualizada.

GitHub

371

Prueba este MCPPatrocinado

Documentación

🔍 Servidor MCP de GPT Researcher

¿Por qué GPT Researcher MCP?

Si bien las aplicaciones de LLM pueden acceder a herramientas de búsqueda web con MCP, GPT Researcher MCP ofrece resultados de investigación profunda. Las herramientas de búsqueda estándar devuelven resultados sin procesar que requieren filtrado manual, a menudo con fuentes irrelevantes y desperdiciando espacio en la ventana de contexto.

GPT Researcher explora y valida de forma autónoma numerosas fuentes, centrándose solo en información relevante, confiable y actualizada. Aunque es ligeramente más lento que la búsqueda estándar (~30 segundos de espera), ofrece:

✨ Información de mayor calidad
📊 Uso optimizado del contexto
🔎 Resultados exhaustivos
🧠 Mejor razonamiento para los LLM

💻 Demostración de Claude Desktop

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

🚀 Inicio rápido con Claude Desktop

¿Quieres usar esto con Claude Desktop de inmediato? Aquí está la ruta más rápida:

Instala las dependencias:

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

Configura tu archivo de configuración de Claude Desktop en ~/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"
      }
    }
  }
}

Reinicia Claude Desktop y ¡comienza a investigar! 🎉

Para instrucciones detalladas de configuración, consulta la sección completa de integración con Claude Desktop a continuación.

Recursos

research_resource: Obtén recursos web relacionados con una tarea determinada mediante investigación.

Herramientas principales

deep_research: Realiza una investigación web profunda sobre un tema, encontrando la información más confiable y relevante
quick_search: Realiza una búsqueda web rápida optimizada para velocidad sobre calidad, devolviendo resultados de búsqueda con fragmentos. Admite cualquier recuperador web compatible con GPTR, como Tavily, Bing, Google, etc. Obtén más información aquí
write_report: Genera un informe basado en los resultados de la investigación
get_research_sources: Obtén las fuentes utilizadas en la investigación
get_research_context: Obtén el contexto completo de la investigación

Prompts

research_query: Crea un prompt de consulta de investigación

Requisitos previos

Antes de ejecutar el servidor MCP, asegúrate de tener:

Python 3.11 o superior instalado
- Importante: GPT Researcher >=0.12.16 requiere Python 3.11+
Claves de API para los servicios que planeas usar:
- Clave de API de OpenAI
- Clave de API de Tavily

También puedes conectar cualquier otro motor de búsqueda web o MCP utilizando los recuperadores compatibles con GPTR. Consulta la documentación aquí

⚙️ Instalación

Clona el repositorio de GPT Researcher:

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

Instala las dependencias de gptr-mcp:

cd gptr-mcp
pip install -r requirements.txt

Configura tus variables de entorno:
- Copia el archivo .env.example para crear un nuevo archivo llamado .env:
```
cp .env.example .env
```
- Edita el archivo .env y agrega tus claves de API y configura otros ajustes:
```
OPENAI_API_KEY=your_openai_api_key
TAVILY_API_KEY=your_tavily_api_key
```

También puedes agregar cualquier otra variable de entorno para tu configuración de GPT Researcher.

🚀 Ejecutando el servidor MCP

Puedes ejecutar el servidor MCP de varias maneras:

Método 1: Directamente usando Python

python server.py

Método 2: Usando la CLI de MCP (si está instalada)

mcp run server.py

Método 3: Usando Docker (recomendado para producción)

Inicio rápido

La forma más sencilla de ejecutar con 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 integración con n8n

Si necesitas conectarte a una red 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: La imagen de Docker usa Python 3.11 para cumplir con los requisitos de gpt-researcher >=0.12.16. Si encuentras errores durante la compilación, asegúrate de usar el Dockerfile más reciente de este repositorio.

Una vez que el servidor esté en ejecución, verás una salida que indica que el servidor está listo para aceptar conexiones. Puedes verificar que funciona:

Endpoint SSE: Accede al endpoint de Server-Sent Events en http://localhost:8000/sse para obtener un ID de sesión
Comunicación MCP: Usa el ID de sesión para enviar mensajes MCP a http://localhost:8000/messages/?session_id=YOUR_SESSION_ID
Pruebas: Ejecuta el script de prueba con python test_mcp_server.py

Importante para la integración Docker/n8n:

El servidor se vincula a 0.0.0.0:8000 para funcionar con contenedores Docker
Usa transporte SSE para la comunicación MCP basada en web
La gestión de sesiones requiere obtener un ID de sesión del endpoint /sse primero
Cada conexión de cliente necesita un ID de sesión único para una comunicación adecuada

🚦 Modos de transporte y mejores prácticas

El servidor MCP de GPT Researcher admite múltiples protocolos de transporte y elige automáticamente el mejor para tu entorno:

Tipos de transporte

Transporte	Caso de uso	Cuándo usarlo
STDIO	Claude Desktop, clientes MCP locales	Predeterminado para desarrollo local
SSE	Docker, clientes web, integración n8n	Habilitado automáticamente en Docker
HTTP transmisible	Implementaciones web modernas	Implementaciones web avanzadas

Detección automática

El servidor detecta automáticamente tu entorno:

# 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

Variables de entorno

Variable	Descripción	Predeterminado	Ejemplo
`MCP_TRANSPORT`	Forzar transporte específico	`stdio`	`sse`, `streamable-http`
`DOCKER_CONTAINER`	Forzar modo Docker	Auto-detectado	`true`

Ejemplos de configuración

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 implementación 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 integración MCP con 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

Cuando se usan transportes SSE o HTTP:

Verificación de salud: GET /health
Endpoint SSE: GET /sse (obtener ID de sesión)
Mensajes MCP: POST /messages/?session_id=YOUR_SESSION_ID

Mejores prácticas

Desarrollo local: Usa STDIO predeterminado para Claude Desktop
Producción: Usa Docker con detección automática de SSE
Pruebas: Usa endpoints de salud para verificar la conectividad
Integración n8n: Usa siempre redes de contenedores con Docker
Implementación web: Considera HTTP transmisible para clientes modernos

Integración con Claude

Puedes integrar tu servidor MCP con Claude usando:

Integración con Claude Desktop - Para usar con la aplicación de escritorio de Claude en Mac

Para instrucciones detalladas, sigue el enlace anterior.

💻 Integración con Claude Desktop

Para integrar tu servidor MCP que se ejecuta localmente con Claude para Mac, necesitarás:

Asegurarte de que el servidor MCP esté instalado y en ejecución
Configurar Claude Desktop:
- Localiza o crea el archivo de configuración en ~/Library/Application Support/Claude/claude_desktop_config.json
- Agrega tu servidor MCP local de GPT Researcher a la configuración con variables de entorno
- Reinicia Claude para aplicar la configuración

⚠️ Importante: Variables de entorno requeridas

Claude Desktop inicia tu servidor MCP como un subproceso separado, por lo que debes pasar explícitamente tus claves de API en la configuración. El servidor no puede acceder a las variables de entorno de tu shell ni al archivo .env automáticamente.

Ejemplo de configuración

{
  "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 seguridad

🔒 Tu configuración de Claude Desktop contiene claves de API sensibles. Protégela:

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

Nunca envíes este archivo al control de versiones.

Alternativa: Script de variables de entorno

Para mayor seguridad, crea un script contenedor:

run_gptr_mcp.sh:

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

Luego úsalo en Claude Desktop:

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

Para instrucciones completas paso a paso, consulta la guía de integración con Claude Desktop.

📝 Ejemplo de uso con 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

🔧 Solución de problemas

Si encuentras problemas al ejecutar el servidor MCP:

Problemas generales

Claves de API: Asegúrate de que tus claves de API estén configuradas correctamente en el archivo .env
Versión de Python: Verifica que estés usando Python 3.11 o superior (requerido por gpt-researcher >=0.14.0)
Dependencias: Asegúrate de que todas las dependencias estén instaladas correctamente: pip install -r requirements.txt
Registros del servidor: Revisa los registros del servidor para ver mensajes de error

Problemas con Docker

Contenedor no accesible:
- Verifica que el contenedor esté en ejecución: docker ps | grep gptr-mcp
- Revisa los registros del contenedor: docker logs gptr-mcp
- Confirma que el servidor se esté vinculando a 0.0.0.0:8000 (los registros deberían mostrarlo)
Problemas de integración con n8n:
- Asegúrate de que ambos contenedores estén en la misma red Docker
- Usa el nombre del contenedor gptr-mcp como nombre de host en n8n
- Configura la URL del servidor MCP como: http://gptr-mcp:8000/sse
Problemas con el ID de sesión:
- El servidor usa transporte SSE que requiere gestión de sesiones
- Primero, obtén un ID de sesión conectándote al endpoint /sse
- Usa el ID de sesión en solicitudes MCP posteriores: /messages/?session_id=YOUR_ID
- Cada cliente necesita su propio ID de sesión

Pasos de integración MCP con n8n

Obtener ID de sesión:

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"}}}'

Llamar herramientas:

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"}}}'

Pruebas del servidor

Ejecuta el script de prueba incluido para verificar la funcionalidad:

python test_mcp_server.py

Esto probará:

Conexión SSE y obtención de ID de sesión
Inicialización de MCP
Descubrimiento y ejecución de herramientas

Problemas con Claude Desktop

Si tu servidor MCP no funciona con Claude Desktop:

El servidor no aparece en Claude:
- Verifica que tu sintaxis claude_desktop_config.json sea JSON válido
- Asegúrate de usar rutas absolutas (no relativas)
- Verifica que la ruta a server.py sea correcta
- Reinicia Claude Desktop por completo
Error "OPENAI_API_KEY no encontrada":
- Asegúrate de haber agregado las claves de API a la sección env en tu configuración
- No olvides ambas OPENAI_API_KEY y TAVILY_API_KEY
- Las claves de API deben ser las claves reales, no marcadores de posición
Las herramientas no aparecen:
- Busca el ícono de herramientas 🔧 en Claude Desktop
- Verifica que el archivo de configuración de Claude Desktop esté en la ubicación correcta:
  - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  - Windows: %APPDATA%\Claude\claude_desktop_config.json
Problemas de Python/Permisos:
- Asegúrate de que Python sea accesible desde la línea de comandos: python --version
- Intenta usar la ruta completa de Python: "command": "/usr/bin/python3" o "command": "python3"
- Verifica los permisos de archivo en tu archivo server.py
¿Aún no funciona?
- Prueba el servidor manualmente: python server.py (debería mostrar el mensaje de transporte STDIO)
- Revisa los registros de Claude Desktop (si están disponibles)
- Prueba el método de script alternativo de la sección de integración anterior

👣 Próximos pasos

Explora la documentación del protocolo MCP para comprender mejor cómo integrarte con Claude
Aprende sobre las características principales de GPT Researcher para mejorar tus capacidades de investigación
Consulta la guía de Uso avanzado para más opciones de configuración

📄 Licencia

Este proyecto está licenciado bajo la Licencia MIT: consulta el archivo LICENSE para más detalles.

📞 Soporte / Contacto

Discord de la comunidad
Correo electrónico: assaf.elovic@gmail.com

⬆️ Volver arriba