Build a Language Learning App with Spaced Repetition and AI Conversation

mkdir lingo && cd lingo && npm init -y
npm install @prisma/client@7 @prisma/adapter-pg@7 pg @anthropic-ai/sdk assemblyai dotenv
npm install -D prisma@7 typescript @types/node @types/pg
npx prisma init --datasource-provider postgresql
export ANTHROPIC_API_KEY=... ASSEMBLYAI_API_KEY=...   # keys from the two consoles, never committed

generator client {
  provider = "prisma-client"
  output   = "../generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model User {
  id             String                @id @default(cuid())
  email          String                @unique
  name           String
  nativeLanguage String                @default("en")
  targetLanguage String                @default("es")
  currentXP      Int                   @default(0)
  totalXP        Int                   @default(0)
  level          String                @default("A1") // A1 A2 B1 B2 C1 C2
  cards          UserCard[]
  sessions       ConversationSession[]
}

model VocabCard {
  id                 String     @id @default(cuid())
  language           String     // "es", "ja", "fr"
  niche              String?    // "business", "medical", "legal"
  word               String
  translation        String
  exampleSentence    String?
  userCards          UserCard[]
}

model UserCard {
  id          String    @id @default(cuid())
  userId      String
  user        User      @relation(fields: [userId], references: [id])
  cardId      String
  card        VocabCard @relation(fields: [cardId], references: [id])
  repetitions Int       @default(0)
  easeFactor  Float     @default(2.5)
  interval    Int       @default(0) // days
  nextReview  DateTime  @default(now())
  status      String    @default("new") // new | learning | review | mastered

  @@unique([userId, cardId])
  @@index([userId, nextReview])
}

model ConversationSession {
  id        String   @id @default(cuid())
  userId    String
  user      User     @relation(fields: [userId], references: [id])
  scenario  String?  // "job_interview", "medical_appointment"
  messages  Json     // array of {role, content}
}

// lib/prisma.ts
import { PrismaPg } from '@prisma/adapter-pg'
import { PrismaClient } from '../generated/prisma/client'

const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })
export const prisma = new PrismaClient({ adapter })

// lib/sm2.ts
import { prisma } from './prisma'

export interface SM2State {
  repetitions: number
  easeFactor: number
  interval: number // days
}

export type Quality = 0 | 1 | 2 | 3 | 4 | 5

// SuperMemo-2: https://super-memory.com/english/ol/sm2.htm
export function sm2(state: SM2State, quality: Quality): SM2State {
  if (quality < 3) {
    return { repetitions: 0, easeFactor: state.easeFactor, interval: 1 }
  }
  const interval =
    state.repetitions === 0 ? 1 : state.repetitions === 1 ? 6 : Math.round(state.interval * state.easeFactor)
  const easeFactor = Math.max(
    1.3,
    state.easeFactor + (0.1 - (5 - quality) * (0.08 + (5 - quality) * 0.02)),
  )
  return { repetitions: state.repetitions + 1, easeFactor, interval }
}

export async function reviewCard(userId: string, cardId: string, quality: Quality) {
  const where = { userId_cardId: { userId, cardId } }
  const userCard = await prisma.userCard.findUnique({ where })
  if (!userCard) throw new Error('Card not found')

  const next = sm2(userCard, quality)
  const nextReview = new Date()
  nextReview.setDate(nextReview.getDate() + next.interval)

  const xpGained = quality >= 4 ? 10 : quality === 3 ? 5 : 2
  const status = next.repetitions >= 5 ? 'mastered' : next.repetitions >= 2 ? 'review' : 'learning'

  await prisma.$transaction([
    prisma.userCard.update({
      where,
      data: { ...next, nextReview, status },
    }),
    prisma.user.update({
      where: { id: userId },
      data: { currentXP: { increment: xpGained }, totalXP: { increment: xpGained } },
    }),
  ])
  return { nextReview, xpGained, status }
}

export function getDueCards(userId: string, limit = 20) {
  return prisma.userCard.findMany({
    where: { userId, nextReview: { lte: new Date() } },
    include: { card: true },
    orderBy: { nextReview: 'asc' },
    take: limit,
  })
}

