Team Collaboration Tutorial

Learn how to set up team workspaces, manage permissions, and collaborate effectively with your team using Plugged.in’s collaboration features.

Overview

Plugged.in provides comprehensive team collaboration features that enable organizations to:

Create shared workspaces for teams
Manage user roles and permissions
Share MCP servers and collections
Collaborate on knowledge bases
Track team activity and usage

Setting Up Your Team

Create an Organization

Navigate to Settings

Go to Settings → Organization in your dashboard

Create Organization

Click “Create Organization” and enter your organization details:

Organization name
Description
Website (optional)
Logo (optional)

Configure Settings

Set up organization preferences:

Default language
Time zone
Notification preferences

Invite Team Members

Add team members by email invitation

Organization Roles

Plugged.in supports multiple organization roles with different permission levels:

Role	Description	Permissions
Owner	Organization owner	Full access to all features and settings
Admin	Administrator	Manage users, projects, and settings
Member	Team member	Create and manage own projects
Viewer	Read-only access	View shared resources only

Project Collaboration

Creating Team Projects

Projects in Plugged.in can be shared across your team:

// Create a team project via API
const project = await fetch('https://plugged.in/api/projects', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'Team Project',
    organization_id: 'org-uuid',
    visibility: 'organization', // or 'public', 'private'
    members: [
      { user_id: 'user1', role: 'admin' },
      { user_id: 'user2', role: 'member' }
    ]
  })
});

Project Roles and Permissions

Each project can have custom role assignments:

Project Owner

Full control over project settings
Can delete the project
Manage all team members
Access all resources

Project Admin

Manage project settings
Add/remove team members
Create and modify resources
Cannot delete project

Project Member

Create and manage MCP servers
Upload documents to knowledge base
Use shared resources
Cannot modify project settings

Project Viewer

View project resources
Use shared MCP servers
Read knowledge base
Cannot make changes

Make your MCP servers available to your team:

Navigate to MCP Servers
Select the server to share
Click Share → Organization
Configure sharing settings:
- Visibility: Organization-wide or specific teams
- Permissions: Use only, or allow modifications
- Notes: Add usage instructions

Group related servers into collections for easier sharing:

{
  "collection": {
    "name": "Development Tools",
    "description": "Essential development MCP servers",
    "servers": [
      "github-server-uuid",
      "database-server-uuid",
      "testing-server-uuid"
    ],
    "visibility": "organization",
    "permissions": {
      "install": ["member", "admin"],
      "modify": ["admin"]
    }
  }
}

Never share servers containing sensitive credentials directly. Use environment variables or secure vaults.

Secure Credential Management

{
  "server_config": {
    "name": "Database Server",
    "type": "STDIO",
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-postgres"],
    "env": {
      "DATABASE_URL": "${SECRET_DATABASE_URL}"
    }
  }
}

Team members provide their own credentials when installing.

Knowledge Base Collaboration

Shared Knowledge Bases

Create team knowledge bases for collective documentation:

Create Knowledge Base

POST /api/knowledge-bases
{
  "name": "Team Documentation",
  "project_id": "project-uuid",
  "visibility": "organization",
  "contributors": ["user1", "user2"]
}

Set Permissions
- Editors: Can add, modify, and delete documents
- Contributors: Can add and modify own documents
- Readers: Read-only access

Version Control All changes are tracked with attribution:

{
  "document_id": "doc-uuid",
  "version": 3,
  "changes": [
    {
      "version": 1,
      "author": "user1",
      "timestamp": "2024-01-15T10:00:00Z",
      "summary": "Initial version"
    },
    {
      "version": 2,
      "author": "user2",
      "timestamp": "2024-01-16T14:30:00Z",
      "summary": "Added API examples"
    }
  ]
}

Document Collaboration Features

Real-time Collaboration

Multiple users can work on documents simultaneously with conflict resolution

Comment System

Add inline comments and discussions on specific document sections

Change Tracking

Full version history with diff viewing and rollback capabilities

Review Workflow

Submit documents for review and approval before publishing

Team Activity Monitoring

Activity Dashboard

Monitor team activity through the dashboard:

// Fetch team activity
const activity = await fetch('https://plugged.in/api/organizations/activity', {
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY'
  }
});

// Response
{
  "activities": [
    {
      "user": "alice@company.com",
      "action": "created_server",
      "resource": "GitHub Integration",
      "timestamp": "2024-01-20T10:30:00Z"
    },
    {
      "user": "bob@company.com",
      "action": "shared_collection",
      "resource": "Dev Tools Collection",
      "timestamp": "2024-01-20T09:15:00Z"
    }
  ]
}

Usage Analytics

Track team usage and resource consumption:

Metric	Description	API Endpoint
Active Users	Daily/monthly active users	`/api/analytics/users`
Server Usage	Most used MCP servers	`/api/analytics/servers`
API Calls	API usage by user/project	`/api/analytics/api`
Storage	Knowledge base storage	`/api/analytics/storage`
Tool Executions	MCP tool usage stats	`/api/analytics/tools`

Communication and Notifications

Team Notifications

Set up team-wide notifications:

// Configure team notifications
const config = {
  organization_id: 'org-uuid',
  notifications: {
    server_errors: {
      enabled: true,
      channels: ['email', 'in_app'],
      recipients: ['admins']
    },
    new_shares: {
      enabled: true,
      channels: ['in_app'],
      recipients: ['all']
    },
    usage_alerts: {
      enabled: true,
      threshold: 90, // percentage
      channels: ['email'],
      recipients: ['owner', 'admins']
    }
  }
};

