Carreira em IA e Machine Learning com Rust

Introdução

Inteligência Artificial e Machine Learning foram, por muito tempo, território quase exclusivo do Python. Isso ainda é verdade para pesquisa e treinamento de modelos, mas a partir de 2023 o ecossistema de IA em Rust amadureceu de forma acelerada — e hoje a linguagem é uma das peças mais importantes da pilha de IA em produção.

O motivo é estrutural. Modelos de linguagem e sistemas de recomendação movem quantidades enormes de tensores, precisam de latência previsível e rodam em ambientes onde cada megabyte de memória conta: servidores de inferência, edge devices, navegadores via WebAssembly e funções serverless. Python brilha na flexibilidade, mas seu custo de runtime e de memória se torna um gargalo justamente nessas cargas. Rust oferece a performance do C++ com segurança de memória garantida em compilação, o que a tornou a escolha padrão para a camada de alta performance de muita infraestrutura de IA.

Projetos como candle (da Hugging Face), mistral.rs, Qdrant e Polars provam o ponto: alguns dos motores mais rápidos de inferência de LLM, busca vetorial e processamento de dados do mercado são escritos em Rust. Para desenvolvedores brasileiros, isso abre uma janela de carreira específica — e relativamente pouco disputada — no cruzamento entre sistemas e IA.

Neste guia você encontra os principais crates, áreas de atuação, empresas que contratam, faixas salariais, um roadmap por nível e projetos práticos para começar a construir portfólio agora. Se você está em transição de carreira, o cruzamento de IA e Rust é um dos caminhos mais quentes do momento.

Por Que Rust Para IA e Machine Learning?

Performance e Latência Previsível

Inferência de modelos é, no fundo, muita multiplicação de matrizes. Sem garbage collector e com compilação ahead-of-time via LLVM, Rust entrega latência estável — fundamental em APIs de inferência onde um pico de latência quebra a experiência do usuário. Em cargas de CPU-bound, motores em Rust como mistral.rs e candle costumam competir diretamente com implementações em C++.

Consumo de Memória

Modelos de linguagem são grandes. Um LLM de 7 bilhões de parâmetros consome dezenas de gigabytes só de pesos. Cada megabyte economizado no runtime vira capacidade de atender mais usuários com o mesmo hardware. O controle fino de memória do Rust — sem runtime pesado, sem alocações implícitas — é exatamente o que plataformas de serving precisam.

Segurança de Memória em Sistemas Críticos

Grande parte da infraestrutura de IA em produção roda em serviços de longa duração. Bugs de uso após liberação (use-after-free) e acessos fora dos limites de buffers, comuns em C/C++, causam vazamentos de memória e travamentos silenciosos. Rust elimina essas classes inteiras de defeitos em tempo de compilação, reduzindo incidentes.

Distribuição Simplificada

Um binário Rust é um arquivo único, sem dependências de runtime. Isso facilita empacotar motores de inferência em containers enxutos, em funções serverless com cold start baixo e em dispositivos embarcados. Para embedder de busca semântica que roda no navegador via WebAssembly, essa propriedade é decisiva.

Ecossistema Nativo Para Dados

Apache Arrow, DataFusion e Polars formam uma pilha de processamento de dados de altíssima performance escrita (em grande parte) em Rust. Pipelines de feature engineering, pré-processamento e ETL que alimentam sistemas de ML ganham ordens de grandeza de velocidade em relação a soluções tradicionais.

Onde Rust Se Encaixa na Pilha de IA

É importante entender a divisão de trabalho, para não prometer o que a linguagem não entrega:

Em resumo: o pesquisador treina em Python, o engenheiro de plataforma faz esse modelo rodar rápido, barato e confiável em produção — e é aí que o Rust entra.

Exemplo: Inferência de Embeddings Para Busca Semântica

Um caso de uso clássico é gerar embeddings de texto para alimentar uma busca semântica. Este exemplo usa o crate ort para rodar um modelo ONNX:

use ort::{Environment, Session, SessionBuilder, Value};
use ndarray::Array2;
use tokenizers::Tokenizer;

/// Gera embeddings de texto usando um modelo exportado como ONNX.
pub struct Embedder {
    session: Session,
    tokenizer: Tokenizer,
}

