Skip to main content
Glama

getProjectsReportingUtilization

Generate utilization reports for your team in CSV, HTML, PDF, or XLSX format. Filter by dates, projects, users, and more to get tailored insights.

Instructions

Generate utilization report in various formats (CSV, HTML, PDF, XLSX). Generates a utilization report containing all people for the provided filters. Only the people that the logged-in user can access will be returned.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
formatYesThe format of the report
zoomNodetermine the type of zoom filter used to display on the report
startDateNofilter by start date
sortOrderNoorder mode
sortNosort by (deprecated, use orderBy)
searchTermNofilter by user first or last name
reportFormatNodefine the format of the report
orderModeNogroup by
orderByNosort by
groupByNogroup by
endDateNofilter by end date
pageSizeNonumber of items in a page
pageNopage number
skipCountsNoSkipCounts allows you to skip doing counts on a list API endpoint for performance reasons.
legacyResponseNoreturn response without summary and its legacy body structure
isReportDownloadNogenerate a report document
isCustomDateRangeNodetermine if the query is for a custom date range
includeUtilizationsNoadds report rows for individual entities
includeTotalsNoadds report summary to response
includeCollaboratorsNoinclude collaborators
includeClientsNoinclude client users
includeArchivedProjectsNoinclude archived projects
IncludeCompletedTasksNoinclude completed tasks
userIdsNofilter by userIds
teamIdsNofilter by team ids
selectedColumnsNocustomise the report by selecting columns to be displayed.
projectIdsNofilter by project ids
jobRoleIdsNofilter by jobrole ids
includeNoinclude
fieldsUtilizationsNoQuery parameter: fields[utilizations]
fieldsUsersNoQuery parameter: fields[users]
companyIdsNofilter by company ids

