What is Snappy Idioms Dot Com?

An interactive, language-learning experience. Snappy Idioms Dot Com uses imagination, context, and active practice to build fluency, not just memorisation.

Vercel AIFunctions Deploy | Snappy Idioms Dot Com

Ver·cel AI Func·tions - Edge De·ploy·ment /ˈvɜː.səl eɪ.aɪ ˈfʌŋk.ʃənz/

AI-Powered Functions! Deploy these edge-optimized functions for blazing-fast word analysis, mnemonic generation, and bulk imports. Perfect for AI-heavy operations.

Word Analysis

Morphology, syllables, stress patterns, IPA phonetics

~2s response

Mnemonic Generator

"Have a Gander" methodology with AI creativity

~3s response

Bulk Import

Process multiple words with AI analysis

~5min max

api/analyze-word.js

/**
 * Vercel Edge Function - Analyze Word Structure
 * Path: /api/analyze-word
 */

import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.SUPABASE_URL,
  process.env.SUPABASE_SERVICE_KEY
);

export const config = {
  runtime: 'edge',
  maxDuration: 30,
};

async function callOpenAI(prompt, schema) {
  const response = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [{ role: 'user', content: prompt }],
      response_format: { type: 'json_schema', json_schema: { name: 'analysis', schema } },
      temperature: 0.3,
    }),
  });

  const data = await response.json();
  return JSON.parse(data.choices[0].message.content);
}

export default async function handler(req) {
  if (req.method !== 'POST') {
    return new Response(JSON.stringify({ error: 'Method not allowed' }), {
      status: 405,
      headers: { 'Content-Type': 'application/json' }
    });
  }

  try {
    const { text } = await req.json();

    if (!text || typeof text !== 'string') {
      return new Response(JSON.stringify({ error: 'Text parameter required' }), {
        status: 400,
        headers: { 'Content-Type': 'application/json' }
      });
    }

    console.log(`[Word Analysis] Analyzing: "${text}"`);

    const prompt = `You are a linguistic analysis expert. Analyze the following English text: "${text}"

Provide a detailed structural breakdown including:

1. **Morphology (Word Parts):**
   - Identify any prefixes (e.g., un-, dis-, re-)
   - Identify the root/base word
   - Identify any suffixes (e.g., -able, -ing, -tion)

2. **Syllabification:**
   - Break the word(s) into syllables with hyphens (e.g., "un-for-get-ta-ble")
   - Count total syllables

3. **Stress Patterns:**
   - Indicate which syllable(s) receive primary stress (1-indexed)

4. **Compound Analysis:**
   - If compound word, identify component parts

5. **Part of Speech:**
   - Noun, verb, adjective, adverb, etc.

6. **Phonetic Spelling (IPA):**
   - International Phonetic Alphabet representation

Provide accurate, education-focused analysis suitable for language learners.`;

    const schema = {
      type: 'object',
      properties: {
        original_text: { type: 'string' },
        morphology: {
          type: 'object',
          properties: {
            prefixes: { type: 'array', items: { type: 'string' } },
            root: { type: 'string' },
            suffixes: { type: 'array', items: { type: 'string' } }
          },
          required: ['prefixes', 'root', 'suffixes']
        },
        syllabification: {
          type: 'object',
          properties: {
            syllable_breaks: { type: 'string' },
            syllable_count: { type: 'number' },
            syllables_array: { type: 'array', items: { type: 'string' } }
          },
          required: ['syllable_breaks', 'syllable_count', 'syllables_array']
        },
        stress: {
          type: 'object',
          properties: {
            primary_stress_position: { type: 'number' },
            stress_pattern: { type: 'string' }
          },
          required: ['primary_stress_position', 'stress_pattern']
        },
        compound_parts: { type: 'array', items: { type: 'string' } },
        part_of_speech: { type: 'string' },
        phonetic_ipa: { type: 'string' }
      },
      required: ['original_text', 'morphology', 'syllabification', 'stress', 'compound_parts', 'part_of_speech', 'phonetic_ipa'],
      additionalProperties: false
    };

    const analysis = await callOpenAI(prompt, schema);

    return new Response(JSON.stringify({
      success: true,
      analysis
    }), {
      status: 200,
      headers: { 'Content-Type': 'application/json' }
    });

  } catch (error) {
    console.error('[Word Analysis] Error:', error);
    return new Response(JSON.stringify({
      error: error.message || 'Analysis failed',
      success: false
    }), {
      status: 500,
      headers: { 'Content-Type': 'application/json' }
    });
  }
}