impl Embedder {
    /// Carrega modelo e tokenizer dos caminhos informados.
    pub fn carregar(
        caminho_modelo: &str,
        caminho_tokenizer: &str,
    ) -> Result<Self, Box<dyn std::error::Error>> {
        let env = Environment::default().into_arc();
        let session = SessionBuilder::new(&env)?
            .with_optimization_level(ort::GraphOptimizationLevel::Level3)?
            .with_intra_threads(4)?
            .with_model_from_file(caminho_modelo)?;

        let tokenizer = Tokenizer::from_file(caminho_tokenizer)
            .map_err(|e| format!("erro ao carregar tokenizer: {e}"))?;

        Ok(Embedder { session, tokenizer })
    }

    /// Codifica um texto em um vetor denso (embedding).
    pub fn embed(&self, texto: &str) -> Result<Vec<f32>, Box<dyn std::error::Error>> {
        // 1. Tokeniza o texto -> input_ids
        let encoding = self
            .tokenizer
            .encode(texto, true)
            .map_err(|e| format!("erro de tokenização: {e}"))?;

        let ids = encoding.get_ids();
        let attention = encoding.get_attention_mask();

        // 2. Monta tensores de entrada no formato esperado pelo modelo
        let shape = (1, ids.len());
        let input_ids: Array2<i64> =
            Array2::from_shape_vec(shape, ids.iter().map(|&v| v as i64).collect())?;
        let attention_mask: Array2<i64> =
            Array2::from_shape_vec(shape, attention.iter().map(|&v| v as i64).collect())?;

        // 3. Roda a inferência
        let outputs = self.session.run(vec![
            Value::from_array(input_ids.into_dyn())?,
            Value::from_array(attention_mask.into_dyn())?,
        ])?;

        // 4. Mean-pooling sobre a sequência (passo comum em modelos tipo BERT)
        let embedding = outputs[0].try_extract_tensor::<f32>()?;
        let view = embedding.view();
        let seq_len = view.shape()[1];
        let dim = view.shape()[2];

        let mut pooled = vec![0.0f32; dim];
        for t in 0..seq_len {
            for d in 0..dim {
                pooled[d] += view[[0, t, d]];
            }
        }
        for v in pooled.iter_mut() {
            *v /= seq_len as f32;
        }

        // 5. Normalização L2 (padrão para similaridade por cosseno)
        let norma = pooled.iter().map(|v| v * v).sum::<f32>().sqrt();
        if norma > 0.0 {
            for v in pooled.iter_mut() {
                *v /= norma;
            }
        }

        Ok(pooled)
    }
}

fn main() {
    let embedder = Embedder::carregar(
        "modelos/all-MiniLM-L6-v2.onnx",
        "modelos/tokenizer.json",
    )
    .expect("falha ao carregar modelo");

    let textos = [
        "Como otimizar consultas em PostgreSQL",
        "How to optimize PostgreSQL queries",
        "Receita de bolo de chocolate",
    ];

    let embeddings: Vec<Vec<f32>> = textos
        .iter()
        .map(|t| embedder.embed(t).expect("erro na inferência"))
        .collect();

    // Similaridade por cosseno entre as duas primeiras frases
    let sim = cosseno(&embeddings[0], &embeddings[1]);
    println!("Similaridade (consultas PT vs EN): {:.4}", sim);

    let sim2 = cosseno(&embeddings[0], &embeddings[2]);
    println!("Similaridade (consulta vs bolo): {:.4}", sim2);
}

/// Produto escalar normalizado = similaridade do cosseno.
fn cosseno(a: &[f32], b: &[f32]) -> f32 {
    a.iter().zip(b.iter()).map(|(x, y)| x * y).sum()
}

Este padrão — tokenizar, rodar inferência, pós-processar — é a espinha dorsal de sistemas de busca semântica, RAG e classificação em produção. O embedding gerado é armazenado em um vector database como o Qdrant para recuperação posterior.

Exemplo: Inferência de LLM com Candle

Para rodar modelos de linguagem diretamente em Rust (sem ONNX), o crate candle da Hugging Face é a referência. O esqueleto abaixo mostra o fluxo:

