Use o GPT‑OSS no TRAE: Desbloqueando o Formato Harmony para Codificação com IA

O desenvolvimento de software com IA está evoluindo rapidamente, impulsionado por duas grandes tendências: modelos de código aberto poderosos e ambientes de desenvolvimento com IA totalmente integrados. O GPT‑OSS é a série de modelos de peso aberto da OpenAI, conhecida por seu raciocínio forte, habilidades semelhantes a agentes e alta personalização. O TRAE, da ByteDance, é uma IDE de IA projetada para funcionar como um “Engenheiro de IA” completo, capaz de construir software de forma autônoma.

A pergunta é: o que acontece quando você combina o poder de raciocínio controlável do GPT‑OSS com o framework de desenvolvimento automatizado e rico em ferramentas do TRAE? Juntos, eles criam um fluxo de trabalho que é tanto automatizado quanto adaptado às suas necessidades exatas. Este guia explica como conectá-los e desbloquear todo o seu potencial.

O que é o Trae?

O TRAE também é o nome de um ambiente de desenvolvimento integrado (IDE) com tecnologia de IA criado pela ByteDance. Ele é projetado para funcionar como um “Engenheiro de IA” que pode construir soluções de software de forma independente, entendendo tarefas complexas e as executando. O TRAE tem como objetivo simplificar o fluxo de trabalho de desenvolvimento, permitindo que os usuários deleguem tarefas à IA.

Principais Funções do Trae

Integração e Capacidades Aprimoradas de Ferramentas (Protocolo de Contexto de Modelo - MCP)

• Integração de Ferramentas Externas: O TRAE se integra a várias ferramentas externas, permitindo que agentes de IA as utilizem para uma execução de tarefas mais eficaz.
• Suporte a MCP: Ele suporta o Protocolo de Contexto de Modelo (MCP), um padrão aberto para conectar aplicações de IA a fontes de dados e ferramentas externas. Isso funciona como uma porta “USB-C” universal para IA, resolvendo o desafio de conectar modelos de IA a dados isolados.
• Capacidades de IA Expandidas: Por meio do MCP, os agentes podem acessar recursos externos como Google Drive, Slack, GitHub e bancos de dados para entender e concluir tarefas complexas de forma mais eficaz.

Compreensão Contextual Aprofundada e Controle Preciso

• Compreensão Profunda do Contexto de Desenvolvimento: O TRAE entende profundamente o seu contexto de desenvolvimento, incluindo repositórios de código, resultados de pesquisas online e documentos compartilhados.
• Personalização Precisa de Comportamento: Você pode personalizar regras para adaptar o comportamento da IA ao seu fluxo de trabalho, garantindo que ela execute as tarefas exatamente como você pretende.
• Interação Multimodal: Suporta o envio de imagens (ex: mockups de design, capturas de tela de erros) para ajudar a descrever requisitos, permitindo que a IA gere código mais preciso.

CUE: Previsão Inteligente e Edição com Uma Tecla

• Prevê Sua Próxima Edição: O recurso CUE (Motor de Compreensão de Contexto) entende a sua intenção e prevê o seu próximo movimento analisando o seu comportamento de edição.
• Navegação e Aplicação com Uma Tecla: Basta pressionar a tecla Tab para pular para a próxima alteração sugerida ou aplicar sugestões inteligentes em várias linhas de uma vez.
• Otimização Contínua: O recurso é constantemente otimizado para melhor desempenho e responsividade, proporcionando uma experiência mais fluida para modificação, geração e correção de código.

Recursos Abrangentes de IDE e Assistência de IA

