API de LLM na Prática: Integrando Modelos de Linguagem em Aplicações

Grandes modelos de linguagem (LLMs) como GPT-4, Claude e Gemini revolucionaram como interagimos com software. Mas construir aplicações robustas com esses modelos vai além de fazer requisições HTTP. Este artigo mostra como integrar LLMs de forma profissional, econômica e escalável.

O Que é uma API de LLM?

Uma API de LLM permite que seu aplicativo envie texto para um modelo de linguagem remoto e receba uma resposta gerada. Em vez de hospedar bilhões de parâmetros localmente, você paga por uso (tipicamente por token processado) e acessa modelos state-of-the-art via HTTPS.

O formato mais comum é o chat completions: você envia uma lista de mensagens (sistema, usuário, assistente) e o modelo retorna a próxima mensagem da conversa.

Principais Provedores e suas Diferenças

O mercado de LLMs está fragmentado, com vários provedores oferecendo capacidades e preços distintos. A escolha do provedor impacta diretamente custo, latência e qualidade das respostas.

Integração Básica com Fetch

A integração mais simples usa uma requisição HTTP comum. Aqui está um exemplo usando a API da OpenAI, mas o padrão é similar para a maioria dos provedores.

async function chatWithLLM(userMessage: string) {
  const response = await fetch("https://api.openai.com/v1/chat/completions", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`,
    },
    body: JSON.stringify({
      model: "gpt-4o-mini",
      messages: [
        { role: "system", content: "Você é um assistente técnico útil." },
        { role: "user", content: userMessage },
      ],
      temperature: 0.7,
      max_tokens: 500,
    }),
  });

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

Arquitetura Recomendada: Backend Proxy

Em aplicações reais, seu frontend não deve falar diretamente com a API do LLM. Um backend proxy oferece múltiplas vantagens: protege a API key, permite rate limiting, caching, logging e transformação de prompts.

// src/routes/api/chat.ts — TanStack Start server route
import { createFileRoute } from "@tanstack/react-router";

export const Route = createFileRoute("/api/chat")({
  server: {
    handlers: {
      POST: async ({ request }) => {
        const { message } = await request.json();

        // Rate limiting, validação, logging podem ir aqui
        const llmResponse = await fetch("https://api.openai.com/v1/chat/completions", {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`,
          },
          body: JSON.stringify({
            model: "gpt-4o-mini",
            messages: [
              { role: "system", content: "Você é um assistente técnico." },
              { role: "user", content: message },
            ],
            temperature: 0.7,
          }),
        });

        const data = await llmResponse.json();
        return Response.json({ reply: data.choices[0].message.content });
      },
    },
  },
});

Otimizando Custos com LLMs

Tokens são a moeda dos LLMs. Cada palavra processada — entrada e saída — custa dinheiro. Aqui estão estratégias práticas para reduzir gastos sem sacrificar qualidade.

• Escolha o modelo certo para a tarefa: use modelos menores (gpt-4o-mini, claude-haiku) para tarefas simples. Reserve modelos grandes para raciocínio complexo.
• Limite max_tokens: defina um teto para respostas, evitando outputs desnecessariamente longos.
• Use cache semântico: armazene respostas de prompts similares e reutilize sem chamar a API.
• Comprima contexto: envie apenas o histórico relevante. Contexto longo é caro e muitas vezes desnecessário.
• Batch processing: quando possível, processe múltiplas requisições em lote em vez de uma a uma.

Streaming de Respostas

Nenhum usuário gosta de esperar 10 segundos vendo um loading. Streaming permite que o texto apareça gradualmente, melhorando drasticamente a percepção de velocidade.

A maioria das APIs de LLM suporta Server-Sent Events (SSE) para streaming. O frontend recebe pedaços da resposta em tempo real e os renderiza conforme chegam.

// Exemplo de streaming no frontend
const response = await fetch("/api/chat-stream", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ message: "Explique TypeScript" }),
});

const reader = response.body?.getReader();
const decoder = new TextDecoder();

while (reader) {
  const { done, value } = await reader.read();
  if (done) break;
  const chunk = decoder.decode(value, { stream: true });
  // Acumular e renderizar o texto parcial
  appendToChat(chunk);
}

Técnicas Avançadas: RAG e Function Calling

RAG (Retrieval-Augmented Generation)

LLMs têm conhecimento limitado e desatualizado. RAG conecta o modelo a uma base de conhecimento externa (documentos, banco de dados vetoriais) para responder com informações atualizadas e verificáveis.

O fluxo é: o usuário faz uma pergunta → você busca documentos relevantes em um banco vetorial → inclui esses documentos no prompt como contexto → o LLM responde baseado nesse contexto.

Function Calling

Function calling permite que o LLM decida quando chamar funções externas (buscar preço, verificar estoque, agendar reunião). O modelo não executa a função — ele apenas pede, e seu código a executa e retorna o resultado.

Segurança e Compliance

Integrar LLMs traz riscos que não existem em APIs tradicionais. Dados sensíveis podem vazar, prompts podem ser manipulados e respostas podem conter informações incorretas.

• Nunca envie PII (dados pessoais) para LLMs de terceiros sem anonimização.
• Implemente input validation: usuários podem tentar jailbreaks ou prompt injection.
• Logue e audite interações para detectar abuso e melhorar o sistema.
• Adicione disclaimers quando o LLM fornece informações que podem ser incorretas.
• Considere modelos self-hosted para dados altamente sensíveis (saúde, financeiro).

Conclusão

Integrar LLMs é mais do que consumir uma API REST. Requer arquitetura pensada, controle de custos, segurança e experiência do usuário. Os times que tratam LLMs como componente crítico da infraestrutura — e não como brinquedo — constroem produtos que realmente aproveitam o potencial da IA generativa.

Comece com um backend proxy simples, meça seus custos por requisição, implemente caching e só então adicione complexidade como RAG e function calling. A simplicidade bem executada vence a arquitetura over-engineered.

Perguntas frequentes

Fontes consultadas

• OpenAI API Documentation
• Anthropic API Documentation
• Building LLM Applications (Lilian Weng)