servidor atlas-mcp

ATLAS: Sistema de gestión de tareas

ATLAS (Adaptive Task & Logic Automation System) es un sistema de gestión de proyectos, conocimientos y tareas para agentes LLM.

Construido sobre una arquitectura de tres niveles:

                  +------------------------------------------+
                  |                PROJECT                   |
                  |------------------------------------------|
                  | id: string                               |
                  | name: string                             |
                  | description: string                      |
                  | status: string                           |
                  | urls?: Array<{title: string, url: string}>|
                  | completionRequirements: string           |
                  | outputFormat: string                     |
                  | taskType: string                         |
                  | createdAt: string                        |
                  | updatedAt: string                        |
                  +----------------+-------------------------+
                            |                    |
                            |                    |
                            v                    v
+----------------------------------+ +----------------------------------+
|               TASK               | |            KNOWLEDGE             |
|----------------------------------| |----------------------------------|
| id: string                       | | id: string                       |
| projectId: string                | | projectId: string                |
| title: string                    | | text: string                     |
| description: string              | | tags?: string[]                  |
| priority: string                 | | domain: string                   |
| status: string                   | | citations?: string[]             |
| assignedTo?: string              | | createdAt: string                |
| urls?: Array<{title: string,     | |                                  |
|   url: string}>                  | | updatedAt: string                |
| tags?: string[]                  | |                                  |
| completionRequirements: string   | |                                  |
| outputFormat: string             | |                                  |
| taskType: string                 | |                                  |
| createdAt: string                | |                                  |
| updatedAt: string                | |                                  |
+----------------------------------+ +----------------------------------+

Implementado como un servidor de Protocolo de Contexto de Modelo (MCP), ATLAS permite a los agentes LLM interactuar con una base de datos de gestión de proyectos, lo que les permite administrar proyectos, tareas y elementos de conocimiento.

Nota importante sobre la versión : La versión 1.5.4 es la última que utiliza SQLite como base de datos. A partir de la versión 2.0, se ha reescrito completamente para usar Neo4j, lo que requiere:
Autohospedaje mediante Docker (docker-compose incluido en el repositorio)
Uso del servicio en la nube AuraDB de Neo4j: https://neo4j.com/product/auradb/
La versión 2.5.0 introduce un nuevo sistema de 3 nodos (Proyectos, Tareas, Conocimiento) que reemplaza la estructura anterior.

Tabla de contenido

Descripción general
Características
Instalación
Ejecución del servidor
Interfaz de usuario web (experimental)
Configuración
Estructura del proyecto
Herramientas
Recursos
Copia de seguridad y restauración de bases de datos
Ejemplos
Licencia

Descripción general

ATLAS implementa el Protocolo de Contexto de Modelo (MCP), lo que permite una comunicación estandarizada entre LLM y sistemas externos a través de:

Clientes : Claude Desktop, IDE y otros clientes compatibles con MCP
Servidores : herramientas y recursos para la gestión de proyectos, tareas y conocimientos
Agentes LLM : modelos de IA que aprovechan las capacidades de gestión del servidor

Integración de sistemas

La Plataforma Atlas integra estos componentes en un sistema cohesivo:

Relación proyecto-tarea : Los proyectos contienen tareas que representan pasos prácticos necesarios para alcanzar los objetivos del proyecto. Las tareas heredan el contexto de su proyecto principal y, al mismo tiempo, proporcionan un seguimiento detallado de cada elemento de trabajo.
Integración de conocimientos : tanto los proyectos como las tareas pueden enriquecerse con elementos de conocimiento, proporcionando a los miembros del equipo la información y el contexto necesarios.
Gestión de dependencias : tanto los proyectos como las tareas admiten relaciones de dependencia, lo que permite flujos de trabajo complejos con prerrequisitos y requisitos de ejecución secuencial.
Búsqueda unificada : la plataforma ofrece capacidades de búsqueda entre entidades, lo que permite a los usuarios encontrar proyectos, tareas o conocimientos relevantes según diversos criterios.

Características

Gestión de proyectos

Seguimiento integral: administre metadatos del proyecto, estados y contenido enriquecido (notas, enlaces, etc.) con soporte integrado para operaciones masivas.
Manejo de dependencias y relaciones: valide y realice un seguimiento automático de las dependencias entre proyectos.

