> ## Documentation Index
> Fetch the complete documentation index at: https://docs.plugged.in/llms.txt
> Use this file to discover all available pages before exploring further.

# Team Collaboration

> Set up team workspaces, manage permissions, and collaborate effectively with your team in Plugged.in

# 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

<Steps>
  <Step title="Navigate to Settings">
    Go to **Settings** → **Organization** in your dashboard
  </Step>

  <Step title="Create Organization">
    Click "Create Organization" and enter your organization details:

    * Organization name
    * Description
    * Website (optional)
    * Logo (optional)
  </Step>

  <Step title="Configure Settings">
    Set up organization preferences:

    * Default language
    * Time zone
    * Notification preferences
  </Step>

  <Step title="Invite Team Members">
    Add team members by email invitation
  </Step>
</Steps>

### 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:

```javascript theme={null}
// 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:

<AccordionGroup>
  <Accordion title="Project Owner">
    * Full control over project settings
    * Can delete the project
    * Manage all team members
    * Access all resources
  </Accordion>

  <Accordion title="Project Admin">
    * Manage project settings
    * Add/remove team members
    * Create and modify resources
    * Cannot delete project
  </Accordion>

  <Accordion title="Project Member">
    * Create and manage MCP servers
    * Upload documents to knowledge base
    * Use shared resources
    * Cannot modify project settings
  </Accordion>

  <Accordion title="Project Viewer">
    * View project resources
    * Use shared MCP servers
    * Read knowledge base
    * Cannot make changes
  </Accordion>
</AccordionGroup>

## Sharing MCP Servers

### Share Within Organization

Make your MCP servers available to your team:

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

### Collection Sharing

Group related servers into collections for easier sharing:

```json theme={null}
{
  "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"]
    }
  }
}
```

### Best Practices for Server Sharing

<Warning>
  Never share servers containing sensitive credentials directly. Use environment variables or secure vaults.
</Warning>

#### Secure Credential Management

```json theme={null}
{
  "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:

1. **Create Knowledge Base**
   ```bash theme={null}
   POST /api/knowledge-bases
   {
     "name": "Team Documentation",
     "project_id": "project-uuid",
     "visibility": "organization",
     "contributors": ["user1", "user2"]
   }
   ```

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

3. **Version Control**
   All changes are tracked with attribution:
   ```json theme={null}
   {
     "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

<CardGroup cols={2}>
  <Card title="Real-time Collaboration" icon="sync">
    Multiple users can work on documents simultaneously with conflict resolution
  </Card>

  <Card title="Comment System" icon="comment">
    Add inline comments and discussions on specific document sections
  </Card>

  <Card title="Change Tracking" icon="history">
    Full version history with diff viewing and rollback capabilities
  </Card>

  <Card title="Review Workflow" icon="check-circle">
    Submit documents for review and approval before publishing
  </Card>
</CardGroup>

## Team Activity Monitoring

### Activity Dashboard

Monitor team activity through the dashboard:

```javascript theme={null}
// 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:

```javascript theme={null}
// 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:

<Tabs>
  <Tab title="Slack">
    ```bash theme={null}
    POST /api/integrations/slack
    {
      "webhook_url": "https://hooks.slack.com/services/...",
      "channel": "#mcp-updates",
      "events": [
        "server.created",
        "server.shared",
        "collection.published"
      ]
    }
    ```
  </Tab>

  <Tab title="Microsoft Teams">
    ```bash theme={null}
    POST /api/integrations/teams
    {
      "webhook_url": "https://outlook.office.com/webhook/...",
      "events": [
        "server.error",
        "usage.limit_reached"
      ]
    }
    ```
  </Tab>

  <Tab title="Discord">
    ```bash theme={null}
    POST /api/integrations/discord
    {
      "webhook_url": "https://discord.com/api/webhooks/...",
      "events": ["all"]
    }
    ```
  </Tab>
</Tabs>

## Access Control Best Practices

### Principle of Least Privilege

Grant users only the permissions they need:

```javascript theme={null}
// 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:

```javascript theme={null}
// 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:

```javascript theme={null}
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:

```javascript theme={null}
// 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**:

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

### Sync Issues

**Issue**: Changes not reflecting for team members
**Solution**:

```bash theme={null}
# 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**:

1. Check notification preferences in user settings
2. Verify email addresses are confirmed
3. Review organization notification settings
4. Check spam/junk folders for email notifications

## Best Practices Summary

<Note>
  Key practices for effective team collaboration:
</Note>

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

## Next Steps

<CardGroup cols={2}>
  <Card title="Custom MCP Server" icon="code" href="/tutorials/custom-mcp-server">
    Learn to build custom MCP servers for your team
  </Card>

  <Card title="Self-Hosting" icon="server" href="/tutorials/self-hosting">
    Deploy Plugged.in on your own infrastructure
  </Card>
</CardGroup>

## Additional Resources

* [Organization Management](/platform/user-management)
* [Security Best Practices](/security/overview)
* [API Documentation](/api/reference)
* [Support Community](https://github.com/orgs/VeriTeknik/discussions)