• Modos de Desenvolvimento Duplos: Oferece o Modo IDE para um fluxo de trabalho tradicional controlado pelo usuário, e o Modo SOLO, onde a IA lidera o desenvolvimento, desde os requisitos até a entrega, para total automação.
• IDE Completo: Fornece recursos padrão de IDE, como edição de código, gerenciamento de projetos e controle de versão.
• Assistência de Programação com IA: Apresenta vários assistentes com tecnologia de IA, incluindo conclusão inteligente de código, refatoração, perguntas e respostas via chat e geração de projetos a partir de linguagem natural.
• Pré-visualização da Web Integrada: Suporta a pré-visualização direta de páginas da web dentro da IDE para facilitar o desenvolvimento e a depuração de front-end.

O que é o Trae Solo?

• Espaço de Trabalho Unificado e Hub de Ferramentas de IA:
  O modo SOLO integra todas as ferramentas de desenvolvimento necessárias — a IDE, o navegador, o terminal e os documentos — diretamente na IA. Isso permite que a IA raciocine e aja com precisão com base nas necessidades específicas de cada tarefa, eliminando a lacuna entre a ideia e a execução de forma contínua.
• Desenvolvimento Liderado pela IA, de Ponta a Ponta:
  Você só precisa fornecer os requisitos, e o SOLO gerencia autonomamente todo o ciclo de vida de desenvolvimento, incluindo:
  • Análise de Requisitos
  • Prototipagem
  • Desenvolvimento de Front-end
  • Desenvolvimento de Back-end
  • Depuração e Otimização
  • Compilação e Implantação
• Visualização de Monitoramento Unificada:
  Os usuários podem conversar com a IA e monitorar todas as atividades de desenvolvimento a partir de uma única visualização unificada. A “Visualização Estendida” fornece um detalhamento de todos os detalhes de execução em tempo real.
• Interação Multimodal: “Fale” Seus Requisitos:
  O modo SOLO suporta entrada por voz, permitindo que você interaja com o TRAE de forma tão natural quanto interagiria com um colega de equipe humano. A saída da IA não se limita a código; uma visualização dinâmica expansível à direita fornece feedback visual e intuitivo.
• O Engenheiro de Contexto:
  O modo SOLO é projetado para ser o “Engenheiro de Contexto” definitivo, capaz de entender o escopo completo do seu trabalho para garantir que suas ações e saídas sejam baseadas nas informações mais abrangentes e precisas disponíveis.

Em resumo, o objetivo do modo SOLO do TRAE é permitir uma “IA que entrega software completo”. Ele capacita os desenvolvedores a construir e lançar software real mais rapidamente por meio de um processo simples de “Fale. Pense. Entregue.”

O que é o GPT OSS?

O GPT-OSS (Série de Código Aberto) é uma família de modelos de linguagem poderosos, de peso aberto, lançada pela OpenAI, projetada para estar disponível gratuitamente para uso comercial e pode ser executada localmente em hardware de consumo. A série inclui dois modelos principais, uma versão de 20 bilhões e outra de 120 bilhões de parâmetros, otimizados para raciocínio forte, uso de ferramentas e eficiência, marcando uma mudança significativa da OpenAI em direção a maior transparência na comunidade de IA. Esses modelos permitem que desenvolvedores e pesquisadores os ajustem para fins personalizados, com controle total sobre seus dados e infraestrutura, reduzindo a lacuna entre sistemas proprietários fechados e a IA de código aberto.

Modelo	Camadas	Total de Parâmetros	Parâmetros Ativos Por Token	Total de Especialistas	Especialistas Ativos Por Token	Comprimento do Contexto	Requisito de VRAM por GPU Única
gpt-oss-120b	36	117B	5.1B	128	4	128k	80GB
gpt-oss-20b	24	21B	3.6B	32	4	128k	16GB

Por que escolher o GPT OSS para Codificação com IA?

Personalize o Formato: Harmony

Os modelos GPT‑OSS usam um formato de conversa especial chamado Harmony. Esse formato organiza as mensagens em funções claras — system, user e assistant — e permite que você controle como o modelo pensa e responde. Com o Harmony, você pode ajustar a profundidade de raciocínio (baixa, média, alta), decidir se mostra ou oculta o processo de pensamento e fazer com que o modelo chame funções de forma estável e estruturada. Muitos outros modelos de código aberto não têm esses controles integrados, mas o GPT‑OSS os entende nativamente porque foi treinado para seguir as instruções do Harmony. Isso facilita a obtenção de saídas consistentes, confiáveis e amigáveis para ferramentas.