use candle_core::{Device, Tensor};
use candle_transformers::models::llama::Llama;
use candle_nn::VarBuilder;
use hf_hub::{api::sync::Api, Repo, RepoType};
use tokenizers::Tokenizer;

/// Carrega um LLM (família Llama) via candle e gera texto.
pub struct GeradorLlm {
    model: Llama,
    tokenizer: Tokenizer,
    device: Device,
}

impl GeradorLlm {
    pub fn carregar(model_id: &str, revision: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let device = Device::Cpu; // ou Device::Cuda(0) com o feature correto
        let api = Api::new()?;
        let repo = api.repo(Repo::with_revision(
            model_id.to_string(),
            RepoType::Model,
            revision.to_string(),
        ));

        let vb = VarBuilder::from_mmaped_safetensors(
            &[repo.get("model.safetensors")?],
            candle_core::DType::F32,
            &device,
        )?;

        let config = candle_transformers::models::llama::LlamaConfig::config_for(&repo.get("config.json")?)?;
        let model = Llama::load(vb, &config)?;
        let tokenizer = Tokenizer::from_file(repo.get("tokenizer.json")?).map_err(|e| e.to_string())?;

        Ok(GeradorLlm { model, tokenizer, device })
    }

    /// Gera `max_tokens` tokens a partir do prompt (greedy decoding simples).
    pub fn gerar(&mut self, prompt: &str, max_tokens: usize) -> Result<String, Box<dyn std::error::Error>> {
        let tokens = self.tokenizer.encode(prompt, true).map_err(|e| e.to_string())?;
        let mut ids: Vec<u32> = tokens.get_ids().iter().map(|&v| v).collect();

        for _ in 0..max_tokens {
            let input = Tensor::new(ids.as_slice(), &self.device)?.unsqueeze(0)?;
            let logits = self.model.forward(&input)?;
            let next = logits.argmax_last()?;
            let next_id = next.squeeze(0)?.to_vec1::<u32>()?[0];
            ids.push(next_id);
        }

        Ok(self.tokenizer.decode(&ids, true).map_err(|e| e.to_string())?)
    }
}

Esse é o tipo de código que empresas como Mistral AI, Hugging Face e diversas startups usam para construir serviços de inferência ultrarrápidos. Em produção você adicionaria KV cache, amostragem por temperatura e batching dinâmico.

Crates Essenciais Para IA em Rust

Deep Learning e LLMs

Inferência de Modelos Treinados

Tensores e Álgebra

Dados e Vector Search

ML Clássico

Para aprofundar a parte de processamento de dados, leia nosso artigo sobre engenharia de dados com Polars e DataFusion.

Áreas de Atuação

Serving de Modelos e Inferência

Construir a camada que coloca um modelo treinado em produção, atendendo requisições com baixa latência e alto throughput. Envolve batching dinâmico, KV cache, quantização e integração com GPUs.

Vector Databases e RAG

Implementar e operar bancos de dados vetoriais, índices ANN (approximate nearest neighbor) e pipelines de geração aumentada por recuperação (RAG). É a área que mais cresce desde a popularização dos LLMs.

Data Engineering e Feature Stores

Construir pipelines de ingestão, transformação e serving de features em escala usando Polars, DataFusion e Arrow. Aqui o Rust substitui diretamente cargas pesadas de Spark e pandas.

Plataforma de MLOps

Desenvolver o tooling que orbita os modelos: roteamento de tráfego entre versões, monitoramento, shadow deployment, orquestração de experimentos. Mistura de engenharia de plataforma e sistemas distribuídos.

IA na Borda e Embarcados

Rodar modelos em dispositivos com restrições — microcontroladores, gateways industriais, navegadores via WebAssembly. O crate tract é a estrela aqui. Leia mais em nossa página sobre sistemas embarcados.

Agentes e Ferramentas de IA

Construção de agentes autônomos, servers de ferramentas (como os do Model Context Protocol) e orquestração de chamadas a LLMs em produção. Veja nosso artigo sobre agentes de IA e MCP em Rust.

Empresas que Contratam

Plataformas de IA e Modelos

