Flipt MCP Server

Implementation Reference

• src/index.ts:494-536 (handler)

  Primary MCP tool registration, schema validation, and handler execution logic for 'create_segment'. Calls FliptClient.createSegment and handles response/error formatting.

  server.tool(
    'create_segment',
    {
      namespaceKey: z.string().min(1),
      key: z.string().min(1),
      name: z.string().min(1),
      description: z.string().optional(),
      matchType: z.enum(['ALL_MATCH_TYPE', 'ANY_MATCH_TYPE']),
    },
    async args => {
      try {
        const segment = await fliptClient.createSegment(
          args.namespaceKey,
          args.key,
          args.name,
          args.description,
          args.matchType
        );
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(segment, null, 2),
            },
          ],
          _meta: {
            uri: `flipt://namespaces/${args.namespaceKey}/segments/${args.key}`,
          },
        };
      } catch (error: any) {
        console.error('Error creating segment:', error);
        return {
          content: [
            {
              type: 'text',
              text: `Failed to create segment: ${error.message}`,
            },
          ],
          isError: true,
        };
      }
    }
  );

• src/index.ts:496-502 (schema)

  Zod input schema defining parameters for the create_segment tool.

  {
    namespaceKey: z.string().min(1),
    key: z.string().min(1),
    name: z.string().min(1),
    description: z.string().optional(),
    matchType: z.enum(['ALL_MATCH_TYPE', 'ANY_MATCH_TYPE']),
  },

• src/services/fliptClient.ts:218-242 (helper)

  FliptClient helper method that converts parameters and calls the generated segmentsApi.createSegment to interact with Flipt API.

  async createSegment(
    namespaceKey: string,
    key: string,
    name: string,
    description?: string,
    matchType?: string
  ) {
    try {
      const segmentMatchType =
        matchType === 'ALL_MATCH_TYPE'
          ? CreateSegmentRequestMatchTypeEnum.AllMatchType
          : CreateSegmentRequestMatchTypeEnum.AnyMatchType;
  
      const response = await this.segmentsApi.createSegment(namespaceKey, {
        key,
        name,
        description,
        matchType: segmentMatchType,
      });
      return response;
    } catch (error) {
      console.error('Error creating segment:', error);
      throw error;
    }
  }

• src/generated/api/models/CreateSegmentRequest.ts:15-71 (schema)

  Generated TypeScript model and enum for CreateSegmentRequest used in the Flipt API client.

  export class CreateSegmentRequest {
      'key': string;
      'name': string;
      'description'?: string;
      'matchType': CreateSegmentRequestMatchTypeEnum;
      'namespaceKey'?: string;
  
      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": "key",
              "baseName": "key",
              "type": "string",
              "format": ""
          },
          {
              "name": "name",
              "baseName": "name",
              "type": "string",
              "format": ""
          },
          {
              "name": "description",
              "baseName": "description",
              "type": "string",
              "format": ""
          },
          {
              "name": "matchType",
              "baseName": "matchType",
              "type": "CreateSegmentRequestMatchTypeEnum",
              "format": "enum"
          },
          {
              "name": "namespaceKey",
              "baseName": "namespaceKey",
              "type": "string",
              "format": ""
          }    ];
  
      static getAttributeTypeMap() {
          return CreateSegmentRequest.attributeTypeMap;
      }
  
      public constructor() {
      }
  }
  
  export enum CreateSegmentRequestMatchTypeEnum {
      AllMatchType = 'ALL_MATCH_TYPE',
      AnyMatchType = 'ANY_MATCH_TYPE'
  }

• src/handlers/toolHandlers.ts:233-274 (handler)

  Alternative handler method in ToolHandlers class for create_segment (appears unused as index.ts registers directly).

  async handleCreateSegment({
    namespaceKey,
    key,
    name,
    description,
    matchType,
  }: {
    namespaceKey: string;
    key: string;
    name: string;
    description?: string;
    matchType: string;
  }) {
    try {
      const segment = await this.fliptClient.createSegment(
        namespaceKey,
        key,
        name,
        description,
        matchType
      );
      return {
        content: [
          {
            type: 'text',
            text: `Successfully created segment: ${JSON.stringify(segment, null, 2)}`,
          },
        ],
      };
    } catch (error) {
      console.error(`Error creating segment in namespace ${namespaceKey}:`, error);
      return {
        content: [
          {
            type: 'text',
            text: `Error creating segment in namespace ${namespaceKey}: ${error}`,
          },
        ],
        isError: true,
      };
    }
  }