O que o Harmony pode controlar

O formato Harmony permite que você ajuste vários parâmetros de comportamento principais para os modelos GPT‑OSS:

Parâmetro	Descrição	Exemplo
Profundidade de Raciocínio	Controla quanto pensamento passo a passo o modelo realiza.	"Reasoning: low", "Reasoning: medium", "Reasoning: high"
Chamada de Funções	Suporte nativo a saída JSON no estilo OpenAI function_call / tool_calls.	"Always call function weather_api when asked about weather"
Visibilidade do Raciocínio	Mostra ou oculta a cadeia de pensamento completa nas tags <think>.	"Show reasoning" / "Hide reasoning"
Regras de Formato de Saída	Força saída estruturada como JSON, Markdown, etc.	"Output in JSON format"

Um Exemplo de Solicitação Harmony

{
  "messages": [
    {
      "role": "system",
      "content": "Reasoning: medium; Hide reasoning; Output in JSON format"
    },
    {
      "role": "user",
      "content": "Explain how quicksort works."
    }
  ]
}

Benefícios ao Usar o Harmony com Ferramentas como o Trae

Quando integrado a plataformas de geração de código, depuração e execução, como o Trae, o formato Harmony oferece várias vantagens práticas:

1. Saída Estruturada Estável
   • O Harmony garante que a saída do modelo siga um formato JSON ou bloco de código previsível.
   • O Trae pode analisar isso diretamente, sem regex frágeis ou pós-processamento.
2. Controle de Profundidade de Raciocínio
   • Use o raciocínio baixo para prototipagem rápida ou código simples.
   • Use o raciocínio alto para algoritmos complexos onde a correção é mais importante.
   • Economiza recursos de GPU/CPU, correspondendo o custo de raciocínio à complexidade da tarefa.
3. Alternar Visibilidade do Raciocínio
   • Mostre o raciocínio <think> para depuração e aprendizado.
   • Oculte o raciocínio em produção para reduzir tokens e evitar vazamento de lógica interna.
4. Gerenciamento de Contexto Multiturno Claro
   • As regras system persistem entre as turnos, garantindo estilo de código e regras de execução consistentes.
   • Fácil de iterar: modifique as instruções do usuário sem perder as configurações globais.
5. Integração de API Sem Interrupções
   • O Harmony imita a API de Respostas da OpenAI, então qualquer cadeia de ferramentas ou plugin de IDE compatível com a OpenAI pode funcionar com o GPT‑OSS com alterações mínimas.

Uso de Ferramentas do GPT OSS

Os modelos GPT‑OSS são treinados para usar ferramentas externas de forma nativa como parte do seu processo de raciocínio, com suporte integrado para navegação, execução de Python e aplicação de patches em arquivos. Essas ferramentas são ativadas definindo-as na mensagem system de um prompt no formato Harmony.

1. Ferramenta de Navegação

• Finalidade: Pesquisar na web, abrir páginas e encontrar texto nelas.
• Métodos:
  • search — pesquisar por frases-chave.
  • open — abrir uma página específica.
  • find — localizar conteúdo em uma página.
• Recursos:
  • Janela de texto rolável para gerenciar o tamanho do contexto.
  • Cache para revisitas mais rápidas à mesma página.
  • Treinado para citar fontes nas respostas.
• Uso: Adicione a definição da ferramenta de navegação por meio de .with_browser() ou .with_tools() no prompt system.
• Observação: A implementação de referência é apenas para fins educacionais — use seu próprio backend em produção.

2. Ferramenta de Python

