Modelos de IA Open Source: Llama, DeepSeek e Mistral na Prática [2026]

Rodar um modelo de IA competente no próprio hardware, sem mandar um byte para fora, deixou de ser passatempo de pesquisador. Os modelos de IA open source disponíveis em 2026 fazem, com folga, o que os modelos fechados de ponta faziam há um ano e meio, custam uma fração do preço por token quando consumidos via API de terceiros, e podem ser baixados, ajustados e embutidos dentro de um produto sem pedir permissão para ninguém. Na Marfin, nós testamos a maior parte deles em uso real: extração de dados de páginas, classificação de leads, geração de rascunho de conteúdo, transcrição enriquecida e automações internas que rodam milhares de vezes por dia.

O que mudou não foi só a qualidade. Mudou a estrutura de custo do mercado inteiro. Quando o DeepSeek publicou um modelo de raciocínio sob licença MIT com preço por token uma ordem de grandeza abaixo do que se cobrava, todo mundo teve que responder. Hoje existe uma camada inteira de provedores de inferência que servem esses pesos por centavos, e existe uma segunda camada de gente rodando os mesmos pesos dentro da própria infraestrutura por razões de compliance. As duas coisas são viáveis, e a escolha entre elas é de engenharia e de conta de padaria.

Este guia cobre o que são de fato os modelos de IA open source, onde o termo engana, as três famílias principais (Llama, DeepSeek e Mistral) com o que cada uma faz bem, quem mais entrou na disputa, como comparar com os modelos fechados que nós usamos no dia a dia, como rodar cada opção na prática, quanto custa em API e em hardware próprio, e dez recomendações para quem vai colocar isso em produção sem queimar orçamento.

Link para esta seçãoO que são modelos de IA open source (e onde o termo engana)

Um modelo de linguagem tem três partes que poderiam ser abertas: a arquitetura, os pesos treinados e os dados de treinamento. Praticamente todos os modelos de IA open source que você vê citados por aí abrem a arquitetura e os pesos, e mantêm os dados fechados. Isso significa que você pode baixar o arquivo, rodar onde quiser, ajustar, quantizar e servir, mas não pode reproduzir o treinamento do zero nem auditar exatamente o que entrou na base.

A Open Source Initiative publicou uma definição formal de IA open source que exige informação suficiente sobre os dados para permitir reprodução. Pela régua dela, quase nenhum modelo popular passa. O termo técnico mais honesto para o que existe é "pesos abertos", ou open weights. Nós usamos "open source" no sentido corrente do mercado, porque é assim que o termo circula, mas vale saber a diferença quando alguém do jurídico perguntar.

Link para esta seçãoPesos abertos, dados fechados, e o que isso significa na prática

Para quem constrói produto, a distinção que pesa é outra: o que a licença deixa você fazer. Você pode usar comercialmente? Pode oferecer o modelo como serviço para terceiros? Pode treinar outro modelo com as saídas dele? Precisa dar crédito? Existe teto de usuários? Essas respostas mudam de família para família e mudam entre versões da mesma família.

O segundo ponto prático é que peso aberto significa controle real sobre o comportamento. Você congela a versão e ela nunca muda debaixo dos seus pés. Quem já teve um prompt de produção quebrar depois de uma atualização silenciosa de modelo fechado entende o valor disso. Um pipeline que classifica 200 mil registros por mês com regras calibradas em cima de um modelo específico ganha estabilidade quando o modelo está no seu bucket e não no roadmap de outra empresa.

Link para esta seçãoAs licenças que mudam a sua vida

DeepSeek libera os pesos sob MIT, que é a licença mais permissiva do grupo: use, modifique, revenda, faça o que quiser. Qwen, do Alibaba, adotou Apache 2.0 na maior parte da linha, também bastante livre. A OpenAI publicou a linha gpt-oss sob Apache 2.0, o que foi uma virada de posicionamento e deu ao mercado dois modelos de raciocínio abertos com respaldo forte.

Llama usa a Llama Community License, que permite uso comercial mas impõe condições: acima de um patamar alto de usuários ativos mensais, você precisa negociar licença separada, e produtos derivados carregam obrigação de nome e de crédito. Para 99% das empresas brasileiras isso é irrelevante na prática, mas está escrito e alguém vai perguntar.