Implementation Reference

  • The handler function that executes the getProjectsReportingUtilization tool logic. Calls the getUtilization service and returns JSON response.
    export async function handleGetProjectsReportingUtilization(input: any) {
      try {
        const data = await getUtilization({ ...input, format: input.format.toLowerCase() });
        return {
          content: [{
            type: "text",
            text: JSON.stringify(data, null, 2)
          }]
        };
      } catch (error: any) {
        return createErrorResponse(error, 'Getting utilization report');
      }
    } 
  • The tool definition (name, description, input schema) for getProjectsReportingUtilization, including all input properties and annotations.
    export const getProjectsReportingUtilizationDefinition = {
      name: "getProjectsReportingUtilization",
      description: "Generate utilization report in various formats (CSV, HTML, PDF, XLSX). Generates a utilization report containing all people for the provided filters. Only the people that the logged-in user can access will be returned.",
      inputSchema: {
        type: 'object',
        properties: {
          format: {
            type: 'string',
            description: 'The format of the report',
            enum: ['csv', 'html', 'pdf', 'xlsx']
          },
          zoom: {
            type: 'string',
            description: 'determine the type of zoom filter used to display on the report',
            enum: [
              'week',
              'month',
              'last3months',
              'quarterbyweek',
              'quarterbymonth'
            ]
          },
          startDate: {
            type: 'string',
            description: 'filter by start date'
          },
          sortOrder: {
            type: 'string',
            description: 'order mode',
            enum: [
              'asc',
              'desc'
            ]
          },
          sort: {
            type: 'string',
            description: 'sort by (deprecated, use orderBy)',
            enum: [
              'name',
              'percentutilization',
              'percentestimatedutilization',
              'availableminutes',
              'unavailableminutes',
              'loggedminutes',
              'billableminutes',
              'unbillableminutes',
              'billableutilization',
              'nonbillableutilization'
            ]
          },
          searchTerm: {
            type: 'string',
            description: 'filter by user first or last name'
          },
          reportFormat: {
            type: 'string',
            description: 'define the format of the report',
            enum: [
              'pdf'
            ]
          },
          orderMode: {
            type: 'string',
            description: 'group by',
            enum: [
              'weekly',
              'monthly'
            ]
          },
          orderBy: {
            type: 'string',
            description: 'sort by',
            enum: [
              'name',
              'percentutilization',
              'percentestimatedutilization',
              'availableminutes',
              'unavailableminutes',
              'loggedminutes',
              'billableminutes',
              'unbillableminutes',
              'companycount',
              'achieved',
              'target',
              'allocatedutilization',
              'totalworkingminutes',
              'availableutilization',
              'unavailableutilization'
            ]
          },
          groupBy: {
            type: 'string',
            description: 'group by',
            enum: [
              'day',
              'week',
              'month'
            ]
          },
          endDate: {
            type: 'string',
            description: 'filter by end date'
          },
          pageSize: {
            type: 'integer',
            description: 'number of items in a page'
          },
          page: {
            type: 'integer',
            description: 'page number'
          },
          skipCounts: {
            type: 'boolean',
            description: 'SkipCounts allows you to skip doing counts on a list API endpoint for performance reasons.'
          },
          legacyResponse: {
            type: 'boolean',
            description: 'return response without summary and its legacy body structure'
          },
          isReportDownload: {
            type: 'boolean',
            description: 'generate a report document'
          },
          isCustomDateRange: {
            type: 'boolean',
            description: 'determine if the query is for a custom date range'
          },
          includeUtilizations: {
            type: 'boolean',
            description: 'adds report rows for individual entities'
          },
          includeTotals: {
            type: 'boolean',
            description: 'adds report summary to response'
          },
          includeCollaborators: {
            type: 'boolean',
            description: 'include collaborators'
          },
          includeClients: {
            type: 'boolean',
            description: 'include client users'
          },
          includeArchivedProjects: {
            type: 'boolean',
            description: 'include archived projects'
          },
          IncludeCompletedTasks: {
            type: 'boolean',
            description: 'include completed tasks'
          },
          userIds: {
            type: 'array',
            description: 'filter by userIds'
          },
          teamIds: {
            type: 'array',
            description: 'filter by team ids'
          },
          selectedColumns: {
            type: 'array',
            description: 'customise the report by selecting columns to be displayed.'
          },
          projectIds: {
            type: 'array',
            description: 'filter by project ids'
          },
          jobRoleIds: {
            type: 'array',
            description: 'filter by jobrole ids'
          },
          include: {
            type: 'array',
            description: 'include'
          },
          fieldsUtilizations: {
            type: 'array',
            description: 'Query parameter: fields[utilizations]'
          },
          fieldsUsers: {
            type: 'array',
            description: 'Query parameter: fields[users]'
          },
          companyIds: {
            type: 'array',
            description: 'filter by company ids'
          }
        },
        required: ['format']
      },
      annotations: {
        title: "Get the Utilization of People in Projects",
        readOnlyHint: false,
        destructiveHint: false,
        openWorldHint: false
      }
    };
  • Registration of the tool definition and handler pair in the toolPairs array
    { definition: getProjectsReportingUserTaskCompletion, handler: handleGetProjectsReportingUserTaskCompletion },
    { definition: getProjectsReportingUtilization, handler: handleGetProjectsReportingUtilization },
  • Re-export of handleGetProjectsReportingUtilization from the tools index
    export { handleGetProjectsReportingUtilization } from './people/getUtilization.js';
  • The service layer helper that makes the actual API call to /reporting/precanned/utilization.{format} endpoint
    import { ensureApiClient } from '../core/apiClient.js';
    
    interface GetUtilizationParams {
      format: 'csv' | 'html' | 'pdf' | 'xlsx';
      zoom?: string;
      startDate?: string;
      sortOrder?: string;
      sort?: string;
      searchTerm?: string;
      reportFormat?: string;
      orderMode?: string;
      orderBy?: string;
      groupBy?: string;
      endDate?: string;
      pageSize?: number;
      page?: number;
      skipCounts?: boolean;
      legacyResponse?: boolean;
      isReportDownload?: boolean;
      isCustomDateRange?: boolean;
      includeUtilizations?: boolean;
      includeTotals?: boolean;
      includeCollaborators?: boolean;
      includeClients?: boolean;
      includeArchivedProjects?: boolean;
      IncludeCompletedTasks?: boolean;
      userIds?: number[];
      teamIds?: number[];
      selectedColumns?: string[];
      projectIds?: number[];
      jobRoleIds?: number[];
      include?: string[];
      fieldsUtilizations?: string[];
      fieldsUsers?: string[];
      companyIds?: number[];
    }
    
    async function getUtilization(params: GetUtilizationParams) {
      const api = ensureApiClient();
      const endpoint = `/reporting/precanned/utilization.${params.format}`;
      const response = await api.get(endpoint, { params });
      return response.data;
    }
    
    export default getUtilization; 
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations provide readOnlyHint=false and destructiveHint=false, and the description adds that only accessible people are returned. It does not disclose whether the report is generated server-side and stored, or just returned as a response. Since annotations already indicate non-read-only nature, the description adds minimal behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with core purpose and formats, followed by details on scope and access. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 32 parameters and no output schema, the description covers the general output (people data) but lacks details on how utilization is calculated, the meaning of various options like zoom, groupBy, etc. For a complex reporting tool, more context on typical usage scenarios would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has 100% coverage with descriptions for all 32 parameters. The description adds a high-level statement about filtering and output content. Given full schema coverage, the description does not need to elaborate on each parameter; it adds marginal value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool generates utilization reports in multiple formats (CSV, HTML, PDF, XLSX) and returns people data filtered by accessibility. This distinguishes it from sibling tools like getProjectsPeopleUtilization (likely raw data) and getProjectsReportingUserTaskCompletion (task completion focus). The verb 'generate report' and explicit formats make purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not explicitly state when to use this tool over alternatives. It implies usage for report generation, but without comparing to siblings like getProjectsReportingUserTaskCompletion or getProjectsPeopleUtilization, an agent may not know the best tool for raw utilization data versus formatted reports. No when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Vizioz/Teamwork-MCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server