---
license: mit
language:
- pt
- en
base_model:
- AtomicChat/Ornith-1.5-9B-GGUF
tags:
- coder
- code
- programmer
- edge
- fast
- smart
---
# LEVUM
[👉 Acesse a Landing Page do Velum AI](https://guell11.github.io/velum-ai/)
### Local · Código · Software
**Um modelo local baseado em Qwen 3.5 9B, direcionado para desenvolvimento de software.**
Escrever. Entender. Corrigir. Refatorar. Construir.
**Menos cerimônia. Mais código rodando.**
---
## Sobre
**LEVUM** é um modelo de **9 bilhões de parâmetros**, baseado em **Qwen 3.5 9B** e direcionado para tarefas de desenvolvimento de software.
O objetivo é simples: trabalhar perto do projeto e transformar instruções em código útil.
O modelo foi pensado para tarefas como:
* geração de código;
* implementação de features;
* debugging;
* refatoração;
* explicação e leitura de código;
* criação de protótipos;
* estruturação de projetos;
* geração de aplicações completas;
* assistência durante desenvolvimento local.
LEVUM segue uma filosofia **local-first**: o modelo pode rodar próximo da IDE, dos arquivos e do contexto real do projeto, dependendo do runtime e da quantização escolhidos.
> **Software primeiro. Local por padrão.**
---
## Especificações
| | |
| ----------------- | -------------------------------------------- |
| **Modelo** | LEVUM |
| **Base** | Qwen 3.5 9B |
| **Parâmetros** | 9B |
| **Foco** | Código / Software |
| **Uso principal** | Desenvolvimento de software |
| **Execução** | Local |
| **Idioma** | Português + capacidades multilíngues da base |
| **Origem** | 🇧🇷 Brasil |
---
# Quantizações
LEVUM é disponibilizado em diferentes níveis de quantização para permitir execução em uma variedade maior de hardware.
A escolha ideal depende principalmente de:
**RAM / VRAM → velocidade → fidelidade**
### Q8 — Fidelidade
Para máquinas com memória suficiente e usuários que querem preservar o máximo possível da qualidade do modelo.
`Q8_0`
---
### Q4 / IQ4 — Equilíbrio
O ponto recomendado para muitos sistemas locais.
Boa relação entre tamanho, consumo de memória e qualidade.
`Q4_K_M` · `Q4_K_S` · `IQ4_XS` · `IQ4_NL` · `Q4_1` · `Q4_0`
---
### Q3 / IQ3 — Compacto
Para hardware mais limitado ou situações onde reduzir RAM/VRAM é prioridade.
`Q3_K_L` · `Q3_K_M` · `Q3_K_S` · `IQ3_M` · `IQ3_S` · `IQ3_XS` · `IQ3_XXS`
---
### Q2 / IQ2 — Ultracompacto
Compressão agressiva para ambientes onde versões maiores simplesmente não cabem.
`Q2_K` · `Q2_K_S` · `IQ2_M` · `IQ2_S` · `IQ2_XS` · `IQ2_XXS` · `Q2_0` · `TQ2_0`
---
### IQ1 — Mínimo
A opção extrema.
`IQ1_M`
Indicada apenas quando economia de memória é mais importante do que preservar a fidelidade máxima do modelo.
---
> **Regra prática:** comece com `Q4_K_M`.
> Se houver memória sobrando, experimente `Q8_0`.
> Se faltar memória, desça para Q3, Q2 ou IQ1.
---
# Executando localmente
## llama.cpp
Baixe uma das versões GGUF do LEVUM e execute com um runtime compatível com GGUF.
```bash
llama-cli \
-m ./LEVUM-Q4_K_M.gguf \
-p "Crie uma API REST em Python usando FastAPI."
```
Para iniciar um servidor local:
```bash
llama-server \
-m ./LEVUM-Q4_K_M.gguf \
-c 8192
```
Depois disso, o modelo pode ser integrado a ferramentas locais que suportem endpoints compatíveis.
---
## Ollama
Crie um `Modelfile` apontando para o GGUF:
```dockerfile
FROM ./LEVUM-Q4_K_M.gguf
PARAMETER temperature 0.6
PARAMETER top_p 0.9
```
Depois:
```bash
ollama create levum -f Modelfile
ollama run levum
```
Exemplo:
```text
>>> Crie uma API em FastAPI para gerenciar projetos e tarefas.
```
---
## LM Studio
1. Baixe uma quantização GGUF do LEVUM.
2. Importe o arquivo no LM Studio.
3. Carregue o modelo.
4. Ajuste o contexto de acordo com a memória disponível.
5. Inicie uma conversa ou o servidor local.
Nenhuma infraestrutura remota é necessária para a inferência quando o modelo está sendo executado localmente.
---
# Prompts
LEVUM funciona melhor quando a tarefa, o contexto e o formato esperado são explícitos.
## Gerar um projeto
```text
Crie um dashboard financeiro interativo em um único arquivo HTML.
Requisitos:
- HTML, CSS e JavaScript no mesmo arquivo
- gráficos interativos
- responsivo
- dados de exemplo
- sem dependências externas obrigatórias
Retorne somente o HTML completo.
```
---
## Implementar uma feature
```text
Analise o código abaixo e implemente autenticação JWT.
Requisitos:
- preserve a arquitetura atual
- valide tokens expirados
- adicione middleware de autenticação
- não altere endpoints públicos
- explique apenas decisões importantes
Código:
[cole o código aqui]
```
---
## Debug
```text
Encontre a causa do bug no código abaixo.
Comportamento esperado:
[descreva]
Comportamento atual:
[descreva]
Erro:
[cole o erro]
Código:
[cole o código]
Identifique a causa e retorne a correção completa.
```
---
## Refatoração
```text
Refatore este código.
Objetivos:
- reduzir duplicação
- melhorar legibilidade
- manter comportamento atual
- preservar a API pública
- evitar abstrações desnecessárias
Retorne primeiro o código refatorado e depois um resumo curto das mudanças.
```
---
# Formato de prompt
Para tarefas maiores, uma estrutura simples costuma produzir resultados mais previsíveis:
```text
OBJETIVO
O que precisa ser construído.
CONTEXTO
Stack, arquivos existentes e arquitetura.
REQUISITOS
Comportamentos obrigatórios.
RESTRIÇÕES
O que não deve ser alterado.
SAÍDA
Formato exato esperado.
```
Por exemplo:
```text
OBJETIVO
Criar uma página de analytics.
CONTEXTO
Projeto React + TypeScript + Tailwind.
REQUISITOS
- gráfico de receita
- filtros por período
- cards de métricas
- tabela de transações
RESTRIÇÕES
- não adicionar novas dependências
- reutilizar componentes existentes
SAÍDA
Retorne os arquivos completos que precisam ser criados ou alterados.
```
---
# Code-first
LEVUM foi pensado para trabalhar dentro do ciclo normal de desenvolvimento:
```text
PROMPT / CÓDIGO
↓
LEVUM
↓
ENTENDER
↓
GERAR
↓
DEBUG
↓
REFATORAR
↓
SOFTWARE RODANDO
```
### Geração
Projetos, componentes, APIs, scripts e features.
### Debug
Análise de erros, comportamento inesperado e correções.
### Refatoração
Estrutura, legibilidade e manutenção de código existente.
### Prototipagem
Transformar uma ideia em algo executável rapidamente.
---
# Exemplo
**Prompt**
```text
Crie um jogo estilo Flappy Bird em um único HTML.
Use apenas HTML, CSS e JavaScript.
Inclua:
- física
- obstáculos
- colisão
- pontuação
- reinício
- controles por teclado e clique
Retorne somente o HTML completo.
```
**Resultado esperado**
```text
prompt
↓
LEVUM
↓
HTML + CSS + JavaScript
↓
browser
↓
software rodando
```
---
# Hardware
O consumo real depende de vários fatores, incluindo:
* quantização;
* tamanho do contexto;
* runtime;
* KV cache;
* CPU;
* GPU;
* quantidade de camadas descarregadas para GPU;
* configuração de inferência.
Por isso, os números de memória podem variar significativamente entre sistemas.
Como regra geral:
```text
mais bits
↑
mais fidelidade
↑
mais memória
menos bits
↓
menos memória
↓
maior compressão
```
Escolha a quantização com base no hardware disponível e na qualidade necessária para a tarefa.
---
# Limitações
LEVUM continua sendo um modelo de linguagem.
Isso significa que ele pode:
* gerar código incorreto;
* inventar APIs ou bibliotecas;
* produzir soluções inseguras;
* interpretar requisitos de forma errada;
* introduzir regressões;
* sugerir dependências inexistentes;
* gerar código que parece correto sem realmente funcionar.
Para software importante, revise, teste e valide o código antes de colocá-lo em produção.
Código gerado por IA não ganha poderes mágicos só porque compilou uma vez.
---
# Uso responsável
Antes de executar código gerado pelo modelo:
1. revise as alterações;
2. verifique dependências;
3. execute testes;
4. valide entradas externas;
5. revise operações de filesystem, rede e banco de dados;
6. não exponha segredos ou credenciais desnecessariamente;
7. use ambientes isolados quando estiver testando código desconhecido.
Para aplicações críticas, o modelo deve funcionar como ferramenta de assistência, não como única camada de revisão.
---
# Modelo base
LEVUM é baseado em:
**Qwen 3.5 9B**
O modelo base fornece a capacidade geral sobre a qual o LEVUM é construído.
Consulte também o model card e a licença do modelo base antes de distribuir ou utilizar derivados.
---
# Licença
O uso do LEVUM está sujeito à licença publicada neste repositório e, quando aplicável, aos termos e condições associados ao modelo base.
Consulte o arquivo `LICENSE` antes de uso comercial, redistribuição ou criação de derivados.
---
# Brasil
### 🇧🇷 FEITO NO BRASIL
**Inteligência que fica por perto.**
Local-first · Code-first · Software-first
`BUILD` · `DEBUG` · `REFACTOR` · `SHIP`
**LEVUM © 2026**