Mistral opera em dois regimes: os modelos menores saem em Apache 2.0, e os maiores saem sob licença de pesquisa que exige acordo comercial para uso em produção. Gemma, do Google, tem termos próprios com política de uso aceitável anexada. Antes de escolher, abra o arquivo de licença do repositório, leia os três parágrafos que importam e guarde um print. Leva dez minutos e evita uma conversa desagradável seis meses depois.

Link para esta seçãoLlama: o padrão de facto do ecossistema

A família Llama, da Meta, é a que tem o maior ecossistema em volta. Isso vale mais do que qualquer benchmark isolado. Tudo que você precisa para servir um modelo em produção nasce com suporte a Llama primeiro: bibliotecas de quantização, runtimes de inferência, ferramentas de fine-tuning, adaptadores LoRA prontos, integrações com bancos vetoriais, documentação em português espalhada por fóruns.

A geração Llama 4 trouxe arquitetura de mistura de especialistas, o que muda a economia de rodar. O Scout ativa cerca de 17 bilhões de parâmetros por token dentro de um total de mais de 100 bilhões, e o Maverick usa o mesmo número de parâmetros ativos com um total bem maior e mais especialistas. Na prática, você paga computação de modelo pequeno com comportamento de modelo grande, desde que tenha memória para carregar tudo. A janela de contexto declarada é gigantesca, e aqui vale um alerta que aprendemos apanhando: contexto declarado e contexto útil são coisas diferentes. A qualidade cai bem antes do limite anunciado em qualquer modelo, aberto ou fechado.

O Llama 3.3 de 70 bilhões de parâmetros continua sendo, para nós, o melhor cavalo de batalha da família para quem quer rodar próprio. Quantizado em 4 bits, ele cabe em torno de 40 a 48 GB de memória, o que significa uma GPU profissional única, duas placas de consumo top de linha ou um Mac com memória unificada de 64 GB. A resposta é sólida em português, o comportamento é previsível e o volume de material de ajuste fino disponível é enorme.

Onde Llama perde: em tarefas de raciocínio matemático pesado e em código de alta complexidade, os modelos chineses mais recentes passaram na frente. E o preço por token nos provedores que servem Llama costuma ficar acima do que DeepSeek e Qwen cobram pelo equivalente.

Link para esta seçãoDeepSeek: o modelo que reescreveu a tabela de preços

DeepSeek é o caso mais interessante de todos porque combinou três coisas que raramente andam juntas: qualidade de fronteira, licença MIT e preço agressivo. A linha V3 usa mistura de especialistas com centenas de bilhões de parâmetros totais e algo em torno de 37 bilhões ativos por token. A linha R1 e sucessoras trouxeram raciocínio explícito com cadeia de pensamento visível, sob a mesma licença permissiva, o que permitiu que meio mundo destilasse aquele comportamento em modelos menores.

O impacto no bolso é o argumento mais forte. Na API oficial, o custo por milhão de tokens fica em ordens de grandeza que tornam viável tarefa que antes não fechava conta: reprocessar um catálogo inteiro, classificar todo o histórico de tickets, rodar avaliação automática em cima de milhares de saídas. Nós migramos rotinas de classificação e extração em lote para lá justamente porque o custo deixou de ser fator de decisão.

Os pontos de atenção são reais e você precisa considerá-los antes de mandar dado de cliente. A API oficial roda em infraestrutura na China, o que levanta questões de residência de dados e de conformidade com a LGPD dependendo do contrato que você tem com seus clientes. Existe alinhamento embutido em temas politicamente sensíveis para o país de origem, o que pode ou não afetar seu caso de uso. E a disponibilidade da API oficial já teve períodos instáveis.

A solução prática que nós adotamos: usar os pesos do DeepSeek servidos por provedores ocidentais de inferência, ou rodar dentro da própria nuvem. A licença MIT permite exatamente isso, e é aí que a escolha de licença deixa de ser detalhe jurídico e vira decisão de arquitetura.

Link para esta seçãoMistral: a opção europeia com licença limpa nos modelos pequenos

Mistral construiu reputação com os modelos pequenos, e é ali que ela continua mais forte. Um modelo de 24 bilhões de parâmetros sob Apache 2.0 que roda bem quantizado em uma única placa de consumo resolve uma quantidade enorme de trabalho real: reescrita de texto, classificação, extração estruturada, roteamento de intenção, resumo. Para pipelines de automação com milhares de chamadas curtas, o modelo pequeno certo bate o modelo grande genérico em custo e em latência, e a diferença de qualidade some quando a tarefa é bem delimitada.