Gestión de tareas

Gestión del ciclo de vida de las tareas: cree, realice un seguimiento y actualice tareas durante todo su ciclo de vida.
Priorización y categorización: asigne niveles de prioridad y categorice las tareas con etiquetas para una mejor organización.
Seguimiento de dependencias: establezca dependencias de tareas para crear flujos de trabajo estructurados.

Gestión del conocimiento

Repositorio de conocimiento estructurado: mantener un repositorio de búsqueda de información relacionada con el proyecto.
Categorización de dominios: organice el conocimiento por dominio y etiquetas para una fácil recuperación.
Soporte de citas: realice un seguimiento de las fuentes y referencias de elementos de conocimiento.

Integración de bases de datos gráficas

Gestión de relaciones nativas: aproveche las transacciones compatibles con ACID y las consultas optimizadas de Neo4j para lograr una integridad de datos sólida.
Búsqueda avanzada y escalabilidad: realice búsquedas basadas en propiedades con coincidencias aproximadas y comodines manteniendo un alto rendimiento.

Búsqueda unificada

Búsqueda entre entidades: encuentre proyectos, tareas o conocimientos relevantes según el contenido, los metadatos o las relaciones.
Opciones de consulta flexibles: compatibilidad con opciones de filtrado avanzado, difuso y sin distinción entre mayúsculas y minúsculas.

Instalación

Clonar el repositorio:
git clone https://github.com/cyanheads/atlas-mcp-server.git cd atlas-mcp-server
Instalar dependencias:
npm install
Configurar Neo4j: Asegúrate de tener una instancia de Neo4j ejecutándose y accesible. Puedes iniciarla usando la configuración de Docker proporcionada:
docker-compose up -d
Actualice su archivo .env con los detalles de conexión de Neo4j (ver Configuración ).
Construir el proyecto:
npm run build

Ejecución del servidor

La mayoría de los clientes MCP ejecutan el servidor automáticamente, pero también puede ejecutarlo manualmente para fines de prueba o desarrollo utilizando los siguientes comandos.

El servidor ATLAS MCP admite múltiples mecanismos de transporte para la comunicación:

E/S estándar (stdio): este es el modo predeterminado y normalmente se utiliza para la integración directa con clientes MCP locales (como extensiones IDE).
npm run start:stdio
Para ello se utiliza la configuración MCP_TRANSPORT_TYPE=stdio .
HTTP transmitible: este modo permite que el servidor escuche solicitudes MCP a través de HTTP, lo que resulta adecuado para clientes remotos o integraciones basadas en web.
npm run start:http
Esto utiliza la configuración MCP_TRANSPORT_TYPE=http . El servidor escuchará en el host y el puerto definidos en su archivo .env (p. ej., MCP_HTTP_HOST y MCP_HTTP_PORT , con el valor predeterminado 127.0.0.1:3010 ). Asegúrese de que su firewall permita las conexiones si accede remotamente.

Interfaz de usuario web (experimental)

Está disponible una interfaz de usuario web básica para ver detalles de proyectos, tareas y conocimientos.

Abriendo la interfaz de usuario :
- Para abrir la interfaz de usuario directamente en su navegador, ejecute el siguiente comando en su terminal:
  npm run webui
Funcionalidad :
- Puedes ver una captura de pantalla de ejemplo de la interfaz de usuario web aquí .

Configuración

Variables de entorno

Las variables de entorno deben configurarse en la configuración del cliente en su cliente MCP, o en un archivo .env en la raíz del proyecto para el desarrollo local.

# Neo4j Configuration
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=password2

# Application Configuration
MCP_LOG_LEVEL=debug # Minimum logging level. Options: emerg, alert, crit, error, warning, notice, info, debug. Default: "debug".
LOGS_DIR=./logs # Directory for log files. Default: "./logs" in project root.
NODE_ENV=development # 'development' or 'production'. Default: "development".

