---
title: "Carreira em IA e Machine Learning com Rust"
url: "https://rustlang.com.br/carreira/nicho-ia-ml/"
markdown_url: "https://rustlang.com.br/carreira/nicho-ia-ml.MD"
description: "Guia de carreira em IA e Machine Learning com Rust: inferência de LLMs, vector databases, data engineering e MLOps. Conheça crates (candle, burn, ort, polars), empresas que contratam, salários no Brasil e no exterior, roadmap e projetos para o portfólio."
date: "2026-07-06"
author: ""
---

# Carreira em IA e Machine Learning com Rust

Guia de carreira em IA e Machine Learning com Rust: inferência de LLMs, vector databases, data engineering e MLOps. Conheça crates (candle, burn, ort, polars), empresas que contratam, salários no Brasil e no exterior, roadmap e projetos para o portfólio.


## 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](/carreira/transicao-para-rust/), 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:

| Camada | Linguagem dominante | Onde Rust aparece |
|--------|---------------------|-------------------|
| Treinamento de modelos | Python (PyTorch, JAX) | Raro (burn, tinygrad-rs) |
| Exportação/serialização | Python + formatos | safetensors, GGUF, ONNX |
| Inferência em produção | C++, Rust | candle, mistral.rs, ort, tract |
| Vector databases / busca semântica | Rust, Go, C++ | Qdrant, LanceDB |
| Data engineering / features | Python, Scala, Rust | Polars, DataFusion, Arrow |
| MLOps e plataforma | Go, Rust, Python | tooling de serving, roteamento |
| Edge e embarcados | C, C++, Rust | tract, microTVM |

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:

```rust
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](https://qdrant.tech) 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:

```rust
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

| Crate | Para que serve |
|-------|----------------|
| `candle` | Framework de ML minimalista da Hugging Face; inferência de LLMs em CPU/GPU |
| `burn` | Framework de deep learning completo, com backends ndarray, wgpu e CUDA |
| `mistral-rs` | Engine de inferência de LLM de altíssima performance |
| `tokenizers` | Tokenização rápida da Hugging Face (usada em produção pelo Transformers) |
| `safetensors` | Serialização segura e rápida de tensores |

### Inferência de Modelos Treinados

| Crate | Para que serve |
|-------|----------------|
| `ort` | Bindings para ONNX Runtime — roda modelos exportados do PyTorch/TF |
| `tract` | Inferência ONNX/TF portátil, ideal para edge e embarcados |
| `rust-bert` | Modelos de NLP prontos (BERT, RoBERTa) |

### Tensores e Álgebra

| Crate | Para que serve |
|-------|----------------|
| `ndarray` | Arrays n-dimensionais estilo NumPy |
| `nalgebra` | Álgebra linear para ciência e jogos |
| `candle-core` | Tensores com autodiff (parte do candle) |

### Dados e Vector Search

| Crate | Para que serve |
|-------|----------------|
| `polars` | DataFrames de altíssima performance (alternativa ao pandas) |
| `datafusion` | Engine de consultas SQL sobre Apache Arrow |
| `arrow` | Formato colunar em memória (padrão de interoperabilidade) |
| `qdrant-client` | Cliente para o vector database Qdrant |
| `lancedb` | Vector database local, otimizado para ML |

### ML Clássico

| Crate | Para que serve |
|-------|----------------|
| `linfa` | Toolkit de ML clássico estilo scikit-learn (SVM, k-means, regressão) |
| `smartcore` | Algoritmos de ML clássico |

Para aprofundar a parte de processamento de dados, leia nosso artigo sobre [engenharia de dados com Polars e DataFusion](/blog/rust-engenharia-dados-polars-datafusion-2026/).

## Á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](/carreira/nicho-embedded/).

### 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](/blog/rust-agentes-ia-mcp-2026/).

## 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](/carreira/trabalho-remoto/) e [salários internacionais](/carreira/salarios-internacional/)

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

## Roadmap de Habilidades

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

1. **Rust sólido**: Ownership, lifetimes, traits, error handling (leia o [guia de traits](/blog/traits-rust-guia-completo-exemplos/))
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](/ecossistema/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](/carreira/salarios-brasil/).

### Brasil (CLT/PJ)

| Nível | Faixa mensal estimada (R$) | Foco típico |
|-------|------------------------------|-------------|
| Júnior | R$ 7.000 - R$ 13.000 | Pipelines de dados, tooling de ML |
| Pleno | R$ 13.000 - R$ 25.000 | Serving de modelos, vector search |
| Sênior | R$ 25.000 - R$ 40.000 | Arquitetura de plataforma de IA |
| Staff / Especialista | R$ 40.000 - R$ 60.000+ | Liderança técnica de IA/ML |

### Remoto Internacional (USD/ano)

| Nível | Faixa anual estimada (USD) | Foco típico |
|-------|-----------------------------|-------------|
| Pleno | $90.000 - $160.000 | Engenharia de inferência, dados |
| Sênior | $160.000 - $250.000 | Plataforma de ML, vector DBs |
| Staff / Principal | $250.000 - $400.000+ | Arquitetura de IA, motores |

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](/carreira/portfolio-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](/carreira/projetos-praticos-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/](/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.