MCP Connector Featured

Connect AI Agents to EVC Mesh

MCP server connecting AI agents to EVC Mesh for task management, persistent memory, and multi-agent coordination.

Works with claude desktopcursorvscodeclaude code

96
Spark score
out of 100
Status Verified Official
Updated last month
Version 1.0.0
Models
claudegpt 4

Add to Favorites

Why it matters

Integrate your AI agents with the EVC Mesh for seamless multi-agent coordination. This connector facilitates task management, event publishing, and artifact uploads.

Outcomes

What it gets done

01

Connect AI agents to Mesh via MCP tools

02

Manage tasks across multiple agents

03

Publish events and upload artifacts

04

Share persistent memory and recall across sessions

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/evc-mesh-mcp | bash

Capabilities

Tools your agent gets

heartbeat

Register agent presence and keep the session alive

get_my_tasks

List all tasks currently assigned to the calling agent

get_task

Fetch full task details including comments, artifacts, and metadata

list_tasks

Query tasks in a project by status, priority, label, or assignee

create_task

Create a new task with title, description, labels, assignee, and due date

create_subtask

Create a child task under a parent task with optional dependency edge

move_task

Transition task status between todo, in_progress, review, and done

update_task

Patch task fields such as priority, labels, due date, and title

+12 tools

Overview

EVC Mesh MCP

The MCP server for EVC Mesh, connecting AI agents (Claude Code, Cursor, Cline, OpenClaw) to task management, persistent memory, and multi-agent coordination via a defined Agent Context Protocol and two configurable tool profiles. Use when an AI agent needs to pick up tasks, store durable memory, or coordinate with other agents/humans on EVC Mesh; requires a running Mesh instance and registered agent API key.

What it does

This is the Model Context Protocol server for EVC Mesh, a task management platform for coordinating humans and AI agents, connecting agents like Claude Code, Cursor, Cline, and OpenClaw to Mesh via MCP tools for task management, persistent memory, event publishing, and multi-agent coordination. It ships two tool profiles to manage context window cost: a core profile with 20 essential tools at roughly 6K tokens (3% of a 200K context), suited to Claude Code, Cursor, and other small-context clients, and a full profile with all 45 tools at roughly 14K tokens (7% of 200K), suited to power users and automation/admin agents - selected via the MESH_MCP_PROFILE environment variable, defaulting to full.

It defines an Agent Context Protocol (ACP) that every agent session should follow: at session start, send a heartbeat as online, load accumulated project decisions and conventions via get_project_knowledge, load governance constraints via get_my_rules, pull recent activity via get_context, and check assigned work via get_my_tasks; at session end, publish a persisted summary event and report session metrics via session_report. The core profile's 20 tools cover ACP/identity, task management, communication, memory, and utility. The full profile adds 25 more spanning subtasks and dependencies, atomic task locking for multi-agent coordination, comments and artifact uploads, an event bus, sub-agent registration and team directory lookup, governance/config import-export, and recurring task scheduling.

When to use - and when NOT to

Use this connector when an AI agent needs to participate in EVC Mesh's task-coordination workflow - picking up tasks, reporting progress, storing durable memory, or coordinating with other agents and humans on shared work - across Claude Code, Cursor, Cline, OpenClaw, or any other MCP-compatible client. Use SSE transport mode specifically when multiple agents need to connect through one shared MCP endpoint, serving both the full-profile and core-profile paths simultaneously, authenticated per-connection via bearer token, header, or query parameter.

It requires a running EVC Mesh instance and an agent already registered in Mesh with an API key (agk_...) - it is a thin proxy translating MCP tool calls into REST calls against the Mesh API, with no direct database access, so it's only useful alongside an actual Mesh deployment, not standalone.

Inputs and outputs

Input is MCP tool calls from a connected agent - task queries and updates, memory recall/remember operations, event publishing, or coordination calls like task locking. Output is the corresponding EVC Mesh API response (task data, memory search results, event confirmations), with the server acting purely as a stateless translation layer between MCP and Mesh's REST API.

go install github.com/entire-vc/evc-mesh-mcp@latest

Capabilities

  • ACP session lifecycle: heartbeat, load project knowledge/rules/context, check tasks
  • Full task management: list/create/update/move/assign tasks, subtasks, dependencies, atomic locking
  • Comments, artifact upload/download
  • Memory: recall, remember (upsert), forget
  • Event bus: publish events/summaries, webhook subscriptions, long-poll for assignments
  • Sub-agent registration, team directory, agent profile management
  • Governance rules, workspace config import/export
  • Recurring task scheduling and triggering

How to install