api/generate-mnemonic.js

PROPRIETARY

/**
 * Vercel Edge Function - Generate Mnemonic
 * Path: /api/generate-mnemonic
 * PROPRIETARY: "Have a Gander at This" Mnemonic Engine
 */

import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.SUPABASE_URL,
  process.env.SUPABASE_SERVICE_KEY
);

export const config = {
  runtime: 'edge',
  maxDuration: 30,
};

async function callOpenAI(prompt, schema) {
  const response = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [{ role: 'user', content: prompt }],
      response_format: { type: 'json_schema', json_schema: { name: 'mnemonic', schema } },
      temperature: 0.8,
    }),
  });

  const data = await response.json();
  return JSON.parse(data.choices[0].message.content);
}

export default async function handler(req) {
  if (req.method !== 'POST') {
    return new Response(JSON.stringify({ error: 'Method not allowed' }), {
      status: 405,
      headers: { 'Content-Type': 'application/json' }
    });
  }

  try {
    const { idiom, mnemonicType, userThinkingStyle, apiKey } = await req.json();

    // Auth check
    if (!apiKey || apiKey !== process.env.ADMIN_API_KEY) {
      return new Response(JSON.stringify({ error: 'Unauthorized' }), {
        status: 401,
        headers: { 'Content-Type': 'application/json' }
      });
    }

    const researchPrinciples = `
PROVEN MEMORY TECHNIQUES (based on peer-reviewed research):

1. LINK-WORD METHOD:
   - Find words in the idiom that SOUND LIKE other English words
   - Create a VIVID mental image connecting the sound-alike word to the meaning

2. THE 10-SECOND RULE:
   - The learner MUST hold the image in their mind for 10 seconds

3. MAKE IT POWERFUL (4 key elements):
   ✓ EMOTION: Make it funny, scary, or dramatic
   ✓ PERSONAL: Include people the learner knows, hobbies, TV shows
   ✓ RIDICULOUS: The more nonsensical and absurd, the better
   ✓ EXAGGERATE: Make objects HUGE (50ft tall!), bright colors, talking objects

4. VISUALIZATION IS MANDATORY:
   - Must be a VISUAL SCENE, not just word associations
   - Engage multiple sensory details
`;

    const thinkingStylePrompts = {
      efficient: 'Create a CONCISE, action-oriented visualization. Under 50 words.',
      critical: 'Create a DETAILED, logical visualization. Explain WHY this works.',
      creative: 'Create a VIVID, imaginative visualization. Go big!',
      balanced: 'Create a well-rounded visualization that balances clarity with creativity.'
    };

    const prompt = `You are the "Have a Gander at This" mnemonic generator.

${researchPrinciples}

IDIOM: "${idiom.phrase}"
MEANING: "${idiom.meaning}"
USER STYLE: ${userThinkingStyle || 'balanced'}

${thinkingStylePrompts[userThinkingStyle] || thinkingStylePrompts.balanced}

Create an unforgettable mnemonic that:
- Uses sound-alike words
- Creates a vivid visual scene
- Includes emotion, personal elements, and exaggeration
- Starts with "Have a gander at this:"
- Maximum 100 words
`;

    const schema = {
      type: 'object',
      properties: {
        sound_connections: { type: 'string' },
        mnemonic: { type: 'string' },
        key_imagery: { type: 'string' },
        power_elements_used: { type: 'array', items: { type: 'string' } },
        revision_reminder: { type: 'string' }
      },
      required: ['sound_connections', 'mnemonic', 'key_imagery', 'power_elements_used', 'revision_reminder'],
      additionalProperties: false
    };

    const response = await callOpenAI(prompt, schema);

    // Log usage
    console.log(`[Mnemonic] Generated for "${idiom.phrase}" - Type: ${mnemonicType} - Style: ${userThinkingStyle}`);

    return new Response(JSON.stringify({
      ...response,
      methodology: '"Have a Gander at This" by Intuitive English - Based on peer-reviewed memory research'
    }), {
      status: 200,
      headers: { 'Content-Type': 'application/json' }
    });

  } catch (error) {
    console.error('[Mnemonic] Error:', error);
    return new Response(JSON.stringify({ error: error.message }), {
      status: 500,
      headers: { 'Content-Type': 'application/json' }
    });
  }
}

api/bulk-import-words.js

LONG-RUNNING

