Ir para o conteúdo

Código aberto · auto-hospedado · seus dados não saem daqui

Um cérebro que suas IAs podem fazer crescer.

Seu conhecimento está espalhado em pastas que ninguém consegue buscar, e toda sessão de agente começa queimando minutos e milhares de tokens para reconstruir um contexto que ele já tinha. O MonkeyLLM transforma esses arquivos numa floresta que o agente percorre: a busca de entrada responde em 1,3 ms sem GPU, e o nó certo fica a poucos saltos baratos, em vez de reler o corpus inteiro.

Suba em quatro comandosFale com a genteDê uma estrela no GitHub

Auto-hospedar é livre, para sempre. Sem contagem de assentos, sem chave para pedir, nada telefonando para casa.

O console Explore mostrando uma floresta de conhecimento com 1.877 nós em 49 galhos
Uma floresta real: 1.877 nós em 49 galhos. Cada cluster é um galho, cada ponto é um nó; linhas sólidas são trilhas curadas, as tracejadas são atalhos que uma caçada descobriu, e o brilho é feromônio deixado pelo uso.
0/11 → 11/11
O mesmo modelo local de 12B em perguntas estritamente multi-hop: como leitor de RAG top-k clássico e depois como navegador da floresta.
0,66×
Custo em tokens por resposta correta contra uma baseline de RAG iterativo, e 8,4 s p95 contra os 17,5 s dela. Errar barato não é economia.
1 × RTX 3060
O rig do benchmark: uma única placa intermediária de 12 GB, não uma GPU de workstation. Um 12B quantizado cabe inteiro nela, e qualquer endpoint compatível com OpenAI (OpenRouter, llama.cpp, Ollama) roda o mesmo modelo sem nenhuma GPU local.
1,3 ms p95
Busca de entrada só com BM25, com recall@5 = 1,00: sem embeddings, sem banco vetorial, sem GPU.

Todo número desta página é reproduzível a partir de scripts versionados no repositório. O paper é um preprint.

O problema

Quanto custam, de verdade, respostas sobre os seus documentos

Fatiar, gerar embeddings, pegar os top k, gerar. É a arquitetura padrão da maioria dos sistemas em produção, e ela é frágil exatamente onde o embasamento mais importa: perguntas cuja resposta precisa ser montada a partir de fatos espalhados por vários documentos. Enquanto isso, seus agentes pagam uma segunda conta: janelas de contexto estouram, e toda sessão começa reconstruindo o que a anterior já sabia.

  • Ele recupera uma vez só

    A aposta sobre quais fragmentos importam é feita antes de o modelo ter lido qualquer coisa, e nunca é revista. Não há segunda olhada, porque não existe de onde olhar.

  • Ele é cego à estrutura

    Um fragmento não sabe nada sobre o documento de onde veio, sobre a tabela ao lado, nem sobre o fato de que a resposta continua três arquivos adiante. Similaridade não é caminho.

  • Ele não aprende nada

    A milésima consulta custa exatamente o que custou a primeira e cai exatamente nos mesmos fragmentos. Nada do que funcionou antes é lembrado.

  • E agentes pagam o imposto do grep

    Observe um agente de código se contextualizar: grep, abrir, ler, reler; minutos e milhares de tokens gastos reconstruindo contexto antes da primeira decisão útil, em toda sessão. Conhecimento sem estrutura taxa os agentes mesmo quando não há retriever nenhum à vista.

O precipício

Em perguntas mistas, o RAG top-k clássico parece respeitável: 12 de 18, o número que uma demo mostra. No instante em que toda pergunta exige três saltos encadeados, ele cai para 0 de 11. A falha é estrutural, o que a torna invisível à amostragem: qualquer avaliação que inclua perguntas de um salto dilui o precipício na média. O remédio de sempre é comprar um modelo maior, e é assim que times acabam pagando preço de fronteira por respostas apenas aceitáveis sobre documentos que já são deles.

Casos de uso

Onde uma floresta se paga