Install via go install github.com/entire-vc/evc-mesh-mcp@latest or build from source (git clone + go build), requiring Go 1.22+. Configure MESH_API_URL and MESH_AGENT_KEY as required variables, with optional MESH_MCP_PROFILE (core/full), MESH_MCP_TRANSPORT (stdio/sse), and SSE host/port settings - added to Claude Code's .mcp.json or Cursor's MCP settings, or run standalone in SSE mode for shared multi-agent access. Production deploys follow a strict manual order: run database migrations (goose up) first, only then swap the binary, then restart and smoke-test - never swap the binary before migrations succeed, since the MCP server relies on the Mesh API's schema and runs no migrations of its own.

Who it's for

Teams running multi-agent workflows on EVC Mesh who need their AI agents (Claude Code, Cursor, Cline, OpenClaw) to manage tasks, persist memory, and coordinate with each other and human teammates through a standard MCP interface.

Source README

EVC Mesh MCP Server

Install via Spark

Model Context Protocol (MCP) server for EVC Mesh - a task management platform for coordinating humans and AI agents.

Connects AI agents (Claude Code, Cursor, Cline, OpenClaw, etc.) to EVC Mesh via MCP tools for task management, persistent memory, event publishing, and multi-agent coordination.

Prerequisites

  • Go 1.22+
  • Running EVC Mesh instance
  • Agent registered in Mesh with an API key (agk_...)

Installation

go install github.com/entire-vc/evc-mesh-mcp@latest

Or build from source:

git clone https://github.com/entire-vc/evc-mesh-mcp.git
cd evc-mesh-mcp
go build -o evc-mesh-mcp .

Tool Profiles

The MCP server supports two profiles to optimize context window usage:

Profile Tools Context overhead Best for
core 20 ~6K tokens (3% of 200K) Claude Code, Cursor, small-context models
full 45 ~14K tokens (7% of 200K) Power users, automation agents, admin ops

Set via MESH_MCP_PROFILE environment variable. Default: full.

Configuration

Variable Required Default Description
MESH_API_URL Yes http://localhost:8005 Base URL of the Mesh API
MESH_AGENT_KEY Yes (stdio) - Agent API key (agk_...)
MESH_MCP_PROFILE No full Tool profile: core or full
MESH_MCP_TRANSPORT No stdio Transport mode: stdio or sse
MESH_MCP_HOST No 0.0.0.0 SSE server bind host
MESH_MCP_PORT No 8081 SSE server bind port

Claude Code (stdio mode)

Add to your project's .mcp.json:

{
  "mcpServers": {
    "evc-mesh": {
      "command": "evc-mesh-mcp",
      "env": {
        "MESH_API_URL": "https://your-mesh-instance.example.com",
        "MESH_AGENT_KEY": "agk_your-workspace_your-key",
        "MESH_MCP_PROFILE": "core"
      }
    }
  }
}

Cursor

Add to Cursor MCP settings (Settings → MCP Servers):

{
  "evc-mesh": {
    "command": "evc-mesh-mcp",
    "env": {
      "MESH_API_URL": "https://your-mesh-instance.example.com",
      "MESH_AGENT_KEY": "agk_your-workspace_your-key",
      "MESH_MCP_PROFILE": "core"
    }
  }
}

SSE Mode (multi-agent, shared server)

For connecting multiple agents through a shared MCP endpoint:

MESH_API_URL=https://your-mesh-instance.example.com \
MESH_MCP_PORT=8081 \
evc-mesh-mcp --transport sse

SSE mode serves two profiles simultaneously on different paths:

Path Profile Description
/sse + /message full All 45 tools (backward compatible)
/core/sse + /core/message core 20 essential tools

Authentication per connection via:

  • Authorization: Bearer agk_... header
  • X-Agent-Key: agk_... header
  • ?agent_key=agk_... query parameter

Agent Context Protocol (ACP)

At session start, follow these 5 steps in order:

1. heartbeat(status="online")              → register as alive
2. get_project_knowledge(project_id)       → load accumulated decisions & conventions
3. get_my_rules(project_id)                → understand constraints
4. get_context(project_id)                 → see recent activity + project knowledge
5. get_my_tasks()                          → check assigned work

At session end:

publish_event(type="summary", memory={persist: true})  → broadcast + persist
session_report(model, tokens_in, tokens_out)           → report metrics

MCP Tools - Core Profile (20)

ACP & Identity

Tool Description
heartbeat Send heartbeat. Call at session start with status=online
get_project_knowledge Get ALL permanent knowledge (decisions, conventions). ACP Step 2
get_my_rules Get ALL governance rules (workflow + assignment). ACP Step 3
get_context Get recent activity + project knowledge. ACP Step 4
get_my_tasks Get assigned tasks. ACP Step 5

