Davna AI: construindo um parceiro de conversa para treinar inglês

O que é o Davna?

1. O aluno grava um áudio falando em inglês;

2. A mensagem aparece no histórico com a transcrição e a tradução para o português;

3. A professora responde por voz, também com transcrição e tradução;

4. Se o aluno cometeu algum erro gramatical, ela aponta com gentileza e mostra a forma correta.

Stack e arquitetura

• apps/client.app → frontend em Next.js, hospedado na Vercel, com rotas de API que funcionam como BFF (Backend for Frontend);

• apps/monolith.api → API em Node.js com Express e Socket.IO;

• apps/multimedia.processing → microsserviço isolado com FFmpeg e ffprobe;

• services/ffmpeg → SDK HTTP que a API usa para falar com o microsserviço;

• modules/ → domínios da aplicação: sala de aula, identidade e acesso, monitoramento, insights de clientes;

• shared/ → kernel funcional (Either, Reader), contratos de repositório e implementações de infraestrutura (MongoDB, S3, OpenAI, Google Sheets).

Anatomia de uma fala: o fluxo completo de um turno

#Etapa 1: Capturando o áudio no navegador

export async function startRecorder(
  fn: (chunk: Blob) => any,
): Promise<Recorder> {
  const preferred = [
    'audio/webm;codecs=opus',
    'audio/webm',
    'audio/ogg',
    'audio/mp4',
  ]

  const supported =
    preferred.find(
      t => MediaRecorder.isTypeSupported && MediaRecorder.isTypeSupported(t),
    ) || 'audio/webm'

  const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
  const mediaRecorder = new MediaRecorder(stream, { mimeType: supported })

  mediaRecorder.ondataavailable = e => {
    if (e.data && e.data.size > 0) fn(e.data)
  }

  // ...
}

#Etapa 2: O problema da duração e o microsserviço de FFmpeg

const DEFAULT_TIMEOUT_MS = 10_000

const args = (
  useFilePath
    ? ['-i', input as string, '-vn', '-c:a', 'aac', '-b:a', '128k']
    : ['-i', 'pipe:0', '-vn', '-c:a', 'aac', '-b:a', '128k']
).concat(outputPath ? [outputPath] : ['-f', 'mp4', 'pipe:1'])

const p = spawn(path, args, { stdio: ['pipe', 'pipe', 'pipe'] })

• Tudo em memória, via pipe → o áudio entra pelo stdin e sai pelo stdout, sem arquivos temporários;

• Timeout de 10 segundos com SIGKILL → um áudio corrompido não pode travar o serviço;

• Metadados via ffprobe → depois da conversão, o ffprobe lê a duração real em milissegundos, que volta para a API nos cabeçalhos da resposta (x-file-duration, x-file-codec, x-file-format).

• Duração confiável → o controle de uso passa a se basear em um número real;

• Formato único → o mesmo áudio toca em qualquer navegador;

• Isolamento de recursos → a CPU consumida pelo FFmpeg não disputa espaço com a API;

• Contrato explícito → a API conhece apenas o SDK; trocar o FFmpeg por um serviço gerenciado no futuro não afeta o domínio.

#Etapa 3: Transcrever, traduzir, responder e falar

const response = await openai.responses.create({
  model: 'o4-mini',
  input: [{ role: 'system', content: instruction }, ...input],
})

// ...

const response = await openai.audio.transcriptions.create({
  file: createReadStream(path),
  model: 'gpt-4o-transcribe',
})

// ...

const response = await openai.audio.speech.create({
  model: 'gpt-4o-mini-tts',
  response_format: 'aac',
  voice: 'alloy',
  input: text,
})

1. Transcrição da fala do aluno com o gpt-4o-transcribe;

2. Tradução da transcrição para o português, com o o4-mini;

3. Resposta da professora, gerada pelo o4-mini a partir de todo o histórico da conversa;

4. Tradução da resposta para o português;

