SidStack LogoSidStack

MCP Server Reference

Complete reference for all 22 MCP tools. Integrate SidStack with Claude Code to give AI agents access to project knowledge, task management, impact analysis, and training.

What is MCP?

The Model Context Protocol (MCP) is an open standard that allows AI assistants like Claude to interact with external tools and data sources. SidStack's MCP server exposes your project knowledge, governance rules, and task management to AI agents.

Learn more at modelcontextprotocol.io

Configuration

Add SidStack to your Claude Code MCP configuration. After running sidstack init, this is auto-generated in your project's .mcp.json:

// .mcp.json (project-level, auto-generated)
{
  "mcpServers": {
    "sidstack": {
      "command": "npx",
      "args": ["@sidstack/mcp-server"]
    }
  }
}

Or for global configuration in Claude Desktop:

// .mcp.json (in your project root)
{
  "mcpServers": {
    "sidstack": {
      "command": "npx",
      "args": ["-y", "@sidstack/mcp-server"]
    }
  }
}

Tool Overview

Knowledge(5 tools)
knowledge_contextBuild session context for Claude from linked entities (task, module, spec, ticket)
knowledge_searchSearch across all knowledge documents
knowledge_listList all knowledge documents from
knowledge_getGet a single knowledge document by ID with full content, metadata, related documents, and dependencies
knowledge_modulesList all modules with their knowledge document counts and types
Tasks(5 tools)
task_createCreate a new task with governance auto-linked based on task type
task_updateUpdate task status, progress, or notes
task_listList tasks with smart filtering
task_getGet a task by ID with full details including governance links, acceptance criteria, and history
task_completeComplete a task with governance validation
Impact Analysis(3 tools)
impact_analyzeRun impact analysis on a planned change
impact_check_gateCheck the implementation gate status for an analysis
impact_listList impact analyses for a project, task, or spec
Tickets(4 tools)
ticket_createCreate a new ticket from external source or manual input
ticket_listList tickets with optional filters by status, type, and priority
ticket_updateUpdate a ticket's status, priority, assignee, or labels
ticket_convert_to_taskConvert a ticket to a governed task for agent execution
Training Room(2 tools)
lesson_createCreate a lesson from one or more incidents
rule_checkGet applicable rules for a given context
Sessions(1 tools)
session_launchLaunch a Claude Code session in an external terminal
OKRs(2 tools)
okr_listList project OKRs with progress summary
okr_updateUpdate progress for one or more Key Results

Tool Reference

Knowledge

Access and search your project's structured knowledge base. Documents are stored in .sidstack/knowledge/ as markdown files with frontmatter.

knowledge_context

Build session context for Claude from linked entities (task, module, spec, ticket). Returns formatted markdown ready for injection into agent prompts.

Parameters: projectPath, taskId?, moduleId?, specId?, ticketId?, maxLength?
knowledge_context({
  projectPath: "/path/to/project",
  moduleId: "auth",
  taskId: "task-123"
})

knowledge_search

Search across all knowledge documents. Returns matching documents with summaries. Searches in title, ID, summary, module, and tags.

Parameters: projectPath, query, type?[], limit?
knowledge_search({
  projectPath: "/path/to/project",
  query: "authentication flow",
  type: ["business-logic", "api-endpoint"]
})

knowledge_list

List all knowledge documents from .sidstack/ (knowledge, skills, principles, modules). Returns summaries without full content.

Parameters: projectPath, type?[], module?, status?, search?, limit?
knowledge_list({
  projectPath: "/path/to/project",
  type: ["api-endpoint"],
  module: "auth"
})

knowledge_get

Get a single knowledge document by ID with full content, metadata, related documents, and dependencies.

Parameters: projectPath, docId
knowledge_get({
  projectPath: "/path/to/project",
  docId: "auth-login-flow"
})

knowledge_modules

List all modules with their knowledge document counts and types. Useful for understanding project structure.

Parameters: projectPath
knowledge_modules({
  projectPath: "/path/to/project"
})

Tasks

Create and manage tasks with governance auto-linking, quality gates, and smart filtering.

task_create

Create a new task with governance auto-linked based on task type. Accepts title in [TYPE] format, description, priority, and acceptance criteria.

Parameters: projectId, title, description, taskType?, priority?, assignedAgent?, acceptanceCriteria?[]
task_create({
  projectId: "my-project",
  title: "[feature] Add OAuth2 login",
  description: "Implement OAuth2 flow with Google provider...",
  taskType: "feature",
  priority: "high"
})

task_update

Update task status, progress, or notes. Use to track work progress through the task lifecycle.

Parameters: taskId, status?, progress?, notes?
task_update({
  taskId: "task-123",
  status: "in_progress",
  progress: 50,
  notes: "Completed API endpoints, starting UI"
})

task_list

List tasks with smart filtering. Presets: actionable (default), blocked, recent, epics, all. Supports search, status, type, and priority filters.

Parameters: projectId, preset?, status?[], search?, taskType?[], priority?, limit?, offset?
task_list({
  projectId: "my-project",
  preset: "actionable"
})

task_get

Get a task by ID with full details including governance links, acceptance criteria, and history.

Parameters: taskId
task_get({ taskId: "task-123" })

task_complete

Complete a task with governance validation. Validates quality gates and blocks if requirements not met. Use force=true to bypass (logs violation).