Quatro cenários: imaginados, não estudos de caso. Cada um parte de um corpus que já existe em algum lugar como pastas que ninguém consegue buscar, e termina no que esse corpus vira quando um agente consegue percorrê-lo.

  • Escritório de contencioso

    Imagine um escritório de advocacia com oitocentos documentos de processo

    Contratos, petições, anexos e correspondência espalhados por um drive compartilhado. A advogada que sabia onde estava o aditivo de 2019 saiu em março, e a caixa de busca só encontra nomes de arquivo.

    Cada documento vira um nó com nome, resumo de até sessenta tokens e links tipados para o caso a que pertence. A busca de entrada devolve o certo em 1,3 ms p95: BM25 sobre SQLite, sem nenhuma GPU no escritório. Planilhas de anexos viram datasets SQL que um assistente consulta, então “quais faturas passaram do teto” é uma consulta, e não uma tarde inteira. E nada sai de casa: a floresta é um repositório git no servidor do próprio escritório.

    Veja como funciona a ingestão
  • Plataforma e operações

    Imagine suas políticas e runbooks como um ativo governado

    Documentos de onboarding em um wiki, runbooks em outro, e as decisões que realmente explicam o produto numa thread de chat de 2023. Toda resposta custa a interrupção de alguém, e ninguém sabe dizer qual versão vale.

    Uma floresta no lugar de um cemitério de pastas, versionada em git, então “quando esta política mudou e quem mudou” é um diff, não um trabalho de arqueologia. As chaves têm escopo por time e só conseguem estreitar, toda leitura deixa uma linha de auditoria, e o mesmo conteúdo governado responde a uma pessoa no console e a um agente por MCP, pelo mesmo portão.

    Veja governança e acesso
  • Engenharia de IA e plataforma

    Dê aos seus agentes uma memória que sobrevive à sessão

    Toda sessão começa do zero. Grep, abrir, ler, reler; minutos e milhares de tokens gastos reconstruindo contexto antes da primeira decisão útil, em toda tarefa, para sempre.

    Aponte seus agentes para a floresta por MCP e eles chegam ao nó certo em um punhado de saltos com orçamento, em vez de reler o repositório. O mesmo modelo local de 12B que fez 0/11 como leitor de RAG top-k faz 11/11 como navegador, com 0,66× dos tokens por resposta correta e 8,4 s p95 contra 17,5 s. O imposto do grep acaba, e acaba também pagar preço de fronteira por respostas aceitáveis sobre os seus próprios arquivos.

    Conecte ao seu agente
  • Times de modelo

    Um corpus limpo o bastante para treinar

    Fine-tuning e engenharia de contexto falham pelo mesmo motivo: ninguém sabe dizer qual versão de qual documento era a verdade no dia em que a rodada começou, nem quais arquivos ficaram ilegíveis em silêncio.

    O Gardener converte, resume e commita cada arquivo que consegue ler a 1,71 s por documento, e nomeia no relatório exatamente o que não conseguiu. Toda escrita é um commit, então um corpus tem revisão, diff e histórico, e uma rodada de treino ou avaliação aponta para uma revisão, não para uma pasta que seguiu em frente sem avisar.

    Leia a pesquisa

Os cenários são ilustrativos: não estamos descrevendo clientes. Os números dentro deles não são: cada figura vem do benchmark versionado no repositório, medido em uma única GPU de consumo.

Ingestão

O que entra é um arquivo. O que sai é um nó.

O Gardener converte, resume e commita tudo que consegue ler, a 1,71 s por documento. Uma planilha sai como uma tabela que o agente consulta em SQL, não como um paredão de texto.

derived-frompart-ofrelated-to.xlsx.csv.json.pdf.docx.md.png.wavdatasetquerydocumentpickmediapick.xlsx.csv.json.pdf.docx.md.png.wavdatasetquerydocumentpickmediapick
  1. 01

    Qualquer arquivo

    PDFs, planilhas, capturas de tela, áudio, ou uma pasta inteira que o host consiga ler. Você entrega do jeito que estão: nenhuma estratégia de chunking para escolher, nenhum schema para declarar, nenhum pré-processamento para manter.

  2. 02

    O Gardener lê

    Converter, escrever um resumo de no máximo sessenta tokens, propor arestas tipadas a partir de uma lista fechada de candidatos, commitar. Um modelo de 12B em uma GPU de consumo faz a passagem inteira, e o relatório nomeia cada arquivo que ele não conseguiu ler.

  3. 03

    Um nó que seu agente navega

    Ele chega com passaporte (título, resumo, tags, arestas tipadas) e com payload: um documento para ler com pick, ou uma tabela SQLite de verdade para consultar em SQL. Já ligado ao que se relaciona.