A empresa também mantém linhas especializadas: um modelo focado em código, um focado em raciocínio com cadeia de pensamento, e versões voltadas a agentes de desenvolvimento. Para times europeus e para empresas brasileiras com cláusula de residência de dados na União Europeia, Mistral é a resposta mais direta, porque a infraestrutura e o enquadramento regulatório já vêm resolvidos.

Onde Mistral fica atrás: os modelos maiores dela vivem sob licença de pesquisa, então o uso comercial passa por acordo. E em benchmarks de fronteira, ela raramente aparece no topo. A jogada dela é outra: entregar o melhor resultado por watt e por euro na faixa média, com licença que o jurídico aprova sem discussão.

Link para esta seçãoQuem mais entrou na disputa: Qwen, Gemma, gpt-oss e os modelos MoE gigantes

Qwen, do Alibaba, virou a escolha padrão de muita gente pelo desempenho multilíngue e pela amplitude da linha, que vai de modelos minúsculos de menos de um bilhão de parâmetros até uma mistura de especialistas de centenas de bilhões, quase toda sob Apache 2.0. Em português, ele se comporta bem, e a família tem variantes para visão e para código.

Gemma, do Google, cobre a faixa de 1 a 27 bilhões de parâmetros com suporte multimodal e foco explícito em rodar em uma única GPU. É a opção mais confortável para quem já vive no ecossistema Google Cloud. A linha gpt-oss da OpenAI, publicada sob Apache 2.0, colocou dois modelos de raciocínio no mercado aberto, sendo que o menor cabe em hardware de consumo e o maior roda em uma placa de datacenter única.

Na ponta de cima apareceram modelos de mistura de especialistas com trilhão de parâmetros totais e algumas dezenas de bilhões ativos, vindos de laboratórios como Moonshot e Zhipu, com foco declarado em uso agêntico e em chamadas de ferramenta. Eles são absurdamente capazes e absurdamente pesados: rodar próprio exige cluster, então na prática você os consome via provedor. Se o seu caso é construir agentes de programação, vale acompanhar essa faixa de perto, porque é onde a diferença para os modelos fechados mais diminuiu.

Link para esta seçãoModelos de IA open source vs modelos fechados: onde cada um ganha

Nós somos práticos sobre isso. A ferramenta de programação com IA que mais usamos na Marfin continua sendo o Claude Code, rodando Opus, e para building no dia a dia usamos o Cursor AI. Para trabalho de engenharia complexo, com muitos arquivos, refatoração longa e uso intenso de ferramentas, os modelos fechados de fronteira ainda entregam uma taxa de acerto que compensa o preço. Um agente que resolve a tarefa de primeira custa menos que três tentativas baratas mais o seu tempo revisando.

Os modelos de IA open source ganham em quatro situações bem definidas. Primeira: volume alto de tarefas repetitivas e delimitadas, onde a diferença de qualidade some e a diferença de preço multiplica. Segunda: dado que não pode sair do perímetro, seja por contrato, por LGPD ou por política interna. Terceira: necessidade de comportamento congelado, sem atualização silenciosa. Quarta: casos onde você precisa de fine-tuning de verdade, com pesos ajustados ao seu domínio, e não só de um prompt bem escrito.

O arranjo que funciona melhor na prática é híbrido, e é o que nós rodamos. Modelo fechado de ponta na camada que exige raciocínio pesado e uso de ferramentas. Modelo aberto pequeno ou médio na camada de volume: classificação, extração, roteamento, primeira triagem, geração de variações. Um roteador simples na frente decide para onde cada requisição vai. Isso derruba custo total sem derrubar qualidade percebida, e é uma peça que faz sentido no tech stack de qualquer startup brasileira.

Link para esta seçãoComo rodar modelos de IA open source na prática

Existem três caminhos, e a escolha entre eles depende de volume, de sensibilidade do dado e de quanto tempo de engenharia você tem para gastar.

Link para esta seçãoNo seu computador

Ollama é o caminho mais rápido para começar. Você instala, roda um comando com o nome do modelo, e em minutos tem um endpoint local compatível com o formato de API que a maioria das bibliotecas já entende. LM Studio faz o mesmo com interface gráfica, o que ajuda quem prefere clicar. Por baixo dos dois está o llama.cpp, que popularizou o formato GGUF e as quantizações.

