Servidor MCP: Investigador profundo de Ollama

Esta es una adaptación del servidor del Protocolo de Contexto de Modelo (MCP) de LangChain Ollama Deep Researcher . Proporciona las capacidades de investigación profunda de las herramientas MCP, que pueden utilizarse dentro del ecosistema del Protocolo de Contexto de Modelo, lo que permite a los asistentes de IA realizar investigaciones exhaustivas sobre temas utilizando LLM locales a través de Ollama.

Funcionalidad principal

El servidor proporciona capacidades de investigación a través de herramientas y recursos MCP, utilizando cualquier LLM alojado por Ollama .

Proceso de investigación

Dado un tema, se realizará lo siguiente:

Generar una consulta de búsqueda web
Recopile resultados de búsqueda web a través de la API de Tavily o Perplexity
Resumir los resultados de la búsqueda
Reflexione sobre el resumen para examinar las lagunas de conocimiento
Generar nuevas consultas de búsqueda para abordar las brechas
Mejorar iterativamente el resumen a través de múltiples ciclos de investigación
Proporcionar un resumen final de Markdown con todas las fuentes utilizadas

Prerrequisitos

Node.js (para ejecutar el servidor MCP)
- Descargar e instalar desde https://nodejs.org/
- Asegúrese de que Node.js esté agregado a la RUTA de su sistema
Python 3.10 o superior
Cálculo (CPU/GPU) capaz de ejecutar el modelo de Ollama seleccionado
Al menos 8 GB de RAM para ejecutar modelos de idiomas más grandes
Claves API requeridas:
- Clave API de Tavily (obtenga una en https://tavily.com )
- Clave API de Perplexity (obtenga una en https://perplexity.ai )
- Clave API de LangSmith (obtenga una en https://smith.langchain.com ) para seguimiento y monitoreo

Asegúrate de poder ejecutar Node.js y npm desde tu terminal o línea de comandos. Puedes verificar tus instalaciones con:

node --version
npm --version
python --version

Si estos comandos fallan, es posible que necesites:

Reinicie su terminal/computadora después de la instalación
Agregue Node.js a su sistema PATH:
- Windows: Editar variables de entorno del sistema → Variables de entorno → Ruta → Agregar directorio de instalación de Node.js
- macOS/Linux: Generalmente lo gestiona el instalador

Instalación

Opción 1: Instalación estándar

Descargue e instale Ollama para su plataforma
Clonar este repositorio e instalar las dependencias:

git clone https://github.com/Cam10001110101/mcp-server-ollama-deep-researcher
cd mcp-server-ollama-deep-researcher
npm install

Instalar dependencias de Python:

Primero, instale uv (recomendado para un mejor rendimiento y resolución de dependencias):

# Windows
pip install uv

# macOS/Linux
pip3 install uv

Luego instale las dependencias del proyecto usando pyproject.toml:

uv pip install .

Nota: Esto instalará el proyecto en modo editable con todas las dependencias especificadas en pyproject.toml. Si prefiere usar pip:

pip install .  # Windows
pip3 install .  # macOS/Linux

Construya el código TypeScript:

npm run build

Obtenga un LLM local de Ollama :

ollama pull deepseek-r1:8b

Opción 2: Instalación de Docker

También puede ejecutar el servidor MCP utilizando Docker, lo que simplifica el proceso de configuración.

Descargue e instale Docker para su plataforma
Clonar este repositorio:

git clone https://github.com/Cam10001110101/mcp-server-ollama-deep-researcher
cd mcp-server-ollama-deep-researcher

Crea un archivo .env con tus claves API (puedes copiar desde .env.example ):

cp .env.example .env
# Edit the .env file with your API keys

Hacer que el script auxiliar sea ejecutable:

chmod +x run-docker.sh

Construya y ejecute el contenedor Docker:

./run-docker.sh start

Asegúrese de que Ollama se esté ejecutando en su máquina host:

ollama pull deepseek-r1:8b  # or your preferred model
ollama serve

Los scripts auxiliares proporcionan varios comandos:

Para macOS/Linux (usando run-docker.sh):

./run-docker.sh start - Construye e inicia el contenedor Docker
./run-docker.sh stop - Detiene el contenedor Docker
./run-docker.sh restart - Reinicia el contenedor Docker
./run-docker.sh logs : muestra los registros del contenedor Docker
./run-docker.sh status - Verifica el estado del contenedor Docker
./run-docker.sh help - Mostrar mensaje de ayuda

Para Windows (usando run-docker.bat):

run-docker.bat start : compila e inicia el contenedor Docker
run-docker.bat stop - Detiene el contenedor Docker
run-docker.bat restart - Reinicia el contenedor Docker
run-docker.bat logs : muestra los registros del contenedor Docker
run-docker.bat status : verifica el estado del contenedor Docker
run-docker.bat help - Mostrar mensaje de ayuda

Nota: El contenedor Docker está configurado para conectarse a Ollama, que se ejecuta en su equipo host. Si también desea ejecutar Ollama en un contenedor, descomente el servicio Ollama en el archivo docker-compose.yml.

Configuración del cliente

Agregue el servidor a su configuración de cliente MCP:

Para la aplicación de escritorio Claude:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Ventanas: %APPDATA%\Claude\claude_desktop_config.json

Para Cline (extensión VS Code):

Windows: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Opción 1: Configuración de instalación estándar

{
  "mcpServers": {
    "ollama-deep-researcher": {
      "command": "node",
      "args": ["path/to/mcp-server-ollama-deep-researcher/build/index.js"],
      "env": {
        "LANGSMITH_TRACING": "true",
        "LANGSMITH_ENDPOINT": "https://api.smith.langchain.com",
        "LANGSMITH_API_KEY": "your-langsmith-key",
        "LANGSMITH_PROJECT": "ollama-deep-researcher-mcp-server",
        "TAVILY_API_KEY": "your-tavily-key",  // Include tvly- prefix
        "PERPLEXITY_API_KEY": "your-perplexity-key",
        "PYTHONPATH": "path/to/mcp-server-ollama-deep-researcher/src"
      }
    }
  }
}

Nota: Reemplace las rutas con rutas absolutas para su sistema:

Windows: utilice C:\\Users\\username\\path\\to\\mcp-server-ollama-deep-researcher
macOS/Linux: Use /Users/username/path/to/mcp-server-ollama-deep-researcher

Para macOS/Linux, es posible que también desees agregar:

"PYTHONUNBUFFERED": "1"

Opción 2: Configuración de la instalación de Docker

Si está utilizando el contenedor Docker, puede configurar el cliente MCP para conectarse al contenedor en ejecución:

{
  "mcpServers": {
    "ollama-deep-researcher": {
      "command": "docker",
      "args": ["exec", "-i", "ollama-deep-researcher-mcp", "node", "build/index.js"],
      "env": {}
    }
  }
}

Esta configuración asume que el contenedor Docker está en ejecución. Las variables de entorno ya están configuradas en el contenedor Docker, por lo que no es necesario especificarlas en la configuración del cliente MCP.

Rastreo y Monitoreo

El servidor se integra con LangSmith para un seguimiento y monitoreo integral del proceso de investigación:

Operación Rastreo :
- Se rastrean todas las interacciones de LLM
- Se monitorizan las operaciones de búsqueda web
- Se realiza un seguimiento de los pasos del flujo de trabajo de investigación
Monitoreo del rendimiento :
- Tiempos de respuesta para cada operación
- Tasas de éxito/fracaso
- Utilización de recursos
Depuración y optimización :
- Rastreos detallados para la resolución de problemas
- Identificación de cuellos de botella en el rendimiento
- Información sobre optimización de consultas

Acceda a todos los rastros en https://smith.langchain.com bajo el nombre de proyecto configurado.

Recursos de MCP

Los resultados de la investigación se almacenan automáticamente como recursos MCP, lo que permite:

Acceso persistente
- Resultados accesibles a través de las URL research://{topic}
- Almacenamiento automático de investigaciones finalizadas
- Contenido en formato JSON con metadatos
Integración del panel de recursos
- La investigación aparece en el panel de recursos del cliente de MCP
- Fácil acceso a temas de investigación anteriores
- Marca de tiempo y descripción de cada resultado
Gestión del contexto
- Reutilización eficiente de la investigación en conversaciones
- Uso reducido de tokens mediante referencias de recursos
- Inclusión selectiva del contexto de investigación

Herramientas disponibles

Configurar

maxLoops : Número de iteraciones de investigación (1-5)
llmModel : modelo de Ollama a utilizar (p. ej., "deepseek-r1:1.5b", "llama3.2")
searchApi : API de búsqueda para usar ("perplejidad" o "tavily")

Configurar parámetros de investigación.

{
  "name": "configure",
  "arguments": {
    "maxLoops": 3,
    "llmModel": "deepseek-r1:1.5b",
    "searchApi": "tavily"
  }
}

Investigación

Investigue cualquier tema utilizando la búsqueda web y la síntesis LLM.

{
  "name": "research",
  "arguments": {
    "topic": "Austin LangChain, aimug.org"
  }
}

Obtener estado

Obtenga el estado actual de la investigación en curso.

{
  "name": "get_status",
  "arguments": {
    "_dummy": "dummy"
  }
}

Incitación

Uso de la API de búsqueda predeterminada, el modelo y las iteraciones máximas (bucles)

Ejemplo de propuesta: "Investigar aplicaciones que prioricen la IA"

Cambiar la configuración predeterminada e iniciar la investigación

Sintaxis: configure with <searchapi> and <model> then research <topic>
Ejemplo de mensaje: "Configure con perplejidad y deepseek-r1:8b, luego investigue aplicaciones de IA prioritarias".

El flujo de trabajo de investigación de Ollama

El proceso de investigación se inspira en IterDRAG . Este enfoque descompone una consulta en subconsultas, recupera documentos para cada una, responde a la subconsulta y, a partir de la respuesta, recupera documentos para la segunda subconsulta.

El proceso funciona de la siguiente manera:

Dado un tema proporcionado por el usuario, utilice un LLM local (a través de Ollama ) para generar una consulta de búsqueda web
Utiliza un motor de búsqueda (configurado para Tavily ) para encontrar fuentes relevantes
Utiliza LLM para resumir los hallazgos de la búsqueda web relacionados con el tema de investigación proporcionado por el usuario
Luego, utiliza el LLM para reflexionar sobre el resumen, identificando lagunas de conocimiento.
Genera una nueva consulta de búsqueda para abordar las brechas de conocimiento.
El proceso se repite y el resumen se actualiza iterativamente con nueva información de la búsqueda web.
Se repetirá en la madriguera del conejo de la investigación.
Se ejecuta durante un número configurable de iteraciones

Salidas

El resultado es un archivo Markdown que contiene el resumen de la investigación, con citas de todas las fuentes utilizadas durante el proceso de investigación.

Todas las fuentes recopiladas durante la investigación se conservan y se pueden referenciar en el resultado final:

Descripción general de la integración del sistema

Solución de problemas

Aquí encontrará soluciones a problemas comunes que podría encontrar:

Problemas de conexión de Ollama

Asegúrese de que Ollama se esté ejecutando: ejecute ollama list en su terminal
Intente ejecutar ollama en modo terminal cerrando la aplicación (Bandeja del sistema/Barra de menú) y ejecutando ollama serve
Comprueba si se puede acceder a Ollama en localhost:11434 , 0.0.0.0:11434 o 127.0.0.1:11434

Problemas con la clave API

Verifique que su clave API esté configurada correctamente en el archivo de configuración
Verifique que su ruta arg apunte a la ubicación real de index.js en este repositorio
Asegúrese de que no haya espacios ni comillas adicionales alrededor de la clave API
Comprueba si tu clave API tiene suficientes créditos/permisos

Problemas con el servidor MCP

Utilice el Inspector MCP para depurar:

npx @modelcontextprotocol/inspector node path/to/server/index.js --model llama3.2 --max-loops 3 --search-api tavily

Problemas con Docker

Si tienes problemas con el contenedor Docker:
- Comprueba si el contenedor se está ejecutando: docker ps
- Ver registros de contenedores: docker logs ollama-deep-researcher-mcp
- Asegúrese de que su archivo .env contenga claves API válidas
- Verifique que Ollama se esté ejecutando en su máquina host y sea accesible desde el contenedor
- Si usar host.docker.internal no funciona, intente usar la dirección IP de su máquina host en la variable de entorno OLLAMA_BASE_URL
- Para problemas de red entre contenedores, asegúrese de que estén en la misma red Docker
Si está ejecutando Ollama en un contenedor:
- Descomente el servicio Ollama en docker-compose.yml
- Asegúrese de que el contenedor Ollama tenga suficientes recursos asignados
- Extraiga el modelo en el contenedor Ollama: docker exec -it ollama ollama pull deepseek-r1:8b

Problemas de compilación

Si npm run build falla con el mensaje "'nodo' no se reconoce":
1. Asegúrese de que Node.js esté instalado correctamente
2. Agregue Node.js a su sistema PATH:
  - Windows: Editar variables de entorno del sistema → Variables de entorno → Ruta → Agregar directorio de instalación de Node.js
  - macOS/Linux: Generalmente lo gestiona el instalador
3. Reinicie su terminal/computadora
4. Intente ejecutar node --version para verificar la instalación

Problemas con Python

Ventanas:

Asegúrese de que Python esté en su PATH
Intente usar python en lugar de python3
Compruebe si pip está instalado: python -m pip --version

macOS/Linux:

Utilice python3 en lugar de python
Comprueba si pip está instalado: python3 -m pip --version
Es posible que necesites instalar pip: sudo apt install python3-pip (Ubuntu/Debian) o brew install python3 (macOS)

Manejo de errores

El servidor proporciona mensajes de error claros para:

Claves API faltantes o no válidas
Problemas de configuración
Problemas con la API de búsqueda
Errores de procesamiento de LLM

Mejoras necesarias

Reintegración y validación más estrictas de langgraph para casos de uso interesantes adicionales.

Arquitectura

Para obtener información detallada sobre la arquitectura y la implementación del servidor, consulte .context/index.md .

Insignia de Glama.ai

Ejemplo de transcripción de mensaje y salida

Inmediato

Configure with perplexity and deepseek-r1:8b then research AI-First Applications

Salida de configuración

{
  "searchApi": "perplexity",
  "llmModel": "deepseek-r1:8b",
  "maxLoops": 3
}

Resultados de la investigación de Ollama

Research configuration updated:
Max Loops: 3
LLM Model: deepseek-r1:8b
Search API: perplexity

### Complete Research Results

**Updated Summary: AI-First Applications in Healthcare: Focus on PathAI**

1. **Design Principles**:
   - PathAI exemplifies a data-driven approach by leveraging extensive datasets to train advanced AI models like PLUTO.
   - Collaboration is central to their success, integrating technology into clinical workflows through partnerships with institutions such as Cleveland Clinic.

2. **Industry Transformations**:
   - In healthcare, PathAI has significantly impacted diagnostic accuracy and efficiency. Their foundation model, PLUTO, demonstrates superior performance in various pathology tasks, outperforming existing models while reducing costs.
   - Collaborations with leading institutions have facilitated the creation of digital pathology data networks, enhancing research and clinical care.

3. **Scalability and Performance**:
   - PathAI's PLUTO model offers enhanced efficiency and compactness, significantly reducing training and inference costs.
   - This innovation underscores their commitment to scalable and effective solutions in healthcare.

4. **Growth and Impact**:
   - PathAI's growth strategy includes strategic partnerships and collaborations, such as their partnership with Cleveland Clinic and acquisition by Quest Diagnostics.
   - These moves accelerate AI and digital pathology adoption, particularly in cancer diagnosis.

This summary highlights PathAI's contributions to healthcare through innovative technology and strategic collaborations, emphasizing their role in driving advancements and improving patient outcomes.

## Sources

### Perplexity Search 1
1. https://intelifaz.com/insights/ai-first-software-design
2. https://www.uxdesigninstitute.com/blog/how-to-design-for-ai-first-products/
3. https://vux.world/ai-design-principles/
4. https://www.leanware.co/insights/ai-first-apps
5. https://adamfard.com/blog/ai-ux-design-framework
6. https://www.sgh.com/insight/artificial-intelligence-best-practices/
7. https://www.index.dev/blog/generative-ai-application-design-principles
8. https://onstrategyhq.com/resources/ai-guiding-principles/
9. https://orangematter.solarwinds.com/2024/04/29/introducing-ai-by-design-principles-for-responsible-ai/
10. https://principles.design/examples/10-principles-for-design-in-the-age-of-ai

### Perplexity Search 2
1. https://cloud.google.com/transform/101-real-world-generative-ai-use-cases-from-industry-leaders
2. https://www.cloudera.com/resources/the-art-of-the-possible/ai-first-benefits-5-real-world-outcomes.html
3. https://builtin.com/artificial-intelligence/examples-ai-in-industry
4. https://www.uxforai.com/p/the-rise-of-ai-first-products
5. https://www.1051theblaze.com/ai-first-mobile-apps/
6. https://www.techtarget.com/searchenterpriseai/tip/The-history-of-artificial-intelligence-Complete-AI-timeline
7. https://gitnation.com/contents/demystifying-ai-first-building-applications-for-the-future
8. https://fptsoftware.com/resource-center/blogs/the-ai-first-future-challenges-and-opportunities
9. https://online.maryville.edu/blog/history-of-ai/
10. https://www.audience.io/blog/artificial-intelligence-first-party-data-the-future-of-data

### Perplexity Search 3
1. https://monday.com/blog/rnd/technical-specification/
2. https://softwaremind.com/blog/8-steps-for-successful-software-implementation/
3. https://www.infotech.com/research/ss/build-your-enterprise-application-implementation-playbook
4. https://interactiveimmersive.io/blog/touchdesigner-lessons/04-technical-implementation-design/
5. https://www.indeed.com/career-advice/finding-a-job/technical-requirements
6. https://www.techtarget.com/searchcustomerexperience/definition/implementation
7. https://theobogroup.com/what-to-know-about-technical-implementations/
8. https://www.ntietz.com/blog/whats-behind-just-implementation/
9. https://public.cyber.mil/stigs/

### Perplexity Search 4
1. https://www.ittbiomed.com/transforming-pathology-with-ai/
2. https://www.pathai.com/resources/pathai-commences-new-year-with-strong-foundation-for-growth-following-key-2023-achievements-in-ai-powered-pathology-products-strategic-partnerships-and-leadership-team-hires/
3. https://canvasbusinessmodel.com/blogs/target-market/pathai-target-market
4. https://www.pathologynews.com/industry-news/pathai-launches-new-pathologist-centric-features-on-aisight-to-enable-efficient-case-review-through-intelligent-case-prioritization-and-real-time-multi-institutional-collaboration/
5. https://newsroom.clevelandclinic.org/2022/03/10/pathai-and-cleveland-clinic-announce-collaboration-to-build-digital-pathology-infrastructure-and-evolve-use-of-ai-powered-pathology-algorithms-in-research-and-clinical-care
6. https://academic.oup.com/jamia/article/30/9/1503/7174318
7. https://hitconsultant.net/2024/05/14/pathai-unveils-ai-foundation-model-built-for-disease-detection/
8. https://newsroom.questdiagnostics.com/2024-05-01-Quest-Diagnostics-to-Acquire-PathAI-Diagnostics-to-Accelerate-AI-and-Digital-Pathology-Adoption-in-Cancer-Diagnosis-Forms-Licensing-Agreements-with-PathAI
9. https://www.multimodal.dev/post/ai-in-healthcare
10. https://canvasbusinessmodel.com/blogs/growth-strategy/pathai-growth-strategy

Salida final de Claude

Key Principles of AI-First Applications:

1. Human-AI Collaboration
- Applications are designed with AI as a core component rather than an add-on
- Focus on augmenting human capabilities rather than replacing them
- Clear feedback loops between AI systems and human users

2. Data-Centric Architecture
- Built around robust data pipelines and continuous learning
- Strong emphasis on data quality and governance
- Scalable infrastructure to handle growing datasets

3. Adaptive User Experience
- Interfaces that evolve based on user interaction patterns
- Contextual awareness and personalization
- Clear communication of AI capabilities and limitations

Real-World Example: PathAI in Healthcare

Core Technology:
- PLUTO foundation model demonstrates superior performance in pathology tasks
- Focuses on efficiency and cost reduction while maintaining high accuracy
- Built for scalability and integration into existing workflows

Implementation Strategy:
- Strategic partnerships with healthcare institutions like Cleveland Clinic
- Creation of digital pathology data networks
- Focus on practical clinical applications and research

Impact:
- Improved diagnostic accuracy in cancer detection
- Enhanced efficiency in pathology workflows
- Reduced costs through optimized resource utilization

Best Practices for AI-First Applications:

1. Technical Implementation
- Start with clear use cases and success metrics
- Build robust data pipelines and validation processes
- Implement continuous monitoring and model updating

2. User Experience
- Design transparent interfaces that build trust
- Provide clear feedback on AI decisions and confidence levels
- Allow for human oversight and intervention

3. Integration and Scaling
- Focus on seamless integration with existing workflows
- Build scalable infrastructure from the start
- Plan for continuous improvement and iteration

Integrations