README.md

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