Três faixas entrando, três tipos de nó saindo. Uma planilha vira um dataset que o agente consulta; um PDF vira um documento que ele lê; uma imagem ou uma gravação vira um nó de mídia. Nada é fatiado e jogado em um vector store: cada chegada mantém sua identidade, seu resumo e seus links, em um único commit.

Veja a tabela completa de conversão

Como funciona

Navegue, não recupere

Três movimentos, emprestados de como um forrageador realmente trabalha uma floresta. O vocabulário é ecológico de propósito, e corresponde um a um a dez ferramentas tipadas que um agente pode chamar por MCP. Cada salto é barato e tem orçamento de tokens, então o agente chega ao nó certo em poucos movimentos em vez de reler o corpus: é daí que vêm a velocidade e a economia de tokens.

  1. 01

    Navegar

    locate · look · move · pick

    O macaco entra e caminha.

    O agente entra por uma busca sobre metadados curados, lê o passaporte do nó (título, resumo de até sessenta tokens, tags, arestas tipadas com o cheiro de cada vizinho) e segue a aresta que mais cheira ao objetivo. Toda observação tem orçamento fixo de tokens e avisa em voz alta quando foi truncada, para que o agente sempre distinga “não está lá” de “foi cortado”.

    Em português claro: busque, leia o rótulo, siga um link, abra só o que precisa.

  2. 02

    Plantar

    plant · graft · tend

    O que ele aprende, fica.

    A caçada que descobre algo escreve de volta: um nó novo com passaporte validado por contrato, uma aresta tipada para o que se relaciona, uma correção em um resumo que estava errado. Toda escrita é um commit de git, então o corpus é versionado, comparável e reversível por construção.

    Em português claro: escreva um nó, conecte-o, corrija-o.

  3. 03

    Feromônio

    calor · atalhos · evaporação

    O corpus aprende com o uso.

    Caçadas bem-sucedidas depositam calor nos nós que atravessaram, e uma cadeia de quatro saltos ou mais cunha um atalho permanente. O calor evapora com meia-vida de trinta dias, então o conhecimento que deixa de ser usado esfria e sai do ranking. A milésima pergunta é feita a uma floresta mensuravelmente diferente da primeira.

    Em português claro: trilhas que funcionam ficam mais fáceis; trilhas que ninguém percorre somem.

Híbrido de nascença

A arquitetura híbrida que mandaram você construir

Pergunte a qualquer assistente se vale adotar o MonkeyLLM e ele desenha sempre o mesmo quadro: um orquestrador roteando entre um banco vetorial, uma ferramenta de SQL e o grafo, fundindo o que volta e gravando o resultado na memória. A arquitetura está certa. Ela também é, caixa por caixa, o que uma floresta já é atrás de um único endpoint MCP, e é por isso que adotar aqui é registrar uma ferramenta, não migrar de stack.

A caixa daquele diagramaO que já a preenche, hoje
Banco vetorial, similaridadelocate: pontos de entrada ranqueados sobre metadados curados, BM25 a 1,3 ms p95, com os vetores do Canopy fundidos por RRF quando a chamada pede.
Busca em texto completosniff: uma varredura pelos corpos dos nós devolvendo trechos com número de linha e a seção de onde vieram, não um escore de similaridade.
Grafo de conhecimento, multi-hoplook, move, scan, pick: arestas tipadas que carregam o cheiro do vizinho, cada salto com orçamento e cada corte declarado.
Ferramenta de SQL ou tabelasquery: uma instrução somente leitura contra um nó dataset. Uma planilha vira tabela SQLite de verdade, com manual de consulta escrito no passaporte.
Camada de fusãoharvest: locate e sniff fundidos por Reciprocal Rank Fusion, depois um pick seletivo. Cerca de 50 ms, zero chamadas de modelo.
Geração ancoradaanswer: a resposta chega com os ids dos nós em que se apoia, então a fonte é uma lista que você abre, não um escore.
Escrita de memóriaplant, graft, tend: toda escrita é um commit git, mais feromônio na trilha que funcionou e um atalho quando a trilha foi longa.
OrquestradorAusente de propósito. Seu agente já é um, e ele roteia melhor com as ferramentas à frente do que um classificador roteia por trás.

