New Relic MCP Server

Instructions

Implementation Reference

• src/tools/synthetics.ts:115-171 (handler)

  Core handler function that executes the GraphQL mutation to create a new browser Synthetics monitor in New Relic.

  async createBrowserMonitor(input: {
    target_account_id?: string;
    name: string;
    url: string;
    frequency: number;
    locations: string[];
  }): Promise<Record<string, unknown> | null> {
    const accountId = input.target_account_id;
    if (!accountId) {
      throw new Error('Account ID must be provided');
    }
  
    const mutation = `
      mutation {
        syntheticsCreateSimpleBrowserMonitor(
          accountId: ${accountId}
          monitor: {
            name: "${input.name}"
            uri: "${input.url}"
            period: ${this.frequencyToPeriod(input.frequency)}
            status: ENABLED
            locations: {
              public: ${JSON.stringify(input.locations)}
            }
          }
        ) {
          monitor {
            id
            name
            uri
            period
            status
          }
          errors {
            type
            description
          }
        }
      }
    `;
  
    const response = await this.client.executeNerdGraphQuery<{
      syntheticsCreateSimpleBrowserMonitor?: {
        monitor?: Record<string, unknown>;
        errors?: Array<{ description?: string }>;
      };
    }>(mutation);
    const result = response.data?.syntheticsCreateSimpleBrowserMonitor;
  
    if (Array.isArray(result?.errors) && result!.errors!.length > 0) {
      throw new Error(
        `Failed to create monitor: ${result!.errors![0]?.description || 'Unknown error'}`
      );
    }
  
    return (result?.monitor as Record<string, unknown>) || null;
  }

• src/tools/synthetics.ts:33-65 (schema)

  Tool schema definition including input validation schema for parameters like name, url, frequency, locations.

    return {
      name: 'create_browser_monitor',
      description: 'Create a new browser-based Synthetics monitor',
      inputSchema: {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            description: 'Name of the monitor',
          },
          url: {
            type: 'string',
            description: 'URL to monitor',
          },
          frequency: {
            type: 'number',
            enum: [1, 5, 10, 15, 30, 60],
            description: 'Check frequency in minutes',
          },
          locations: {
            type: 'array',
            items: { type: 'string' },
            description: 'Location codes for monitoring',
          },
          target_account_id: {
            type: 'string',
            description: 'Optional New Relic account ID',
          },
        },
        required: ['name', 'url', 'frequency', 'locations'],
      },
    };
  }

• src/server.ts:77-78 (registration)

  Registers the create_browser_monitor tool by including it in the tools array via getCreateMonitorTool().

  syntheticsTool.getListMonitorsTool(),
  syntheticsTool.getCreateMonitorTool(),

• src/server.ts:258-282 (handler)

  Dispatch handler in server that validates inputs and delegates to SyntheticsTool.createBrowserMonitor.

  case 'create_browser_monitor': {
    const { name, url, frequency, locations } = args as Record<string, unknown>;
    if (typeof name !== 'string' || name.trim() === '') {
      throw new Error('create_browser_monitor: "name" (non-empty string) is required');
    }
    if (typeof url !== 'string' || url.trim() === '') {
      throw new Error('create_browser_monitor: "url" (non-empty string) is required');
    }
    if (typeof frequency !== 'number' || !Number.isFinite(frequency) || frequency <= 0) {
      throw new Error('create_browser_monitor: "frequency" (positive number) is required');
    }
    if (
      !Array.isArray(locations) ||
      (locations as unknown[]).some((l) => typeof l !== 'string')
    ) {
      throw new Error('create_browser_monitor: "locations" must be an array of strings');
    }
    return await new SyntheticsTool(this.client).createBrowserMonitor({
      name,
      url,
      frequency,
      locations: locations as string[],
      target_account_id: accountId,
    });
  }

• src/tools/synthetics.ts:173-183 (helper)

  Helper function to convert frequency minutes to New Relic period strings used in the mutation.

  private frequencyToPeriod(frequency: number): string {
    const periodMap: { [key: number]: string } = {
      1: 'EVERY_MINUTE',
      5: 'EVERY_5_MINUTES',
      10: 'EVERY_10_MINUTES',
      15: 'EVERY_15_MINUTES',
      30: 'EVERY_30_MINUTES',
      60: 'EVERY_HOUR',
    };
    return periodMap[frequency] || 'EVERY_5_MINUTES';
  }