Team MCP Server Limits

const totalInstallations = await db
  .select()
  .from(mcpServerInstallations)
  .where(eq(mcpServerInstallations.team_id, teamId));

const totalCount = totalInstallations.length;

if (totalCount >= team.mcp_server_limit) {
  throw new Error(`Team has reached the maximum limit of ${team.mcp_server_limit} MCP server installations`);
}

Team Limit: mcp_server_limit = 5

Current Installations:
- 2 catalog STDIO servers (sequential-thinking, filesystem)
- 1 catalog HTTP server (context7)
- 2 GitHub-deployed servers (custom-mcp-1, custom-mcp-2)

Total: 5 installations ✅ (at limit)

const currentInstallations = await db
  .select({
    installation: mcpServerInstallations,
    server: mcpServers
  })
  .from(mcpServerInstallations)
  .leftJoin(mcpServers, eq(mcpServerInstallations.server_id, mcpServers.id))
  .where(eq(mcpServerInstallations.team_id, teamId));

// Count only stdio servers from catalog
const nonHttpCount = currentInstallations.filter(
  (row) => row.server?.transport_type === 'stdio' &&
           (row.server?.source === 'official_registry' || row.server?.source === 'manual')
).length;

if (nonHttpCount >= team.non_http_mcp_limit) {
  throw new Error(`Team has reached the maximum limit of ${team.non_http_mcp_limit} non-HTTP (stdio) MCP servers`);
}

Team Limit: non_http_mcp_limit = 1

Current Catalog Installations:
- 1 STDIO server (sequential-thinking) ✅ (at limit)
- 2 HTTP servers (context7, brightdata) ✅ (not counted)

GitHub Installations:
- 2 STDIO servers (custom-mcp-1, custom-mcp-2) ✅ (not counted - separate limit)

Result: 1 catalog STDIO server ✅ (at limit)

const githubInstallations = await db
  .select()
  .from(mcpServerInstallations)
  .leftJoin(mcpServers, eq(mcpServerInstallations.server_id, mcpServers.id))
  .where(
    and(
      eq(mcpServerInstallations.team_id, teamId),
      eq(mcpServers.source, 'github')
    )
  );

const githubCount = githubInstallations.length;

if (githubCount >= team.github_mcp_limit) {
  throw new Error(`Team has reached the maximum limit of ${team.github_mcp_limit} GitHub MCP server deployments`);
}

Team Limit: github_mcp_limit = 1

Current GitHub Deployments:
- 1 GitHub server (custom-mcp-server) ✅ (at limit)

Catalog Installations:
- 3 catalog servers (any type) ✅ (not counted - separate limit)

Result: 1 GitHub deployment ✅ (at limit)

// File: services/backend/src/routes/admin/teams/update.ts:187

const minimumRequired = finalNonHttpLimit + finalGithubLimit;

if (finalMcpServerLimit < minimumRequired) {
  throw new Error(
    `mcp_server_limit (${finalMcpServerLimit}) must be at least ${minimumRequired} ` +
    `(non_http_mcp_limit: ${finalNonHttpLimit} + github_mcp_limit: ${finalGithubLimit})`
  );
}

Configuration:
- non_http_mcp_limit = 2
- github_mcp_limit = 3
- mcp_server_limit = 5 ✅ (valid: 5 >= 2 + 3)

Maximum possible installations:
- 2 catalog STDIO servers
- 3 GitHub servers
- Total: 5 installations

If mcp_server_limit = 4 ❌ (invalid: 4 < 2 + 3)

export const teams = pgTable('teams', {
  id: text('id').primaryKey(),
  name: text('name').notNull(),
  // ... other fields

  // Limit fields
  non_http_mcp_limit: integer('non_http_mcp_limit').notNull().default(1),
  mcp_server_limit: integer('mcp_server_limit').notNull().default(5),
  github_mcp_limit: integer('github_mcp_limit').notNull().default(1),

  // ... other fields
});

export const mcpServerInstallations = pgTable('mcpServerInstallations', {
  id: text('id').primaryKey(),
  team_id: text('team_id').notNull().references(() => teams.id),
  server_id: text('server_id').notNull().references(() => mcpServers.id),
  // ... other fields
});

