CoolPC MCP Server

Instructions

Implementation Reference

• src/index.ts:761-891 (handler)

  The handler function that performs the search for motherboards based on socket, chipset, form factor, applies sorting and limits the results from the product data.

  private searchMotherboard(args: any) {
    const { socket, chipset, form_factor, sort_by, limit = 10 } = args;
    const results: any[] = [];
  
    // Find motherboard category
    const mbCategory = this.productData.find(cat => 
      cat.category_name.includes('主機板') || cat.category_name.includes('MB')
    );
  
    if (!mbCategory) {
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify({
              error: "Motherboard category not found",
              results: []
            }, null, 2),
          },
        ],
      };
    }
  
    // Search through all motherboard subcategories
    for (const subcat of mbCategory.subcategories) {
      for (const product of subcat.products) {
        let matches = true;
  
        // Filter by socket if specified
        if (socket && matches) {
          const socketLower = socket.toLowerCase();
          const subcatLower = subcat.name.toLowerCase();
          const specsText = product.specs.join(' ').toLowerCase();
          const rawTextLower = product.raw_text.toLowerCase();
          
          if (!subcatLower.includes(socketLower) && 
              !specsText.includes(socketLower) && 
              !rawTextLower.includes(socketLower)) {
            matches = false;
          }
        }
  
        // Filter by chipset if specified
        if (chipset && matches) {
          const chipsetLower = chipset.toLowerCase();
          const specsText = product.specs.join(' ').toLowerCase();
          const modelLower = product.model?.toLowerCase() || '';
          const rawTextLower = product.raw_text.toLowerCase();
          
          if (!specsText.includes(chipsetLower) && 
              !modelLower.includes(chipsetLower) &&
              !rawTextLower.includes(chipsetLower)) {
            matches = false;
          }
        }
  
        // Filter by form factor if specified
        if (form_factor && matches) {
          const formLower = form_factor.toLowerCase();
          const specsText = product.specs.join(' ').toLowerCase();
          const rawTextLower = product.raw_text.toLowerCase();
          
          // Handle different form factor names
          const formFactorAliases: { [key: string]: string[] } = {
            'atx': ['atx', 'a.t.x'],
            'matx': ['matx', 'm-atx', 'micro atx', 'micro-atx'],
            'itx': ['itx', 'mini-itx', 'mini itx']
          };
          
          let hasFormFactor = false;
          const aliases = formFactorAliases[formLower] || [formLower];
          for (const alias of aliases) {
            if (specsText.includes(alias) || rawTextLower.includes(alias)) {
              hasFormFactor = true;
              break;
            }
          }
          
          if (!hasFormFactor) {
            matches = false;
          }
        }
  
        if (matches) {
          results.push({
            ...product,
            category_name: mbCategory.category_name,
            subcategory_name: subcat.name,
          });
        }
      }
    }
  
    // Sort results
    if (sort_by === 'price_asc') {
      results.sort((a, b) => a.price - b.price);
    } else if (sort_by === 'price_desc') {
      results.sort((a, b) => b.price - a.price);
    }
  
    // Apply limit
    const limitedResults = results.slice(0, limit);
  
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            total_found: results.length,
            showing: limitedResults.length,
            filters: {
              socket: socket || "any",
              chipset: chipset || "any",
              form_factor: form_factor || "any",
              sort_by: sort_by || "none"
            },
            results: limitedResults.map(p => ({
              brand: p.brand,
              model: p.model,
              specs: p.specs,
              price: p.price,
              original_price: p.original_price,
              discount_amount: p.discount_amount,
              subcategory: p.subcategory_name,
              markers: p.markers,
            })),
          }, null, 2),
        },
      ],
    };
  }

• src/index.ts:226-251 (schema)

  The input schema defining parameters for the search_motherboard tool: socket, chipset, form_factor, sort_by, limit.

  inputSchema: {
    type: "object",
    properties: {
      socket: {
        type: "string",
        description: "CPU socket - MUST match your CPU. Intel: '1700' (12-14th gen), '1851' (Core Ultra). AMD: 'AM5' (Ryzen 7000+), 'AM4' (older Ryzen). Check CPU specs first!",
      },
      chipset: {
        type: "string",
        description: "Motherboard chipset determines features. Intel: 'Z790' (high-end), 'B760' (mainstream), 'H610' (budget). AMD: 'X670' (high-end), 'B650' (mainstream), 'A620' (budget)",
      },
      form_factor: {
        type: "string",
        description: "Physical size - must fit your case. 'ATX' (full size, most expansion), 'mATX' or 'MATX' (compact, good balance), 'ITX' (mini, small builds)",
      },
      sort_by: {
        type: "string",
        enum: ["price_asc", "price_desc"],
        description: "Price sorting order. 'price_asc' = budget boards first, 'price_desc' = feature-rich boards first",
      },
      limit: {
        type: "number",
        description: "Maximum results to return. Valid range: 1-50, default: 10. More results = more brand/feature options",
      },
    },
  },

• src/index.ts:223-252 (registration)

  Tool registration in the ListToolsRequestSchema handler, including name, description, and inputSchema.

  {
    name: "search_motherboard",
    description: "Specialized motherboard (MB/mainboard) search tool. Find motherboards by CPU socket, chipset, and size. Critical for system compatibility - must match CPU socket and case size.",
    inputSchema: {
      type: "object",
      properties: {
        socket: {
          type: "string",
          description: "CPU socket - MUST match your CPU. Intel: '1700' (12-14th gen), '1851' (Core Ultra). AMD: 'AM5' (Ryzen 7000+), 'AM4' (older Ryzen). Check CPU specs first!",
        },
        chipset: {
          type: "string",
          description: "Motherboard chipset determines features. Intel: 'Z790' (high-end), 'B760' (mainstream), 'H610' (budget). AMD: 'X670' (high-end), 'B650' (mainstream), 'A620' (budget)",
        },
        form_factor: {
          type: "string",
          description: "Physical size - must fit your case. 'ATX' (full size, most expansion), 'mATX' or 'MATX' (compact, good balance), 'ITX' (mini, small builds)",
        },
        sort_by: {
          type: "string",
          enum: ["price_asc", "price_desc"],
          description: "Price sorting order. 'price_asc' = budget boards first, 'price_desc' = feature-rich boards first",
        },
        limit: {
          type: "number",
          description: "Maximum results to return. Valid range: 1-50, default: 10. More results = more brand/feature options",
        },
      },
    },
  },

• src/index.ts:304-325 (registration)

  Registration in the CallToolRequestSchema handler's switch statement that routes calls to the searchMotherboard method.

  switch (name) {
    case "search_products":
      return this.searchProducts(args);
    case "search_cpu":
      return this.searchCPU(args);
    case "search_gpu":
      return this.searchGPU(args);
    case "search_ram":
      return this.searchRAM(args);
    case "search_ssd":
      return this.searchSSD(args);
    case "search_motherboard":
      return this.searchMotherboard(args);
    case "get_product_by_model":
      return this.getProductByModel(args);
    case "list_categories":
      return this.listCategories();
    case "get_category_products":
      return this.getCategoryProducts(args);
    default:
      throw new Error(`Unknown tool: ${name}`);
  }