AX Platform MCP Server for AI Agent Collaboration

Overview

The AX Platform MCP (Model Context Protocol) server is a lightweight service that enables multiple AI agents and human collaborators to share context, coordinate workflows, and exchange structured messages in real time. It implements an open, channel-based protocol for storing and broadcasting pieces of context (documents, facts, state, and signals) so agents can cooperate on tasks without duplicating memory or losing continuity across turns.

By centralizing context management, the MCP server simplifies multi-agent orchestration: agents can publish context snippets, subscribe to updates, query historical context, and attach metadata like provenance or confidence scores. This makes it easier to build composite AI systems that need shared memory, synchronized task state, or collaborative decision-making across different models and services.

Features

• Channel-based context sharing for segmented collaboration
• Publish/subscribe APIs (HTTP + WebSocket) for real-time updates
• Persistent storage with pluggable backends (e.g., PostgreSQL, Redis, filesystem)
• Metadata and provenance on context items (confidence, source, timestamps)
• Queryable history and basic filtering/TTL support
• Lightweight authentication and workspace isolation
• SDK-ready API surface for agent integrations

Installation / Configuration

Minimum requirements: Node.js (16+), Docker (optional), and a backing datastore such as PostgreSQL or Redis for production.

Clone repository and install dependencies:

git clone https://github.com/AX-MCP/PaxAI.git
cd PaxAI
# If using npm
npm install
# If using pnpm
pnpm install

Environment variables (example .env):

PORT=8080
NODE_ENV=production
DATABASE_URL=postgres://user:pass@db:5432/mcp
REDIS_URL=redis://redis:6379
JWT_SECRET=your-jwt-secret
STORAGE_DRIVER=postgres
DEFAULT_TTL_SECONDS=604800

Run locally:

# using node
npm run build
npm start

# or (development)
npm run dev

Docker (simple run):

docker build -t ax-mcp .
docker run -p 8080:8080 \
  -e PORT=8080 \
  -e DATABASE_URL=postgres://user:pass@db:5432/mcp \
  -e JWT_SECRET=secret \
  ax-mcp

Docker Compose (example):

version: "3.8"
services:
  mcp:
    image: ax-mcp:latest
    ports: ["8080:8080"]
    environment:
      - DATABASE_URL=postgres://postgres:password@db:5432/mcp
      - REDIS_URL=redis://redis:6379
      - JWT_SECRET=change_me
  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
  redis:
    image: redis:7

API Reference (quick)

Example: publish a context item

curl -X POST "http://localhost:8080/channels/alerts/context" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "fact",
    "content": "Server cpu > 90%",
    "meta": {"source":"monitoring", "confidence":0.95}
  }'

Subscribe via WebSocket (wscat):

wscat -c "ws://localhost:8080/ws?workspace=workspace-123" \
  -H "Authorization: Bearer <token>"

Available Tools / Resources

• HTTP REST API for CRUD operations on workspaces, channels, and context
• WebSocket endpoint for push notifications and live subscriptions
• Pluggable storage adapters (Postgres, Redis, in-memory for testing)
• Client SDKs (JavaScript/TypeScript) — include helpers for authentication, publishing, and subscribing
• OpenAPI/Swagger spec for endpoint discovery and code generation
• Example integrations and templates in the repo (agents, worker demos)

Use Cases

1. Multi-agent task coordination

   • Several specialized agents (planner, searcher, summarizer) coordinate through a shared channel. The planner publishes tasks and context; workers subscribe, update progress, and append results. Agents avoid redundant retrievals because shared facts are centrally stored.

2. Shared memory for chained reasoning

   • An LLM orchestrator stores intermediate chain-of-thought outputs and retrieved documents in a channel. Later steps query past context to maintain coherence and reduce prompt length by referencing stored snippets.

3. Human-in-the-loop review

   • Agents propose decisions with provenance metadata. Human reviewers subscribe to a review channel, annotate items, and push approvals back. The MCP server records decisions and timestamps for audit trails.

4. Alert and signal routing

   • Monitoring agents publish alerts to specific channels (e.g., infra, security). Response agents subscribe to relevant channels, claim tasks, and post remediation steps—maintaining a timeline of actions and status updates.

5. Cross-service orchestration

   • Different microservices exchange workflow state as context items, using workspaces to isolate environments (staging vs production). This allows services to react to state changes without tight coupling.

Getting Started Tips

• Start with the in-memory or SQLite driver for development; switch to Postgres/Redis in production.
• Use workspaces to separate environments and apply fine-grained access controls.
• Keep context items small and idempotent — use references to large blobs stored elsewhere.
• Leverage the WebSocket feed for low-latency agent coordination and avoid polling.

This server is intended as a coordination layer: treat it as authoritative for shared context and let agents remain stateless where possible, retrieving the latest context from MCP when making decisions.