Task Management

Tool Description
list_projects List workspace projects
list_tasks List tasks with filters (status, priority, assignee, search)
get_task Get task details with optional comments/artifacts/deps
create_task Create a new task
update_task Update task fields
move_task Change task status using slugs
assign_task Assign/unassign a task
get_task_context Get everything about a task in one call

Communication

Tool Description
add_comment Add comment to a task (markdown)
publish_event Publish event + optional memory hint for persistence

Memory

Tool Description
recall Search memory by keywords
remember Save knowledge (UPSERT by key)
forget Delete a memory entry

Utility

Tool Description
report_error Report an error on a task
session_report Report session metrics (model, tokens, cost)

MCP Tools - Full Profile (adds 25 more)

Additional Task Tools

Tool Description
get_project Get project details with statuses and custom fields
create_subtask Create subtask under a parent
add_dependency Add dependency between tasks
checkout_task Atomic task lock for multi-agent coordination
release_task Release atomic task lock

Comments & Artifacts

Tool Description
list_comments List task comments
upload_artifact Upload file/code/log to a task
list_artifacts List task artifacts
get_artifact Get artifact details and download URL

Event Bus

Tool Description
publish_summary Publish work summary (convenience wrapper)
subscribe_events Configure webhook delivery for events
poll_tasks Long-poll for new task assignments

Agent & Team

Tool Description
register_sub_agent Register a sub-agent
list_sub_agents List sub-agents (optionally recursive)
get_team_directory Get workspace team directory
update_agent_profile Update agent role, capabilities, profile

Governance & Config

Tool Description
get_project_rules Get all project rules
get_assignment_rules Get assignment rules
get_workflow_rules Get workflow rules with caller permissions
import_workspace_config Import workspace config from YAML
export_workspace_config Export workspace config as YAML

Recurring Tasks

Tool Description
create_recurring_task Create recurring task schedule
list_recurring_schedules List recurring schedules
get_recurring_history Get instance history for a schedule
trigger_recurring_now Trigger next instance immediately

Architecture

AI Agent (Claude Code / Cursor / Cline / OpenClaw)
    ↕ MCP (stdio or SSE)
EVC Mesh MCP Server (core or full profile)
    ↕ REST API (HTTP)
EVC Mesh API Server
    ↕
PostgreSQL / Redis / NATS / S3

The MCP server is a lightweight proxy - it translates MCP tool calls into REST API requests. No direct database access needed.

Deploy checklist (prod server - no CI)

evc-mesh-mcp has no CD pipeline; deploys are manual. Mandatory order (per
CLAUDE-workflow.md §1b Deploy Discipline):
migrate (goose up)binary swaprestart. Never swap the binary before migrations pass.

# 1. Build for the prod target
GOOS=linux GOARCH=amd64 go build -o evc-mesh-mcp .

# 2. Copy binary to prod
scp evc-mesh-mcp root@prod-host:/opt/evc-mesh-mcp/evc-mesh-mcp.new

# 3. On the prod host: run migrations FIRST, then swap binary
ssh root@prod-host

  # STEP 1 - Run evc-mesh DB migrations (mcp server reads the same DB).
  # goose CLI is not installed on the host - use the official docker image.
  # If this exits non-zero, STOP - do NOT swap the binary.
  DB_URL=$(grep ^DATABASE_URL /opt/evc-mesh/.env.prod | cut -d= -f2-)
  docker run --rm --network host \
    -v /opt/evc-mesh/migrations:/migrations \
    ghcr.io/pressly/goose:latest \
    goose -dir /migrations postgres "$DB_URL" up

  # STEP 2 - Swap binary (only after migrations succeed)
  mv /opt/evc-mesh-mcp/evc-mesh-mcp /opt/evc-mesh-mcp/evc-mesh-mcp.bak.$(date +%Y%m%d-%H%M%S)
  mv /opt/evc-mesh-mcp/evc-mesh-mcp.new /opt/evc-mesh-mcp/evc-mesh-mcp

  # STEP 3 - Restart
  sudo systemctl restart evc-mesh-mcp

  # STEP 4 - Smoke test
  curl -sf http://localhost:8081/health || echo "SMOKE FAILED"

evc-mesh-mcp does not run its own migrations - it relies on the evc-mesh API's
schema. The goose step above ensures the schema matches before the new binary serves traffic.

Related

FAQ

Common questions

Trust

How it checks out

Official By maintainer
Downloads 13

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.