Quantização é o conceito que você precisa entender antes de baixar qualquer coisa. Um modelo em precisão original ocupa cerca de 2 GB por bilhão de parâmetros. Quantizado em 4 bits, cai para algo em torno de 0,6 GB por bilhão, com perda de qualidade que vai de imperceptível a moderada dependendo do método e do tamanho do modelo. Regra prática que nós usamos: em modelos de 7 a 30 bilhões, a quantização de 4 bits de boa qualidade é o ponto de equilíbrio. Em modelos abaixo de 4 bilhões, a perda começa a doer.

O que cabe onde: um notebook com 16 GB de RAM roda modelos de 7 a 8 bilhões com folga. Com 32 GB, você chega confortavelmente em 14 bilhões e arranha 24. Um Mac com 64 GB de memória unificada roda um 70 bilhões quantizado com velocidade utilizável para trabalho interativo. Acima disso, você entra em território de GPU dedicada.

Link para esta seçãoEm API de terceiros

Para a maioria dos casos, esta é a resposta certa e nós dizemos isso sem meias palavras. Provedores como Together, Fireworks, Groq, DeepInfra e agregadores tipo OpenRouter servem os mesmos pesos abertos com endpoint compatível, faturamento por token, escala elástica e nenhuma GPU para você administrar. O custo por token é baixo o suficiente para que comprar hardware só faça sentido em volumes bem altos.

A vantagem escondida aqui é a troca de modelo sem trocar código. Como todos expõem o mesmo formato de API, você aponta uma variável de ambiente para outro modelo e mede a diferença em produção. Nós fazemos isso rotineiramente: mesma tarefa, cinco modelos, comparação de custo, latência e taxa de acerto num conjunto de casos de teste que a gente mantém versionado.

Link para esta seçãoNo seu próprio servidor

Quando o volume justifica ou o dado exige, o caminho é vLLM ou SGLang em cima de GPUs suas ou alugadas. Esses runtimes fazem processamento em lote contínuo e gerenciamento inteligente de memória de atenção, o que multiplica a taxa de transferência em relação a rodar ingenuamente. A conta que fecha a decisão é simples: pegue o custo mensal da instância com GPU, divida pelo número de tokens que você processa por mês e compare com o preço por token do provedor. Abaixo de um certo volume, o provedor sempre ganha, porque ele amortiza a placa entre muitos clientes e você não.

Link para esta seçãoFine-tuning, RAG e quando cada um resolve

A confusão mais cara que nós vemos é gente pagando fine-tuning para resolver problema de contexto. As duas técnicas resolvem coisas diferentes e a ordem de tentativa deveria ser sempre a mesma.

Primeiro, prompt melhor. Boa parte do que parece limitação do modelo se resolve com instrução mais específica, exemplos no prompt e formato de saída definido. O guia de prompt engineering cobre as técnicas que mais rendem. Segundo, contexto recuperado: se o modelo precisa saber fatos que ele não tem, você busca esses fatos e coloca no prompt. Terceiro, e só então, fine-tuning: quando o que você precisa mudar é o comportamento, o formato, o tom ou o vocabulário de domínio, e nenhuma instrução consegue fixar isso de forma confiável.

Aqui os modelos de IA open source têm vantagem estrutural clara. Ajustar pesos com LoRA em um modelo de 7 a 14 bilhões custa dezenas de dólares em GPU alugada e algumas horas, e o adaptador resultante é seu, versionável, portátil entre provedores. Você monta o conjunto de treino com algumas centenas a alguns milhares de exemplos bem curados, treina, avalia contra um conjunto separado e compara com o baseline. Sem avaliação medida, fine-tuning vira fé.

Link para esta seçãoPreços e planos

Os valores abaixo são aproximados, em dólares por milhão de tokens, e servem para ordem de grandeza. Preços de inferência mudam com frequência e variam por provedor, por quantização e por região, então confirme na origem antes de fechar orçamento.

Rodar próprio muda a estrutura do gasto. Uma instância de nuvem com uma GPU de 80 GB fica na faixa de US$ 2 a 4 por hora sob demanda, o que dá algo entre US$ 1.500 e 3.000 por mês se ficar ligada o tempo todo. Isso só ganha do provedor quando você mantém a placa ocupada de verdade. Se a sua carga é irregular, com picos e vales, o custo por token real dispara porque você paga a GPU parada. Hardware local para desenvolvimento é outra conversa: um Mac com 64 GB ou uma placa de consumo de 24 GB pagam-se rápido só em experimentação, sem contar token nenhum.