• Hugging Face: Mantenedora do candle, tokenizers e safetensors — núcleo de inferência em Rust
• Mistral AI: Desenvolve o mistral.rs, engine de inferência de LLM
• Modular: Arquitetura de IA e a linguagem Mojo, com componentes em Rust
• Together AI / Anyscale: Plataformas de inferência em escala

Vector Databases e Dados

• Qdrant: Vector database open source escrito em Rust
• LanceDB: Vector DB orientado a ML, em Rust
• DataStax / Voltron Data: Mantenedoras do Apache Arrow e DataFusion
• Pola-rs (Polars): O projeto e empresas que o adotam em produção

Big Tech

• Amazon (AWS): Infraestrutura de ML, Inferentia, Firecracker para isolamento
• Google: Componentes de ML e infraestrutura
• Meta (Facebook): Llama stack e ferramentas de inferência
• Cloudflare: Workers AI combina Rust e WebAssembly para IA na borda

No Brasil e Remoto

• Fintechs (Nubank, bancos digitais): Plataformas de dados e modelos de crédito/risco
• Startups de dados e ML: Pipelines de feature engineering e serving
• Consultorias e laboratórios de dados: Migração de pipelines pesados para Rust
• Trabalho remoto internacional: A combinação de ML + Rust é especialmente valorizada fora do Brasil — confira nossa página sobre trabalho remoto e salários internacionais

Para ver vagas abertas, consulte nossa seção de vagas de Rust e o diretório de empresas que usam Rust.

Roadmap de Habilidades

Nível Júnior (0-12 meses)

1. Rust sólido: Ownership, lifetimes, traits, error handling (leia o guia de traits)
2. Tensores e ndarray: Operações básicas, broadcasting
3. Serialização: serde, formato JSON e safetensors
4. Python básico e PyTorch: Entender como modelos são treinados e exportados
5. ONNX: Exportar um modelo simples e rodá-lo com ort
6. HTTP e async: tokio, axum ou actix-web para expor inferência via API
7. Bancos de dados: SQL com SQLx e noções de vector search

Nível Pleno (1-3 anos)

1. Inferência avançada: KV cache, quantização (GGUF, INT8/INT4), batching
2. GPU e aceleração: CUDA e wgpu/Metal no burn e candle
3. Vector search: Qdrant, índices HNSW, métricas de similaridade
4. Data engineering: Polars e DataFusion em pipelines reais
5. Performance: Profiling com criterion e flamegraphs, alocação zero-copy
6. MLOps: Versionamento de modelos, monitoramento, A/B testing
7. Sistemas distribuídos: Filas, particionamento, consistência eventual

Nível Sênior (3+ anos)

1. Arquitetura de serving: Orquestração de múltiplos modelos, roteamento inteligente
2. Otimização de baixo nível: SIMD, memory layout, cache-friendly data structures
3. Design de motores: Contribuir para candle, burn, Qdrant ou criar o seu
4. Plataforma de ML: Multi-tenancy, isolamento, observabilidade end-to-end
5. Pesquisa aplicada: Quantização treinada, speculative decoding, mixture of experts
6. Liderança técnica: Definir o roadmap de plataforma de IA de um time ou empresa

Expectativas Salariais

Importante: as faixas abaixo são estimativas de mercado consolidadas a partir de plataformas públicas como Glassdoor, salario.com.br e Levels.fyi, além de relatos da comunidade. Valores reais variam bastante por empresa, regime (CLT, PJ, remoto), senioridade efetiva e pacote de equity. Trate os números como referência, não como garantia. Para faixas detalhadas por especialização, veja nossa página de salários de Rust no Brasil.

Brasil (CLT/PJ)

Remoto Internacional (USD/ano)

A combinação de Machine Learning e sistemas de baixo nível é uma das mais bem pagas do mercado de tecnologia, e devs brasileiros que dominam as duas frequentemente acessam salários em dólar via trabalho remoto. O prêmio existe justamente porque poucas pessoas unem conhecimento sólido de ML com domínio de Rust.

Certificações e Caminhos de Aprendizado

Diferente de cloud ou segurança, não há certificações formais de IA em Rust — o mercado avalia por portfólio e contribuições. Caminhos concretos:

