Datasets:

Brunobkr
/

OFFELLIA_Kernel_llama-server

license: mit
language:
  - pt
  - en
tags:
  - llama.cpp
  - fastapi
  - llm-ui
  - agentic
  - local-inference
  - self-hosted
  - privacy
pretty_name: ΩFFΣLLIα_KΣrnΣl_₣ΔβLLΣ_Chat_RAM

ΩFFΣLLIα_KΣrnΣl_₣ΔβLLΣ_Chat_RAM

Text/Code Edition — proxy, login e UI unificada sobre o llama-server, 100% local, sem telemetria e com conversas voláteis (somente em RAM).

📖 Visão geral

O ΩFFΣLLIα_KΣrnΣl_₣ΔβLLΣ_Chat_RAM é 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.

A partir desta versão, as conversas são voláteis por design: vivem exclusivamente na memória RAM durante a sessão do processo e desaparecem ao encerrar o Kernel. Nenhum input ou output de chat é gravado em disco — privacidade efêmera por padrão.

✨ Recursos principais

Recurso	Descrição
Chat / Código	Streaming via `llama-server` externo (porta `:8080` por padrão).
Conversas voláteis (RAM)	Histórico mantido apenas em memória durante a sessão; zero escrita em disco; tudo é descartado ao encerrar o processo.
Isolamento de contexto	Cada conversa carrega exclusivamente seu próprio histórico e persona — contextos nunca se misturam entre conversas.
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 e tempo por resposta.
Exportação manual	Botão para exportar a conversa ativa em `.md` — a única forma de persistir um chat, sob decisão explícita do usuário.
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, zero rastro de conversas em disco.

🧠 Modelo de memória

Componente	Persistência	Onde vive
Conversas (chats)	❌ Volátil	RAM do processo — descartada ao encerrar o Kernel.
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.

🤖 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. A persistência do agente é independente e não foi afetada pelo modo volátil das conversas.

📦 Requisitos

pip install "fastapi[standard]" uvicorn httpx itsdangerous "passlib[argon2]" \
            cryptography pypdf

Você também precisa de um llama-server (do llama.cpp) rodando localmente — por padrão em http://127.0.0.1:8080.

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

Inicie seu llama-server (exemplo):

llama-server -m seu-modelo.gguf -c 32768 --port 8080

Inicie o Kernel:

python ΩFFΣLLIα_KΣrnΣl_₣ΔβLLΣ_Chat_RAM.py

No primeiro boot, defina a senha de acesso (ou exporte via OFFSELLIA_PASS).
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.

⚡ Lembrete: conversas existem somente enquanto o processo estiver ativo. Para guardar um chat, use ⤓ Exportar conversa (.md) na sidebar antes de encerrar.

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

offsellia_data/
├── kernel.json            # configuração do Kernel
├── tls_cert.pem           # certificado TLS autoassinado
├── tls_key.pem            # chave TLS
├── static/                # assets offline (opcional)
├── 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

Conversas não possuem diretório: residem unicamente na memória do processo enquanto o Kernel estiver ativo.

🔌 Endpoints principais

Método	Rota	Função
`GET`	`/`	Interface web/mobile.
`POST`	`/login`	Autenticação.
`POST`	`/api/extract`	Extração de texto de `.txt` / `.pdf`.
`GET/POST/DELETE`	`/api/chats[/{id}]`	CRUD de conversas (em RAM, válido na sessão).
`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/*`, `/tokenize`, …	Proxy transparente para o `llama-server`.

🔒 Segurança e privacidade

Conversas voláteis: nenhum input ou output de chat toca o disco — o histórico vive apenas em RAM e morre com o processo.
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.

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