Link para esta seção10 dicas para usar modelos de IA open source sem se enrolar

1. Comece pelo provedor, não pela GPU. Suba a tarefa em API de terceiro, meça custo real por mês e só depois avalie hardware próprio. A maioria dos projetos descobre que a conta do provedor é menor que a da placa ociosa.

2. Monte um conjunto de avaliação antes de escolher o modelo. Trinta a cinquenta casos reais do seu domínio, com saída esperada anotada. Sem isso, você está trocando de modelo por impressão, e impressão erra.

3. Use modelo pequeno para tarefa delimitada. Classificar, extrair campo, rotear intenção e reescrever trecho curto não exigem modelo de fronteira. Um modelo de 7 a 24 bilhões bem instruído resolve, e a diferença de custo é de uma a duas ordens de grandeza.

4. Leia a licença antes de construir em cima. MIT e Apache 2.0 liberam praticamente tudo. Licenças comunitárias e de pesquisa trazem condições que podem inviabilizar o seu modelo de negócio, e descobrir isso depois do produto pronto é caro.

5. Fixe a versão do modelo em produção. Aponte para uma revisão específica dos pesos, guarde o hash e documente. A liberdade de congelar o comportamento é uma das maiores vantagens dos pesos abertos, e ela se perde se você usa uma tag que se move.

6. Trate quantização como decisão de qualidade, não só de memória. Rode o seu conjunto de avaliação em duas quantizações diferentes antes de decidir. Em algumas tarefas a queda é invisível, em outras, especialmente as que exigem precisão numérica, ela aparece na hora.

7. Não mande dado sensível para API oficial sem checar residência. Se o dado é de cliente, verifique onde ele é processado e o que o contrato do provedor diz sobre retenção. Rodar os mesmos pesos em provedor ocidental ou na sua nuvem resolve o problema sem trocar de modelo.

8. Combine aberto e fechado com um roteador simples. Uma regra de duas linhas que manda tarefa curta para o modelo barato e tarefa complexa para o modelo de fronteira derruba a fatura sem derrubar resultado. Vale para pipelines de conteúdo e para automação de marketing com IA.

9. Prefira ajustar prompt e contexto antes de treinar pesos. Fine-tuning resolve comportamento e formato, e é a última parada, não a primeira. Quem começa por ele quase sempre está gastando GPU para consertar um prompt preguiçoso.

10. Instrumente custo por tarefa, não por mês. Registre tokens de entrada e saída por chamada e agregue por tipo de tarefa. É a única forma de descobrir que aquele único endpoint esquecido está consumindo metade do orçamento de IA da empresa.

A conclusão prática que nós tiramos depois de rodar isso em produção por um bom tempo é que a pergunta certa deixou de ser aberto ou fechado. A pergunta é qual camada do seu produto tolera qual nível de qualidade e qual nível de custo. Trabalho de engenharia difícil, agente que precisa navegar um repositório inteiro e tarefa onde o erro sai caro continuam merecendo o melhor modelo fechado disponível. Tudo que é volume, repetição, triagem e primeira versão pertence aos modelos de IA open source, e o dinheiro que sobra dessa troca costuma financiar o resto da operação.

Para quem está montando esse arranjo agora, o passo inicial é modesto e rende: escolha uma tarefa repetitiva do seu pipeline, meça quanto ela custa hoje, rode a mesma tarefa em dois modelos abertos via provedor e compare acerto, latência e preço em cima de casos reais. Em uma tarde você tem número em vez de opinião, e número é o que sustenta a decisão na próxima reunião de custo. Se o seu time ainda está construindo produto com ferramentas de IA e quer entender o terreno todo, vale conhecer também o que é vibe coding e como a IA generativa se encaixa no negócio antes de escolher onde cada modelo entra.

Leia também:

• IA generativa: o que é, como funciona e como usar na prática
• Agentes de IA para programação: como funcionam e quais usar
• Claude Code: tutorial completo em português
• Prompt engineering: guia completo com técnicas para 2026
• Tech stack 2026: as ferramentas que toda startup brasileira precisa
• Cursor AI: tutorial de como criar um app do zero
• O que é vibe coding e como começar
• IA generativa para negócios: aplicações reais
• Como usar o Claude no dia a dia
• Supabase: tutorial completo para backend de projetos com IA