# MCP Transport Configuration
MCP_TRANSPORT_TYPE=stdio # 'stdio' or 'http'. Default: "stdio".
MCP_HTTP_HOST=127.0.0.1 # Host for HTTP transport. Default: "127.0.0.1".
MCP_HTTP_PORT=3010 # Port for HTTP transport. Default: 3010.
# MCP_ALLOWED_ORIGINS=http://localhost:someport,https://your-client.com # Optional: Comma-separated list of allowed origins for HTTP CORS.

# MCP Security Configuration
# MCP_AUTH_SECRET_KEY=your_very_long_and_secure_secret_key_min_32_chars # Optional: Secret key (min 32 chars) for JWT authentication if HTTP transport is used. CRITICAL for production. *Note: Production environment use has not been tested yet.*
MCP_RATE_LIMIT_WINDOW_MS=60000 # Rate limit window in milliseconds. Default: 60000 (1 minute).
MCP_RATE_LIMIT_MAX_REQUESTS=100 # Max requests per window per IP for HTTP transport. Default: 100.

# Database Backup Configuration
BACKUP_MAX_COUNT=10 # Maximum number of backup sets to keep. Default: 10.
BACKUP_FILE_DIR=./atlas-backups # Directory where backup files will be stored (relative to project root). Default: "./atlas-backups".

# OpenRouter LLM Configuration (Optional - additional parameters present in `src/config/index.ts`)
# OPENROUTER_API_KEY=your_openrouter_api_key # API key for OpenRouter services.
LLM_DEFAULT_MODEL="google/gemini-2.5-flash-preview:thinking" # Default LLM model.

Consulte src/config/index.ts para conocer todas las variables de entorno disponibles, sus descripciones y valores predeterminados.

Configuración del cliente MCP

La configuración de su cliente MCP depende del propio cliente y del tipo de transporte seleccionado. Algunos clientes (como mcp-inspector ) pueden usar un archivo mcp.json en la raíz del proyecto para definir las configuraciones del servidor; actualícelas según sea necesario.

Para el transporte de Stdio (configuración de ejemplo):

{
  "mcpServers": {
    "atlas-mcp-server-stdio": {
      "command": "node",
      "args": ["/full/path/to/atlas-mcp-server/dist/index.js"],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USER": "neo4j",
        "NEO4J_PASSWORD": "password2",
        "MCP_LOG_LEVEL": "info",
        "NODE_ENV": "production",
        "MCP_TRANSPORT_TYPE": "stdio"
      }
    }
  }
}

Para HTTP Streamable (configuración de ejemplo): si su cliente admite la conexión a un servidor MCP a través de HTTP Streamable, debe proporcionar el punto final del servidor (por ejemplo, http://localhost:3010/mcp ) en la configuración de su cliente.

{
  "mcpServers": {
    "atlas-mcp-server-http": {
      "command": "node",
      "args": ["/full/path/to/atlas-mcp-server/dist/index.js"],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USER": "neo4j",
        "NEO4J_PASSWORD": "password2",
        "MCP_LOG_LEVEL": "info",
        "NODE_ENV": "production",
        "MCP_TRANSPORT_TYPE": "http",
        "MCP_HTTP_PORT": "3010",
        "MCP_HTTP_HOST": "127.0.0.1"
        // "MCP_AUTH_SECRET_KEY": "your-secure-token" // If authentication is enabled on the server
      }
    }
  }
}

Nota: Utilice siempre rutas absolutas para args al configurar los comandos del cliente si el servidor no se encuentra en el directorio de trabajo inmediato del cliente. La MCP_AUTH_SECRET_KEY del bloque env del cliente es ilustrativa; el manejo real de tokens para la comunicación cliente-servidor depende de las capacidades del cliente y del mecanismo de autenticación del servidor (p. ej., enviar un JWT en un encabezado Authorization ).

Estructura del proyecto

El código base sigue una estructura modular:

src/
├── config/          # Configuration management (index.ts)
├── index.ts         # Main server entry point
├── mcp/             # MCP server implementation (server.ts)
│   ├── resources/   # MCP resource handlers (index.ts, types.ts, knowledge/, projects/, tasks/)
│   └── tools/       # MCP tool handlers (individual tool directories)
├── services/        # Core application services
│   ├── llm-providers/ # LLM provider integrations (e.g., OpenRouter)
│   └── neo4j/       # Neo4j database services (index.ts, driver.ts, backupRestoreService.ts, etc.)
├── types/           # Shared TypeScript type definitions (errors.ts, mcp.ts, tool.ts)
└── utils/           # Utility functions and internal services (e.g., logger, errorHandler, sanitization)

