File size: 12,870 Bytes
df2e5c4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 | ---
license: mit
language:
- pt
- en
---
tags:
- llama.cpp
- fastapi
- llm-ui
- agentic
- local-inference
- self-hosted
- privacy
- speculative-decoding
- mtp
pretty_name: ΩFFΣLLIα_KΣrnΣl_MTP
---
<p align="center">
<img src="capa.png" alt="ΩFFΣLLIα_KΣrnΣl_MTP" width="100%"/>
</p>
<h1 align="center">ΩFFΣLLIα_KΣrnΣl_MTP</h1>
<p align="center">
<em>Text/Code Edition — proxy, login e UI unificada sobre o <code>llama-server</code>, 100% local, sem telemetria e com persistência local de conversas, personas e agente.</em>
</p>
<p align="center">
<img src="https://img.shields.io/badge/Python-3.10%2B-3776AB?logo=python&logoColor=white" alt="Python" />
<img src="https://img.shields.io/badge/FastAPI-async-009688?logo=fastapi&logoColor=white" alt="FastAPI" />
<img src="https://img.shields.io/badge/backend-llama.cpp-000000" alt="llama.cpp" />
<img src="https://img.shields.io/badge/persistência-local%20(JSON)-9aa7ff" alt="Persistência local" />
<img src="https://img.shields.io/badge/telemetria-zero-4ade80" alt="Zero telemetria" />
<img src="https://img.shields.io/badge/TLS-autoassinado-6d83ff" alt="TLS" />
<img src="https://img.shields.io/badge/MTP-speculative%20decoding-22d3ee" alt="MTP / Speculative Decoding" />
</p>
## 📖 Visão geral
O ΩFFΣLLIα_KΣrnΣl_MTP é uma camada única em Python (FastAPI) que serve uma interface web/mobile completa para conversar com modelos de linguagem servidos por um `llama-server` local. Tudo roda na sua máquina: nenhuma requisição externa, nenhum ping de telemetria e nenhum dado saindo do seu ambiente.
O foco é texto e código: chat com streaming, renderização de Markdown, LaTeX e highlight de código, métricas de inferência em tempo real, personas customizáveis e um subsistema agêntico com um agente autônomo real executando em segundo plano.
O histórico de conversas é **persistido localmente em arquivos JSON**, permitindo que você retome seus chats, personas e o estado do agente ao reiniciar o Kernel. Você também pode exportar manualmente qualquer conversa para `.md` quando desejar portabilidade.
Esta versão adiciona detecção e sinalização de MTP (Multi-Token Prediction / speculative decoding): quando o `llama-server` no `:8080` é iniciado com aceleração por draft, o Kernel detecta o estado e exibe um indicador visual dedicado, além de reportar a taxa de aceitação do draft em cada resposta.
## ✨ Recursos principais
| Recurso | Descrição |
| --- | --- |
| Chat / Código | Streaming via `llama-server` externo (porta `:8080` por padrão). |
| Persistência Local | Histórico de conversas, personas e agente salvos em disco (JSON) na pasta `offsellia_data/`. |
| Isolamento de contexto | Cada conversa carrega exclusivamente seu próprio histórico e persona — contextos nunca se misturam. |
| Detecção de MTP | Sinalização visual de *speculative decoding* (MTP) no `:8080`, com taxa de aceitação do draft exibida por resposta. |
| Upload `.txt` / `.pdf` | Extração de texto e injeção no contexto (suporte a janela de contexto alta). |
| Renderização rica | Markdown + KaTeX (LaTeX) + emojis + *syntax highlight* de código. |
| Métricas em tempo real | Contexto usado da janela, tokens/s ao vivo, total de tokens, tempo por resposta e aceitação de MTP quando ativo. |
| Exportação manual | Botão para exportar a conversa ativa em `.md` para backup ou portabilidade. |
| Personas | Criação/edição com persistência local, injetadas como *system prompt* (sem limite de caracteres). |
| Agêntica | Um único agente real, em segundo plano, com memória própria persistente e relatórios por ação. |
| Segurança | Login com sessão assinada, rate-limit, TLS autoassinado, *headers* de segurança. |
| Privacidade | Zero telemetria, zero conexão externa, dados restritos ao seu disco local. |
## 🧠 Modelo de memória e Persistência
| Componente | Persistência | Onde vive |
| --- | --- | --- |
| Conversas (chats) | ✅ Persistente | `offsellia_data/chats/` (JSON). |
| Personas | ✅ Persistente | `offsellia_data/personas/` (JSON). |
| Agente (config) | ✅ Persistente | `offsellia_data/agent/agent.json`. |
| Agente (memória) | ✅ Persistente | `offsellia_data/agent/memory/memory.json`. |
| Agente (relatórios) | ✅ Persistente | `offsellia_data/agent/reports/`. |
Cada requisição ao modelo envia o contexto completo e exclusivo da conversa ativa (`persona + histórico`). O `llama-server` não retém estado semântico entre chamadas — o isolamento entre conversas é absoluto.
## ⚡ Sinalização de MTP (Speculative Decoding)
O MTP (Multi-Token Prediction) é uma cabeça de draft embutida em certos modelos GGUF que permite ao `llama-server` acelerar a geração via speculative decoding — o modelo rascunha múltiplos tokens à frente e os verifica em lote. Ganhos típicos ficam na faixa de 1.4–2.2× quando a taxa de aceitação do draft é alta.
O Kernel não ativa o MTP — isso é uma flag de inicialização do `llama-server` (`--spec-type draft-mtp`). O que o Kernel faz é detectar e sinalizar o estado, por dois caminhos complementares:
1. **Proativo (`/props`)**: ao verificar a saúde do upstream, o Kernel consulta o `/props` do `llama-server` e lê o estado de speculative decoding.
2. **Confirmação ao vivo (timings)**: ao final de cada geração, o Kernel inspeciona os timings da resposta; se houver estatísticas de draft, o MTP é confirmado como realmente exercido — fonte de verdade independente do `/props`.
### Indicador visual
Na barra de status da sidebar, ao lado da pill de saúde do upstream, há uma pill **MTP** dedicada:
| Estado | Cor | Significado |
| --- | --- | --- |
| MTP | Cinza | Upstream offline ou estado desconhecido. |
| MTP | Vermelho | Upstream online, porém *sem* speculative decoding ativo. |
| MTP | Verde-azulado | *Speculative decoding* ativo segundo `/props`. |
| MTP ✓ | Ciano (com brilho) | Confirmado ao vivo pelos *timings* de uma geração real. |
> *Nota:* Em algumas *builds* o `/props` pode reportar `speculative: false` mesmo com `--spec-type draft-mtp` ativo. Por isso a confirmação por *timings* prevalece: assim que uma geração real exercita o *draft*, a *pill* fica verde/ciano independentemente do que o `/props` informar.
### Métrica por resposta
Quando o MTP é exercido, a linha de métricas de cada resposta inclui a taxa de aceitação do draft, por exemplo:
`✓ 79 tokens · 4.8 tok/s · 76.46s · MTP 87% aceit (139/159)`
## 🤖 Subsistema Agêntico
O Kernel inclui um único agente real (nunca mais de um) que opera de forma autônoma:
- Execução em segundo plano em ciclos com intervalo configurável.
- Memória própria persistente e em tempo real (`agent/memory/memory.json`).
- Relatórios por ciclo gravados em pasta dedicada (`agent/reports/`).
- Ações reais configuráveis:
- `shell` — execução de comandos de shell
- `python` — execução de código Python
- `http` — requisições HTTP de saída
- `file_write` — escrita de arquivos restrita ao workspace
- `llm` — raciocínio via `llama-server`
- Permissão root opcional via senha mantida apenas em memória (nunca gravada em disco).
- Controle total: criar, configurar, ativar/desativar, rodar agora, excluir e recriar.
- Autonomia ajustável: supervisionado ou autônomo, com limite de passos por ciclo.
O agente raciocina respondendo estritamente em JSON e executa apenas as ações habilitadas, registrando cada passo na memória e nos relatórios.
## 📦 Requisitos
```bash
pip install "fastapi[standard]" uvicorn httpx itsdangerous "passlib[argon2]" \
cryptography pypdf
```
Você também precisa de um `llama-server` (do [llama.cpp](https://github.com/ggml-org/llama.cpp)) rodando localmente — por padrão em `http://127.0.0.1:8080`.
Para speculative decoding, é necessário um `llama-server` com suporte a MTP e um GGUF que contenha a cabeça de draft. A sinalização do Kernel funciona com qualquer upstream; o indicador permanecerá vermelho quando o MTP não estiver ativo.
### Assets offline (opcional)
Para uso 100% offline, coloque em `offsellia_data/static/`:
`marked.min.js`, `katex.min.js`, `katex.min.css`, `auto-render.min.js`, `highlight.min.js`, `github-dark.min.css` (+ pasta de fonts do KaTeX)
Há fallback por CDN comentado no código, caso prefira carregar os assets remotamente.
## 🚀 Como usar
1. Inicie seu `llama-server` (exemplo simples):
```bash
llama-server -m seu-modelo.gguf -c 32768 --port 8080
```
Ou, para habilitar speculative decoding com um GGUF que tenha cabeça MTP:
```bash
llama-server -m seu-modelo-MTP.gguf -c 32768 --port 8080 \
--spec-type draft-mtp --spec-draft-n-max 2 --spec-draft-p-min 0.75
```
2. Inicie o Kernel:
```bash
python ΩFFΣLLIα_KΣrnΣl_MTP.py
```
3. No primeiro boot, defina a senha de acesso (ou exporte via `OFFSELLIA_PASS`).
4. Acesse `https://<seu-ip-local>:5000` e faça login.
*(Por usar TLS autoassinado, o navegador exibirá um aviso de certificado na primeira visita — aceite para prosseguir em rede local).*
💡 **Dica:** Se iniciou com `--spec-type draft-mtp`, a pill **MTP** acende após a primeira geração (confirmação por timings) e a taxa de aceitação aparece nas métricas. Use o botão **⤓ Exportar conversa (.md)** na sidebar para salvar uma cópia legível do seu chat.
## ⚙️ Configuração
A configuração fica em `offsellia_data/kernel.json`, criada automaticamente no primeiro boot:
| Campo | Padrão | Descrição |
| --- | --- | --- |
| `port` | `5000` | Porta do Kernel. |
| `bind` | `0.0.0.0` | Interface de *bind*. |
| `use_tls` | `true` | Ativa TLS autoassinado. |
| `n_ctx` | `50000` | Janela de contexto reportada na UI (alinhe ao seu `llama-server`). |
| `upstreams.llm` | `http://127.0.0.1:8080` | Endereço do `llama-server`. |
Variável de ambiente opcional: `OFFSELLIA_PASS` para definir a senha sem prompt interativo.
## 🗂️ Estrutura de dados
```text
offsellia_data/
├── kernel.json # configuração do Kernel
├── tls_cert.pem # certificado TLS autoassinado
├── tls_key.pem # chave TLS
├── static/ # assets offline (opcional)
├── chats/ # histórico de conversas (JSON)
├── personas/ # personas persistidas (JSON)
└── agent/
├── agent.json # configuração do agente
├── memory/memory.json # memória persistente do agente
├── reports/ # relatórios por ciclo
└── workspace/ # área de trabalho do agente
```
## 🔌 Endpoints principais
| Método | Rota | Função |
| --- | --- | --- |
| GET | `/` | Interface web/mobile. |
| POST | `/login` | Autenticação. |
| GET | `/api/health` | Saúde do upstream LLM + estado de MTP (via `/props`). |
| POST | `/api/extract` | Extração de texto de `.txt` / `.pdf`. |
| GET/POST/DELETE | `/api/chats[/{id}]` | CRUD de conversas (persistidas em JSON). |
| GET/POST/DELETE | `/api/personas[/{id}]` | CRUD de personas. |
| GET/POST/DELETE | `/api/agent` | CRUD do agente único. |
| POST | `/api/agent/enable` | Ativa/desativa o agente. |
| POST | `/api/agent/run` | Dispara um ciclo imediato. |
| POST | `/api/agent/root` | Arma/desarma senha root (em memória). |
| GET/DELETE | `/api/agent/memory` | Lê/limpa a memória do agente. |
| GET | `/api/agent/reports[/{id}]` | Lista/abre relatórios. |
| * | `/v1/*`, `/props`, `/tokenize`, … | Proxy transparente para o `llama-server`. |
## 🔒 Segurança e privacidade
- **Privacidade Local:** Todo o histórico de conversas, personas e relatórios do agente é gravado exclusivamente em disco local (`offsellia_data/`). Nenhum dado é enviado para servidores externos.
- Sessões assinadas com `itsdangerous` e cookies `HttpOnly` / `SameSite`.
- Senha de acesso protegida com Argon2.
- Rate-limit no login (8 tentativas / 5 min por IP).
- Headers de segurança: `X-Content-Type-Options`, `X-Frame-Options`, `Referrer-Policy`.
- TLS autoassinado gerado automaticamente (SAN inclui IPs LAN e gateway de hotspot).
- Senha root do agente nunca é gravada em disco — vive apenas em memória durante a sessão do processo.
- Zero telemetria e nenhuma chamada de rede além do seu `llama-server` local.
- Detecção de MTP sem custo de privacidade: a leitura de `/props` ocorre apenas entre o Kernel e o seu `llama-server` local.
## ⚠️ Aviso
O subsistema agêntico pode executar ações reais no sistema (shell, Python, escrita de arquivos e, opcionalmente, comandos com privilégios root). Habilite cada ação de forma consciente, mantenha o agente em modo supervisionado quando possível e use o workspace dedicado. A responsabilidade pelo uso é inteiramente sua.
## 📜 Licença
MIT
|