RooCode Integration

Integrate Dispersl with RooCode through Model Context Protocol (MCP) to enhance your collaborative development environment with multi-agent AI capabilities and specialized development workflows.

What You'll Get

With Dispersl integrated into RooCode, you can:

Enhance collaborative coding with multi-agent coordination
Generate complex applications with specialized AI agents
Automate team development workflows with dedicated agents
Manage collaborative Git operations through AI assistance
Generate shared documentation automatically
Coordinate multiple development tasks across team members

Prerequisites

RooCode account and workspace access
Active Dispersl account with API access
Dispersl MCP key (obtained from your dashboard)
Team permissions for MCP integrations

Setup Instructions

Step 1: Get Your Dispersl MCP Key

Obtain your Dispersl MCP key:

Log into your Dispersl dashboard
Navigate to Settings → MCP Integration
Generate a new MCP key or copy your existing key
Save this key securely for configuration

Or via API:

curl -X GET "https://api.dispersl.com/v1/mcp/key" \
  -H "Authorization: Bearer YOUR_DISPERSL_API_KEY"

Step 2: Configure RooCode MCP Integration

Workspace Configuration

Open RooCode workspace settings
Navigate to Integrations → MCP Servers
Add new MCP server:

{
  "name": "dispersl",
  "url": "https://dispersl.com/mcp/YOUR_DISPERSL_MCP_KEY",
  "enabled": true,
  "shared": true
}

Team Configuration

For team-wide access, configure in team settings:

{
  "team_mcp_servers": {
    "dispersl": {
      "url": "https://dispersl.com/mcp/YOUR_DISPERSL_MCP_KEY",
      "permissions": ["read", "write", "execute"],
      "team_access": true,
      "project_scoped": false
    }
  }
}

Step 3: Project-Specific Configuration

Create .dispersl-roocode.json in your project root:

{
  "roocode_integration": {
    "enabled": true,
    "collaborative_mode": true,
    "team_coordination": true,
    "shared_context": true
  },
  "agents": {
    "code": {
      "model": "anthropic/claude-3-sonnet",
      "collaborative_editing": true,
      "team_awareness": true,
      "conflict_resolution": "smart_merge"
    },
    "test": {
      "model": "openai/gpt-4",
      "shared_testing": true,
      "team_coverage": true,
      "collaborative_reviews": true
    },
    "git": {
      "model": "deepseek/deepseek-r1",
      "team_workflows": true,
      "collaborative_commits": true,
      "merge_assistance": true
    },
    "docs": {
      "model": "google/gemini-pro",
      "shared_documentation": true,
      "team_standards": true,
      "collaborative_editing": true
    }
  },
  "team_settings": {
    "shared_memory": true,
    "context_synchronization": true,
    "collaborative_planning": true,
    "team_notifications": true
  }
}

Step 4: Configure Team Permissions

Set up team access controls:

{
  "dispersl_permissions": {
    "team_lead": {
      "agents": ["plan", "code", "test", "git", "docs"],
      "coordination": true,
      "admin_access": true
    },
    "senior_developer": {
      "agents": ["code", "test", "git", "docs"],
      "coordination": true,
      "admin_access": false
    },
    "developer": {
      "agents": ["code", "test", "docs"],
      "coordination": false,
      "admin_access": false
    },
    "intern": {
      "agents": ["code", "docs"],
      "coordination": false,
      "admin_access": false
    }
  }
}

Verification

Test your Dispersl integration in RooCode:

Open RooCode workspace
Access the AI assistant panel

Test the connection:

@dispersl Show available agents for team collaboration

Test team coordination:

@dispersl Plan a feature that multiple team members can work on simultaneously

If successful, you'll see Dispersl agents available for team coordination.

Using Dispersl in RooCode

Collaborative Development

Team Feature Development

@dispersl Plan a user authentication system for team development:

Requirements:
- Multiple developers working simultaneously
- Frontend and backend components
- Comprehensive testing strategy
- Shared documentation
- Coordinated Git workflow

Please create a plan that allows team members to work on different parts without conflicts.

Collaborative Code Review

@dispersl Review this pull request with team context:
- Analyze code quality and standards
- Check for integration issues
- Suggest improvements
- Coordinate with team coding standards
- Generate review comments for team discussion

Multi-Agent Team Coordination

Distributed Development

Team Project: E-commerce Platform

Team Member 1 (Frontend):
- @dispersl Generate React components for product catalog
- Coordinate with backend API requirements
- Ensure consistent UI/UX patterns

Team Member 2 (Backend):
- @dispersl Create API endpoints for product management
- Coordinate with frontend data requirements
- Implement proper authentication

Team Member 3 (Testing):
- @dispersl Generate comprehensive test suites
- Coordinate with both frontend and backend changes
- Set up automated testing pipeline

Dispersl coordinates all agents to ensure compatibility and consistency.