Herramientas

ATLAS proporciona un conjunto integral de herramientas para la gestión de proyectos, tareas y conocimientos, a las que se puede acceder a través del Protocolo de Contexto de Modelo.

Operaciones del proyecto

Nombre de la herramienta	Descripción	Argumentos clave
`atlas_project_create`	Crea nuevos proyectos (individuales/masivos).	`mode` ('single'/'bulk'), `id` (ID opcional generado por el cliente para el modo individual), detalles del proyecto ( `name` , `description` , `status` , `urls` , `completionRequirements` , `dependencies` , `outputFormat` , `taskType` ). Para el modo masivo, use `projects` (matriz de objetos de proyecto). `responseFormat` ('formatted'/'json', opcional, valor predeterminado: 'formatted').
`atlas_project_list`	Enumera proyectos (todos/detalles).	`mode` ('todos'/'detalles', predeterminado: 'todos'), `id` (para el modo de detalles), filtros ( `status` , `taskType` ), paginación ( `page` , `limit` ), incluye ( `includeKnowledge` , `includeTasks` ), `responseFormat` ('formateado'/'json', opcional, predeterminado: 'formateado').
`atlas_project_update`	Actualiza proyectos existentes (individuales/masivos).	`mode` ('single'/'bulk'), `id` (para modo individual), `updates` el objeto. Para modo masivo, use `projects` (matriz de objetos, cada uno con `id` y `updates` ). `responseFormat` ('formatted'/'json', opcional, valor predeterminado: 'formatted').
`atlas_project_delete`	Elimina proyectos (individuales/en masa).	`mode` ('único'/'masivo'), `id` (para modo único) o `projectIds` (matriz para modo masivo). `responseFormat` ('formateado'/'json', opcional, predeterminado: 'formateado').

Operaciones de tareas

Nombre de la herramienta	Descripción	Argumentos clave
`atlas_task_create`	Crea nuevas tareas (individuales/masivas).	`mode` ('único'/'masivo'), `id` (ID opcional generado por el cliente), `projectId` , detalles de la tarea ( `title` , `description` , `priority` , `status` , `assignedTo` , `urls` , `tags` , `completionRequirements` , `dependencies` , formato `outputFormat` , `taskType` ). Para el modo masivo, use `tasks` (matriz de objetos de tarea). `responseFormat` ('formateado'/'json', opcional, valor predeterminado: 'formateado').
`atlas_task_update`	Actualiza tareas existentes (individuales/masivas).	`mode` ('single'/'bulk'), `id` (para modo individual), `updates` el objeto. Para modo masivo, use `tasks` (matriz de objetos, cada uno con `id` y `updates` ). `responseFormat` ('formatted'/'json', opcional, valor predeterminado: 'formatted').
`atlas_task_delete`	Elimina tareas (individuales/masivas).	`mode` ('único'/'masivo'), `id` (para modo único) o `taskIds` (matriz para modo masivo). `responseFormat` ('formateado'/'json', opcional, predeterminado: 'formateado').
`atlas_task_list`	Enumera las tareas para un proyecto específico.	`projectId` (obligatorio), filtros ( `status` , `assignedTo` , `priority` , `tags` , `taskType` ), clasificación ( `sortBy` , `sortDirection` ), paginación ( `page` , `limit` ), `responseFormat` ('formateado'/'json', opcional, predeterminado: 'formateado').

Operaciones de conocimiento