Parameters: taskId, agentId?, force?, reason?
task_complete({
  taskId: "task-123",
  agentId: "worker-1"
})

Impact Analysis

Analyze planned changes for scope, risks, data flows, and generate validation checklists before implementation.

impact_analyze

Run impact analysis on a planned change. Analyzes scope (affected modules, files), risks (severity, blocking status), data flows, and generates a validation checklist.

Parameters: description, projectId?, taskId?, specId?, changeType?, targetModules?[], targetFiles?[]
impact_analyze({
  description: "Add OAuth2 authentication",
  projectId: "my-project",
  changeType: "feature",
  targetModules: ["auth", "api"]
})

impact_check_gate

Check the implementation gate status for an analysis. Returns blocked, warning, or clear status with details about blockers.

Parameters: analysisId?, taskId?, specId?
impact_check_gate({
  taskId: "task-123"
})

impact_list

List impact analyses for a project, task, or spec. Filter by status (pending, analyzing, completed, failed).

Parameters: projectId?, taskId?, specId?, status?, limit?
impact_list({
  projectId: "my-project",
  status: "completed"
})

Tickets

External issue intake from Jira, GitHub, Linear, or manual entry. Triage, review, and convert to tasks.

ticket_create

Create a new ticket from external source or manual input. Supports types: bug, feature, improvement, task, epic.

Parameters: projectId, title, description?, type?, priority?, externalId?, source?, labels?[], externalUrls?[], reporter?
ticket_create({
  projectId: "my-project",
  title: "Login fails on slow connections",
  type: "bug",
  priority: "high",
  source: "github",
  externalId: "#456"
})

ticket_list

List tickets with optional filters by status, type, and priority.

Parameters: projectId, status?[], type?[], priority?[], limit?
ticket_list({
  projectId: "my-project",
  status: ["new", "reviewing"]
})

ticket_update

Update a ticket's status, priority, assignee, or labels.

Parameters: ticketId, status?, priority?, assignee?, labels?[]
ticket_update({
  ticketId: "ticket-456",
  status: "approved",
  assignee: "dev-team"
})

ticket_convert_to_task

Convert a ticket to a governed task for agent execution. Automatically maps ticket type to task type (bug->bugfix, feature->feature, etc.).

Parameters: ticketId
ticket_convert_to_task({
  ticketId: "ticket-456"
})

Training Room

Lessons-learned system. Create lessons from incidents and check applicable rules for continuous improvement.

lesson_create

Create a lesson from one or more incidents. Captures what went wrong (problem), why (root cause), and how to prevent it (solution).

Parameters: projectPath, moduleId, title, problem, rootCause, solution, incidentIds?[], applicability?
lesson_create({
  projectPath: "/path/to/project",
  moduleId: "auth",
  title: "Always validate JWT expiry",
  problem: "Expired tokens were accepted",
  rootCause: "Missing expiry check in middleware",
  solution: "Add exp validation to auth middleware"
})

rule_check

Get applicable rules for a given context. Use before performing actions to check what rules apply based on module, role, and task type.

Parameters: projectPath, moduleId, role, taskType
rule_check({
  projectPath: "/path/to/project",
  moduleId: "auth",
  role: "dev",
  taskType: "feature"
})

Sessions

Launch Claude Code sessions in external terminals with task context, governance skills, and training injected.

session_launch

Launch a Claude Code session in an external terminal. Optionally links to a task, module, and includes training context (skills, rules) in the session prompt.

Parameters: projectDir, taskId?, moduleId?, prompt?, mode?, terminal?, agentRole?, includeTraining?
session_launch({
  projectDir: "/path/to/project",
  taskId: "task-123",
  moduleId: "auth",
  agentRole: "dev",
  includeTraining: true
})

OKRs

Track project Objectives and Key Results. Data stored in .sidstack/project-okrs.json.

okr_list

List project OKRs with progress summary. Shows yearly overview, quarterly breakdown, objectives, and key results with current progress.

Parameters: projectPath, quarter?
okr_list({
  projectPath: "/path/to/project",
  quarter: "Q1-2026"
})

okr_update

Update progress for one or more Key Results. Use after completing features, milestones, or significant deliverables.

Parameters: projectPath, updates[{ krId, progress }], reason?
okr_update({
  projectPath: "/path/to/project",
  updates: [{ krId: "KR-1.1", progress: 75 }],
  reason: "Shipped knowledge editor v1"
})

Integration Guide

1. Initialize Project

Run sidstack init --governance in your project directory. This creates .mcp.json with the MCP server config, .sidstack/ with governance structure, and .claude/commands/ with slash commands.

2. Open in Claude Code

Open the project in Claude Code. It will automatically detect .mcp.json and start the MCP server. You may need to approve auto-approval settings in .claude/settings.local.json.

3. Use Tools

Claude will automatically use SidStack tools when relevant. You can also use slash commands like /sidstack:agent to explicitly invoke governance workflows. The CLAUDE.md file injected during init instructs Claude on task management protocols.

4. Build Knowledge

Use /sidstack:knowledge-builder or the CLI to create knowledge documents. These persist across sessions and provide context to every AI agent that works on your project.

Impact Analysis Risk Rules

The impact_analyze tool evaluates changes against these risk rules:

Core module modificationhigh
Multiple modules affectedmedium
Breaking API changeshigh
Database schema changeshigh
Security-sensitive codecritical
Gate status: blocked (must resolve)warning (can proceed)clear (safe)