ATLAS Work Orchestrator (v2.8.15)

ATLAS (Adaptive Task & Logic Automation System) functions as a specialized Model Context Protocol (MCP) nexus, architected to govern the lifecycle of managed computational endeavors (Projects), discrete operational mandates (Tasks), and supporting evidentiary context (Knowledge Records) for advanced AI entities.

It employs a tripartite data model persistence strategy rooted in a Neo4j graph database foundation:

                  +-------------------------------------------+
                  |               ENDURANCE (PROJECT)         |
                  |-------------------------------------------|
                  | identifier: string                        |
                  | charterName: string                       |
                  | mandate: string                           |
                  | lifecycleState: string                    |
                  | externalReferences?: Array<{title: string, uri: string}>|
                  | successCriteria: string                 |
                  | requiredOutputSchema: string              |
                  | executionClass: string                    |
                  | inceptionTimestamp: string                |
                  | lastModifiedTimestamp: string             |
                  +----------------+--------------------------+
                            |                    |
                            |                    |
                            v                    v
+----------------------------------+ +----------------------------------+
|               ACTION (TASK)      | |            CONTEXTUAL (KNOWLEDGE)  |
|----------------------------------| |----------------------------------|
| identifier: string               | | identifier: string               |
| parentEnduranceId: string        | | parentEnduranceId: string        |
| objectiveTitle: string           | | artifactText: string             | 
| directive: string                | | contextualLabels?: string[]      |
| urgencyRanking: string           | | dataDomain: string               | 
| lifecycleState: string           | | provenance?: string[]            |
| delegatee?: string               | | inceptionTimestamp: string       |
| externalReferences?: Array<{title: string, uri: string}>| | lastModifiedTimestamp: string    |
| contextualLabels?: string[]      | |                                  |
| successCriteria: string          | |                                  |
| requiredOutputSchema: string     | |                                  |
| executionClass: string           | |                                  |
| inceptionTimestamp: string       | |                                  |
| lastModifiedTimestamp: string    |
+----------------------------------+ +----------------------------------+

Deployed as an MCP compliant endpoint, ATLAS furnishes autonomous agents (LLMs) with programmatic access to manipulate structured objectives, track iterative steps, and integrate evidentiary material.

Critical Architectural Note: Deployment versions preceding 2.0 relied upon SQLite persistence. Current iterations (2.0+) mandate a Neo4j graph environment, accessible via: - Self-managed infrastructure using bundled Docker Compose definitions. - Hosted solutions utilizing Neo4j AuraDB cloud infrastructure: https://neo4j.com/product/auradb/

Version 2.5.0 fundamentally restructured the data schema into the three distinct persistent entities shown above (Endurance, Action, Contextual).

High-Level Concept

ATLAS adheres strictly to the Model Context Protocol (MCP) specification, facilitating machine-to-machine interaction through:

Consumers: Any MCP-compliant interface (e.g., IDE plugins, specialized desktop applications, other server processes).
Providers: This service itself, offering structured management capabilities.
AI Entities: Models leveraging the provider's structured data layer for context-aware operations.

System Synthesis

The Atlas Framework interlinks these elements into a coherent operational plane:

Endurance-Action Linkage: Projects encapsulate Actions, which are the concrete steps required to meet the Project's charter. Actions inherit macro-context from the Endurance while providing granular accountability for individual work units.
Contextual Enrichment: Both Endurance units and Actions can be augmented with Knowledge Records, furnishing necessary background data and verification sources to all system actors.
Prerequisite Sequencing: Both organizational levels support explicit dependency declarations, enabling the construction of rigorous, sequential workflow paths.
Holistic Querying: The platform exposes unified search mechanisms, allowing rapid discovery of relevant Projects, Actions, or Contextual items based on metadata or content analysis.

Key Capabilities