/**
 * Vercel Edge Function - Bulk Import Words
 * Path: /api/bulk-import-words
 * WARNING: Long-running function (may take minutes)
 */

import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.SUPABASE_URL,
  process.env.SUPABASE_SERVICE_KEY
);

export const config = {
  runtime: 'edge',
  maxDuration: 300, // 5 minutes max
};

async function analyzeWord(word) {
  const response = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [{
        role: 'user',
        content: `Analyze the English word "${word}" and provide:
1. Part of speech
2. Clear definition
3. Example sentence
4. Topic category (Technology, Food, Travel, Business, etc.)
5. CEFR level (A1-C2)
6. IPA phonetic spelling
7. Syllable count
8. Syllable breaks with hyphens
9. Stress pattern with capitals
10. Primary stress position (1-indexed)

Use British English.`
      }],
      response_format: {
        type: 'json_schema',
        json_schema: {
          name: 'word_analysis',
          schema: {
            type: 'object',
            properties: {
              part_of_speech: { type: 'string' },
              definition: { type: 'string' },
              example_sentence: { type: 'string' },
              topic: { type: 'string' },
              level: { type: 'string', enum: ['A1', 'A2', 'B1', 'B2', 'C1', 'C2'] },
              phonetic_ipa: { type: 'string' },
              syllable_count: { type: 'number' },
              syllable_breaks: { type: 'string' },
              stress_pattern: { type: 'string' },
              stress_position: { type: 'number' }
            },
            required: ['part_of_speech', 'definition', 'example_sentence', 'topic', 'level'],
            additionalProperties: false
          }
        }
      },
      temperature: 0.3,
    }),
  });

  const data = await response.json();
  return JSON.parse(data.choices[0].message.content);
}

export default async function handler(req) {
  if (req.method !== 'POST') {
    return new Response(JSON.stringify({ error: 'Method not allowed' }), {
      status: 405,
      headers: { 'Content-Type': 'application/json' }
    });
  }

  try {
    const { words, apiKey } = await req.json();

    // Auth check
    if (!apiKey || apiKey !== process.env.ADMIN_API_KEY) {
      return new Response(JSON.stringify({ error: 'Unauthorized - Admin only' }), {
        status: 403,
        headers: { 'Content-Type': 'application/json' }
      });
    }

    if (!words || !Array.isArray(words)) {
      return new Response(JSON.stringify({ error: 'Words array required' }), {
        status: 400,
        headers: { 'Content-Type': 'application/json' }
      });
    }

    console.log(`[BulkImport] Processing ${words.length} words`);

    const results = {
      total: words.length,
      successful: 0,
      skipped: 0,
      failed: 0,
      details: []
    };

    for (let i = 0; i < words.length; i++) {
      const word = words[i].trim();

      if (!word) {
        results.skipped++;
        continue;
      }

      try {
        // Check for duplicates
        const { data: existing } = await supabase
          .from('VocabularyWord')
          .select('id')
          .eq('word', word)
          .limit(1);

        if (existing && existing.length > 0) {
          console.log(`[BulkImport] Skipping duplicate: ${word}`);
          results.skipped++;
          results.details.push({ word, status: 'skipped', reason: 'Already exists' });
          continue;
        }

        // Analyze word with AI
        console.log(`[BulkImport] [${i + 1}/${words.length}] Analyzing: ${word}`);
        const aiResponse = await analyzeWord(word);

        // Create vocabulary entry
        const wordData = {
          word: word,
          part_of_speech: aiResponse.part_of_speech || 'noun',
          definition: aiResponse.definition,
          example_sentence: aiResponse.example_sentence || `Example with ${word}.`,
          phonetic_spelling: aiResponse.phonetic_ipa || '',
          topic: aiResponse.topic || 'General',
          level: aiResponse.level || 'B1',
          syllable_count: aiResponse.syllable_count || null,
          syllable_breaks: aiResponse.syllable_breaks || '',
          stress_pattern: aiResponse.stress_pattern || '',
          stress_position: aiResponse.stress_position || null
        };

        await supabase.from('VocabularyWord').insert(wordData);

        results.successful++;
        results.details.push({
          word,
          status: 'success',
          level: wordData.level,
          pos: wordData.part_of_speech
        });

        console.log(`[BulkImport] ✓ [${i + 1}/${words.length}] Added: ${word}`);

        // Rate limiting: 500ms between words
        if (i < words.length - 1) {
          await new Promise(resolve => setTimeout(resolve, 500));
        }

      } catch (wordError) {
        console.error(`[BulkImport] Failed: ${word}`, wordError.message);
        results.failed++;
        results.details.push({
          word,
          status: 'failed',
          error: wordError.message
        });
      }
    }

    console.log(`[BulkImport] Complete - Success: ${results.successful}, Skipped: ${results.skipped}, Failed: ${results.failed}`);

    return new Response(JSON.stringify({
      success: true,
      results
    }), {
      status: 200,
      headers: { 'Content-Type': 'application/json' }
    });

  } catch (error) {
    console.error('[BulkImport] Fatal error:', error);
    return new Response(JSON.stringify({
      success: false,
      error: error.message
    }), {
      status: 500,
      headers: { 'Content-Type': 'application/json' }
    });
  }
}