Nombre de la herramienta	Descripción	Argumentos clave
`atlas_knowledge_add`	Agrega nuevos elementos de conocimiento (individuales/en masa).	`mode` ('single'/'bulk'), `id` (ID opcional generado por el cliente), `projectId` , detalles de conocimiento ( `text` , `tags` , `domain` , `citations` ). Para el modo masivo, use `knowledge` (matriz de objetos de conocimiento). `responseFormat` ('formatted'/'json', opcional, valor predeterminado: 'formatted').
`atlas_knowledge_delete`	Elimina elementos de conocimiento (individuales o en masa).	`mode` ('único'/'masivo'), `id` (para modo único) o `knowledgeIds` (matriz para modo masivo). `responseFormat` ('formateado'/'json', opcional, predeterminado: 'formateado').
`atlas_knowledge_list`	Enumera elementos de conocimiento para un proyecto específico.	`projectId` (obligatorio), filtros ( `tags` , `domain` , `search` ), paginación ( `page` , `limit` ), `responseFormat` ('formateado'/'json', opcional, predeterminado: 'formateado').

Operaciones de búsqueda

Nombre de la herramienta	Descripción	Argumentos clave
`atlas_unified_search`	Realiza una búsqueda unificada entre entidades.	`value` (término de búsqueda, obligatorio), `property` (opcional: si se especifica, realiza una búsqueda de expresiones regulares en esta propiedad; si se omite, realiza una búsqueda de texto completo), filtros ( `entityTypes` , `taskType` , `assignedToUserId` ), opciones ( `caseInsensitive` (predeterminado: verdadero, para expresiones regulares), `fuzzy` (predeterminado: falso, para expresiones regulares 'contiene' o texto completo de Lucene difuso)), paginación ( `page` , `limit` ), `responseFormat` ('formatted'/'json', opcional, predeterminado: 'formatted').

Operaciones de investigación

Nombre de la herramienta	Descripción	Argumentos clave
`atlas_deep_research`	Inicia un proceso de investigación profunda estructurado mediante la creación de un plan jerárquico dentro de la base de conocimiento del Atlas.	`projectId` (obligatorio), `researchTopic` (obligatorio), `researchGoal` (obligatorio), `scopeDefinition` (opcional), `subTopics` (matriz obligatoria de objetos, cada uno con `question` (obligatorio), `initialSearchQueries` (matriz opcional), `nodeId` (opcional), `priority` (opcional), `assignedTo` (opcional), `initialStatus` (opcional, predeterminado: 'todo')), `researchDomain` (opcional), `initialTags` (opcional), `planNodeId` (opcional), `createTasks` (opcional, predeterminado: verdadero), `responseFormat` ('formatted'/'json', opcional, predeterminado: 'formatted').

Operaciones de base de datos

Nombre de la herramienta	Descripción	Argumentos clave
`atlas_database_clean`	Destructivo: restablece completamente la base de datos, eliminando todos los proyectos, tareas y conocimientos.	`acknowledgement` (debe establecerse como `true` para confirmar, obligatorio), `responseFormat` ('formatted'/'json', opcional, predeterminado: 'formatted').

Recursos

ATLAS expone datos de proyectos, tareas y conocimientos a través de puntos finales de recursos MCP estándar.

Recursos directos

Nombre del recurso	Descripción
`atlas://projects`	Lista de todos los proyectos en la plataforma Atlas con soporte de paginación.
`atlas://tasks`	Listado de todas las tareas en la plataforma Atlas con soporte de paginación y filtrado.
`atlas://knowledge`	Lista de todos los elementos de conocimiento en la plataforma Atlas con soporte de paginación y filtrado.

Plantillas de recursos

Nombre del recurso	Descripción
`atlas://projects/{projectId}`	Recupera un solo proyecto por su identificador único ( `projectId` ).
`atlas://tasks/{taskId}`	Recupera una sola tarea por su identificador único ( `taskId` ).
`atlas://projects/{projectId}/tasks`	Recupera todas las tareas que pertenecen a un proyecto específico ( `projectId` ).
`atlas://knowledge/{knowledgeId}`	Recupera un único elemento de conocimiento mediante su identificador único ( `knowledgeId` ).
`atlas://projects/{projectId}/knowledge`	Recupera todos los elementos de conocimiento que pertenecen a un proyecto específico ( `projectId` ).

Copia de seguridad y restauración de bases de datos

ATLAS ofrece funciones para realizar copias de seguridad y restaurar el contenido de la base de datos de Neo4j. La lógica principal reside en src/services/neo4j/backupRestoreService.ts .

Proceso de copia de seguridad

