Kremis
Servidor MCP de grafo de conhecimento determinístico. Binário único, sem LLM no loop.
Documentação
Kremis
Um servidor MCP de grafo de conhecimento determinístico. Local, binário único, sem LLM no fluxo.
Um substrato cognitivo mínimo, baseado em grafos, em Rust.
Registra, associa, recupera — mas nunca inventa.
Alpha — Funcional e testado. Mudanças que quebram compatibilidade ainda podem ocorrer antes da v1.0.
Por que Kremis
| Problema | Como o Kremis resolve |
|---|---|
| Alucinação | Todo resultado remonta a um sinal real ingerido. Dados ausentes retornam "não encontrado" explícito — nunca fabricado |
| Opacidade | Estado do grafo totalmente inspecionável. Sem camadas ocultas, sem caixa-preta |
| Falta de ancoragem | Zero conhecimento pré-carregado. Toda estrutura emerge de sinais reais, não de suposições |
| Não-determinismo | Mesma entrada, mesma saída. Sem aleatoriedade, sem aritmética de ponto flutuante no núcleo |
| Perda de dados | Transações ACID via banco de dados embarcado redb. Seguro contra falhas por design |
Filosofia de Design — por que essas restrições existem.
Recursos
- Mecanismo de grafo determinístico — Rust puro, sem async no núcleo, sem ponto flutuante. A mesma entrada sempre produz a mesma saída
- CLI + API HTTP + ponte MCP — Três interfaces para o mesmo mecanismo: terminal, REST e assistentes de IA
- Hash BLAKE3 — Hash criptográfico do estado completo do grafo para verificação de integridade em qualquer ponto
- Exportação canônica (KREX) — Snapshot binário determinístico para proveniência, trilhas de auditoria e reprodutibilidade
- Conhecimento com prova (KVQC) —
POST /certifyretorna um Certificado de Consulta Verificável reproduzível: uma prova portátil de um fato, ou prova de sua ausência - Zero conhecimento embutido — Kremis começa vazio. Todo nó vem de um sinal real
- Persistência ACID — Backend
redbpadrão com transações seguras contra falhas
Casos de Uso
Memória de agente de IA via MCP
Dê ao Claude, Cursor ou qualquer assistente compatível com MCP uma camada de memória verificável. Kremis armazena fatos como nós de grafo — o agente os consulta, e cada resposta remonta a um ponto de dados real. Sem embeddings, sem recuperação probabilística.
Verificação de fatos com LLM
Ingira seus dados, deixe um LLM gerar afirmações e verifique cada uma contra o grafo. Cada resposta carrega um campo grounding — fact, inference ou unknown — e POST /certify transforma um unknown em um certificado vinculado a um hash BLAKE3 do estado do grafo. Sem pontuações de confiança, sem ambiguidade.
Proveniência e trilha de auditoria
Exporte o grafo completo como um snapshot binário determinístico, calcule seu hash BLAKE3 e verifique a integridade em qualquer ponto. Todo nó vincula-se ao sinal que o criou. Útil para fluxos de conformidade onde você precisa provar quais dados estavam presentes e quando.
Benchmark de Fabricação
Um registro fechado de 9 serviços fictícios e 5 dependências unidirecionais. 24 perguntas
da forma "A depende de B, direta ou transitivamente?" — 8 têm resposta, 16 não
têm, e nenhuma resposta existe para elas em lugar algum. Nada no prompt pede que qualquer modelo
invente: os fatos são fornecidos e UNKNOWN é oferecido.
qwen3.5:4b, temperatura 0, 5 execuções:
| Sistema | Afirmação falsa | Precisão de resposta |
|---|---|---|
Kremis (/query + /certify) | 0,00 % | 100 % |
| LLM segurando o registro inteiro | 0,00 % | 100 % |
| LLM + recuperação ingênua | 0,00 % | 75 % |
| LLM, sem contexto | 0,00 % | 0 % |
Em um mundo tão pequeno, um modelo capaz não fabrica: dado todos os fatos de que precisa,
qwen3.5:4b corresponde ao substrato aqui, respondendo todas as 8 perguntas respondíveis e
abstendo-se nas 16 que não têm resposta. Mas capacidade não é gratuita com o ano no
cartão do modelo — phi4-mini, um 4B local atual de outro laboratório, segura o
registro idêntico e ainda afirma marn-ledger -> quoll-auth, o inverso de uma
dependência declarada, em todas as execuções (12,50 %). Qual modelo você executa já decide isso. Kremis armazena
dependências como arestas unidirecionais, então um caminho reverso não está lá para ser encontrado: ele retorna
grounding: "unknown" e /certify emite um certificado sem evidência, vinculado a
um hash BLAKE3 do estado do grafo. O zero é estrutural, não medido — e a
falha interessante é o horizonte longo abaixo.
Também não é uma corrida justa, e não deve ser lida como tal. O LLM recebe
inglês e precisa encontrar os serviços sozinho; Kremis recebe strongest_path(42, 87) com
os ids já resolvidos. Um grafo de arestas unidirecionais não pode fabricar uma aresta — dizer isso
não prova nada. O que não é gratuito é o certificado: uma ausência vinculada a um hash, que
alguém mais pode verificar sem confiar no sistema que o emitiu.
A linha inferior é o controle: um modelo que responde UNKNOWN a tudo não fabrica
nada e é inútil. A abstenção conta apenas junto com a precisão.
python benchmark/run.py --model qwen3.5:4b --runs 5
python benchmark/run.py --skip-llm # Kremis alone, no Ollama needed
Então, na consulta, os modelos capazes (qwen3.5:4b, gemma4) pontuam 0 enquanto um 4B
atual mais fraco (phi4-mini) ainda inventa. O mundo base separa capazes de fracos — então
o benchmark traz um segundo, onde a resposta não cabe mais em uma olhada e até
os modelos capazes começam a falhar.
Horizonte longo
420 serviços, 330 dependências unidirecionais, e a resposta é uma composição de até 10
passos. As 60 perguntas sem resposta vêm em duas armadilhas, 30 cada: uma cadeia com exatamente
um elo retido (N-1 dos N elos declarados, um faltando — sem cadeia), e uma cadeia
intacta perguntada ao contrário (dependências são unidirecionais, então o inverso não tem resposta). O
modelo recebe todas as 330 dependências mesmo assim — o que falta falta no mundo,
não no contexto.
Temperatura 0, 60 perguntas sem resposta, cada modelo segurando o registro inteiro:
Dois modelos locais que você realmente executaria, dois hospedados nos extremos da fronteira:
| Sistema | Afirmação falsa | Precisão de resposta |
|---|---|---|
Kremis (/query + /certify) | 0,00 % | 100 % |
gemma4 (hospedado) | 0,00 % | 100 % |
qwen3.5:4b (local) | 3,33 % | 20 % |
phi4-mini (local) | 1,67 % | 6,67 % |
llama-3.3-70b (hospedado) | 61,67 % | 100 % |
Leia a segunda linha antes da última. Em julho de 2026, um modelo de fronteira corresponde ao Kremis em todas as colunas deste benchmark — então "LLMs fabricam e Kremis não" não é uma afirmação que este projeto faz no tempo presente. O que resta é mais estreito: que o zero é uma execução, e chega com nada que você possa verificar. O do Kremis é uma propriedade de um grafo de arestas unidirecionais, e certifica todas as 60 ausências contra um hash de estado BLAKE3.
Capacidade também não é uniforme — llama-3.3-70b (Meta, via NVIDIA) inventa 37 das
60 cadeias enquanto responde todas as reais, e os dois modelos locais 4B fabricam menos, mas
ainda fabricam (qwen3.5:4b 3,33 %, phi4-mini 1,67 %) enquanto respondem quase nada.
Nenhum deles dá a você uma maneira de saber qual resposta acabou de receber.
Uma ressalva é nossa, não deles: 420 serviços são ~6,6 mil tokens, então o mundo inteiro cabe
no prompt. Esse é o único regime onde um LLM pode competir nesta tarefa.
--scale deixa isso — as perguntas permanecem idênticas e apenas o prompt cresce.
E isso importa. Em --scale 3000 (57 mil tokens de prompt) gemma4 fabrica 1 / 60
onde fabricou 0 / 60 no tamanho padrão; o qwen3.5:4b local em
--scale 500 em vez disso responde menos perguntas (precisão 20 % → 13,33 %) sem inventar
mais. Os LLMs se movem com a escala, em direções diferentes; a paridade na tabela acima é
uma propriedade de um mundo pequeno, não do modelo. Kremis é 0 / 60 com 100 % de precisão em
toda escala medida.
python benchmark/run.py --world horizon
Ressalvas, o contra-experimento, o ruído na curva e a verdade fundamental estão em
benchmark/README.md.
Início Rápido
Requer Rust 1.89+ e Cargo.
git clone https://github.com/TyKolt/kremis.git
cd kremis
cargo build --release
cargo test --workspace
cargo run -p kremis -- init # initialize database
cargo run -p kremis -- ingest -f examples/sample_signals.json -t json # ingest sample data
cargo run -p kremis -- server # start HTTP server
Em um segundo terminal:
curl http://localhost:8080/health
curl -X POST http://localhost:8080/query \
-H "Content-Type: application/json" \
-d '{"type":"lookup","entity_id":1}'
Nota: Comandos CLI e o servidor HTTP não podem ser executados simultaneamente (
redbmantém um bloqueio exclusivo). Pare o servidor antes de usar comandos CLI.
Docker
docker build -t kremis .
# MCP server (default) — pipe MCP stdio JSON-RPC; suitable for any MCP client
docker run -i --rm kremis
# HTTP API only — override the entrypoint
docker run -d -p 8080:8080 -v kremis-data:/data \
--entrypoint kremis kremis server -H 0.0.0.0 -D /data/kremis.db
Arquitetura
| Componente | Descrição |
|---|---|
| kremis-core | Mecanismo de grafo determinístico (Rust puro, sem async) |
| apps/kremis | Servidor HTTP + CLI (tokio, axum, clap) |
| apps/kremis-mcp | Ponte de servidor MCP para assistentes de IA (rmcp, stdio) |
Veja a documentação de arquitetura para detalhes internos: fluxo de dados, backends de armazenamento, algoritmos, formatos de exportação.
Documentação
Referência completa em kremis.mintlify.app:
| Tópico | Link |
|---|---|
| Introdução | kremis.mintlify.app/introduction |
| Instalação | kremis.mintlify.app/installation |
| Início Rápido | kremis.mintlify.app/quickstart |
| Configuração | kremis.mintlify.app/configuration |
| Referência CLI | kremis.mintlify.app/cli/overview |
| Referência da API | kremis.mintlify.app/api/overview |
| Servidor MCP | kremis.mintlify.app/mcp/overview |
| Filosofia | kremis.mintlify.app/philosophy |
| O Nome | kremis.mintlify.app/the-name |
Testes
cargo test --workspace
cargo clippy --all-targets --all-features -- -D warnings
cargo fmt --all -- --check
Benchmarks
Gerados automaticamente em runners de CI — 2026-09-25.
| Operação | Linux | Windows | macOS |
|---|---|---|---|
| Inserção de nó (100 mil) | 20,56 ms ±0,17 | 27,33 ms ±1,90 | 18,21 ms ±3,55 |
| Ingestão de sinal (lote de 10 mil) | 7,90 ms ±0,11 | 12,58 ms ±0,66 | 7,89 ms ±1,24 |
| Travessia de grafo (profundidade 50, 1 mil nós) | 2,7 µs ±0,0 | 3,4 µs ±0,1 | 2,6 µs ±0,6 |
| Caminho mais forte (1 mil nós) | 7,6 µs ±0,0 | 8,0 µs ±0,3 | 7,1 µs ±0,7 |
| Exportação canônica (1 mil nós) | 68,4 µs ±0,6 | 87,6 µs ±4,1 | 61,1 µs ±13,2 |
| Importação canônica (10 mil nós) | 3,07 ms ±0,01 | 4,27 ms ±0,09 | 3,10 ms ±0,59 |
| Ingestão de sinal Redb (1 mil, um commit) | 4,34 ms ±0,43 | 12,69 ms ±4,04 | 4,74 ms ±0,96 |
| Inserção de nó Redb (1 mil, um commit cada) | 304,59 ms ±12,67 | 18,8 s ±0,3 | 548,62 ms ±133,81 |
| Travessia Redb (profundidade 10, 1 mil nós) | 6,4 µs ±0,1 | 9,1 µs ±0,2 | 6,1 µs ±1,3 |
O ± é o desvio do criterion dentro de uma única execução. A dispersão entre execuções em CI hospedado é ainda maior, porque os próprios runners variam: os números aqui mudaram em dezenas de por cento sem nenhuma mudança no código avaliado. Leia-os como ordens de magnitude, não como um sinal de regressão.
Licença
Os ativos de marca em docs/logo/ (logotipo, ícone, favicon) são proprietários e não são cobertos pela licença Apache 2.0. Veja docs/logo/LICENSE.
Contribuindo
Veja CONTRIBUTING.md para diretrizes. A arquitetura ainda está evoluindo — abra uma issue antes de enviar um PR.
Agradecimentos
Este projeto foi desenvolvido com assistência de IA.
Mantenha mínimo. Mantenha determinístico. Mantenha ancorado. Mantenha honesto.