O Modelo de Interface de LLM
Tokens, janelas de contexto, prompts e esquemas de saída estruturada ou de ferramentas podem parecer um conjunto de detalhes de API de LLM não relacionados.
Na verdade, eles são uma única ideia: um modelo de linguagem grande é uma função de texto-de-entrada, texto-de-saída com uma janela de atenção de tamanho fixo, e todas as convenções nesta seção existem para gerenciar o que entra nessa janela e o que sai dela como algo que um programa pode realmente usar.
Esta página conecta Noções Básicas de LLMs, Tokens, Custo e Limites de Taxa, Engenharia de Prompt e Saída Estruturada em um único modelo, em vez de quatro tópicos de API separados.
Resumo
- Um LLM é uma função sem estado sobre uma janela de tokens de tamanho fixo, e o prompting, o gerenciamento de contexto e a saída estruturada são todas técnicas para controlar o que entra nessa janela e o que sai dela.
- Por que é Importante: Todas as restrições práticas que os desenvolvedores encontram - custo, latência, "o modelo esqueceu o contexto anterior", JSON malformado - remontam à contagem de tokens e aos limites da janela de contexto, e não à imprevisibilidade do modelo.
- Conceitos Chave: token, janela de contexto, prompt como interface, papéis de sistema/usuário/assistente, saída estruturada, esquema de ferramenta/função.
- Quando Usar: Ao projetar qualquer recurso baseado em LLM, decidir o que colocar em um prompt, quanta história manter e se deve pedir texto livre ou uma resposta estruturada e analisável.
- Limitações / Compromissos: Uma janela de contexto maior custa mais por chamada e não garante que o modelo pondere tudo igualmente; a saída estruturada restringe a forma da resposta do modelo a um custo para sua liberdade expressiva.
- Tópicos Relacionados: embeddings e recuperação, streaming de respostas, diferenças de SDK do provedor.
Fundamentos
Um token é a unidade que um LLM realmente lê e escreve, não exatamente uma palavra e não exatamente um caractere, mas um pedaço de subpalavra produzido pelo tokenizador do modelo.
Palavras comuns são frequentemente um único token e palavras mais raras são divididas em várias.
Cada prompt que você envia e cada resposta que você recebe é contada, precificada e limitada em tokens, não em caracteres ou palavras, razão pela qual a contagem de tokens é o primeiro ajuste mental que vale a pena fazer.
A janela de contexto é o número máximo de tokens, prompt mais resposta combinados na maioria das APIs, que um modelo pode atender em uma única chamada, e é um limite rígido.
Tokens além dele são rejeitados imediatamente ou truncados silenciosamente, e nada que você faça no prompt altera esse limite para um determinado modelo.
Uma analogia útil é um quadro branco de tamanho fixo: você pode escrever o que quiser nele, mas quando ele está cheio, adicionar uma nova linha significa apagar uma antiga.
O modelo não tem memória além do que cabe atualmente naquele quadro branco, chamado do zero em cada chamada de API.
Isso leva à reestruturação central desta seção: o prompt é a interface.
Onde uma API tradicional tem uma assinatura de função fixa, a "assinatura" de um LLM é qualquer texto que você escolher colocar dentro da janela de contexto em uma determinada chamada - instruções, exemplos, conversa anterior, documentos recuperados - e o modelo não tem acesso a nada fora dela.
Mecânicas e Interações
A estrutura de papéis de sistema/usuário/assistente é a forma padrão dessa interface.
O papel do sistema define instruções permanentes e persona, o papel do usuário carrega a tarefa ou pergunta real, e o papel do assistente contém as próprias respostas anteriores do modelo ao reproduzir uma conversa.
Como o modelo é sem estado entre as chamadas, uma conversa de vários turnos não é o modelo "lembrando" de nada.
É o seu código reenviando toda a conversa anterior, como tokens, dentro da janela de contexto a cada vez, razão pela qual o histórico da conversa tem um custo real e crescente de tokens à medida que se torna mais longo.
chamada 1: [sistema] [usuário: "oi"] -> [assistente: "olá"]
chamada 2: [sistema] [usuário: "oi"] [assistente: "olá"]
[usuário: "quanto é 2+2?"] -> [assistente: "4"]
Cada chamada reenvia tudo o que veio antes - o modelo não tem estado próprio entre as chamadas.
É por isso também que o design de prompt e o gerenciamento de contexto são a mesma habilidade subjacente: decidir o que incluir é decidir o que cabe em um quadro branco de tamanho fixo, e cada token gasto em uma coisa é um token não disponível para outra.
Saída estruturada e esquemas de ferramentas/funções existem para resolver um problema totalmente diferente.
A saída nativa de um LLM é texto de formato livre, mas a maioria dos programas precisa de uma forma específica e analisável - um objeto JSON com campos conhecidos, ou uma chamada para uma função específica com argumentos tipados - para realmente agir sobre a resposta.
Em vez de analisar texto livre com regexes e esperar que a formulação do modelo permaneça consistente, as APIs de saída estruturada permitem que você forneça um esquema que restringe a resposta do modelo a corresponder a essa forma, transformando as palavras do modelo em um valor que seu programa pode usar diretamente.
Chamada de ferramenta estende essa mesma ideia um passo adiante: em vez de pedir ao modelo para responder diretamente, você descreve as funções disponíveis no esquema do prompt, e o trabalho do modelo se torna escolher qual função chamar e com quais argumentos.
Seu código, não o modelo, realmente a executa.
Considerações Avançadas e Aplicações
Em escala, o tamanho fixo da janela de contexto torna-se uma restrição arquitetônica real, em vez de um inconveniente.
Um aplicativo que deseja que um modelo raciocine sobre mais informações do que cabem em uma janela, como um documento grande, uma conversa longa ou uma grande base de conhecimento, não pode simplesmente usar um prompt maior além desse limite.
Geração aumentada por recuperação existe especificamente para contornar isso: em vez de colocar uma base de conhecimento inteira em cada prompt, uma busca baseada em embedding recupera apenas os poucos trechos relevantes para a consulta atual, e apenas esses são gastos do orçamento de tokens.
Conversas longas atingem o mesmo muro por uma direção diferente, razão pela qual aplicativos reais resumem ou truncam turnos mais antigos em vez de reproduzir um transcripto em constante crescimento literalmente em cada chamada.
O crescimento ilimitado do histórico eventualmente excede a janela, e mesmo antes disso, torna cada chamada mais lenta e mais cara.
As garantias da saída estruturada também diferem significativamente por mecanismo, o que importa ao escolher quão estritamente você precisa que a forma seja aplicada.
| Estratégia de Saída | Força | Fraqueza | Melhor Ajuste |
|---|---|---|---|
| Texto de formato livre + análise manual | Nenhum esquema para projetar; máxima expressividade do modelo | Frágil - uma mudança de formulação quebra silenciosamente seu analisador | Prototipagem, saída legível por humanos, uso de baixo risco |
| JSON com prompt (pedir educadamente, analisar o resultado) | Funciona com qualquer modelo; nenhuma funcionalidade especial de API necessária | O modelo ainda pode emitir JSON inválido ou desviar do esquema em respostas longas | Necessidades estruturadas simples onde retentativas ocasionais são aceitáveis |
| Saída estruturada nativa / geração com restrição de esquema | A resposta é garantida ou fortemente restrita a corresponder ao seu esquema | Requer suporte do provedor para o recurso; restringe a liberdade de formulação do modelo | Sistemas de produção que analisam a resposta programaticamente |
Esquemas de ferramentas complicam isso ainda mais em sistemas agenticos.
O modelo escolher a ferramenta errada, ou fornecer argumentos que não correspondem aos tipos descritos, é um modo de falha funcionalmente o mesmo que JSON malformado em saída estruturada simples, apenas um nível removido - o esquema é tão bom quanto a precisão com que descreve o que a função realmente precisa.
Conceitos Equivocados Comuns
- "O modelo se lembra de nossa conversa anterior." Ele não se lembra - seu código reenvia todo o histórico relevante como tokens em cada chamada, e o modelo não tem estado persistente entre as requisições.
- "Uma janela de contexto maior significa que não preciso pensar no que incluo." Uma janela maior eleva o teto, mas não garante que o modelo pondere o conteúdo distante tão fortemente quanto o conteúdo recente, e cada token incluído ainda custa dinheiro e latência.
- "Saída estruturada significa que o modelo entende JSON melhor." Significa que a API restringe ou valida a saída do modelo contra um esquema que você fornece - o modelo ainda está gerando tokens, apenas direcionado ou verificado contra uma forma.
- "Chamada de ferramenta significa que o modelo executa a função." O modelo apenas decide qual função chamar e com quais argumentos; seu código de aplicativo é o que realmente a executa e retorna um resultado.
- "Mais tokens no prompt sempre melhoram a resposta." Contexto irrelevante ou mal organizado pode diluir a atenção do modelo no que realmente importa, razão pela qual recuperação e construção cuidadosa de prompts superam simplesmente colar tudo o que está disponível.
FAQs
O que é um token e por que o modelo não conta apenas caracteres?
Um token é um pedaço de subpalavra produzido pelo tokenizador do modelo - palavras comuns são frequentemente um token, palavras mais raras são divididas em várias. Modelos são treinados e precificados em tokens porque essa é a unidade em que seu vocabulário interno opera, não caracteres brutos.
O que exatamente é a janela de contexto?
O número máximo de tokens, prompt e resposta combinados na maioria das APIs, que um modelo pode atender em uma única chamada. É um limite rígido: o conteúdo além dele é truncado ou rejeitado, não apenas mais difícil para o modelo lidar.
O modelo realmente se lembra de mensagens anteriores em uma conversa?
Não, o modelo é sem estado entre as chamadas. Uma conversa de vários turnos funciona porque seu código reenvia todo o histórico relevante como parte do prompt em cada nova chamada, razão pela qual conversas longas custam mais tokens por chamada à medida que crescem.
O que significa "o prompt é a interface" na prática?
Significa que o texto que você coloca na janela de contexto - instruções, exemplos, histórico, documentos recuperados - funciona como uma assinatura de função. É toda a superfície de entrada sobre a qual o modelo pode agir, e nada fora dela é visível para o modelo.
Por que os papéis de sistema, usuário e assistente existem como coisas separadas?
Eles dão ao modelo uma maneira consistente de distinguir instruções permanentes da tarefa real em questão, e das próprias voltas anteriores do modelo ao reproduzir uma conversa. Sem essa estrutura, instruções e conteúdo conversacional seriam mais difíceis para o modelo ponderar corretamente.
Que problema a saída estruturada realmente resolve?
LLMs produzem nativamente texto de formato livre, mas a maioria dos programas precisa de uma forma específica e analisável para agir. A saída estruturada permite que você forneça um esquema que restringe a resposta a corresponder a essa forma, em vez de analisar texto de formato livre com regexes.
Como a chamada de ferramenta/função é diferente de apenas pedir saída estruturada?
A saída estruturada molda uma resposta direta em um esquema; a chamada de ferramenta faz com que o modelo escolha entre funções descritas e produza argumentos para uma delas, mas seu próprio código é o que realmente executa essa função - o modelo nunca executa nada sozinho.
Por que não posso simplesmente colar um documento inteiro e grande no prompt?
Se os tokens do documento mais suas instruções e resposta esperada excederem a janela de contexto, ele será truncado ou rejeitado. Mesmo abaixo do limite, um documento colado muito grande custa proporcionalmente mais por chamada e pode diluir a atenção do modelo na parte que realmente importa.
O que a geração aumentada por recuperação está resolvendo, em termos deste modelo?
Resolve o problema do limite da janela de contexto para grandes bases de conhecimento. Em vez de tentar encaixar tudo em cada prompt, uma busca baseada em embedding recupera apenas os trechos relevantes para a consulta atual, de modo que apenas esses tokens sejam gastos do orçamento.
O JSON com prompt é tão confiável quanto as APIs de saída estruturada nativas?
Não. O JSON com prompt ainda pode desviar do esquema pretendido ou produzir JSON inválido, especialmente em respostas mais longas, enquanto os recursos nativos de saída estruturada restringem ou validam a resposta diretamente contra seu esquema, ao custo de exigir suporte do provedor.
Por que uma conversa mais longa fica mais lenta e custa mais, mesmo com a mesma pergunta?
Toda a conversa anterior é reenviada como tokens em cada chamada. À medida que o histórico cresce, cada chamada subsequente carrega um prompt maior, o que custa mais tokens e leva mais tempo para o modelo processar, independentemente de quão simples seja a pergunta atual.
Adicionar mais contexto sempre melhora a resposta do modelo?
Não automaticamente. Contexto irrelevante, redundante ou mal organizado pode diluir a atenção do modelo para longe da parte que realmente importa, razão pela qual a construção deliberada de prompts e a recuperação tendem a superar simplesmente incluir tudo o que está disponível.
Relacionados
- Noções Básicas de LLMs - primeiras chamadas práticas, papéis e conclusões
- Tokens, Custo e Limites de Taxa - contagem de tokens e gerenciamento de orçamento na prática
- Engenharia de Prompt - técnicas para moldar o que entra na janela
- Saída Estruturada - código de trabalho para respostas com restrição de esquema
- Embeddings e Similaridade - o mecanismo de recuperação que contorna o limite da janela de contexto
- Streaming e Chamadas Assíncronas de LLM - como as respostas são entregues após serem geradas
Versões de Stack: Esta página é conceitual e descreve o comportamento da forma da API comum em todos os SDKs de provedores de LLM atuais; ela não cita números de versão de modelo específicos, pois eles mudam mais rápido do que este modelo mental.