export const mcpServers = pgTable('mcpServers', {
  id: text('id').primaryKey(),
  name: text('name').notNull(),

  // Key fields for limits
  source: text('source', { enum: ['official_registry', 'manual', 'github'] }).notNull(),
  transport_type: text('transport_type', { enum: ['stdio', 'http', 'sse'] }).notNull(),
  visibility: text('visibility').notNull().default('team'),
  owner_team_id: text('owner_team_id').references(() => teams.id),

  // ... other fields
});

const totalInstallations = await db
  .select()
  .from(mcpServerInstallations)
  .where(eq(mcpServerInstallations.team_id, teamId));

const totalCount = totalInstallations.length;

// Get server source
const [server] = await db
  .select({ source: mcpServers.source })
  .from(mcpServers)
  .where(eq(mcpServers.id, serverId));

if (server.source === 'github') {
  console.log('GitHub-deployed server');
} else {
  console.log('Catalog server');
}

const stdioInstallations = await db
  .select()
  .from(mcpServerInstallations)
  .leftJoin(mcpServers, eq(mcpServerInstallations.server_id, mcpServers.id))
  .where(
    and(
      eq(mcpServerInstallations.team_id, teamId),
      eq(mcpServers.transport_type, 'stdio')
    )
  );

const stdioCount = stdioInstallations.length;

throw new Error(
  `Team has reached the maximum limit of ${limit} MCP server installations. ` +
  `Current installations: ${currentCount}. ` +
  `Please remove existing installations or contact your administrator to increase the limit.`
);

async function getTotalInstallations(teamId: string): Promise<number> {
  const installations = await db
    .select()
    .from(mcpServerInstallations)
    .where(eq(mcpServerInstallations.team_id, teamId));

  return installations.length;
}

async function getCatalogStdioCount(teamId: string): Promise<number> {
  const installations = await db
    .select()
    .from(mcpServerInstallations)
    .leftJoin(mcpServers, eq(mcpServerInstallations.server_id, mcpServers.id))
    .where(
      and(
        eq(mcpServerInstallations.team_id, teamId),
        eq(mcpServers.transport_type, 'stdio'),
        or(
          eq(mcpServers.source, 'official_registry'),
          eq(mcpServers.source, 'manual')
        )
      )
    );

  return installations.length;
}

async function getGithubDeploymentCount(teamId: string): Promise<number> {
  const installations = await db
    .select()
    .from(mcpServerInstallations)
    .leftJoin(mcpServers, eq(mcpServerInstallations.server_id, mcpServers.id))
    .where(
      and(
        eq(mcpServerInstallations.team_id, teamId),
        eq(mcpServers.source, 'github')
      )
    );

  return installations.length;
}

async function checkTeamLimits(teamId: string, serverId: string): Promise<void> {
  // Get team limits
  const [team] = await db
    .select({
      mcp_server_limit: teams.mcp_server_limit,
      non_http_mcp_limit: teams.non_http_mcp_limit,
      github_mcp_limit: teams.github_mcp_limit
    })
    .from(teams)
    .where(eq(teams.id, teamId));

  // Get server details
  const [server] = await db
    .select({
      source: mcpServers.source,
      transport_type: mcpServers.transport_type
    })
    .from(mcpServers)
    .where(eq(mcpServers.id, serverId));

  // Check total installations limit
  const totalCount = await getTotalInstallations(teamId);
  if (totalCount >= team.mcp_server_limit) {
    throw new Error(`Team has reached the maximum limit of ${team.mcp_server_limit} MCP server installations`);
  }

  // Check catalog STDIO limit (if applicable)
  if (
    server.transport_type === 'stdio' &&
    (server.source === 'official_registry' || server.source === 'manual')
  ) {
    const stdioCount = await getCatalogStdioCount(teamId);
    if (stdioCount >= team.non_http_mcp_limit) {
      throw new Error(`Team has reached the maximum limit of ${team.non_http_mcp_limit} non-HTTP (stdio) MCP servers`);
    }
  }

  // Check GitHub deployment limit (if applicable)
  if (server.source === 'github') {
    const githubCount = await getGithubDeploymentCount(teamId);
    if (githubCount >= team.github_mcp_limit) {
      throw new Error(`Team has reached the maximum limit of ${team.github_mcp_limit} GitHub MCP server deployments`);
    }
  }
}