Collaborative Architecture Planning

@dispersl Plan microservices architecture for team development:

Team Structure:
- 3 backend developers
- 2 frontend developers  
- 1 DevOps engineer
- 1 QA engineer

Requirements:
- Service separation for parallel development
- Shared API contracts
- Consistent testing strategies
- Coordinated deployment pipeline
- Shared documentation standards

Team Workflow Automation

Automated Code Integration

RooCode Workflow: Continuous Integration

1. Developer commits code
2. @dispersl Code Agent reviews changes
3. @dispersl Test Agent runs automated tests
4. @dispersl Git Agent manages merge conflicts
5. @dispersl Docs Agent updates documentation
6. Team notification of integration status
7. Automatic deployment if all checks pass

Team Knowledge Sharing

@dispersl Create team knowledge base:
- Document coding standards and patterns
- Generate onboarding materials
- Create troubleshooting guides
- Maintain architecture documentation
- Share best practices across team

Advanced Team Features

Collaborative Agent Coordination

Shared Context Management

{
  "shared_context": {
    "project_knowledge": true,
    "team_preferences": true,
    "coding_standards": true,
    "architecture_decisions": true,
    "shared_memory": true
  }
}

Team-Aware Code Generation

{
  "team_awareness": {
    "member_specializations": true,
    "workload_distribution": true,
    "skill_matching": true,
    "conflict_avoidance": true,
    "collaborative_suggestions": true
  }
}

Real-Time Collaboration

Live Coding Assistance

Multiple team members coding simultaneously:
- @dispersl provides context-aware suggestions
- Agents coordinate to avoid conflicts
- Real-time code quality feedback
- Shared debugging assistance
- Collaborative problem solving

Team Communication Integration

@dispersl Slack/Teams Integration:
- Notify team of agent activities
- Share code generation results
- Coordinate development tasks
- Alert on potential conflicts
- Provide progress updates

Best Practices

Team Coordination

Establish clear roles: Define which team members use which agents
Shared standards: Maintain consistent coding and documentation standards
Communication protocols: Set up clear communication about agent usage
Conflict resolution: Implement processes for handling agent conflicts

Collaborative Workflows

Parallel development: Use agents to enable simultaneous work on different components
Shared context: Ensure all team members benefit from shared agent knowledge
Code consistency: Use agents to maintain consistent code quality across the team
Knowledge sharing: Leverage agents to document and share team knowledge

Security and Access Control

Permission management: Control which team members can access which agents
Secure credentials: Manage MCP keys securely across the team
Audit trails: Track agent usage across team members
Data privacy: Ensure team code and data remain secure

Troubleshooting

Common Issues

"Team members can't access Dispersl agents"

Verify team permissions are configured correctly
Check that MCP server is enabled for team access
Ensure all team members have proper RooCode permissions
Restart RooCode workspace after configuration changes

"Agent coordination conflicts"

Review team workflow configurations
Check for conflicting agent instructions
Verify shared context is working properly
Coordinate agent usage timing across team

"Inconsistent agent behavior across team"

Ensure all team members use the same configuration
Verify shared context synchronization
Check for different MCP key configurations
Review team-specific agent settings

Team Coordination Issues

Establish communication protocols for agent usage
Coordinate agent scheduling to avoid conflicts
Share agent results effectively across the team
Monitor team agent usage and optimize accordingly
Regular team sync on agent effectiveness and improvements

Getting Help

Check RooCode team logs for integration issues
Review Dispersl team dashboard for usage analytics
Coordinate with team lead on configuration issues
Community support: Join our Discord for team collaboration tips
Enterprise support: Contact for team-specific assistance

Example Team Workflows

Agile Sprint Development

Sprint Planning with Dispersl:

Week 1: Sprint Planning
- @dispersl Plan Agent: Break down user stories
- Team assignment based on agent recommendations
- Shared architecture decisions

Week 2-3: Development
- Parallel development with agent coordination
- Continuous integration with agent assistance
- Real-time code quality monitoring

Week 4: Sprint Review
- @dispersl generates sprint summary
- Code quality metrics and team performance
- Documentation updates and knowledge sharing

Open Source Project Management

Community Development:
- @dispersl helps coordinate contributor work
- Automated code review for pull requests
- Documentation generation for new features
- Onboarding assistance for new contributors
- Consistent code quality across contributors

Enterprise Development Team

Large-Scale Application Development:
- Multiple teams working on different services
- Shared API contracts and documentation
- Coordinated testing strategies
- Consistent deployment pipelines
- Cross-team knowledge sharing

Next Steps

Set up team configuration following the instructions above
Coordinate with team members on agent usage protocols
Test collaborative workflows with simple team tasks
Scale to complex team projects with multi-agent coordination
Optimize team productivity with shared agent intelligence

Ready to enhance your RooCode team development with Dispersl's collaborative multi-agent AI platform!

N8n Vscode