// lib/conversation.ts
import Anthropic from '@anthropic-ai/sdk'

const client = new Anthropic() // reads ANTHROPIC_API_KEY
const MODEL = 'claude-sonnet-5-5'

const SCENARIOS = {
  job_interview: 'You are an HR manager interviewing the user for a job at a Madrid tech company.',
  medical_appointment: 'You are a doctor in Madrid. The user is a patient describing symptoms.',
}

export async function chat(
  userMessage: string,
  history: { role: 'user' | 'assistant'; content: string }[],
  scenario: keyof typeof SCENARIOS,
  targetLanguage: string,
) {
  const response = await client.messages.create({
    model: MODEL,
    max_tokens: 512,
    system: `${SCENARIOS[scenario]}
Always reply in ${targetLanguage} and stay in character.
After your reply, add one final line starting with "Tip:" that corrects any grammar mistake
in the user's last message or suggests better phrasing. Keep it short.`,
    messages: [...history, { role: 'user', content: userMessage }],
  })

  const text = response.content.flatMap((b) => (b.type === 'text' ? [b.text] : [])).join('')
  const tip = text.match(/^Tip: (.+)$/m)?.[1] ?? null
  const reply = text.replace(/^Tip: .+$/m, '').trim()
  return { reply, tip, outputTokens: response.usage.output_tokens }
}

// lib/pronunciation.ts
import { AssemblyAI } from 'assemblyai'

const assemblyai = new AssemblyAI({ apiKey: process.env.ASSEMBLYAI_API_KEY! })

const words = (s: string) => s.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, '').split(/\s+/).filter(Boolean)

function lcs(a: string[], b: string[]) {
  const t = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0))
  for (let i = 1; i <= a.length; i++)
    for (let j = 1; j <= b.length; j++)
      t[i][j] = a[i - 1] === b[j - 1] ? t[i - 1][j - 1] + 1 : Math.max(t[i - 1][j], t[i][j - 1])
  return t[a.length][b.length]
}

// Scores how much of the target sentence a speech recognizer heard. This measures
// intelligibility, not phoneme-level accuracy.
export async function scoreSpeech(audio: Buffer, expectedText: string, language: string) {
  const transcript = await assemblyai.transcripts.transcribe({
    audio: await assemblyai.files.upload(audio),
    language_code: language, // e.g. "es", "ja", "fr"
  })
  if (transcript.status === 'error') throw new Error(transcript.error ?? 'Transcription failed')
  if (!transcript.text) return { score: 0, heard: '', feedback: 'No speech detected.' }

  const expected = words(expectedText)
  const score = Math.round((lcs(expected, words(transcript.text)) / expected.length) * 100)
  const feedback =
    score >= 90 ? 'Clear and easy to understand.'
    : score >= 70 ? `Mostly clear. We heard: "${transcript.text}".`
    : `We heard: "${transcript.text}". Listen to the native audio and try again.`
  return { score, heard: transcript.text, feedback }
}

// lib/exercises.ts
import Anthropic from '@anthropic-ai/sdk'

const client = new Anthropic()

export async function generateGrammarExercise(topic: string, level: string, language: string) {
  const response = await client.messages.create({
    model: 'claude-sonnet-5-5',
    max_tokens: 512,
    messages: [{
      role: 'user',
      content: `Write one fill-in-the-blank ${language} grammar exercise at CEFR level ${level} about: ${topic}.
Reply with only a JSON object with the keys instruction, sentence (using ___ for the blank),
blank, options (4 strings including the blank), and explanation (in English).`,
    }],
  })
  const text = response.content.flatMap((b) => (b.type === 'text' ? [b.text] : [])).join('')
  const json = text.match(/\{[\s\S]*\}/)?.[0]
  if (!json) throw new Error('Model did not return JSON')
  const exercise = JSON.parse(json) as { instruction: string; sentence: string; blank: string; options: string[]; explanation: string }
  if (!exercise.options.includes(exercise.blank)) throw new Error('Invalid exercise, retry')
  return exercise
}