Domain Area	Core Functionality Summary
Endurance Oversight	- Comprehensive Metadata Tracking: Manage structural data, status flags, and rich content (documentation, URIs) with native support for batch operations. - Inter-Endurance Validation: Automatically check and enforce dependency constraints between high-level objectives.
Action Execution Mgmt	- Lifecycle Control: Provision, monitor, and finalize discrete Actions across their entire existence. - Hierarchical Organization: Allocate urgency ratings and categorize Actions using metadata tags for superior organization. - Workflow Structuring: Define prerequisite dependencies to construct complex execution graphs.
Contextual Data Mgmt	- Structured Data Reservoir: Maintain an indexed, queryable repository of domain-specific reference material. - Categorization via Labels: Organize data using domain specifications and associated tags for optimized retrieval. - Provenance Tracking: Systematically log citation sources linked to specific knowledge artifacts.
Graph Database Reliance	- Transactional Integrity: Utilize Neo4j's ACID features and optimized traversal algorithms for data robustness. - Scalable Retrieval: Execute property-based lookups augmented with fuzzy matching and wildcard patterns without performance degradation.
Unified Indexing	- Cross-Entity Discovery: Locate pertinent Projects, Actions, or Contextual Records via content, properties, or structural links. - Flexible Search Modalities: Support for case-insensitivity, approximate string matching, and advanced query syntax filtering.

Deployment Instructions

Source Acquisition:

bash git clone https://github.com/cyanheads/atlas-mcp-server.git cd atlas-mcp-server
Dependency Resolution:

bash npm install
Graph Database Initialization: A Neo4j instance must be operational. Use the included orchestration configuration:

bash docker-compose up -d

Configure the .env file with the established Neo4j connection parameters.
Compilation: bash npm run build

Execution Modes

Most MCP Consumers initiate the provider implicitly; however, manual invocation is available for debugging or standalone testing.

ATLAS MCP Provider facilitates communication across several transport protocols:

Standard I/O (stdio): The default channel, primarily utilized for tightly coupled integration with local host clients (e.g., IDE extensions).

bash npm run start:stdio

This enforces MCP_TRANSPORT_TYPE=stdio.

Streamable HTTP Endpoint: Enables remote client interaction or web-based consumption by exposing the provider via HTTP requests.

bash npm run start:http

This activates MCP_TRANSPORT_TYPE=http, binding to the host/port specified in .env (default: 127.0.0.1:3010). Network access controls must permit traffic on this port for remote access.

Visualization Interface (Beta)

A rudimentary graphical interface exists for browsing Endurance, Action, and Contextual records.

Accessing the Interface:

Execute the following command to initiate the local web server: bash npm run webui

Interface Snapshot: A sample rendering of the interface is available for preview at ./examples/webui-example.png.

System Parameters

Configuration settings are governed by environment variables, specified either within the MCP Client configuration context or via a project root .env file during local operation.

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

# Application Runtime Settings
MCP_LOG_LEVEL=debug # Logging verbosity: emerg, alert, crit, error, warning, notice, info, debug. Default: "debug".
LOGS_DIR=./logs # Location for persistent log files. Default: "./logs".
NODE_ENV=development # Operational context: 'development' or 'production'. Default: "development".

# MCP Transport Layer Configuration
MCP_TRANSPORT_TYPE=stdio # 'stdio' or 'http'. Default: "stdio".
MCP_HTTP_HOST=127.0.0.1 # Interface binding for HTTP transport. Default: "127.0.0.1".
MCP_HTTP_PORT=3010 # Listener port for HTTP transport. Default: 3010.
# MCP_ALLOWED_ORIGINS=... # Optional: Whitelist for CORS headers in HTTP mode.

# Security and Throttling (HTTP Mode)
# MCP_AUTH_SECRET_KEY=... # REQUIRED for secured HTTP. Must be >= 32 characters. (Note: Production security stabilization pending.)
MCP_RATE_LIMIT_WINDOW_MS=60000 # Time window for throttling (milliseconds). Default: 60000.
MCP_RATE_LIMIT_MAX_REQUESTS=100 # Request ceiling per window per client IP. Default: 100.

# Persistence Control
BACKUP_MAX_COUNT=10 # Maximum number of historical backup sets retained. Default: 10.
BACKUP_FILE_DIR=./atlas-backups # Target directory for persistence snapshots. Default: "./atlas-backups".

Complete variable specification and default hierarchy are documented in src/config/index.ts.

Consumer Configuration Directives

