Integration Workflows

What You'll Learn

Practical integration workflows combining custom subagents, rules, and MCP servers for real-world development scenarios.

Integration Methods

Philosophy: Combine methods to create comprehensive workflows tailored to your needs.

Common Integration Patterns

Database Development Workflow

Stack: Migration Reviewer Subagent + AGENTS.md Standards + PostgreSQL MCP Server

Subagent:

---
name: migration-reviewer
description: Reviews database migrations for safety
---
Checks: Destructive operations, reversibility, indexing, blocking operations

AGENTS.md:

## Database Standards
- All migrations reviewed by @migration-reviewer
- Test on staging before production
- Include rollback procedures

MCP: PostgreSQL server for query execution, schema inspection, migration validation

Workflow: Write migration → @migration-reviewer validates → MCP tests on staging → PR documentation

API Development with Security

Stack: Security Auditor + AGENTS.md Rules + Custom API Testing Tool

Components:

• Subagent: @api-security-auditor - Input validation, SQL injection, auth, rate limiting
• Rules: All endpoints require security review, rate limiting on public APIs
• External Tools: Automated endpoint testing and security scans via custom integration

Result: Automatic security review before PR approval.

Frontend Accessibility

Stack: Accessibility Auditor + WCAG Rules + Lighthouse Integration

Workflow:

Create component → @a11y-auditor reviews → Lighthouse tests accessibility → Rules enforce >90 score

MCP Configuration Examples

Understanding MCP

Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context to LLMs. MCP servers are executables that implement the protocol. They're not database connections or API endpoints, but programs that run and communicate via JSON-RPC 2.0.

Key Concepts:

• MCP Servers: Executables (Node.js packages, Python scripts, etc.) that implement the MCP protocol
• Configuration: Tells Verdent how to start the server (command + args)
• Communication: Servers handle their own business logic (queries, API calls, etc.)

Basic Setup

Location: .mcp.json in project root

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/myapp_dev"
      ]
    }
  }
}

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/myapp_dev"
      ]
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Explanation:

• mcpServers - Required top-level key for MCP configuration
• command - Executable to run (typically npx for Node.js packages)
• args - Arguments passed to the command (package name, connection strings, etc.)
• env - Environment variables for authentication/configuration

Multi-Environment

{
  "mcpServers": {
    "postgres-dev": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "${DEV_DATABASE_URL}"
      ]
    },
    "postgres-staging": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "${STAGING_DATABASE_URL}"
      ]
    },
    "postgres-prod": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "${PROD_DATABASE_URL}"
      ]
    }
  }
}

Best Practice: Use environment variables for connection strings to keep credentials secure. MCP servers handle read-only behavior internally based on their implementation. Consult specific server documentation for access control options.

Workspace Integration

Project-Specific Configuration

Setup:

1. Store in project root: .mcp.json
2. Commit to version control for team sharing
3. Team members automatically use project MCP servers

Microservices Example:

{
  "mcpServers": {
    "users-db": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/users"
      ]
    },
    "orders-db": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5433/orders"
      ]
    }
  }
}

Team Collaboration

Shared AGENTS.md Standards

Commit to version control for team-wide consistency:

# AGENTS.md

## Code Review Process
- Run @code-reviewer before PR
- Address all security warnings
- Minimum 80% test coverage

## Integration Requirements
- @migration-reviewer for database changes
- @api-security-auditor for new endpoints
- @a11y-auditor for UI components

## MCP Servers
- Use postgres-staging MCP server for queries
- Never use postgres-prod MCP server for exploratory queries

Benefits: Consistent behavior, enforced standards, automatic quality gates.

Multi-Agent Coordination

Complex Feature Workflow

Example: New payment endpoint

1. Developer request → 2. Main agent generates code →
3. @api-security-auditor reviews security →
4. @migration-reviewer validates schema →
5. MCP tests on staging →
6. Main agent generates tests and PR

Result: Fully reviewed endpoint with security and database best practices applied.

Integration Best Practices

Progressive Adoption

Phase 1: Basic rules

## Code Standards
- Use TypeScript strict mode
- Run tests before commit

Phase 2: Add specialized subagent

## Code Review
- Run @security-reviewer before PR

Phase 3: Integrate MCP

## Database Access
- Use MCP postgres-staging for queries

Strategic Combinations

Team Documentation Best Practices

When documenting integrations for your team, include:

• Custom Subagents: List each subagent's name, purpose, and when to invoke it
• AGENTS.md Rules: Document rules with rationale explaining the "why" behind each standard
• MCP Servers: Describe each server's purpose, access level (read-only/write), and when to use it
• Integration Workflows: Provide example workflows showing how components work together
• Troubleshooting: Document common issues specific to your setup and their solutions

Troubleshooting

See Also