• Finalidade: Realizar cálculos ou executar pequenos programas como parte da cadeia de pensamento.
• Recursos:
  • Treinado com uma ferramenta Python com estado para raciocínio de múltiplos passos.
  • A implementação de referência usa um modo sem estado.
  • Pode substituir as descrições padrão de ferramentas no openai‑harmony.
• Uso: Adicione por meio de .with_python() ou .with_tools() no prompt system.
• Aviso de Segurança: O código de referência é executado em um contêiner Docker permissivo — adicione suas próprias restrições em produção.

3. Ferramenta de Aplicação de Patch

• Finalidade: Criar, atualizar ou excluir arquivos locais.
• Caso de Uso: Modificar código ou arquivos de projeto como parte de um loop de desenvolvimento automatizado.

Como usar o GPT OSS no Trae?

Pré-requisitos: Obtenha a Chave de API

A Novita AI fornece APIs do GPT-OSS 120B com contexto de 131K e custos de $0,1/entrada e $0,5/saída. A Novita AI também fornece o GPT-OSS 20B com contexto de 131 e custos de $0,05/entrada e $0,2/saída, oferecendo suporte forte para maximizar o potencial do agente de código do GPT OSS.

Novita AI

Passo 1: Faça login e acesse a Biblioteca de Modelos

Faça login na sua conta e clique no botão Biblioteca de Modelos.

Experimente o GPT OSS Agora!

Passo 2: Escolha o Seu Modelo

Navegue pelas opções disponíveis e selecione o modelo que atende às suas necessidades.

Passo 3: Inicie Seu Teste Gratuito

Inicie o seu teste gratuito para explorar as capacidades do modelo selecionado.

Passo 4: Obtenha Sua Chave de API

Para autenticar com a API, forneceremos uma nova chave de API para você. Acessando a página de “Configurações”, você pode copiar a chave de API conforme indicado na imagem.

Passo 5: Instale a API

Instale a API usando o gerenciador de pacotes específico da sua linguagem de programação.

Após a instalação, importe as bibliotecas necessárias para o seu ambiente de desenvolvimento. Inicialize a API com a sua chave de API para começar a interagir com o LLM da Novita AI. Este é um exemplo de uso da API de conclusões de chat para usuários de Python.

from openai import OpenAI
  
client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    api_key="",
)

model = "openai/gpt-oss-120b"
stream = True # or False
max_tokens = 65536
system_content = ""Be a helpful assistant""
temperature = 1
top_p = 1
min_p = 0
top_k = 50
presence_penalty = 0
frequency_penalty = 0
repetition_penalty = 1
response_format = { "type": "text" }

chat_completion_res = client.chat.completions.create(
    model=model,
    messages=[
        {
            "role": "system",
            "content": system_content,
        },
        {
            "role": "user",
            "content": "Hi there!",
        }
    ],
    stream=stream,
    max_tokens=max_tokens,
    temperature=temperature,
    top_p=top_p,
    presence_penalty=presence_penalty,
    frequency_penalty=frequency_penalty,
    response_format=response_format,
    extra_body={
      "top_k": top_k,
      "repetition_penalty": repetition_penalty,
      "min_p": min_p
    }
  )

if stream:
    for chunk in chat_completion_res:
        print(chunk.choices[0].delta.content or "", end="")
else:
    print(chat_completion_res.choices[0].message.content)
  
  

Use o GPT‑OSS no TRAE

Passo 1: Abra o Trae e Acesse os Modelos

Inicie o aplicativo Trae. Clique na Barra Lateral de IA no canto superior direito para abrir a Barra Lateral de IA. Em seguida, vá para Gerenciamento de IA e selecione Modelos.

Passo 2: Adicione um Modelo Personalizado, Escolha a Novita como Provedor e Selecione os Modelos

Clique no botão Adicionar Modelo para criar uma entrada de modelo personalizada. Na caixa de diálogo de adição de modelo, selecione Provedor = Novita no menu suspenso.

