Flipt MCP Server

Implementation Reference

• src/index.ts:923-963 (handler)

  MCP tool registration, input schema (Zod), and handler implementation for 'create_rule'. Calls fliptClient.createRule and formats response.

  server.tool(
    'create_rule',
    {
      namespaceKey: z.string().min(1),
      flagKey: z.string().min(1),
      segmentKey: z.string().min(1),
      rank: z.number().int().optional(),
      segmentOperator: z.enum(['OR_SEGMENT_OPERATOR', 'AND_SEGMENT_OPERATOR']).optional(),
    },
    async args => {
      try {
        const response = await fliptClient.createRule(
          args.namespaceKey,
          args.flagKey,
          args.segmentKey,
          args.rank,
          args.segmentOperator
        );
  
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(response, null, 2),
            },
          ],
        };
      } catch (error: any) {
        console.error('Error creating rule:', error);
        return {
          content: [
            {
              type: 'text',
              text: `Failed to create rule: ${error.message}`,
            },
          ],
          isError: true,
        };
      }
    }
  );

• src/services/fliptClient.ts:305-323 (helper)

  FliptClient helper method that invokes the generated RulesServiceApi.createRule with mapped parameters.

  async createRule(
    namespaceKey: string,
    flagKey: string,
    segmentKey: string,
    rank?: number,
    segmentOperator?: string
  ) {
    try {
      const response = await this.rulesApi.createRule(namespaceKey, flagKey, {
        segmentKey,
        rank: rank || 1,
        segmentOperator: (segmentOperator as any) || 'OR_SEGMENT_OPERATOR',
      });
      return response;
    } catch (error) {
      console.error('Error creating rule:', error);
      throw error;
    }
  }

• src/generated/api/models/CreateRuleRequest.ts:15-77 (schema)

  Generated TypeScript model for the CreateRuleRequest used in the Flipt API calls.

  export class CreateRuleRequest {
      'flagKey'?: string;
      'segmentKey'?: string;
      'rank': number;
      'namespaceKey'?: string;
      'segmentKeys'?: Array<string>;
      'segmentOperator'?: CreateRuleRequestSegmentOperatorEnum;
  
      static readonly discriminator: string | undefined = undefined;
  
      static readonly mapping: {[index: string]: string} | undefined = undefined;
  
      static readonly attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string}> = [
          {
              "name": "flagKey",
              "baseName": "flagKey",
              "type": "string",
              "format": ""
          },
          {
              "name": "segmentKey",
              "baseName": "segmentKey",
              "type": "string",
              "format": ""
          },
          {
              "name": "rank",
              "baseName": "rank",
              "type": "number",
              "format": "int32"
          },
          {
              "name": "namespaceKey",
              "baseName": "namespaceKey",
              "type": "string",
              "format": ""
          },
          {
              "name": "segmentKeys",
              "baseName": "segmentKeys",
              "type": "Array<string>",
              "format": ""
          },
          {
              "name": "segmentOperator",
              "baseName": "segmentOperator",
              "type": "CreateRuleRequestSegmentOperatorEnum",
              "format": "enum"
          }    ];
  
      static getAttributeTypeMap() {
          return CreateRuleRequest.attributeTypeMap;
      }
  
      public constructor() {
      }
  }
  
  export enum CreateRuleRequestSegmentOperatorEnum {
      OrSegmentOperator = 'OR_SEGMENT_OPERATOR',
      AndSegmentOperator = 'AND_SEGMENT_OPERATOR'
  }