Mecanismo : El proceso de copia de seguridad exporta todos los nodos Project , Task y Knowledge , junto con sus relaciones, a archivos JSON independientes. También se crea un archivo full-export.json con todos los datos.
Salida : Cada copia de seguridad crea un directorio con marca de tiempo (p. ej., atlas-backup-YYYYMMDDHHMMSS ) dentro de la ruta de copia de seguridad configurada (predeterminado: ./atlas-backups/ ). Este directorio contiene projects.json , tasks.json , knowledge.json , relationships.json y full-export.json .
Copia de seguridad manual : puede activar una copia de seguridad manual mediante el script proporcionado:
npm run db:backup
Este comando ejecuta scripts/db-backup.ts , que llama a la función exportDatabase .

Proceso de restauración

Mecanismo : El proceso de restauración primero borra por completo la base de datos Neo4j existente. A continuación, importa los nodos y las relaciones desde los archivos JSON ubicados en el directorio de respaldo especificado. Prioriza full-export.json si está disponible.
Advertencia : Restaurar desde una copia de seguridad es una operación destructiva. Sobrescribirá todos los datos actuales de su base de datos Neo4j.
Restauración manual : para restaurar la base de datos desde un directorio de respaldo, utilice el script de importación:
npm run db:import <path_to_backup_directory>
Reemplace <path_to_backup_directory> con la ruta real a la carpeta de respaldo (p. ej., ./atlas-backups/atlas-backup-20250326120000 ). Este comando ejecuta scripts/db-import.ts , que llama a la función importDatabase .
Manejo de relaciones : El proceso de importación intenta recrear las relaciones basándose en las propiedades id almacenadas en los nodos durante la exportación. Asegúrese de que sus nodos tengan propiedades id consistentes para que las relaciones se restablezcan correctamente.

Ejemplos

El directorio examples/ contiene ejemplos prácticos que demuestran varias características del servidor ATLAS MCP.

Ejemplo de copia de seguridad : Ubicado en examples/backup-example/ , muestra la estructura y el formato de los archivos JSON generados por el comando npm run db:backup . Consulte el archivo README de ejemplos para obtener más información.
Ejemplo de investigación profunda : Ubicado en examples/deep-research-example/ , este ejemplo muestra el resultado y la estructura generados por la herramienta atlas_deep_research . Incluye un archivo Markdown ( covington_community_grant_research.md ) que resume el plan de investigación y un archivo JSON ( full-export.json ) que contiene los datos sin procesar exportados desde la base de datos tras la creación del plan. Consulte el archivo README de ejemplos para obtener más información.

Licencia

Licencia Apache 2.0

You must be authenticated.

security – no known vulnerabilities

license - permissive license

quality - confirmed to work

Tools

View all tools

ATLAS (Sistema de Automatización Lógica y de Tareas Adaptativas) es un servidor de Protocolo de Contexto de Modelo que proporciona capacidades de gestión jer��rquica de tareas para Modelos de Lenguaje Grandes (LLM). Esta herramienta proporciona a los LLM la estructura y el contexto necesarios para gestionar tareas y dependencias complejas.

Related MCP Servers

Notion MCP Server
SAhmadUmass
-
security
F
license
-
quality
A Model Context Protocol server that enables Claude and other LLMs to interact with Notion workspaces, providing capabilities like searching, retrieving, creating and updating pages, as well as managing databases.
Last updated -
275
2
TypeScript
Atlassian Confluence MCP Server
aashari
A
security
F
license
A
quality
A Model Context Protocol server that enables AI assistants like Claude to access and search Atlassian Confluence content, allowing integration with your organization's knowledge base.
Last updated -
5
319
8
TypeScript
MCP-Server-TESS
diegofornalha
-
security
F
license
-
quality
A Model Context Protocol server that enables integration with the TESS API, allowing users to list and manage agents, execute agents with custom messages, and manage files through natural language interfaces.
Last updated -
TypeScript
MongoDB MCP Serverofficial
mongodb-js
-
security
A
license
-
quality
A Model Context Protocol server that enables AI assistants to interact with MongoDB Atlas resources through natural language, supporting database operations and Atlas management functions.
Last updated -
1,644
188
TypeScript
Apache 2.0

View all related MCP servers