• AWS / GCP / Azure Machine Learning: Para entender a plataforma de ML das clouds, mesmo que o código de produção seja Rust
• Deep Learning Specialization (Andrew Ng / DeepLearning.AI): Fundamentos de redes neurais
• Hugging Face Course: NLP, transformers e o ecossistema que o candle implementa
• Fast.ai: Machine Learning prático

O que realmente pesa no currículo de IA com Rust:

• Contribuições open source em candle, burn, Polars, Qdrant ou DataFusion
• Projetos públicos no GitHub (veja dicas em portfólio no GitHub)
• Artigos e palestras sobre inferência, vector search ou data engineering

Projetos Práticos Para o Portfólio

1. Busca semântica com ONNX + Qdrant: Indexe documentos e recupere por similaridade
2. Servidor de inferência de embeddings: API em Axum com ort, com métricas e cache
3. Chatbot RAG: LLM via candle ou mistral.rs recuperando contexto de uma base vetorial
4. Pipeline de dados com Polars: Substitua um script pandas por Polars e meça o ganho
5. Classifier de texto na borda: Modelo exportado com tract rodando via WebAssembly
6. Feature store: Pipeline DataFusion + Arrow servindo features para um modelo
7. Proxy de LLM com rate limiting: Roteamento entre provedores com métricas e quotas
8. Benchmark de inferência: Compare candle, ort e tract em latência e memória

Esses projetos resolvem problemas reais e demonstram exatamente as habilidades que empresas de IA procuram. Para mais ideias, veja nossa página de projetos práticos com Rust.

Recursos de Aprendizado

Documentação e Tutoriais

• The Rust Book e Rust by Example: Base essencial da linguagem
• Zero to Production in Rust (Luca Palmieri): Melhor referência de backend em Rust
• Documentação do candle e do burn: Direto da fonte
• Nosso guia de IA e ML em Rust: Visão geral prática em /blog/rust-inteligencia-artificial-ml-2026/

Comunidades

• r/LocalLLaMA e Hugging Face: Onde a inferência em Rust é discutida
• Discord do candle e do burn: Canais oficiais dos projetos
• Rust Brasil (Discord): Comunidade brasileira de Rust
• Qdrant e Polars Discord: Para dúvidas sobre vector search e data engineering

Conferências e Eventos

• RustConf: Palestras de ML e sistemas
• The AI Engineer Summit / AI Engineer: Cruzamento de IA e engenharia
• QCon: Tracks de plataforma de ML
• Meetups de Rust no Brasil: Networking presencial

Conclusão

Carreira em IA e Machine Learning com Rust é, em 2026, uma das janelas mais atrativas e menos saturadas da tecnologia. Enquanto todo mundo disputa vagas genéricas de “engenheiro de dados Python” ou “cientista de dados”, a combinação de domínio de ML com systems programming em Rust é rara e disputada — especialmente por empresas que precisam colocar modelos em produção de forma rápida, barata e confiável.

A boa notícia é que o caminho é claro: você não precisa abandonar o Python. O profissional mais valorizado é justamente quem transita entre os dois mundos — treina e experimenta em Python, e serve e escala em Rust. Se você já tem base em uma das pontas, adicionar a outra é uma questão de meses de estudo focado.

Próximos Passos Concretos

1. Solidifique Rust: Ownership, async e error handling sem hesitação
2. Aprenda o básico de ML e PyTorch: O suficiente para treinar e exportar modelos
3. Rode seu primeiro modelo com ort: Exporte um classificador ONNX e sirva via Axum
4. Estude vector search: Suba um Qdrant local e indexe documentos com embeddings
5. Construa um projeto RAG: Combine LLM (candle/mistral.rs) com recuperação vetorial
6. Migre um pipeline para Polars: Meça e documente o ganho de performance
7. Contribua para open source: Um PR no candle, burn, Polars ou Qdrant vale ouro no currículo
8. Publique o que aprender: Artigos e benchmarks constroem autoridade
9. Monte um portfólio público: No GitHub, com READMEs claros e métricas
10. Candidate-se a vagas: Filtre por “ML infrastructure”, “inference”, “platform engineer” — onde Rust brilha

O cruzamento entre IA e sistemas é onde os problemas mais difíceis — e mais bem pagos — da década estão acontecendo. Investir nessa combinação agora coloca você em uma posição privilegiada no mercado, no Brasil e no mundo.