Speak CI Integration

Overview

GitHub Actions pipeline for Speak integrations with mocked API tests and audio validation.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure ci integration for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_ci_integration_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak ci integration
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// CI test with mocked responses
async function runCITests() {
  const mockClient = new MockSpeakClient();
  await mockClient.assessPronunciation({ audioPath: "test.wav", targetText: "hello", language: "en" });
  console.log("CI tests passed");
}

Step 3: Verification

npm test

Output

• Speak CI Integration configured and verified
• CI pipeline with mocked Speak API tests
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For deployment, see speak-deploy-integration.

Examples

Basic: Apply ci integration with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Common Errors

Overview

Diagnose and fix common Speak API errors: authentication failures, audio format issues, rate limits, and session management problems.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• ffmpeg installed for audio processing

Instructions

Error Code Reference

Quick Diagnostic

# Check API key validity
curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer $SPEAK_API_KEY" \
  https://api.speak.com/v1/languages
# 200 = valid, 401 = invalid, 403 = insufficient permissions

# Check audio format
ffprobe -v quiet -print_format json -show_streams recording.wav \
  | python3 -c "import sys,json; s=json.load(sys.stdin)['streams'][0]; print(f'Rate: {s[\"sample_rate\"]}Hz, Channels: {s[\"channels\"]}')"
# Must be: Rate: 16000Hz, Channels: 1

Error Recovery Pattern