Integration with Communication Tools

Connect Plugged.in with your team’s communication tools:

Slack
Microsoft Teams
Discord

POST /api/integrations/slack
{
  "webhook_url": "https://hooks.slack.com/services/...",
  "channel": "#mcp-updates",
  "events": [
    "server.created",
    "server.shared",
    "collection.published"
  ]
}

POST /api/integrations/teams
{
  "webhook_url": "https://outlook.office.com/webhook/...",
  "events": [
    "server.error",
    "usage.limit_reached"
  ]
}

POST /api/integrations/discord
{
  "webhook_url": "https://discord.com/api/webhooks/...",
  "events": ["all"]
}

Access Control Best Practices

Principle of Least Privilege

Grant users only the permissions they need:

// Role-based access control
const permissions = {
  developer: [
    'servers.create',
    'servers.read',
    'servers.execute',
    'knowledge.read'
  ],
  analyst: [
    'servers.read',
    'servers.execute',
    'knowledge.read',
    'knowledge.write'
  ],
  admin: [
    'servers.*',
    'knowledge.*',
    'users.manage',
    'settings.modify'
  ]
};

Audit Logging

Enable comprehensive audit logging:

// Query audit logs
const auditLogs = await fetch('https://plugged.in/api/audit-logs', {
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY'
  },
  params: {
    start_date: '2024-01-01',
    end_date: '2024-01-31',
    user: 'user-uuid',
    action: 'server.delete'
  }
});

Workflow Automation

Automated Onboarding

Set up automated workflows for new team members:

class TeamOnboarding {
  async onboardMember(email, role) {
    // 1. Send invitation
    const invitation = await this.inviteUser(email, role);

    // 2. Create default project
    const project = await this.createProject({
      name: `${email} Workspace`,
      template: 'starter'
    });

    // 3. Install default servers
    await this.installDefaultServers(project.uuid);

    // 4. Share team collections
    await this.shareTeamCollections(project.uuid);

    // 5. Add to team channels
    await this.addToChannels(email);

    // 6. Send welcome email
    await this.sendWelcomeEmail(email, {
      project_uuid: project.uuid,
      getting_started_url: 'https://plugged.in/getting-started'
    });

    return { invitation, project };
  }
}

Approval Workflows

Implement approval processes for sensitive operations:

// Request approval for production server
const approvalRequest = await fetch('https://plugged.in/api/approvals', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    type: 'server_deployment',
    resource: {
      server_uuid: 'prod-server-uuid',
      environment: 'production'
    },
    approvers: ['admin1', 'admin2'],
    required_approvals: 2,
    deadline: '2024-01-25T00:00:00Z'
  })
});

Troubleshooting Common Issues

Permission Conflicts

Issue: User cannot access shared resources Solution:

Verify user is part of the organization
Check project membership and role
Confirm resource sharing settings
Review organization-wide permissions

Sync Issues

Issue: Changes not reflecting for team members Solution:

# Force sync via API
POST /api/sync/force
{
  "organization_id": "org-uuid",
  "resources": ["servers", "collections", "knowledge_bases"]
}

Notification Delivery

Issue: Team members not receiving notifications Solution:

Check notification preferences in user settings
Verify email addresses are confirmed
Review organization notification settings
Check spam/junk folders for email notifications

Best Practices Summary

Key practices for effective team collaboration:

Clear Role Definition: Define roles and responsibilities clearly
Regular Audits: Review permissions and access regularly
Documentation: Maintain comprehensive team documentation
Communication: Set up appropriate notification channels
Security: Use secure credential management practices
Training: Provide onboarding and training for team members
Monitoring: Track usage and activity for optimization

​Team Collaboration Tutorial

​Overview

​Setting Up Your Team

​Create an Organization

​Organization Roles

​Project Collaboration

​Creating Team Projects

​Project Roles and Permissions

​Sharing MCP Servers

​Share Within Organization

​Collection Sharing

​Best Practices for Server Sharing

​Secure Credential Management

​Knowledge Base Collaboration

​Shared Knowledge Bases

​Document Collaboration Features

Real-time Collaboration

Comment System

Change Tracking

Review Workflow

​Team Activity Monitoring

​Activity Dashboard

​Usage Analytics

​Communication and Notifications

​Team Notifications

​Integration with Communication Tools

​Access Control Best Practices

​Principle of Least Privilege

​Audit Logging

​Workflow Automation

​Automated Onboarding

​Approval Workflows

​Troubleshooting Common Issues

​Permission Conflicts

​Sync Issues

​Notification Delivery

​Best Practices Summary

​Next Steps

Custom MCP Server

Self-Hosting

​Additional Resources

Team Collaboration Tutorial

Overview

Setting Up Your Team

Create an Organization

Organization Roles

Project Collaboration

Creating Team Projects

Project Roles and Permissions

Sharing MCP Servers

Share Within Organization

Collection Sharing

Best Practices for Server Sharing

Secure Credential Management

Knowledge Base Collaboration

Shared Knowledge Bases

Document Collaboration Features

Team Activity Monitoring

Activity Dashboard

Usage Analytics

Communication and Notifications

Team Notifications

Integration with Communication Tools

Access Control Best Practices

Principle of Least Privilege

Audit Logging

Workflow Automation

Automated Onboarding

Approval Workflows

Troubleshooting Common Issues

Permission Conflicts

Sync Issues

Notification Delivery

Best Practices Summary

Next Steps

Additional Resources