README.md

---
license: mit
language:
- pt
- en
base_model:
- AtomicChat/Ornith-1.5-9B-GGUF
tags:
- coder
- code
- programmer
- edge
- fast
- smart
---

<div align="center">


![image](https://cdn-uploads.huggingface.co/production/uploads/644afe169279988e0cbcd2d9/jCFCVTpFLOvaCUOF90b9o.png)

<br>

# 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.**

</div>

---

## 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

<div align="center">

### 🇧🇷 FEITO NO BRASIL

**Inteligência que fica por perto.**

Local-first · Code-first · Software-first

<br>

`BUILD` · `DEBUG` · `REFACTOR` · `SHIP`

<br>

**LEVUM © 2026**

</div>