E nada aqui pede que você desligue o que já roda

Uma floresta ocupa um lugar na lista de ferramentas do seu agente, ela não pede a lista. Deixe o pipeline de hoje respondendo o que ele responde bem, adote o corpus em que o seu recuperador é pior, e deixe o agente rotear entre os dois. A fusão vetorial na entrada continua desligada por padrão porque, sobre metadados curados, ela mediu pior que o BM25 sozinho: recall@1 de 1,00 para 0,40. Um recurso que liga em silêncio uma regressão medida é uma armadilha, não um padrão.

Cada caixa mapeada, com um exemplo completo

O Princípio da Floresta

“Gaste inteligência no ambiente para poder gastar menos no modelo.”
MonkeyLLM · The Forest Principle

Estruture o corpus de modo que cada passo de recuperação seja uma decisão local barata sobre sinais curados. Deixe o uso bem-sucedido modificar a estrutura. Então o modelo necessário em tempo de consulta encolhe em ordens de grandeza, e é por isso que um modelo de 12B em uma GPU de consumo supera a arquitetura de que um modelo de fronteira precisa para falhar com elegância.

O reflexo do mercado é uma janela maior, um leitor maior, um re-ranker melhor: inteligência em tempo de consulta, paga a cada consulta, sem aprender nada. O Princípio da Floresta move esse gasto para o momento da ingestão e para a estrutura, onde ele acumula.

Leia a pesquisa

As peças

Um engine, e três coisas construídas em volta dele

O console é uma janela. A floresta atrás dele é o produto, e o engine que a serve não tem host, nem servidor, nem interface acoplada.

Engine

A floresta e as dez primitivas

Um pacote Python puro com a CLI `vine`. Aponte para uma pasta e você tem uma floresta: uma árvore de nós de markdown versionada em git. Opere do seu próprio código, ou entregue a qualquer cliente MCP com um comando: sem host, sem contas, na sua máquina.

from monkeyllm import Vine
from monkeyllm.harvest import harvest

vine = Vine("./brain")
vine.plant({"id": "inbox/first-note", "type": "note",
            "parent": "inbox/_index", "title": "First note",
            "summary": "Where this brain begins."})

vine.locate("where does this brain begin?")
harvest(vine, "first note")

Station

Identidade, política e auditoria em volta de um engine intocado

Um contêiner auto-hospedável: REST em `/v1`, MCP em `/mcp`, política por floresta, chaves com escopo e trilha de auditoria. É o que transforma um diretório pessoal em um ativo compartilhado e governado.

O console Access: uma linha por pessoa, com nível, escopo e tokens ativos

Studio

A janela para a floresta

Faça perguntas que chegam com suas fontes, percorra a árvore como um grafo vivo, consulte datasets em SQL, alimente a floresta, conceda acesso, vincule modelos. O que o console mostra, um cliente de API com a mesma chave também busca: não existe caminho privilegiado.

O console Overview: o que há nesta floresta e o que você pode fazer aqui

Clipper

O navegador plantando direto na floresta

Uma extensão para Chrome, Edge e Brave: o artigo legível ou só a sua seleção como markdown, uma captura de tela ou uma região arrastada como nó de mídia, anotada, com um recado para o Gardener e o endereço da página anexado.

Capturando e anotando uma região da página, com um recado para o Gardener

Governança e segurança

Uma floresta que você entrega para auditoria

