Streaming de Respostas IA com React Server Components e Vercel AI SDK

Streaming de Respostas IA com React Server Components e Vercel AI SDK

A febre da Inteligência Artificial fez com que toda empresa de software tentasse colocar um "Assistente Inteligente" dentro do seu sistema da noite para o dia. O problema é que muitas dessas implementações nascem com uma arquitetura amadora e falha.

O erro fatal? A Chamada Síncrona Bloqueante.

Quando o seu usuário pergunta algo complexo para a IA (como "Gere um relatório de vendas do mês passado"), modelos de linguagem podem levar vários segundos para raciocinar e cuspir a resposta completa. Se você usar uma API tradicional que só responde quando tudo termina, o usuário fica olhando para um carregamento sem fim e, dependendo do limite de tempo configurado no servidor, do proxy ou da plataforma, a requisição pode estourar com um erro 504 Gateway Timeout ou a famosa "Tela Branca da Morte".

A solução mais adequada para isso é o Streaming.

Neste artigo, vou te mostrar como usar o Vercel AI SDK para construir uma conexão contínua entre o seu Frontend (Next.js) e o modelo de IA, entregando a resposta palavra por palavra na tela do cliente, exatamente como o ChatGPT faz, reduzindo drasticamente a latência percebida.


O Vercel AI SDK: A Ponte Definitiva

O Vercel AI SDK é uma biblioteca de código aberto que padroniza a comunicação com dezenas de provedores de IA (OpenAI, Anthropic, Google) usando as tecnologias de WebStreams.

Ao invés de esperar a IA terminar para só então responder, a rota de API devolve um stream que vai sendo preenchido conforme o modelo gera o texto. Na Vercel, essa rota roda como uma Function em Node.js com Fluid compute, cujo limite padrão de duração é de 300 segundos (ajustável com maxDuration), o que é folga de sobra para uma resposta de chat. Se você quiser comparar com o runtime Edge, eu explico as diferenças em Edge Functions vs Serverless; hoje a própria Vercel recomenda Node.js para a maioria dos casos.

1. Criando a Rota da API (Backend)

Vou criar a rota que recebe as mensagens do usuário e se conecta com o modelo. Os exemplos abaixo usam a API atual do AI SDK (streamText + toUIMessageStreamResponse).

// src/app/api/chat/route.ts
import { openai } from '@ai-sdk/openai';
import { streamText, convertToModelMessages, type UIMessage } from 'ai';

// 1. Tempo máximo de execução da função, em segundos
export const maxDuration = 60;

export async function POST(req: Request) {
  // 2. Extraímos as mensagens (no formato de UI) do corpo da requisição
  const { messages }: { messages: UIMessage[] } = await req.json();

  // 3. Disparamos a chamada para o modelo.
  // streamText NÃO espera o modelo terminar de pensar (e não leva await):
  // ele começa a entregar os pedaços (chunks) imediatamente.
  const result = streamText({
    model: openai('gpt-5-mini'), // troque pelo modelo/provedor que preferir
    system: 'Você é um assistente de suporte focado em ajudar clientes de um SaaS B2B.',
    messages: await convertToModelMessages(messages),
  });

  // 4. Retornamos o stream contínuo para o cliente (Frontend)
  return result.toUIMessageStreamResponse();
}

2. O React Component Inteligente (Frontend)

Agora, vou criar a interface. O pacote @ai-sdk/react fornece o hook useChat, que esconde toda a complexidade de ler WebStreams e atualizar o estado do React em tempo real. Na versão atual, o hook não gerencia mais o campo de texto: o input fica num useState do próprio componente, e o envio é feito com sendMessage. Por padrão, ele já envia para /api/chat.

// src/components/SupportChatbot.tsx
'use client';

import { useState } from 'react';
import { useChat } from '@ai-sdk/react';

export default function SupportChatbot() {
  // O hook gerencia o histórico de mensagens e a leitura do streaming
  // em tempo real (palavra por palavra). O input é estado nosso.
  const { messages, sendMessage, status } = useChat();
  const [input, setInput] = useState('');

  return (
    <div className="flex flex-col w-full max-w-md py-24 mx-auto stretch">
      <div className="space-y-4 mb-8">
        {messages.map(message => (
          <div
            key={message.id}
            className={`p-4 rounded-lg ${message.role === 'user' ? 'bg-gray-100 text-right' : 'bg-blue-50'}`}
          >
            <strong>{message.role === 'user' ? 'Você: ' : 'IA: '}</strong>
            {/* Cada mensagem é composta por "parts" (texto, ferramentas etc.) */}
            {message.parts.map((part, i) =>
              part.type === 'text' ? <span key={i}>{part.text}</span> : null
            )}
          </div>
        ))}
      </div>

      <form
        onSubmit={e => {
          e.preventDefault();
          if (!input.trim()) return;
          sendMessage({ text: input });
          setInput('');
        }}
        className="flex gap-2"
      >
        <input
          className="w-full p-2 border border-gray-300 rounded shadow-xl"
          value={input}
          placeholder="Como posso te ajudar hoje?"
          onChange={e => setInput(e.target.value)}
          disabled={status !== 'ready'}
        />
        <button
          type="submit"
          className="bg-black text-white px-4 py-2 rounded font-bold"
          disabled={status !== 'ready'}
        >
          Enviar
        </button>
      </form>
    </div>
  );
}

A Vantagem Estratégica do Streaming

Ao implementar essa arquitetura, você resolve três problemas mortais de uma vez só:

  1. Retenção de Usuário: Ao ver a primeira palavra aparecendo na tela rapidamente, o cérebro do usuário entende que o sistema é rápido. Ele não abandona a página enquanto a IA está redigindo o texto longo.
  2. Infraestrutura Resiliente: Você não prende conexões pesadas no seu banco de dados ou no seu servidor Node.js principal. O trabalho bruto é terceirizado para o provedor da LLM e entregue pela malha distribuída da Vercel.
  3. Escala com Custo Controlado: Como a função passa a maior parte do tempo esperando o provedor da LLM, o Fluid compute consegue atender várias conversas na mesma instância, e uma Arquitetura de Alta Demanda absorve picos de acesso sem exigir servidores dedicados.

A Inteligência Artificial parou de ser um laboratório de testes; ela é agora o núcleo de engajamento dos softwares modernos. Se a sua empresa ainda desenvolve IAs que deixam o usuário olhando para um "ícone de carregamento" girando por 15 segundos, o seu produto já está obsoleto.


Precisa de apoio técnico para a sua empresa?

Se a sua operação busca especialistas para modernização de sistemas legados ou desenvolvimento de sistemas sob medida com arquitetura de alta performance (Next.js e Supabase), conheça meus serviços de tecnologia ou fale diretamente comigo pelo WhatsApp.


Albanir Neves

Albanir Neves

Especialista em Sistemas Sob Medida

Com mais de 12 anos de experiência técnica, ajudo empresas a escalar e digitalizar processos através de sistemas sob medida, automação avançada e integrações B2B com Inteligência Artificial.