5. Síntese de voz da resposta com o gpt-4o-mini-tts, já no formato AAC;

6. Leitura dos metadados do áudio gerado pelo FFmpeg e armazenamento no S3.

#Etapa 4: Tempo real com Socket.IO

export const appendAndReplyHandler = Handler<Env, Data, Metadata>(
  request =>
    async ({ emitter, /* ...dependências */ }) => {
      emitter.emit('classroom:replying', { classroom_id, participant_id })

      const result = await transcribeAndAppend({ audio, classroom_id, participant_id })(env)

      if (isLeft(result)) {
        emitter.emit('error:service', { status: 'error', message: result.value.message })
        return Response.metadata({ status: 'error' })
      }

      emitter.emit('classroom:updated', {
        remainingConsumption: remainingConsumption(result.value.consume),
        classroom: result.value.classroom,
        message: result.value.message,
      })

      emitter.emit('classroom:replying', { classroom_id, participant_id: teacher_id })

      const result2 = await teacherGeneratesResponse({ classroom, teacher_id })(env)

      // ... mesmo tratamento: erro → error:service, sucesso → classroom:updated
    },
)

• "Digitando..." enquanto sua fala é transcrita;

• Sua mensagem aparecer com transcrição e tradução;

• "Any está respondendo..." enquanto a IA pensa e gera a voz;

• A resposta da professora pronta para tocar.

Dando personalidade à professora

const transcription = await gpt.respond({
  instruction:
    'You are a conversational assistant with the tone and clarity of a supportive teacher. Continue the conversation naturally, always aiming to educate and guide the user. Whenever the user makes linguistic or grammatical mistakes, gently point them out and provide the correct form—always with empathy and encouragement. Your explanations should be clear, constructive, and never condescending. Maintain a warm, patient, and respectful tone at all times. For your first message, introduce yourself briefly as a teacher named Any, greet the user warmly, and ask what topic they would like to talk about today.',
  input,
})

• "Continue the conversation naturally" → a prioridade é a conversa fluir, não virar uma aula expositiva;

• "gently point them out and provide the correct form" → corrigir é parte do objetivo, mas sem interromper o diálogo;

• "never condescending" → quem está aprendendo já se sente exposto; a IA não pode piorar isso;

• "For your first message, introduce yourself" → quando o aluno entra numa sala vazia, é a professora quem quebra o gelo e pergunta sobre o que ele quer conversar.

Controlando o custo: o limite de uso diário

const actualDay = new Date(new Date().toDateString())

const actuals = msgs.filter(msg => msg.created_at >= actualDay)
const consume = actuals
  .map(msg => msg.data.duration)
  .reduce((val, curr) => val + curr, 0)

if (consume >= 60 * 60 * 1000 /* 1h */)
  return Left({
    status: 'error',
    message: "This user can't consume more today",
  })

Uma IA falsa para não pagar pela IA de verdade

Deploy: Docker, EC2 e um runner self-hosted

• Vercel → frontend Next.js;

• AWS EC2 → API, microsserviço de FFmpeg e MongoDB, orquestrados com Docker Compose;

• AWS S3 → armazenamento dos áudios.

Desafios e soluções encontradas

Roadmap e próximos passos

• Modelar a sala de aula como um grafo → mensagens, áudios, textos e participantes viram nós conectados por arestas. Uma transcrição, uma tradução ou um resumo passam a ser representações derivadas de um conteúdo, e não campos fixos;

• Políticas de uso flexíveis → limites por dia, semana ou mês, em minutos ou em tokens, concedidos por planos;

• Transações com Saga → operações que envolvem vários repositórios ganham compensações automáticas em caso de falha;

• Um orquestrador dedicado para a IA → tirar o turno da conversa de dentro do handler do socket e levá-lo para um serviço próprio;

• Paralelizar etapas independentes → a tradução da fala do aluno, por exemplo, não precisa esperar pela resposta da professora.

Conclusão