async function resilientSpeakCall<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (err: any) {
      const code = err.response?.data?.error?.code;
      if (code === 'audio_format_invalid') {
        // Auto-convert and retry
        throw new Error('Convert audio to WAV 16kHz mono before retrying');
      }
      if (code === 'session_expired') {
…

Speak Core Workflow A: AI Conversation Practice

Overview

Primary workflow for Speak: AI-powered conversation practice with real-time pronunciation feedback and adaptive tutoring. Speak uses GPT-4o for conversation generation and OpenAI's Realtime API for speech processing, delivering sub-second response times.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Audio handling capabilities (microphone or pre-recorded files)

Instructions

Step 1: Start a Conversation Session

import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient({
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  language: 'es',
});

// Start a restaurant ordering scenario in Spanish
const session = await client.startConversation({
  scenario: 'ordering-food',
  language: 'es',
  level: 'intermediate',
  nativeLanguage: 'en',
  maxTurns: 10,
  feedbackDetail: 'phoneme', // 'word' or 'phoneme'
});

console.log('Session started:', session.id);
console.log('AI Tutor:', session.firstPrompt.text);
// "Bienvenido al restaurante. Soy tu camarero. Que le gustaria ordenar?"

Step 2: Send Student Responses

// Submit audio for pronunciation scoring
const turn1 = await client.sendTurn(session.id, {
  audioPath: './recordings/student-response-1.wav',
});

console.log('Tutor:', turn1.tutorText);
console.log('Pronunciation:', turn1.pronunciationScore); // 0-100
console.log('Grammar:', turn1.corrections);
// [{original: "yo quiero", suggestion: "quisiera", note: "More polite form for ordering"}]
console.log('Vocabulary:', turn1.vocabularyNotes);
// ["camarero = waiter", "ordenar = to order"]

// Or submit text (skips pronunciation scoring)
const turn2 = await client.sendTurn(session.id, {
  text: 'Quisiera una ensalada y un vaso de agua, por favor.',
});

Step 3: Conversation Loop with Progress Tracking

async function runConversationLesson(
  client: SpeakClient,
  scenario: string,
  language: string,
  level: string,
) {
  const session = await client.startConversation({
    scenario, language, level, nativeLanguage: 'en',
  });

  const turns: TurnResult[] = [];
  let isComplete = false;

  while (!isComplete && turns.length < 10) {
    // Display tutor prompt
    const prompt = turns.length === 0
      ? session.firstPrompt.text
      : turns[turns.length - 1].tutorText;
    console.log(`\nTutor: ${prompt}`);

    // Get student audio (mic input or file)
    const audioPath = await recordStudentAudio();

    // Submit and get feedback
 …

Speak Core Workflow B: Pronunciation Training

Overview

Secondary workflow for Speak: detailed pronunciation training with phoneme-level analysis and adaptive practice. Uses OpenAI's speech recognition with Speak's proprietary proficiency graph to identify and drill weak phonemes.

Prerequisites

• Completed speak-core-workflow-a
• Audio recording capability (WAV 16kHz mono)
• ffmpeg installed for audio preprocessing

Instructions

Step 1: Pronunciation Assessment

import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient({
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  language: 'es',
});

// Assess pronunciation of a specific phrase
const result = await client.assessPronunciation({
  audioPath: './recordings/hola-como-estas.wav',
  targetText: 'Hola, como estas?',
  language: 'es',
  detailLevel: 'phoneme',
});

console.log(`Overall score: ${result.score}/100`);
for (const word of result.words) {
  const flag = word.score < 70 ? 'WEAK' : 'OK';
  console.log(`  [${flag}] "${word.text}": ${word.score}/100`);
  if (word.phonemes) {
    for (const p of word.phonemes.filter(p => p.score < 70)) {
      console.log(`    Phoneme "${p.symbol}": ${p.score} — ${p.suggestion}`);
    }
  }
}

Step 2: Adaptive Drill Loop

async function pronunciationDrill(
  client: SpeakClient,
  phrases: string[],
  language: string,
  targetScore: number = 80,
  maxAttempts: number = 3,
) {
  const weakPoints: Map<string, number[]> = new Map();
  const results: DrillResult[] = [];

  for (const phrase of phrases) {
    let bestScore = 0;
    let attempts = 0;

    while (bestScore < targetScore && attempts < maxAttempts) {
      const audioPath = await recordStudentAudio(phrase);
      const result = await client.assessPronunciation({
        audioPath, targetText: phrase, language, detailLevel: 'phoneme',
      });

      bestScore = Math.max(bestScore, result.score);
      attempts++;

      // Track weak phonemes
      for (const word of result.words) {
        for (const p of (word.phonemes || []).filter(p => p.score < 70)) {
          const scores = weakPoints.get(p.symbol) || [];
          scores.push(p.score);
          weakPoints.set(p.symbol, scores);
        }
      }

      if (result.score >= targetScore) {
        console.log(`"${phrase}": PASSED (${result.score}/100, ${attempts} attempts)`);
      } else if (attempts < maxAttempts) {
        console.log(`"${phrase}": ${result.score}/100 — try again`);
      }
    }

    results.push({ phrase, bestScore, attempts });
  }

  return { results, weakPoints };
}

Step 3: Weakness Report

Speak Cost Tuning

Overview

Optimize Speak API costs through usage monitoring, tier selection, and efficient audio processing.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure cost tuning for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_cost_tuning_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak cost tuning
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Cost Tuning configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply cost tuning with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Data Handling

Overview

Handle student audio data, assessment records, and learning progress with GDPR/COPPA compliance.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure data handling for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_data_handling_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak data handling
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Data Handling configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply data handling with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Debug Bundle

Overview

Collect diagnostic information for Speak API issues: auth verification, audio format validation, session inspection, and network testing.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• ffmpeg installed for audio processing

Instructions

Current State

!node --version 2>/dev/null || echo 'N/A' !ffmpeg -version 2>/dev/null | head -1 || echo 'ffmpeg not installed'

Step 1: Auth Diagnostic

#!/bin/bash
set -euo pipefail
echo "=== Speak Debug Bundle ==="
echo "Time: $(date -u)"

echo -e "\n--- Auth Check ---"
STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer $SPEAK_API_KEY" \
  https://api.speak.com/v1/languages)
echo "API Key Status: HTTP $STATUS"
[ "$STATUS" = "200" ] && echo "  Auth: OK" || echo "  Auth: FAILED"

echo -e "\n--- Environment ---"
echo "SPEAK_API_KEY set: $([ -n \"${SPEAK_API_KEY:-}\" ] && echo 'yes' || echo 'no')"
echo "SPEAK_APP_ID set: $([ -n \"${SPEAK_APP_ID:-}\" ] && echo 'yes' || echo 'no')"

Step 2: Audio Format Validator

import { execSync } from 'child_process';

function validateAudio(filePath: string): { valid: boolean; issues: string[] } {
  const issues: string[] = [];
  try {
    const info = JSON.parse(execSync(
      `ffprobe -v quiet -print_format json -show_streams "${filePath}"`,
      { encoding: 'utf-8' }
    ));
    const stream = info.streams[0];

    if (stream.codec_name !== 'pcm_s16le') issues.push(`Codec: ${stream.codec_name} (need pcm_s16le)`);
    if (parseInt(stream.sample_rate) !== 16000) issues.push(`Sample rate: ${stream.sample_rate} (need 16000)`);
    if (stream.channels !== 1) issues.push(`Channels: ${stream.channels} (need 1/mono)`);

    const size = parseInt(execSync(`stat -f%z "${filePath}"`, { encoding: 'utf-8' }));
    if (size > 25 * 1024 * 1024) issues.push(`File too large: ${(size/1024/1024).toFixed(1)}MB (max 25MB)`);
    if (size < 1000) issues.push('File too small — may be empty or corrupt');
  } catch (e) {
    issues.push(`Cannot read file: ${e}`);
  }
  return { valid: issues.length === 0, issues };
}

Step 3: Network Connectivity

echo -e "\n--- Network ---"
curl -s -o /dev/null -w "API: HTTP %{http_code} in %{time_total}s\n" \
  -H "Authorization: Bearer $SPEAK_API_KEY" \
  https://api.speak.com/v1/health

curl -s -o /dev/null -w "OpenAI: HTTP %{http_code} in %{time_total}s\n" \
  …

Speak Deploy Integration

Overview

Deploy Speak language learning features to Vercel, Cloud Run, or containerized environments.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure deploy integration for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_deploy_integration_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak deploy integration
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Deploy Integration configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply deploy integration with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Enterprise RBAC

Overview

Configure Speak for schools and organizations: SSO, teacher/student roles, class management, and usage reporting.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure enterprise rbac for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_enterprise_rbac_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak enterprise rbac
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Enterprise RBAC configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply enterprise rbac with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Hello World

Overview

Create your first AI tutoring session with Speak. Demonstrates conversation practice, pronunciation assessment, and real-time feedback using GPT-4o-powered tutoring.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Microphone access (optional for testing)

Instructions

Step 1: Start a Conversation Session

import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient({
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  language: 'es',
});

// Start a beginner Spanish lesson
const session = await client.startConversation({
  scenario: 'greetings',
  language: 'es',
  level: 'beginner',
  nativeLanguage: 'en',
});

console.log('Session ID:', session.id);
console.log('AI Tutor:', session.firstPrompt.text);
// Output: "Hola! Bienvenido a tu leccion de espanol. Como te llamas?"
console.log('Audio URL:', session.firstPrompt.audioUrl);

Step 2: Send a Student Response

// Submit text response (or audio file for pronunciation scoring)
const turn = await client.sendTurn(session.id, {
  text: 'Hola, me llamo Juan. Mucho gusto.',
  // Or: audioPath: './recordings/response.wav'
});

console.log('Tutor response:', turn.tutorText);
console.log('Pronunciation score:', turn.pronunciationScore); // 0-100
console.log('Grammar corrections:', turn.corrections);
// Output: [{original: "me llamo", suggestion: null, correct: true}]
console.log('Vocabulary notes:', turn.vocabularyNotes);

Step 3: Pronunciation Assessment

// Assess pronunciation of a specific phrase
const assessment = await client.assessPronunciation({
  audioPath: './recordings/hola-como-estas.wav',
  targetText: 'Hola, como estas?',
  language: 'es',
  detailLevel: 'phoneme', // 'word' or 'phoneme'
});

console.log(`Overall score: ${assessment.score}/100`);
for (const word of assessment.words) {
  console.log(`  "${word.text}": ${word.score}/100`);
  if (word.phonemes) {
    for (const p of word.phonemes.filter(p => p.score < 70)) {
      console.log(`    Weak phoneme: ${p.symbol} (${p.score}) - ${p.suggestion}`);
    }
  }
}

Step 4: End Session and Review

const summary = await client.endSession(session.id);
console.log('Session Summary:');
console.log(`  Duration: ${summary.durationMinutes} min`);
console.log(`  Turns: ${summary.totalTurns}`);
console.log(`  Pronunciation: ${summary.avgPronunciationScore}/100`);
console.log(`  Grammar: ${summary.grammarAccuracy}%`);
console.…

Speak Incident Runbook

Overview

Incident response for Speak API outages: triage, fallback to offline mode, and recovery procedures.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure incident runbook for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_incident_runbook_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak incident runbook
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// CI test with mocked responses
async function runCITests() {
  const mockClient = new MockSpeakClient();
  await mockClient.assessPronunciation({ audioPath: "test.wav", targetText: "hello", language: "en" });
  console.log("CI tests passed");
}

Step 3: Verification

npm test

Output

• Speak Incident Runbook configured and verified
• CI pipeline with mocked Speak API tests
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For deployment, see speak-deploy-integration.

Examples

Basic: Apply incident runbook with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Install & Auth

Overview

Set up the Speak language learning platform integration. Speak uses OpenAI's GPT-4o and Realtime API for AI tutoring with real-time pronunciation feedback. Supports 14+ languages including Korean, Spanish, Japanese, French, and Mandarin.

Prerequisites

• Node.js 18+ or Python 3.10+
• Speak developer account with API access
• Microphone for speech input testing

Instructions

Step 1: Install Dependencies

set -euo pipefail
# Core Speak SDK
npm install @speak/language-sdk

# Audio processing dependencies
npm install openai          # OpenAI Realtime API for speech
npm install fluent-ffmpeg   # Audio format conversion
npm install node-record-lpcm16  # Microphone capture

Step 2: Configure Authentication

# Speak API credentials
export SPEAK_API_KEY="your-speak-api-key"
export SPEAK_APP_ID="your-app-id"

# OpenAI key for Realtime API (used by Speak for speech processing)
export OPENAI_API_KEY="your-openai-key"

# Create .env file
cat << 'EOF' >> .env
SPEAK_API_KEY=your-speak-api-key
SPEAK_APP_ID=your-app-id
OPENAI_API_KEY=your-openai-key
EOF

Step 3: Initialize the Client

// src/speak/client.ts
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient({
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  language: 'es', // Target language: es, ko, ja, fr, de, pt, zh, id
});

// Verify connection
async function verifySetup() {
  const languages = await client.getLanguages();
  console.log('Available languages:', languages.map(l => l.code).join(', '));
  const health = await client.health.check();
  console.log('API status:', health.status);
}

verifySetup();

Step 4: Configure Speech Recognition

// OpenAI Realtime API for speech-to-text (used by Speak)
import OpenAI from 'openai';

const openai = new OpenAI();

async function transcribeAudio(audioPath: string): Promise<string> {
  const transcription = await openai.audio.transcriptions.create({
    file: fs.createReadStream(audioPath),
    model: 'whisper-1',
    language: 'es', // Match target language
  });
  return transcription.text;
}

Step 5: Supported Languages

Speak Local Dev Loop

Overview

Set up a fast local development workflow for Speak language learning integrations. Includes mock tutor responses for offline development, audio test fixtures, and a debug mode for scoring analysis.

Prerequisites

• Completed speak-install-auth setup
• Node.js 18+ with npm/pnpm
• ffmpeg installed (for audio conversion)

Instructions

Step 1: Project Structure

speak-app/
  src/
    speak/client.ts       # Speak API client
    speak/tutor.ts        # AI tutor conversation manager
    speak/pronunciation.ts # Pronunciation assessment
    speak/audio.ts        # Audio recording and preprocessing
  tests/
    mocks/                # Mock responses for offline dev
    fixtures/             # Sample audio files for testing
    unit/                 # Unit tests with mocked API
    integration/          # Integration tests (needs API key)
  .env.development        # Dev credentials
  .env.test              # Test credentials (mock mode)

Step 2: Mock Tutor for Offline Development

// tests/mocks/mock-speak-client.ts
export class MockSpeakClient {
  async startConversation(config: any) {
    return {
      id: 'mock-session-123',
      firstPrompt: {
        text: 'Hola! Bienvenido. Como te llamas?',
        audioUrl: null,
      },
    };
  }

  async sendTurn(sessionId: string, input: any) {
    return {
      tutorText: 'Muy bien! Tu pronunciacion es buena.',
      pronunciationScore: 85,
      corrections: [],
      vocabularyNotes: ['llamo = I call myself'],
    };
  }

  async assessPronunciation(config: any) {
    return {
      score: 82,
      words: [
        { text: 'Hola', score: 95, phonemes: [] },
        { text: 'como', score: 78, phonemes: [
          { symbol: 'o', score: 65, suggestion: 'Round lips more' }
        ]},
      ],
    };
  }
}

Step 3: Audio Test Fixtures

# Generate test audio files using text-to-speech
# macOS:
say -v "Paulina" "Hola, como estas" -o tests/fixtures/hola-es.wav
# Linux:
espeak -v es "Hola, como estas" -w tests/fixtures/hola-es.wav

# Convert to required format
ffmpeg -i tests/fixtures/hola-es.wav -ar 16000 -ac 1 tests/fixtures/hola-es-16k.wav

Step 4: Development Scripts

{
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "dev:mock": "SPEAK_MOCK_MODE=true tsx watch src/index.ts",
    "test": "vitest run",
    "test:watch": "vitest",
    "lesson:test": "tsx src/test-lesson.ts"
  }
}

Step 5: Debug Mode

// Enable detailed scoring output
const DEBUG…

Speak Migration Deep Dive

Overview

Migrate between language learning platforms, import student progress, and transition from legacy speech APIs.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure migration deep dive for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_migration_deep_dive_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak migration deep dive
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Migration Deep Dive configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply migration deep dive with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Multi-Environment Setup

Overview

Configure Speak across dev, staging, and production with separate API keys and mock modes.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure multi env setup for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_multi_env_setup_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak multi-environment setup
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Multi-Environment Setup configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply multi env setup with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Observability

Overview

Monitor Speak API health, assessment latency, session metrics, and pronunciation score distributions.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure observability for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_observability_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak observability
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Observability configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply observability with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Performance Tuning

Overview

Optimize Speak API latency with audio preprocessing, response caching, and connection pooling.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure performance tuning for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_performance_tuning_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak performance tuning
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Performance Tuning configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply performance tuning with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak Production Checklist

Overview

Production readiness checklist for Speak language learning integrations: auth, audio pipeline, monitoring, and compliance.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• ffmpeg installed for audio processing

Instructions

Authentication

• [ ] API keys stored in secrets manager
• [ ] Key rotation schedule established (90 days)
• [ ] Separate keys for dev/staging/production
• [ ] Error handling for expired keys

Audio Pipeline

• [ ] Audio preprocessor converts to WAV 16kHz mono
• [ ] File size validation (< 25MB)
• [ ] Duration validation (0.5s - 60s)
• [ ] Background noise detection/warning
• [ ] Fallback for unsupported audio formats

Rate Limiting & Performance

• [ ] Rate-limited client wrapper implemented
• [ ] Retry logic with exponential backoff on 429
• [ ] Request queue for batch assessments
• [ ] Response caching where appropriate

Monitoring & Alerting

• [ ] API response time tracking
• [ ] Error rate monitoring (target < 1%)
• [ ] Rate limit hit tracking
• [ ] Assessment score distribution monitoring
• [ ] Session completion rate tracking

Compliance

• [ ] Student data privacy policy documented
• [ ] Audio data retention policy implemented
• [ ] COPPA compliance verified (if applicable)
• [ ] FERPA compliance verified (if educational)
• [ ] GDPR data processing agreement (if EU users)

Verification Script

#!/bin/bash
set -euo pipefail
echo "Speak Production Readiness"
curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" \
  https://api.speak.com/v1/health | jq '.status'
echo "  Auth: PASS"
ffmpeg -version > /dev/null 2>&1 && echo "  ffmpeg: PASS" || echo "  ffmpeg: FAIL"
echo "Checks complete."

Output

• Checklist implementation complete
• Speak API integration verified
• Production-ready patterns applied

Error Handling

Resources

• …

Speak Rate Limits

Overview

Handle Speak API rate limits with exponential backoff, request queuing, and optimization strategies.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Rate Limit Overview

Rate-Limited Client

class RateLimitedSpeakClient {
  private lastRequest = 0;
  private minDelay: number;

  constructor(private client: SpeakClient, requestsPerMinute: number = 60) {
    this.minDelay = 60000 / requestsPerMinute;
  }

  private async throttle() {
    const elapsed = Date.now() - this.lastRequest;
    if (elapsed < this.minDelay) {
      await new Promise(r => setTimeout(r, this.minDelay - elapsed));
    }
    this.lastRequest = Date.now();
  }

  async assessPronunciation(config: PronunciationConfig) {
    await this.throttle();
    return this.retryOn429(() => this.client.assessPronunciation(config));
  }

  private async retryOn429<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
    for (let i = 0; i < maxRetries; i++) {
      try {
        return await fn();
      } catch (err: any) {
        if (err.response?.status === 429 && i < maxRetries - 1) {
          const wait = parseInt(err.response.headers['retry-after'] || String(2 ** i));
          console.log(`Rate limited. Waiting ${wait}s...`);
          await new Promise(r => setTimeout(r, wait * 1000));
          continue;
        }
        throw err;
      }
    }
    throw new Error('Max retries exceeded');
  }
}

Batch Assessment Queue

async function batchAssess(client: RateLimitedSpeakClient, recordings: Recording[]) {
  const results = [];
  for (const rec of recordings) {
    const result = await client.assessPronunciation({
      audioPath: rec.path, targetText: rec.text, language: rec.lang,
    });
    results.push({ ...rec, score: result.score });
    console.log(`Assessed "${rec.text}": ${result.score}/100`);
  }
  return results;
}

Output

• Limits implementation complete
• Speak API integration verified
• Production-ready patterns applied

Error Handling

Speak Reference Architecture

Overview

Production architecture for Speak language learning apps: client, API gateway, assessment engine, and progress store.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure reference architecture for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_reference_architecture_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak reference architecture
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Reference Architecture configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply reference architecture with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.

Speak SDK Patterns

Overview

Production patterns for Speak language learning API: conversation sessions, pronunciation assessment, audio preprocessing, and batch operations.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• ffmpeg installed for audio processing

Instructions

Pattern 1: Conversation Session Manager

class ConversationManager {
  private client: SpeakClient;
  private sessions: Map<string, SessionState> = new Map();

  async startLesson(language: string, scenario: string, level: string) {
    const session = await this.client.startConversation({
      scenario, language, level, nativeLanguage: 'en',
    });
    this.sessions.set(session.id, {
      turns: [], startTime: Date.now(), language,
    });
    return session;
  }

  async submitResponse(sessionId: string, audioPath: string) {
    const turn = await this.client.sendTurn(sessionId, { audioPath });
    this.sessions.get(sessionId)?.turns.push(turn);
    return turn;
  }

  async endAndReport(sessionId: string) {
    const summary = await this.client.endSession(sessionId);
    const state = this.sessions.get(sessionId)!;
    return {
      ...summary,
      duration: (Date.now() - state.startTime) / 1000,
      totalTurns: state.turns.length,
      avgPronunciation: state.turns.reduce((s, t) =>
        s + (t.pronunciationScore || 0), 0) / state.turns.length,
    };
  }
}

Pattern 2: Audio Preprocessor

import { execSync } from 'child_process';

function preprocessAudio(inputPath: string): string {
  const outputPath = inputPath.replace(/\.[^.]+$/, '.processed.wav');
  // Convert to WAV 16kHz mono PCM — required by Speak API
  execSync(
    `ffmpeg -y -i "${inputPath}" -ar 16000 -ac 1 -c:a pcm_s16le "${outputPath}"`,
    { stdio: 'pipe' }
  );
  return outputPath;
}

Pattern 3: Retry with Backoff

async function withRetry<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (err: any) {
      if (err.response?.status === 429 && i < maxRetries - 1) {
        const wait = parseInt(err.response.headers['retry-after'] || '5');
        await new Promise(r => setTimeout(r, wait * 1000));
        continue;
      }
      throw err;
    }
  }
  throw new Error('Max retries exceeded');
}