Configuration methodology is client-dependent. Some consumers utilize a local configuration file (e.g., mcp.json in the root) to define how to invoke and connect to the provider; adjust this file as required.

For Stdio Transport (Client Configuration Example):

{
  "mcpServers": {
    "atls-orchestrator-stdio": {
      "command": "node",
      "args": ["/absolute/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": "development",
        "MCP_TRANSPORT_TYPE": "stdio"
      }
    }
  }
}

For Streamable HTTP (Client Configuration Example): If the Consumer supports connecting to a remote HTTP-exposed MCP server, the endpoint (e.g., http://localhost:3010/mcp) is specified directly in the client's connection settings.

{
  "mcpServers": {
    "atls-orchestrator-http": {
      "command": "node",
      "args": ["/absolute/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": "development",
        "MCP_TRANSPORT_TYPE": "http",
        "MCP_HTTP_PORT": "3010",
        "MCP_HTTP_HOST": "127.0.0.1"
        // "MCP_AUTH_SECRET_KEY": "token" // Required if server enforces JWT validation via headers.
      }
    }
  }
}

Security Note: Use absolute paths in invocation arguments (args) unless the provider binary resides within the client's current working directory. Authentication token management (MCP_AUTH_SECRET_KEY) relies on the client correctly injecting the necessary credentials (e.g., in an Authorization header).

Codebase Layout

The modular design partitions responsibilities as follows:

src/
├── config/          # System parameter loading and validation module (index.ts)
├── index.ts         # Primary server bootstrap and initialization
├── mcp/             # MCP Abstraction Layer
│   ├── resources/   # Handlers for MCP Resource queries (index.ts, types.ts, contextual/, endurance/, action/)
│   └── tools/       # Definitions and execution logic for exposed Agent Tools (individual tool directories)
├── services/        # Core Business Logic Modules
│   └── neo4j/       # Graph persistence abstraction (index.ts, driver.ts, persistence/backupRestoreService.ts, etc.)
├── types/           # Shared TypeScript interfaces and definitions (errors.ts, mcp.ts, tool-definitions.ts)
└── utils/           # Internal utilities (e.g., centralized logger, exception handling, data sanitization functions)

Exposed Agent Tools

ATLAS exposes a defined set of callable functions (Tools) via the MCP interface for external agents.

Endurance Management Functions

Tool Name	Functionality Summary	Parameter Specification (Key Arguments)
`atls_endurance_forge`	Initializes new Endurance entities (single or batch).	`operationMode` ('single'/'batch'), `clientReferenceId` (optional for single), Endurance metadata (`charterName`, `mandate`, `lifecycleState`, `externalReferences`, `successCriteria`, `requiredOutputSchema`, `executionClass`), `batchInputs` (array for batch mode). `outputFormat` ('structured'/'payload', default: 'structured').
`atls_endurance_scan`	Retrieves a listing of existing Endurances.	`operationMode` ('all'/'detail'), `targetId` (for detail mode), filtering criteria (`lifecycleState`, `executionClass`), pagination (`pageIndex`, `itemCount`), inclusivity flags (`includeContext`, `includeActions`), `outputFormat`.
`atls_endurance_amend`	Modifies current Endurance records (single or batch).	`operationMode` ('single'/'batch'), `targetId` (for single mode), `modificationPayload` object. For batch, use `batchUpdates` (array of {id, modifications}). `outputFormat`.
`atls_endurance_retire`	Permanently removes Endurance entities (single or batch).	`operationMode` ('single'/'batch'), `targetId` (for single mode) or `enduranceIds` (array for batch). `outputFormat`.

Action Management Functions

Tool Name	Functionality Summary	Parameter Specification (Key Arguments)
`atls_action_forge`	Creates new Action instances (single or batch).	`operationMode` ('single'/'batch'), `clientReferenceId`, `parentEnduranceId`, Action data (`objectiveTitle`, `directive`, `urgencyRanking`, `lifecycleState`, `delegatee`, `externalReferences`, `contextualLabels`, `successCriteria`, `requiredOutputSchema`, `executionClass`, `initialStatus`). `outputFormat`.
`atls_action_amend`	Updates operational Actions (single or batch).	`operationMode` ('single'/'batch'), `targetId`, `modificationPayload`. For batch, use `batchUpdates` (array of {id, modifications}). `outputFormat`.
`atls_action_retire`	Deletes Action records (single or batch).	`operationMode` ('single'/'batch'), `targetId` or `actionIds` (array). `outputFormat`.
`atls_action_scan`	Fetches Actions associated with an Endurance.	`parentEnduranceId` (mandatory), filtering criteria (`lifecycleState`, `delegatee`, `contextualLabels`, `executionClass`), ordering (`orderBy`, `direction`), pagination (`pageIndex`, `itemCount`), `outputFormat`.

Contextual Data Functions

Tool Name	Functionality Summary	Parameter Specification (Key Arguments)
`atls_context_deposit`	Ingests new Contextual Artifacts (single or batch).	`operationMode` ('single'/'batch'), `clientReferenceId`, `parentEnduranceId`, Artifact data (`artifactText`, `contextualLabels`, `dataDomain`, `provenance`). `outputFormat`.
`atls_context_discard`	Removes Contextual Artifacts (single or batch).	`operationMode` ('single'/'batch'), `targetId` or `knowledgeIds` (array). `outputFormat`.
`atls_context_scan`	Retrieves Contextual Artifacts linked to an Endurance.	`parentEnduranceId` (mandatory), filtering criteria (`contextualLabels`, `dataDomain`, `searchQuery`), pagination (`pageIndex`, `itemCount`), `outputFormat`.

Discovery Functions

Tool Name	Functionality Summary	Parameter Specification (Key Arguments)
`atls_holistic_query`	Executes an indexed search across all data entities.	`queryTerm` (mandatory term), `scopeFilter` (optional: restrict search to specific property fields; overrides default text search), filtering parameters (`entityTypes` array, `executionClass`, `delegateeId`), options (`isCaseInsensitive` (default: true), `enableFuzzyMatch` (default: false, triggers Lucene fuzzy logic)), pagination (`pageIndex`, `itemCount`), `outputFormat`.

Strategic Research Functions

Tool Name	Functionality Summary	Parameter Specification (Key Arguments)
`atls_strategic_plan`	Generates a structured, hierarchical research mandate executed as a sub-project within the Atlas knowledge framework.	`parentEnduranceId` (mandatory), `researchTopicCharter` (mandatory), `desiredOutcomeStatement` (mandatory), `scopeBoundary` (optional), `subTasks` (required array of objects: {`queryPrompt` (mandatory), `initialDataSources` (optional array), `uniqueNodeId` (optional), `priorityLevel` (optional), `assignedAgent` (optional), `initialStatus` (optional, default: 'PENDING')), `researchContextDomain` (optional), `initialMetadataTags` (optional), `planRootNodeId` (optional), `autoCreateActions` (optional, default: true), `outputFormat`.

System Maintenance Functions

Tool Name	Functionality Summary	Parameter Specification (Key Arguments)
`atls_system_purge`	High-Risk Operation: Atomically wipes all stored graph data (Endurances, Actions, Contexts).	`confirmationToken` (Must be set to `TRUE` to override safety lock, mandatory), `outputFormat`.

Reference Endpoints

ATLAS exposes resource access points consistent with MCP standards for direct data retrieval by consumers.

Resource Path	Purpose
`atls://endurances`	Indexed enumeration of all active Endurances, supporting pagination controls.
`atls://actions`	Indexed enumeration of all Actions across the system, supporting filtering and paging.
`atls://context`	Indexed enumeration of all Contextual Artifacts, supporting filtering and paging.

Template Path	Purpose
`atls://endurances/{parentEnduranceId}`	Retrieves the full manifest for a singular Endurance entity.
`atls://actions/{actionId}`	Retrieves the full manifest for a singular Action entity.
`atls://endurances/{parentEnduranceId}/actions`	Lists all Actions dependent on a specified Endurance.
`atls://context/{contextualId}`	Retrieves the full manifest for a singular Contextual Artifact.
`atls://endurances/{parentEnduranceId}/context`	Lists all Contextual Artifacts referenced by a specified Endurance.

Data Persistence Management

Functionality is provided within src/services/neo4j/persistence/backupRestoreService.ts to safeguard and reload the graph state.

State Snapshotting (Backup)

Methodology: The snapshot procedure serializes all primary Node types (Endurance, Action, Contextual) and their connecting relationships into discrete JSON artifacts. A consolidated manifest (full-export.json) is also generated.
Storage: Snapshots are timestamped and deposited into the directory defined by BACKUP_FILE_DIR (default: ./atlas-backups/). Each set includes files like endurances.json, actions.json, context.json, relationships.json, and the consolidated export.
On-Demand Snapshot: Trigger a manual export via: bash npm run db:backup This executes the necessary service routines for data export.

State Reloading (Restore)

Critical Warning: Reloading data is idempotent and destructive. It mandates a total erasure of the current Neo4j dataset prior to re-ingestion.
On-Demand Reload: To reload the system from a previous state, use the importer script, specifying the source directory: bash npm run db:import <path_to_backup_directory> (Example: ./atlas-backups/atls-snapshot-20250326120000). Successful relationship reconstruction is contingent upon consistent identifier fields surviving the export phase.

Operational Scenarios

The examples/ directory contains practical demonstrations of the provider's operational schema.

Persistence Showcase: In examples/backup-example/, observe the resulting schema and content format generated by the npm run db:backup procedure. Consult Examples README for detailed data introspection.
Research Execution Example: The examples/strategic-plan-example/ folder illustrates the artifact generation from the atls_strategic_plan tool. This includes a summary markdown file detailing the generated research mandate structure and the raw full-export.json reflecting the created graph structure.

Licensing

Distributed under the terms of the Apache License, Version 2.0.

Engineered for Model Context Protocol Compliance

WIKIPEDIA DEFINITION (Business Management Tools Context): Business management implements all the systematic processes, applications, control mechanisms, computational solutions, and established methodologies utilized by commercial entities to effectively navigate evolving market dynamics, maintain competitive advantage, and achieve measurable performance enhancements.

== Management Tool Taxonomy == Systems can be functionally segmented according to organizational department or specific management facet, encompassing planning utilities, process automation engines, record-keeping solutions, human capital management tools, algorithmic decision support, and oversight mechanisms.

The modern management tool landscape has undergone radical transformation over the past decade, driven by exponential technological progress, making optimal selection challenging. This complexity stems from relentless pressure to reduce operational expenditure, maximize revenue streams, gain deep customer insight, and deliver product solutions precisely meeting stated requirements. Consequently, leadership requires a strategic, rather than purely opportunistic, selection methodology for these tools. Unadapted adoption often results in systemic instability. Business management tools necessitate careful vetting followed by meticulous tailoring to the organization's unique operational profile.

== Predominant Tools (2013 Survey Benchmark) == Bain & Company analysis from 2013 highlighted prevalent tool adoption globally, reflecting regional priorities amidst market conditions. The top ten management disciplines identified were:

Strategic Roadmapping
Customer Relationship Optimization (CRM)
Personnel Engagement Measurement
Competitive Benchmarking
Performance Indexing (Balanced Scorecard)
Core Competency Definition
Operational Outsourcing Strategy
Organizational Transition Management
Supply Chain Optimization
Mission/Vision Articulation & Market Segmentation & Total Quality Frameworks

== Enterprise Software Applications == Software collections designed for end-user business functions are termed business applications. These systems are critical for augmenting productivity, quantifying operational output, and ensuring precise execution of corporate tasks. Evolution proceeded from foundational Management Information Systems (MIS) to comprehensive Enterprise Resource Planning (ERP) suites, later incorporating Customer Relationship Management (CRM) capabilities, culminating in the current proliferation of cloud-native business management platforms. While a proven link exists between IT investment and organizational returns, maximal value extraction hinges on two factors: the efficacy of the implementation effort and the diligence applied to initial tool selection and customization.

== Specialized Tools for Mid-Sized Enterprises (SMEs) == SME-focused toolsets are vital as they provide leverage points for scaling operations and optimizing constrained resources.

atls-agent-workspace-orchestrator

Author

cyanheads

Quick Info

Actions

Tags