Code
    Shopify AI Product OptimizerUpdated Jul 13, 2026TS

    Shopify AI Product Optimizer Ai Suggestions source

    Imported TypeScript file from worker/services/ai-suggestions.ts.

    Source file

    worker/services/ai-suggestions.ts

    TypeScript254 lines
    1. import OpenAI from "openai";
    2. import type { SEOAnalysis, SEOIssue } from "./seo-analyzer";
    3. import { DEFAULT_PRODUCT_OPTIMIZATION_MODEL } from "../../app/lib/ai-models";
    5. interface ProductData {
    6. id: string;
    7. title?: string;
    8. handle?: string;
    9. descriptionHtml?: string;
    10. seo?: {
    11. title?: string;
    12. description?: string;
    13. };
    14. productType?: string;
    15. vendor?: string;
    16. tags?: string[];
    17. }
    19. interface ShopSettings {
    20. aiProvider?: string | null;
    21. aiModel?: string | null;
    22. brandVoice?: string | null;
    23. targetAudience?: string | null;
    24. primaryLanguage?: string | null;
    25. }
    27. export interface Suggestion {
    28. field: string;
    29. currentValue: string;
    30. suggestedValue: string;
    31. rationale: string;
    32. riskLevel: "low" | "medium" | "high";
    33. }
    35. const openai = new OpenAI({
    36. apiKey: process.env.OPENAI_API_KEY,
    37. });
    39. export async function generateSuggestions(
    40. product: ProductData,
    41. analysis: SEOAnalysis,
    42. shopSettings: ShopSettings
    43. ): Promise<Suggestion[]> {
    44. const suggestions: Suggestion[] = [];
    46. // Group issues by field
    47. const issuesByField = analysis.issues.reduce((acc, issue) => {
    48. if (!acc[issue.field]) {
    49. acc[issue.field] = [];
    50. }
    51. acc[issue.field].push(issue);
    52. return acc;
    53. }, {} as Record<string, SEOIssue[]>);
    55. // Generate suggestions for each field with issues
    56. for (const [field, issues] of Object.entries(issuesByField)) {
    57. try {
    58. const suggestion = await generateFieldSuggestion(
    59. product,
    60. field,
    61. issues,
    62. shopSettings
    63. );
    64. if (suggestion) {
    65. suggestions.push(suggestion);
    66. }
    67. } catch (error) {
    68. console.error(`Error generating suggestion for ${field}:`, error);
    69. }
    70. }
    72. return suggestions;
    73. }
    75. async function generateFieldSuggestion(
    76. product: ProductData,
    77. field: string,
    78. issues: SEOIssue[],
    79. shopSettings: ShopSettings
    80. ): Promise<Suggestion | null> {
    81. const currentValue = getCurrentValue(product, field);
    82. const issueMessages = issues.map((i) => i.message).join("\n- ");
    84. const systemPrompt = buildSystemPrompt(shopSettings);
    85. const userPrompt = buildUserPrompt(product, field, currentValue, issueMessages);
    87. const response = await openai.chat.completions.create({
    88. model: shopSettings.aiModel || DEFAULT_PRODUCT_OPTIMIZATION_MODEL,
    89. messages: [
    90. { role: "system", content: systemPrompt },
    91. { role: "user", content: userPrompt },
    92. ],
    93. response_format: { type: "json_object" },
    94. temperature: 0.7,
    95. max_tokens: 1000,
    96. });
    98. const content = response.choices[0]?.message?.content;
    99. if (!content) return null;
    101. try {
    102. const parsed = JSON.parse(content);
    103. return {
    104. field: mapFieldName(field),
    105. currentValue: currentValue || "",
    106. suggestedValue: parsed.suggestion,
    107. rationale: parsed.rationale,
    108. riskLevel: determineRiskLevel(field),
    109. };
    110. } catch {
    111. console.error("Failed to parse AI response:", content);
    112. return null;
    113. }
    114. }
    116. function buildSystemPrompt(settings: ShopSettings): string {
    117. let prompt = `You are an SEO expert for e-commerce. Your task is to generate optimized content for product listings.
    119. Guidelines:
    120. - Write clear, compelling copy that appeals to both search engines and humans
    121. - Include relevant keywords naturally
    122. - Follow SEO best practices for length and formatting
    123. - Be specific and descriptive`;
    125. if (settings.brandVoice) {
    126. prompt += `\n\nBrand voice: ${settings.brandVoice}`;
    127. }
    129. if (settings.targetAudience) {
    130. prompt += `\n\nTarget audience: ${settings.targetAudience}`;
    131. }
    133. if (settings.primaryLanguage && settings.primaryLanguage !== "en") {
    134. prompt += `\n\nWrite in: ${getLanguageName(settings.primaryLanguage)}`;
    135. }
    137. prompt += `\n\nRespond with a JSON object containing:
    138. {
    139. "suggestion": "your optimized content",
    140. "rationale": "brief explanation of improvements made"
    141. }`;
    143. return prompt;
    144. }
    146. function buildUserPrompt(
    147. product: ProductData,
    148. field: string,
    149. currentValue: string | undefined,
    150. issues: string
    151. ): string {
    152. let prompt = `Optimize the ${getFieldLabel(field)} for this product:\n\n`;
    154. prompt += `Product: ${product.title}\n`;
    155. if (product.productType) prompt += `Type: ${product.productType}\n`;
    156. if (product.vendor) prompt += `Brand: ${product.vendor}\n`;
    157. if (product.tags?.length) prompt += `Tags: ${product.tags.join(", ")}\n`;
    159. prompt += `\nCurrent ${getFieldLabel(field)}:\n${currentValue || "(empty)"}\n`;
    160. prompt += `\nIssues to address:\n- ${issues}\n`;
    162. // Add field-specific instructions
    163. switch (field) {
    164. case "seoTitle":
    165. prompt += `\nRequirements: 30-60 characters, include primary keyword, be compelling.`;
    166. break;
    167. case "seoDescription":
    168. prompt += `\nRequirements: 120-160 characters, include call-to-action, summarize key benefits.`;
    169. break;
    170. case "title":
    171. prompt += `\nRequirements: 20-70 characters, clear and descriptive, include product type.`;
    172. break;
    173. case "description":
    174. prompt += `\nRequirements: Use HTML formatting (<p>, <ul>, <strong>), at least 100 chars, highlight features and benefits.`;
    175. break;
    176. }
    178. return prompt;
    179. }
    181. function getCurrentValue(product: ProductData, field: string): string | undefined {
    182. switch (field) {
    183. case "title":
    184. return product.title;
    185. case "seoTitle":
    186. return product.seo?.title;
    187. case "seoDescription":
    188. return product.seo?.description;
    189. case "description":
    190. return product.descriptionHtml;
    191. case "handle":
    192. return product.handle;
    193. case "tags":
    194. return JSON.stringify(product.tags);
    195. default:
    196. return undefined;
    197. }
    198. }
    200. function mapFieldName(field: string): string {
    201. const mapping: Record<string, string> = {
    202. seoTitle: "seoTitle",
    203. seoDescription: "seoDescription",
    204. title: "title",
    205. description: "description",
    206. handle: "handle",
    207. tags: "tags",
    208. };
    209. return mapping[field] || field;
    210. }
    212. function determineRiskLevel(field: string): "low" | "medium" | "high" {
    213. switch (field) {
    214. case "seoTitle":
    215. case "seoDescription":
    216. return "low"; // These don't affect display
    217. case "tags":
    218. return "low";
    219. case "title":
    220. return "medium"; // Affects display but not URLs
    221. case "description":
    222. return "medium";
    223. case "handle":
    224. return "high"; // Affects URLs, requires redirects
    225. default:
    226. return "medium";
    227. }
    228. }
    230. function getFieldLabel(field: string): string {
    231. const labels: Record<string, string> = {
    232. seoTitle: "SEO title",
    233. seoDescription: "meta description",
    234. title: "product title",
    235. description: "product description",
    236. handle: "URL handle",
    237. tags: "product tags",
    238. };
    239. return labels[field] || field;
    240. }
    242. function getLanguageName(code: string): string {
    243. const names: Record<string, string> = {
    244. en: "English",
    245. es: "Spanish",
    246. fr: "French",
    247. de: "German",
    248. pt: "Portuguese",
    249. it: "Italian",
    250. nl: "Dutch",
    251. ja: "Japanese",
    252. };
    253. return names[code] || "English";
    254. }