Pattern 4: Progress Tracker

class LearningProgress {
  private history: SessionSummary[] = [];

  addSession(summary: SessionSummary) {
    this.history.push(summary);
  }

  getReport() {
    const recent = this.history.slice(-10);
    return {
   …

Speak Security Basics

Overview

Security best practices for Speak API keys, audio data privacy, student data protection, and COPPA/FERPA compliance.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• ffmpeg installed for audio processing

Instructions

API Key Security

# Never commit API keys
echo '.env' >> .gitignore
echo '.env.local' >> .gitignore

# Use secrets manager in production
export SPEAK_API_KEY="$(aws secretsmanager get-secret-value --secret-id speak/api-key --query SecretString --output text)"

Audio Data Privacy

// Speak processes audio on their servers — do NOT store student audio locally
// unless required by your application
class PrivacyAwareClient {
  async assessAndClean(audioPath: string, targetText: string, language: string) {
    try {
      const result = await this.client.assessPronunciation({
        audioPath, targetText, language,
      });
      return result;
    } finally {
      // Delete local audio file after assessment
      fs.unlinkSync(audioPath);
    }
  }
}

Student Data Protection

• Never log student audio recordings
• Redact student names from API logs
• Store assessment scores, not raw audio
• Implement data retention policies (delete after N days)
• COPPA compliance for students under 13: parental consent required
• FERPA compliance for educational institutions: student data agreements

Security Checklist

• [ ] API keys in secrets manager, not code
• [ ] Audio files deleted after processing
• [ ] Student PII not logged
• [ ] HTTPS enforced for all API calls
• [ ] Rate limiting prevents abuse
• [ ] Access logs maintained for audit

Output

• Basics implementation complete
• Speak API integration verified
• Production-ready patterns applied

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

Speak Upgrade & Migration

Overview

Upgrade Speak SDK versions, migrate between language learning platforms, and handle API version changes.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Current State

!npm list @speak/language-sdk 2>/dev/null || echo 'Speak SDK not installed'

Step 1: Check Current Version

npm list @speak/language-sdk
npm outdated @speak/language-sdk

Step 2: Upgrade SDK

npm install @speak/language-sdk@latest
npm test  # Run tests to verify compatibility

Step 3: API Version Migration

// Check for deprecated endpoints
const DEPRECATED_ENDPOINTS = [
  '/v1/lessons/start',      // Replaced by /v1/conversations/start
  '/v1/speech/score',       // Replaced by /v1/pronunciation/assess
];

// Migration map
const ENDPOINT_MIGRATION = {
  '/v1/lessons/start': '/v1/conversations/start',
  '/v1/speech/score': '/v1/pronunciation/assess',
};

Step 4: Platform Migration (from Duolingo/Babbel APIs)

// Map learning data between platforms
interface MigrationMapper {
  mapProficiencyLevel(source: string): 'beginner' | 'intermediate' | 'advanced';
  mapLanguageCode(source: string): string;
  mapProgress(source: any): SpeakProgress;
}

const duolingoMapper: MigrationMapper = {
  mapProficiencyLevel(crowns: string) {
    const c = parseInt(crowns);
    if (c < 3) return 'beginner';
    if (c < 6) return 'intermediate';
    return 'advanced';
  },
  mapLanguageCode: (code) => code, // Same ISO codes
  mapProgress: (duo) => ({
    vocabulary: duo.words_learned,
    level: duolingoMapper.mapProficiencyLevel(duo.crowns),
  }),
};

Post-Upgrade Verification

npm test
node -e "const s = require('@speak/language-sdk'); console.log('SDK version:', s.version || 'loaded OK')"

Output

• Migration implementation complete
• Speak API integration verified
• Production-ready patterns applied

Error Handling

Speak Webhooks & Events

Overview

Handle Speak lesson completion events, progress webhooks, and achievement notifications.

Prerequisites

• Completed speak-install-auth setup
• Valid API credentials configured
• Understanding of Speak API patterns

Instructions

Step 1: Configuration

Configure webhooks events for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_webhooks_events_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak webhooks & events
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

• Speak Webhooks & Events configured and verified
• Production-ready Speak integration
• Error handling and monitoring in place

Error Handling

Resources

• Speak Website
• OpenAI Realtime API
• Speak GPT-4 Blog

Next Steps

For production checklist, see speak-prod-checklist.

Examples

Basic: Apply webhooks events with default settings for a standard Speak integration.

Production: Configure with monitoring, alerting, and team-specific language learning requirements.