vercel.json

{
  "version": 2,
  "functions": {
    "api/analyze-word.js": {
      "runtime": "edge",
      "maxDuration": 30
    },
    "api/generate-mnemonic.js": {
      "runtime": "edge",
      "maxDuration": 30
    },
    "api/bulk-import-words.js": {
      "runtime": "edge",
      "maxDuration": 300
    }
  },
  "env": {
    "SUPABASE_URL": "@supabase_url",
    "SUPABASE_SERVICE_KEY": "@supabase_service_key",
    "ADMIN_API_KEY": "@admin_api_key",
    "OPENAI_API_KEY": "@openai_api_key"
  }
}

package.json

{
  "name": "snappy-ai-functions",
  "version": "1.0.0",
  "type": "module",
  "dependencies": {
    "@supabase/supabase-js": "^2.39.0"
  }
}

README.md

# Snappy English - AI Functions (Vercel Edge)

Edge-optimized serverless functions for AI-powered language analysis.

## Functions

### 1. Word Analysis
**Endpoint:** `POST /api/analyze-word`
**Body:** `{ "text": "uncomfortable" }`
**Features:** Morphology, syllables, stress patterns, IPA phonetics

### 2. Mnemonic Generation
**Endpoint:** `POST /api/generate-mnemonic`
**Body:** `{ "idiom": {...}, "mnemonicType": "visual", "userThinkingStyle": "creative", "apiKey": "..." }`
**Features:** "Have a Gander at This" methodology, research-backed memory techniques

### 3. Bulk Import Words
**Endpoint:** `POST /api/bulk-import-words`
**Body:** `{ "words": ["word1", "word2"], "apiKey": "..." }`
**Features:** AI analysis + database insertion, duplicate detection, rate limiting

## Setup

1. **Install Vercel CLI**
   ```bash
   npm i -g vercel
   vercel login
   ```

2. **Create project folder**
   ```
   mkdir snappy-ai-functions
   cd snappy-ai-functions
   mkdir api
   ```

3. **Add files**
   - `api/analyze-word.js`
   - `api/generate-mnemonic.js`
   - `api/bulk-import-words.js`
   - `package.json`
   - `vercel.json`

4. **Deploy**
   ```bash
   vercel --prod
   ```

5. **Set environment variables** in Vercel Dashboard

## Environment Variables Required

- `SUPABASE_URL`
- `SUPABASE_SERVICE_KEY`
- `ADMIN_API_KEY` (for protected endpoints)
- `OPENAI_API_KEY`

## Usage Examples

**Word Analysis:**
```bash
curl -X POST https://your-project.vercel.app/api/analyze-word \
  -H "Content-Type: application/json" \
  -d '{"text":"uncomfortable"}'
```

**Mnemonic Generation:**
```bash
curl -X POST https://your-project.vercel.app/api/generate-mnemonic \
  -H "Content-Type: application/json" \
  -d '{"idiom":{"phrase":"break the ice","meaning":"..."},"apiKey":"YOUR_KEY"}'
```

**Bulk Import:**
```bash
curl -X POST https://your-project.vercel.app/api/bulk-import-words \
  -H "Content-Type: application/json" \
  -d '{"words":["example","test"],"apiKey":"YOUR_KEY"}'
```

## Performance

✅ Edge runtime = ~50ms cold start
✅ Global CDN distribution
✅ Automatic retries
✅ Detailed logging
✅ Rate limiting built-in

Quick Deploy:

Create folder: mkdir snappy-ai-functions && cd snappy-ai-functions && mkdir api
Copy 3 API files into api/ folder
Add package.json and vercel.json to root
Deploy: vercel --prod
Set env vars in Vercel Dashboard