O que decide se uma arquitetura sobrevive a uma revisão de segurança: não recursos parafusados depois, mas propriedades que o desenho já tinha.

  • Um portão, três superfícies

    Studio, REST e MCP autenticam com as mesmas chaves em um único ponto de verificação. Não existe canal lateral privilegiado e, deliberadamente, não existe painel de superadministrador separado.

  • Chaves que só estreitam

    O acesso é concedido primeiro como nível e depois como capacidades (read, query, write, tend, ingest, admin), com escopo por floresta e, quando é uma só, por galho. Uma chave pareada para um agente nunca amplia o que você já tem.

  • Toda resposta é reproduzível

    Toda escrita é um commit de git; toda leitura é uma chamada tipada, com orçamento e rastro registrado. Pergunte a um pipeline de RAG por que ele recuperou aquilo e você recebe similaridades de cosseno. Pergunte a uma floresta e você recebe uma trilha que dá para percorrer.

  • Auto-hospedado por padrão

    Um contêiner na sua infraestrutura. Tudo que vale guardar vive em volumes nomeados que são seus, então atualizar é um rebuild, não uma migração.

  • Nenhum dado sai da sua infra

    Nada é enviado para nós: nem seus documentos, nem suas consultas, nem a atividade dos seus agentes. Os vínculos de modelo são escolha sua, inclusive um endpoint llama.cpp puramente local.

  • Link alucinado é impossível

    Na ingestão, o Curator propõe arestas apenas a partir de uma lista fechada de candidatos vinda do catálogo. Um alvo de link alucinado é estruturalmente impossível, não apenas improvável.

Propriedade

É seu. Leia o código, rode para sempre.

Sem aprisionamento a fornecedor, sem contagem de assentos, sem chave para pedir, nada telefonando para casa. Cada linha é pública e auto-hospedar é sem restrições: se desaparecêssemos amanhã, sua floresta nem perceberia, porque ela é markdown num repositório git que já é seu.

Ver a licença em detalheDê uma estrela no GitHub

  • Cada nó é um arquivo markdown puro no seu próprio repositório git, legível, comparável e portátil sem nós.

  • Nada é enviado para nós: nem seus documentos, nem suas consultas, nem a atividade dos seus agentes.

  • Toda capacidade está no build aberto. Não existe plano pago escondendo um recurso de que você precisa.

Comece agora

Quatro comandos até um cérebro navegável

Auto-hospedar é o caminho padrão, e é sem restrições. Você não precisa de nós para começar, e também não deveria aceitar nossos números na base da confiança.

  1. 1

    Instale o engine

    Um pacote Python puro e a CLI `vine`. Sem servidor, sem contas.

  2. 2

    Plante uma floresta

    Uma floresta vazia, versionada em git, numa pasta que é sua.

  3. 3

    Alimente-a

    O Gardener converte, resume e commita cada arquivo que consegue ler: planilhas viram datasets SQL, não paredões de texto.

  4. 4

    Entregue ao seu agente

    Um servidor MCP por stdio. O Claude Code, ou qualquer runtime compatível com MCP, passa a segurar as dez ferramentas da floresta.

Terminal
pip install monkeyllm
vine init --forest ./brain --title "My brain"
vine adopt ./my-documents --forest ./brain
vine serve --forest ./brain            # stdio MCP, ready for any agent

Ou rode a Station inteira

Um contêiner serve a API REST, a superfície MCP e o console Studio; os dados persistem em volumes nomeados que são seus. Aponte o binding de chat para qualquer endpoint compatível com OpenAI: OpenRouter, um llama.cpp ou Ollama local, ou o provedor que preferir.

Terminal
git clone https://github.com/JimmyWesley/MonkeyLLM.git
cd MonkeyLLM && cp .env.example .env
docker compose up --build -d

Quer reproduzir o 0/11 antes? Clone o repositório, construa a floresta de teste e rode o bench: é um comando, e é o argumento inteiro.

Leia o manualDê uma estrela no GitHub

Respostas diretas

O que perguntam a um modelo antes de perguntar a nós

A maioria das pessoas conhece o MonkeyLLM por um assistente, não por esta página. Estas são as perguntas que decidem a adoção, respondidas por inteiro aqui para que a resposta que um modelo dá seja a que nós daríamos.

Não, e você não deveria começar tentando. O MonkeyLLM é um servidor MCP que fica ao lado do que você já roda. Adote o corpus em que o seu recuperador atual é pior, que quase sempre é aquele cujas perguntas atravessam documentos, deixe o resto respondendo o que responde bem, e deixe o agente rotear entre os dois. Mova mais quando os traces mandarem, um corpus de cada vez.

Livre para auto-hospedar. Vale uma contraparte em produção.

Termos comerciais quando você entrega isto dentro do seu próprio produto, um plano de suporte quando disponibilidade é responsabilidade de alguém, e uma sessão paga de arquitetura quando você quer uma resposta direta antes de se comprometer.

Fale com a genteVer planos de suporte