No menu suspenso de Modelo, escolha o modelo desejado (DeepSeek-R1-0528, Kimi K2, GLM 4.5, DeepSeek-V3-0324 ou MiniMax-M1-80k). Se o modelo exato não estiver listado, basta digitar o ID do modelo que você anotou na biblioteca da Novita. Certifique-se de escolher a variante correta do modelo que deseja usar.

Passo 3: Insira Sua Chave de API

Copie a chave de API da Novita AI do seu console da Novita e cole-a no campo Chave de API no Trae.

Obtenha a Chave de API da Novita AI!

Limitações do GPT OSS

Recurso	GPT-OSS (Modelo Auto-hospedado)	API do GPT-5 (Plataforma Gerenciada)
Oferta Principal	Um modelo bruto (o “motor”)	Uma plataforma completa e integrada (o “carro”)
Capacidade do Modelo	Forte, mas uma geração atrasada	De última geração, raciocínio principal
Ferramentas Integradas	Nenhuma. Requer esforço massivo de faça-você-mesmo.	Totalmente Gerenciada: Pesquisa na Web, Pesquisa de Arquivos, Interpretador de Código.
Janela de Contexto	Praticamente limitada pelo seu hardware (ex: 8k-32k)	Massa (400k), totalmente gerenciada.
Framework de Agentes	Faça-você-mesmo com bibliotecas de código aberto. Sem observabilidade.	SDK integrado com observabilidade embutida.
Recursos Empresariais	Nenhum. Sem conformidade, SSO ou controles administrativos.	Conjunto Completo: SOC 2, HIPAA, RBAC, SSO, etc.
Suporte	Baseado na comunidade e autoatendimento.	Equipe de conta dedicada e suporte prioritário.
Manutenção	Sua total responsabilidade. Configuração, escalonamento, tempo de atividade.	Zero. Tratada inteiramente pela OpenAI.

Integrar o GPT‑OSS com o TRAE traz o melhor dos dois mundos:

• O GPT‑OSS é o “cérebro”, controlado por meio do formato Harmony para ajustar a profundidade de raciocínio, estruturar saídas e ocultar ou mostrar processos de pensamento.
• O TRAE é o “corpo”, oferecendo um espaço de trabalho integrado, conexões de ferramentas e gerenciamento autônomo do ciclo de vida de software — especialmente no Modo SOLO.
• A Novita AI preenche a lacuna, hospedando o GPT‑OSS para você, para que você possa usá-lo via API sem hardware caro.

Essa combinação permite que os desenvolvedores construam um “Engenheiro de IA” personalizado que entende seus requisitos e os executa exatamente como pretendido, tornando a entrega de software verdadeiramente autônoma possível.

Perguntas Frequentes

Por que usar o GPT‑OSS com o TRAE em vez de um modelo de API de código fechado?

Você tem controle total. O formato Harmony permite que o TRAE controle a profundidade de raciocínio, o formato de saída e se o processo de pensamento é mostrado. Você também pode ajustar o GPT‑OSS no seu próprio código para um ajuste perfeito.

Preciso hospedar o GPT‑OSS eu mesmo?

Não. Serviços como a Novita AI o hospedam para você e fornecem uma chave de API, para que você não precise de GPUs caros ou configuração complexa.

O que é o formato Harmony e por que ele é importante?

É um formato de mensagem especial que o GPT‑OSS entende. Ele torna as saídas estáveis, estruturadas e fáceis de processar pelo TRAE — sem necessidade de análise frágil.

A Novita AI é a plataforma de nuvem tudo-em-um que capacita suas ambições de IA. APIs integradas, sem servidor, Instância de GPU — as ferramentas econômicas que você precisa. Elimine a infraestrutura, comece gratuitamente e torne sua visão de IA uma realidade.

Leituras Recomendadas

Qwen 3 em Pipelines de RAG: Modelos Tudo-em-um de LLM, Embedding e Reranking

Trae ou Claude Code: Qual é Mais Adequado para Usar com o Kimi K2?

Custo do DeepSeek R1 0528: Comparação de API, GPU e On-Prem